Para añadir un nivel adicional de seguridad a los mensajes MQTT en la red, se incorpora SSL/TLS para un dispositivo ESP8266.

Para simplificar el ejemplo, la explicación supone que tiene operando el dispositivo con

Mensajes con ESP8266-Parpadeo LED

y se ha habilitado un broker SSL/TLS con certificado "local" siguiendo el ejemplo de

MQTT – Mosquitto TLS

Librerías Arduino

Para manejar TLS en la conexión, se usa la libreria siguiente:

#include <WiFiClientSecure.h>

Servidor MQTT puerto

El primer valor a actualizar para mensajes TLS es el puerto, revise este valor antes de continuar.

// MQTT: Servidor
char* MQTT_IP = "192.168.10.40";
uint16_t MQTT_puerto = 8883;

Certificados TLS

Los certificados a usar corresponden al certificado de la autoridad y del servidor mqtt.

Para el certificado de la autoridad mqtt-ca.crt se usa el contenido del archivo abierto como texto.

El certificado del servidor mqtt-srv se usa en formato reducido de fingerprint, obtenido con la instruccion descrita anteriormente en la sección mosquitto TLS.

// Certificados TLS: Certificate Authority
const char caCert[] PROGMEM = R"EOF(-----BEGIN CERTIFICATE-----
MIIDRzCCAi+gAwIBAgIUMtlZSXzSZfHpBI0vrnxdLrQuNgwwDQYJKoZIhvcNAQEL
BQAwMzELMAkGA1UEBhMCRUMxDDAKBgNVBAcMA0d5ZTEWMBQGA1UEAwwNMTkyLjE2
.... // ....
OpA6IPNIHmDSSPxgejZq4booviVKro2/M++iOUuGj1jkjR6XSQ6x1JgK0DVyiBtD
4od+M4mYk7gz/CHgl1JEsTVPyUZK4OO/oxC7
-----END CERTIFICATE-----
)EOF";

// MQTT: cert SHA1 fingerprint
const uint8_t mqttCertFingerprint[] = {0x19,0x50,0x25,0x2C,0xD8,0x6A,0x54,0xE6,0xBC,0x8B,0xA4,0x5F,0x76,0x3F,0xD0,0x7D,0xE0,0x5F,0x7C,0x6C};

Conexiones WiFi Seguras

Para usar los componentes de WifiClient y PubsubClient se requiere añadir los detallas de los certificados, por lo que se sustituyen las línea como se muestra:

// Clientes WiFi y MQTT
//WiFiClient wificlient;
// PubSubClient mqttclient(wificlient);

// X.509 parsed CA Cert 
X509List caCertX509(caCert);
// Secure client connection class
WiFiClientSecure wificlient;
// MQTT: Client connection
PubSubClient mqttclient(wificlient);

MQTT - Inicio

En la sección de inicio de MQTT se añaden las partes para que tome en cuenta los certificados al momento de realizar la conexión por Wifi

  // Configura cliente TLS
  // añade CA cert en los sitios de confianza
  wificlient.setTrustAnchors(&caCertX509);
  // Habilita self-signed cert
  wificlient.allowSelfSignedCerts(); 
  // añade fingerprint para validar conexión
  wificlient.setFingerprint(mqttCertFingerprint); 

El resto de las instrucciones se mantienen iguales al proceso anterior.

Ejemplo: Parpadea LED

/* ESP8266 Sensor Parpadea. edelros@espol.edu.ec
 *  con SSL/TLS, Para usar, actualice las secciones de:
 *  - WIFI:Router, MQTT:Servidor, MQTT:Dispositivo
 *  ESP-01 al usar GPIO1 y GPIO3,(Tx,Rx), NO USE Serial.print()
*/
#include <ESP8266WiFi.h>
#include <WiFiClientSecure.h>
#include <PubSubClient.h>

// WIFI: conexión a Router
char* ssid = "miRouter";
char* password = "miRouterclave";

// MQTT: Servidor
char* MQTT_IP = "192.168.10.40";
uint16_t MQTT_puerto = 8883;
char* MQTT_usuario = "usuarioprueba";
char* MQTT_contrasena = "usuarioclave";

