3.4 MQTT TLS – Archivo.ino para mensajes de estado LED

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 dispositico 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 intrucciones 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/

3.3 MQTT – Archivo.ino – Mensajes de estado LED

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();
      }
    }
  }

3.2 MQTT – Broker de pruebas con usuario y contraseña

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

https://mosquitto.org/download/

1.1 Iniciar del servicio MQTT- Mosquitto

Para que el servicio MQTT-Mosquitto esté activo se utiliza la apliación «Servicios» de «Windows.

busque la apliación con el botón de búsqueda de windows:

Con la apliació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"

2.3. 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.

2.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 enlace:

MQTT – Mosquitto usuario y contraseña

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

3.1 MQTT – Esquema del mensaje de estado o acción

Referencia: MQTT, https://mqtt.org/ . Mosquitto, https://mosquitto.org/

1. MQTT  Concepto

MQTT (Message Queing Telemetry Transport) es un protocolo de comunicación entre máquinas (M2M) ligero y simplificado que sirve para comunicar estados o acciones de los dispositivos.

Una vez conectado el dispositivo a la red WiFi (sección anterior), el siguiente paso consiste en enviar los mensajes de estado, o recibir las instrucciones de acción que son llamados los mensajes MQTT.

mensajes MQTT
Estado Acción
encendido/apagado encender/apagar
ON / OFF 1/0
26° C bajar a 26° C

Para administrar los mensajes de requiere servidor que opere como oficina de correos, también llamado «broker«.

El ‘broker’ recibe los mensajes publicados por los dispositivos (pub) y los re-envia a los destinatarios o suscriptores (sub) conectados al servicio de mensajería.

El broker MQTT seleccionado para el ejercicio es Mosquitto por ser de tipo «open source». El broker se puede implementar en un equipo servidor e incluso en una laptop con objetivos de pruebas básicas.

2. MQTT – Protocolo

Los mensajes MQTT en los dispositivos tienen dos tipos de procesos:

  • Publicación o envío de mensajes de estado (pub)
  • Suscripción o recepción de mensajes de estado (sub)

Por ejemplo, para anunciar el cambio de estado de una puerta como abierta o cerrada usando un sensor se realiza la acción de publicación hacia un broker.

3. MQTT – Parámetros de comunicación

Un mensaje MQTT tiene  elementos semejantes a un correo electrónico. Para mostrar la semejanza, se usa como ejemplo un mensaje con la acción de apagar una lámpara de la oficina en la siguiente tabla.

correo electrónico MQTT
De: Juan Dispositivo/MQTT_ID: lampara01
Para: María Broker/puerto: 192.168.10.50:1883
Asunto: lámpara de oficina tópico: ‘oficina/lampara’
Mensaje: Apagar por favor, la dejé encendida estado/acción: ‘OFF’

Los elementos del mensaje en el esquema IoT y MQTT se muestran sobre el esquema IoT para el caso del sensor en una puerta. Se observa la forma de identificar cada elemento en cada componente o capa del modelo IoT.

Semejante a la conexión de WiFi hacia el Router, en MQTT se requiere disponer de los datos de un «administrador de mensajes» o «broker MQTT», que lo identifiquen en la red y a la vez también algún medio de control de uso como usuario y contraseña.

broker MQTT
Parámetro valor
dirección IP 192.168.10.50
puerto 1883
usuario usuarioprueba
contraseña usuarioclave

El broker MQTT además de identificarse por la dirección IP y usa un número de puerto para identificar también el servicio, pues pueden existir otros procesos en el mismo «servidor». El puerto básico es 1883, en el caso que se use encriptación de mensajes por TLS/SSL el puerto cambia a 8883.

En el ejemplo, se presentan valores que deben ser actualizados con los datos correspondientes a la configuración del broker que esté usando.

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

El dispositivo también debe ser identificado para el mensaje, teniendo como parámetros complementarios el identificador MQTT_ID.

Otro parámetro es el tema o tópico (MQTT_TOPIC) que también se usa para ubicar el dispositivo en un entorno o área y una variable de estado o acción separada mediante una barra de división «/».

El estado del dispositivo o valor de sensor se establece en una variable MQTT_Estado.

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

Para el proceso también se puede usar una bandera de conectado o desconectado, para determinar si es posible enviar el mensaje sobre la red de datos.

En la práctica un dispositivo podría disponer de uno o mas sensores y/o actuador. Por ejemplo el sensor DHT11 entrega valores de temperatura y humedad, y disponer de un interruptor relé para encender o apagar un foco. En estos casos sería necesario distinguir varios tópicos o estados para el dispositivo.

4.  Esquema de instrucciones por Bloques

En el esquema de instrucciones por bloques para el dispositivo se requiere añadir algunas partes para operar con MQTT.  El mensaje MQTT viaja sobre una red de datos como WiFi, por lo que es necesario haber completado la parte de conexión a Wifi descrita en la sección anterior.

4.1 Bloque de inicio

Los procesos para mensajería con MQTT se pueden manejar con la librería es PubSubClient.h que se añade en el gestor de librerías del IDE.

Revise que se encuentre disponible en el menú de programa/incluir librería/gestor de librerias, de no ser así, aparece el botón de instalar en la ventana de la figura.

Con lo que se puede incluir la librería y los proceso para establecer un cliente en el broker MQTT.

#include <PubSubClient.h>

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

4.2 Bloque de configuración setup()

Se requiere realizar una conexión con el broker MQTT, se forma semejante a la conexión al router, por lo que se crea un proceso denominado inicia_mqtt() solamente si se ha establecido una conexión WiFi.

4.3 Blucle o lazo de operación Loop()

Una vez realizada la lectura del sensor, de tener disponible una conexión WiFi y una conexión a un broker MQTT se realiza la publicación del valor del sensor en el tópico correspondiente.

    publica_estado();

4.4 Bloques de procedimiento inicia_mqtt() y publica_estado()

El procedimiento inicia_mqtt() se encarga de establecer los parámetros del broker y la conexión, que de completarse inicializa el estado del dispositivo publicando el valor del sensor o actuador.

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

  // Si conectado, inicializa estado
  if (mqttclient.connected()){
      publica_estado();
  }

El procedimiento de publicación de estado tiene dos partes, la conformación del mensaje y el envío del mensaje.

  // 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);
  }

La siguiente página presenta el archivo con las instrucciones completas para la operación de un dispositivo.