// MQTT: Dispositivo
char* MQTT_ID = "sensor01";
char* MQTT_TOPIC = "oficina/mensaje";
char MQTT_SensorEstado[10] = "OFF";

// Certificados TLS: Certificate Authority
const char caCert[] PROGMEM = R"EOF(-----BEGIN CERTIFICATE-----
MIIDRzCCAi+gAwIBAgIUMtlZSXzSZfHpBI0vrnxdLrQuNgwwDQYJKoZIhvcNAQEL
.......// ........
OpA6IPNIHmDSSPxgejZq4booviVKro2/M++iOUuGj1jkjR6XSQ6x1JgK0DVyiBtD
4od+M4mYk7gz/CHgl1JEsTVPyUZK4OO/oxC7
-----END CERTIFICATE-----
)EOF";

// MQTT: cert SHA1 fingerprint
const uint8_t mqttCertFingerprint[] = {0x19,0x50,0x25,0x2C,0xD8,0x6A,0x54,0xE6,0xBC,0x8B,0xA4,0x5F,0x76,0x3F,0xD0,0x7D,0xE0,0x5F,0x7C,0x6C};

// Sensor 
const uint8_t sensor_pin = 1;
volatile boolean sensor_estado  = false;

// LED monitor interno: ESP01-pin=1, ESP07-pin=2
const uint8_t LED_pin = 2;

// Mensajes por Puerto Serial
volatile boolean serial_msg = true;

// Clientes WiFi y MQTT
//WiFiClient wificlient;
// PubSubClient mqttclient(wificlient);

// X.509 parsed CA Cert 
X509List caCertX509(caCert);
// Secure client connection class
WiFiClientSecure wificlient;
// MQTT: Client connection
PubSubClient mqttclient(wificlient);

void setup() {

  if (serial_msg){
    Serial.begin(74880);//74880, 115200
    while (!Serial){delay(50);}
    Serial.println("inicia setup");
  }
  
  // LED monitor, Enciende en LOW
  pinMode(LED_pin, OUTPUT);

  // conexión WIFI y MQTT
  inicia_wifi();
  if (WiFi.status() == WL_CONNECTED){
    inicia_mqtt();
  }
}

void loop() {
  
  // Parpadea estado de sensor
  if (sensor_estado==true){
    sensor_estado = false;
  }else{
    sensor_estado = true;
  }
  
  // LED Monitor Parpadea, enciende en LOW
  if (sensor_estado ==true) {
    digitalWrite(LED_pin, LOW);
    delay(1000); // un segundo
  }
  if (sensor_estado ==false) {
    digitalWrite(LED_pin, HIGH);
    delay(1000);
  }

  if (WiFi.status()==WL_CONNECTED) {
    publica_estado();
  }
  
  //Revisa estado de Wifi o reintenta conexión  
  if (WiFi.status() != WL_CONNECTED){
    inicia_wifi();
  }else{
    if (mqttclient.connected()==false){
        inicia_mqtt(); // reintento
    }
    if (mqttclient.connected()==true){
      mqttclient.loop();
    }
  }
  yield(); // procesa wifi
} 

sección de inicio MQTT completa:

void inicia_mqtt() {
  int intentos = 5;
  int cuenta = 0;

  // Configura cliente TLS
  // añade CA cert en los sitios de confianza
  wificlient.setTrustAnchors(&caCertX509);
  // Habilita self-signed cert
  wificlient.allowSelfSignedCerts(); 
  // añade fingerprint para validar conexión
  wificlient.setFingerprint(mqttCertFingerprint); 

  mqttclient.setServer(MQTT_IP, MQTT_puerto);
  mqttclient.connect(MQTT_ID, MQTT_usuario, MQTT_contrasena);
  //mqttclient.setCallback(callback);

  if (serial_msg){
    Serial.print(" MQTT Conectando a ");
    Serial.println(MQTT_IP);
  }
  
  while (!mqttclient.connected()&&(cuenta<=intentos)){
    cuenta = cuenta + 1;
    
    // LED Monitor parpadeo MQTT, enciende LOW
    digitalWrite(LED_pin, LOW);
    delay(600);
    digitalWrite(LED_pin, HIGH);
    delay(400);
    
    if (serial_msg){
      Serial.print(".");
    }
  }
  
  // Si conectado, inicializa estado
  if (mqttclient.connected()){
      publica_estado();
  }
  
  if (serial_msg){
    //Fin de "...."
    Serial.println();
    Serial.print("; MQTT Conectado: ";);
    Serial.println(mqttclient.connected());
    Serial.print("; MQTT Estado: ";);
    Serial.println(mqttclient.state());
  }
}

sección de publicación MQTT es igual que en el ejercicio que le precede

// Publicar el estados del dispositivo
void publica_estado() {
  
  // formato para envio (Texto)
  if (sensor_estado == true ){
    snprintf(MQTT_SensorEstado,10, "ON");
  }else{
    snprintf(MQTT_SensorEstado,10, "OFF");
  }

  // publicar estados
  if (mqttclient.connected()==true) {
    mqttclient.publish(MQTT_TOPIC,MQTT_SensorEstado,true);
  }

  if (serial_msg){
    if (mqttclient.connected()==true) {
      Serial.println(MQTT_SensorEstado);
    }
    if (mqttclient.connected()==false) {
      Serial.println("MQTT desconectado");
    }
  }
}

sección de inicio de Wifi es igual que en el ejercicio que le precede.

void inicia_wifi(){
  int intentos = 10;
  int cuenta = 0;

  if (serial_msg){
    Serial.print(" WIFI Conectando a ");
    Serial.println(ssid);
    }
  
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);
  
  while ((WiFi.status() != WL_CONNECTED) && (cuenta < intentos)){
    if (serial_msg){
      Serial.print(".");
      }
    cuenta = cuenta+1;
    // Parpadeo de Monitor enciende en LOW
    digitalWrite(LED_pin, LOW);
    delay(300);
    digitalWrite(LED_pin, HIGH);
    delay(200);
    }
  
  if (serial_msg){
    Serial.println();  //Fin de "..."
    if (WiFi.status() == WL_CONNECTED){
      Serial.print(" Estado: ");
      Serial.println(WiFi.status());
      Serial.print(" MAC: ");
      Serial.println(WiFi.macAddress());
      Serial.print(" IP: ");
      Serial.println(WiFi.localIP());
      Serial.print(" RSSI: ");
      Serial.println(WiFi.RSSI());
      Serial.println();
      }
    if (WiFi.status() != WL_CONNECTED){
      WiFi.printDiag(Serial);
      Serial.println();
      }
    }
  }

Referencia: https://blog.thewalr.us/2019/03/27/using-esp8266-as-an-iot-endpoint-with-encrypted-mqtt-transport/

Referencia: Librería mqtt https://pubsubclient.knolleary.net/api

Para esta sección se supone que ha establecido la conexión a la red WiFi y dispone de un un servidor/broker MQTT de pruebas,  semejante a lo realizado en las secciones anteriores.

1. Bloque de inicio

Para MQTT se incluye la libreria PubSubClient.h para la activación de un cliente sobre WiFi. como se indica en las intrucciones siguientes:

#include <PubSubClient.h >

// Clientes WiFi y MQTT
WiFiClient wificlient;
PubSubClient mqttclient(wificlient);

2. Configuración de inicio setup()

Para el bloque de configuración setup() se verifica el estado de la conexión WiFi antes del intento de conexión al broker MQTT-Mosquitto.

  // conexión WIFI y MQTT
  inicia_wifi();
  if (WiFi.status() == WL_CONNECTED){
    inicia_mqtt();
  }

El proceso inicia_mqtt() se establecen los párámetros de servidor, identificación de usario, conexión y la primera actualización de estado con pub/sub que corresponda.

3. Procedimientos MQTT

Se usa el procedimiento de inicio de conexión y de publicación de estados con sensores. En el caso de actuador se añade el proceso de recepción de mensajes en el dispositivo (callback)

3.1 Procedimiento inicia_mqtt()

Con los parámetros del broker y dispositivo se establece la conexión con el servidor (setServer(), connect()).

Se tiene un periodo de espera mientras se parpadea el led y se presenta un punto en el puerto serial. En caso de que se verifica conexión se publica el estado inicial del sensor antes de volver al bucle de operación.

void inicia_mqtt() {
  int espera = 5;
  int cuenta = 0;
  
  mqttclient.setServer(MQTT_IP, MQTT_puerto);
  mqttclient.connect(MQTT_ID, MQTT_usuario,
                      MQTT_contrasena);
  //mqttclient.setCallback(callback);

  if (serial_msg){
    Serial.print(" MQTT Conectando a ");
    Serial.println(MQTT_IP);
  }
  
  while (!mqttclient.connected()&&(cuenta<=espera)){
    cuenta = cuenta + 1;
    
    // LED Monitor parpadeo MQTT, enciende LOW
    digitalWrite(LED_pin, LOW);
    delay(600);
    digitalWrite(LED_pin, HIGH);
    delay(400);
    
    if (serial_msg){
      Serial.print(".");
    }
  }
  
  // Si conectado, inicializa estado
  if (mqttclient.connected()){
      publica_mqtt();
  }
  
  if (serial_msg){
    //Fin de "...."
    Serial.println();
    Serial.print(" MQTT Conectado: ");
    Serial.println(mqttclient.connected());
    Serial.print(" MQTT Estado: ");
    Serial.println(mqttclient.state());
  }
}

Se añaden algunos mensajes de estado hacia el computador como parte del proceso de depuración en la etapa de desarrollo y programación.

El resultado de esta subrutina en la pantalla "monitor_serie" es;

inicia setup
 WIFI Conectando a miRouter
.......
 Estado: 3
 MAC: 2C:3A:E8:0A:98:66
 IP: 192.168.10.11
 RSSI: -56

 MQTT Conectando a 192.168.10.50
OFF

 MQTT Conectado: 1
 MQTT Estado: 0
ON
OFF
ON
OFF
ON
OFF

....

OFF
ON
MQTT desconectado
 MQTT Conectando a 192.168.10.50
.....

Como una prueba de funcionamiento, al final se muestra el resultado al desconectar el cable del servidor MQTT.

Estos parámetros se deben actualizar para cada dispositivo específico a desarrolar.

Los valores para mqttclient.state() que se pueden obtener son:

-4 : MQTT_CONNECTION_TIMEOUT - the server didn't respond within the keepalive time
-3 : MQTT_CONNECTION_LOST - the network connection was broken
-2 : MQTT_CONNECT_FAILED - the network connection failed
-1 : MQTT_DISCONNECTED - the client is disconnected cleanly
 0 : MQTT_CONNECTED - the client is connected
 1 : MQTT_CONNECT_BAD_PROTOCOL - the server doesn't support the requested version of MQTT
 2 : MQTT_CONNECT_BAD_CLIENT_ID - the server rejected the client identifier
 3 : MQTT_CONNECT_UNAVAILABLE - the server was unable to accept the connection
 4 : MQTT_CONNECT_BAD_CREDENTIALS - the username/password were rejected
 5 : MQTT_CONNECT_UNAUTHORIZED - the client was not authorized to connect

Referencia: https://pubsubclient.knolleary.net/api

3.2 Procedimiento publica_mqtt()

La publicación de estados se realiza como una subrutina, en el ejemplo es solo encendido y apagado de un LED

// Publicar el estados del dispositivo
void publica_mqtt() {
  
  // formato para envio (Texto)
  if (sensor_estado == true ){
    snprintf(MQTT_SensorEstado,10, "ON");
  }else{
    snprintf(MQTT_SensorEstado,10, "OFF");
  }

  // publicar estados
  if (mqttclient.connected()==true) {
    mqttclient.publish(MQTT_TOPIC,
                       MQTT_SensorEstado,
                       true);
  }

  if (serial_msg){
    if (mqttclient.connected()==true) {
      Serial.println(MQTT_SensorEstado);
    }
    if (mqttclient.connected()==false) {
      Serial.println("MQTT desconectado");
    }
  }
}

4. Instrucciones Arduino

Las instrucciones usadas para que el estado del parpadeo de un LED se transmita al broker MQTT se incluyen en para la parte principal en la pestaña principal.

/* ESP8266/ESP32 Sensor LED Parpadea. 
 * edelros@espol.edu.ec
 * Actualice: WIFI:Router, MQTT:Servidor, MQTT:Dispositivo
 * ESP-01, NO USE Serial.print()
*/
// detectar placa al compilar
# ifdef defined(ESP8266)
  #include <ESP8266WiFi.h>
# elif defined(ESP32)
  #include <WiFi.h>
# endif
#include <PubSubClient.h>
// Clientes WiFi y MQTT
WiFiClient wificlient;
PubSubClient mqttclient(wificlient);

// WIFI: conexión a Router
char* ssid = "miRouter";
char* password = "miRouterClave";

// MQTT: Servidor
char* MQTT_IP = "192.168.10.50";
uint16_t MQTT_puerto = 1883;
char* MQTT_usuario = "usuarioprueba";
char* MQTT_contrasena = "usuarioclave";

// MQTT: Dispositivo
char* MQTT_ID = "Dispositivo";
char* MQTT_TOPIC = "oficina/mensaje";
char MQTT_SensorEstado[10] = "OFF";
boolean mqtt_desconectado = true;

// Sensor 
const uint8_t sensor_pin = 1;
volatile boolean sensor_estado  = false;

// LED monitor interno: ESP01-pin=1, ESP07-pin=2
const uint8_t LED_pin = 2;

// Mensajes por Puerto Serial
volatile boolean serial_msg = true;

void setup() {

  if (serial_msg){
    Serial.begin(115200);//74880, 115200
    while (!Serial){delay(50);}
    Serial.println("inicia setup");
  }
  
  // LED monitor, Enciende en LOW
  pinMode(LED_pin, OUTPUT);

  // conexión WIFI y MQTT
  inicia_wifi();
  if (WiFi.status() == WL_CONNECTED){
    inicia_mqtt();
  }
}

void loop() {
  // Parpadea estado de sensor
  if (sensor_estado==true){
    sensor_estado = false;
  }else{
    sensor_estado = true;
  }
  
  // LED Monitor Parpadea, enciende en LOW
  if (sensor_estado ==true) {
    digitalWrite(LED_pin, LOW);
    delay(1000); // un segundo
  }
  
  #ifdef defined(ESP8266)
    yield(); // procesa wifi
  #endif
  
  if (sensor_estado ==false) {
    digitalWrite(LED_pin, HIGH);
    delay(1000);
  }

  if (mqttclient.connected()==true){
    publica_mqtt();
  }
  
  //Revisa estado de Wifi o reintenta conexión  
  if (WiFi.status() != WL_CONNECTED){
    inicia_wifi();
  }else{
    if (mqttclient.connected()==false){
        inicia_mqtt(); // reintento
    }
    if (mqttclient.connected()==true){
      mqttclient.loop();
    }
  }
  #ifdef defined(ESP8266)
      yield(); // procesa wifi
  #endif
} 

Si no se ha implementado el broker MQTT solo obtendrá mensajes de "MQTT desconectado".

Al final, recuerde añadir los otros procedimientos inicia_wifi(), inicia_mqtt(), publica_mqtt().

void inicia_wifi(){
  int espera = 10; // >=10 para conectar
  int cuenta = 0;

  // mensajes por serial activado
  if (serial_msg){
    Serial.print(" WIFI Conectando a ");
    Serial.println(ssid);
    }
  
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);
  
  while ((WiFi.status()!=WL_CONNECTED)&&(cuenta<espera)){
    cuenta = cuenta+1;
    
    // Parpadeo de Monitor enciende en LOW
    digitalWrite(LED_pin, LOW);
    delay(300);
    digitalWrite(LED_pin, HIGH);
    delay(200);
    
    if (serial_msg){
      Serial.print(".");
      }
    }

  //activado mensajes por serial
  if (serial_msg){
    Serial.println();  //Fin de "..."
    if (WiFi.status() == WL_CONNECTED){
      Serial.print(" Estado: ");
      Serial.println(WiFi.status());
      Serial.print(" MAC: ");
      Serial.println(WiFi.macAddress());
      Serial.print(" IP: ");
      Serial.println(WiFi.localIP());
      Serial.print(" RSSI: ");
      Serial.println(WiFi.RSSI());
      Serial.print(" Canal: ");
      Serial.println(WiFi.channel());
      Serial.println();
      }
    if (WiFi.status() != WL_CONNECTED){
      WiFi.printDiag(Serial);
      Serial.println();
      }
    }
  }

Para probar el funcionamiento de un dispositivo con mensajes MQTT se requiere disponer de un broker MQTT.

El ejercicio de Parpadeo LED, con validación de usuario y contraseña, presenta la recepción de los mensajes MQTT  de la siguiente forma:

pi@raspberry:~ $ mosquitto_sub -d -t "oficina/mensaje" -u "usuarioprueba" -P "usuarioclave"
oficina/mensaje ON
oficina/mensaje OFF
oficina/mensaje ON
oficina/mensaje OFF
oficina/mensaje ON
oficina/mensaje OFF
oficina/mensaje ON
oficina/mensaje OFF
oficina/mensaje ON

Se propone disponer de uno usando Mosquitto instalado en un Raspberry Pi para todo lo que se presenta en el Blog.

Sin embargo, si se está iniciando y no se dispone de todo o el acceso a un laboratorio, también es posible tener uno instalado en una pc.

Mosquitto es open source y se puede descargar para instalarlo en varias plataformas.

La descripción en detalle para Raspberry Pi se encuentra en la sección:

Broker/Gestión / MQTT – Mosquitto instalar

1. Instalación en Windows

Descargue el instalador para Windows en el enlace siguiente

dhttps://mosquitto.org/download

1.1 Iniciar del servicio MQTT- Mosquitto

Para que el servicio MQTT-Mosquitto esté activo se utiliza la aplicación "Servicios" de "Windows.

busque la aplicación con el botón de búsqueda de Windows:

Con la aplicación de servicios, localice el servicio "Mosquitto-Broker". Para establecer el estado puede usar las propiedades, con "click derecho" del mouse.

Establezca el inicio en modo "manual", solo si va a utilizar el programa como pruebas, sino en "automático" para que siempre esté activo. Luego proceda con el botón de "iniciar"

1.2 Verificar el servicio "Mosquitto-Broker"

Las instrucciones anteriores habilitan y permiten observar que el servicio "Mosquitto-Broker" se encuentra "En ejecución".

También se puede comprobar el funcionamiento usando una ventana "Símbolo de sistema" y la instrucción:

netstat -an

Observando que el puerto 1883 se encuentra en modo "LISTENING", esperando que lleguen los mensajes al broker.

1.3 Pruebas de operación

Para probar la mensajería, se requieren dos ventanas de "símbolo de sistema". La primera para "escuchar" los mensajes (sub) y la segunda para "enviar" los mensajes (pub).

En una ventana de comando, se suscribirse a un tópico ejemplo, para recibir los mensajes:

mosquitto_sub -v -t "oficina/mensaje"

en otra ventana publicar un nuevo estado en el tópico:

mosquitto_pub -t "oficina/mensaje" -m "mensaje mqtt"

Si el resultado es semejante al mostrado en la imagen del ejemplo, MQTT se encuentra funcionando correctamente y listo para enviar y recibir mensajes desde un dispositivo.

1.4 archivo de configuración en Windows

La configuración de MQTT se realiza en el archivo mosquitto.conf que se encuentra en c:\program files\mosquitto\

Recuerde que al cambiar la configuración debe reiniciar el servicio para que se apliquen los cambios.

Puede proceder con otras acciones dadas en la sección "Broker/Gestión"/MQTT-Mosquito, semejante lo mostrado en el siguiente tema

Referencia: https://www.mundotelematico.com/instalacion-de-mosquitto-mqtt-broker-en-windows/