2.1 IoT WiFi Actuador Binario – Tomacorriente

Presentación

El dispositivo inalámbrico se usa para controlar el estado encendido o apagado (actuador) de un aparato eléctrico AC (lámpara) de baja potencia.

El dispositivo se implementa usando un relé, como base para el desarrollo de otros circuitos.

El relé seleccionado paa prototipos es el básico usado con arduinos, se alimenta de 5VDC y permite controlar cargas de 120VAC semejante al mostrado en la figura.

El control del relé se realiza por medio de una instrucción MQTT de publicación.

implementación versión 1

La versión 1 ha instalado en una caja sobrepuesta plástica. Para pruebas, se ha conectado una lámpara al tomacorriente. Por ejemplo las lámparas de Jardín, Patio, balcón, etc.

Es dispositivo es la introducción para desarrollar actuadores, se utiliza tomacorriente único considerando las limitaciones de los pines en el módulo ESP-01.

De utilizar dos tomacorrientes independientes enla caja, será necesario disponer de dos pines de Control.

Se propone usar GPIO3 o RXD debido a la estabilidad del pin durante el arranque del módulo ESP01.

También se intentó probó configurar con GPIO0 y GPIO2 dado que su estado predeterminado se puede reconfigurar por software una vez iniciado el módulo en modo de operación. Sin embargo, al inciar el módulo al conectar energía, éstos pines tienen cambios de estado que causan «rebotes» inesperados en el relé, por lo que se desiste de usar éstos pines por posibles daños a los aparatos o cosas conectadas al tomacorriente.

3.4 IoT WiFi Interruptor-Tomacorriente: MQTT-HA

Esta es la última sección a realizar, pues se supone que tiene listo el dispositivo, construido y operativas las partes: Dispositivo y Broker.

El objetivo es incorporar dispositivo Interruptor-Tomacorriente en el broker MQTT y observar los resultados.

Se plantea observar los estados del dispositivo en dos formas:

  • Desde un navegador en la página local de Home-Assistant
  • Desde una consola conectando al servidor MQTT

1. Incorporar el dispositivo en Home Assistant

Se requiere modificar el archivo configuration.yaml en el raspberry.

Se puede realizar en forma local desde el raspberry que tiene monitor, teclado y mouse conectado, y editar el archivo que se encuentra en el directorio:

 /home/homeassistant/.homeassistant/configuration.yaml

La otra forma es conectarse via remota por medio de una sesión ssh. Requiere dirección, usuario y password. Los detalles se dan en la sección Raspberry.

En el archivo se añade los datos del dispositivo interruptor-tomacorriente, que en el caso actual para pruebas se identifica como una luminaria (light).

El sensor trabaja con MQTT, se le asigna un nombre más sencillo de reconocer como «oficina luz 1» y se complementa con la instrucción de identificación en el formato: lugar/cosa/acción.

light:
  - platform: mqtt
    name: 'oficina_luz1'
    state_topic: 'oficina/luz1/estado'
    command_topic: 'oficina/luz1/cambia'
    optimistic: false

Se añade la la instrucción de control para el dispositivo (command_topic) también con el formato indicado, «oficina/luz1/cambia».

otra forma de presentación en Home-Assistant. editando las tarjetas por dispositivo (Cards):

 

1.2  Monitoreo desde MQTT

Para monitorear señal desde consola Raspberry usando MQTT, usar la instrucción:

mosquitto_sub -h 192.168.10.100 -t oficina/luz1/estado

En el caso de control del actuador, se utiliza una intruccion semejante para publicar:

mosquitto_pub -h 192.168.10.100 -t oficina/luz1/cambia -m on

Dispositivo como interruptor

Se aplica el mismo concepto del dispositivo para el caso de un interruptor, no necesariamente de luz. Para el caso de interruptor, hay que observar la capacidad máxima de manejo de corriente del Relay usado, para evitar sobrecargas.

Como ejemplo, se presenta el formato para interruptor en Home-Assistant, lo que requiere también realizar un cambio en el archivo.ino en la sección MQTT. Sin embargo no afecta al resto de las instrucciones.

switch:
  - platform: mqtt
    name: 'oficina_Interruptor1'
    state_topic: 'oficina/switch1/estado'
    command_topic: 'oficina/switch1/cambia'
    optimistic: false


Entre algunas de las cosas que se pueden realiza con un dispositivo tipo binario.

3.1 IoT WiFi Sensor-Actuador: Interruptor-Tomacorriente

Presentación

El dispositivo inalámbrico se usa para controlar el estado encendido o apagado (actuador) de un aparato eléctrico AC (lámpara) de baja potencia.

El control se lo puede realizar físicamente al pulsar un interruptor tradicional (sensor) o por medio de una instrucción MQTT.

El sensor de interruptor y el actuador de control AC trabajan en conjunto desde el mismo dispositivo. Éste dispositivo es la integración de los dos dispositivos anteriores: Sensor Puerta-Ventana y Actuador tomacorriente, ambos de estado binario (ON/OFF).

implementación versión 1

La versión 1 mostrada en la imagen se ha instalado en una caja sobrepuesta plástica. Para pruebas, se ha conectado una lámpara al tomacorriente.

El control se realiza tanto por el interruptor como por la página en la computadora, ambos marcados en rojo en la imagen.

La carga máxima AC de control depende del Relé  seleccionado.

Se ha usado una placa perforada para ensamblar el prototipo, sin embargo al final del tema en Placas PCB se presenta el diseño de la placa de circuito.

Premisas para desarrrollo en la versión 1

  • Diseño de dispositivos con conexión inalámbrica WIFI
  • Conoce los datos para conexión a la red a WIFI y broker MQTT
  • Dispone de acceso a un broker MQTT local
  • Dispone de Arduino IDE para cargar las instrucciones en el ESP8266
  • Emplea diseños abiertos tipo: Open Hardware y Open Software
  • Dispone de los componentes en el mercado local
  • Considera componentes alternos a los no disponibles en el mercado local
  • Identifica las etapas de desarrollo e inconvenientes en la implementación

Temas para desarrollo posterior

Incorporar Sensor para medir consumo de energía.

Sensores Analógicos
Ampliar la forma de carga de scripts en el tablero, de forma alámbrica o inalámbrica.

Revisar el uso de los canales WIFI para evitar desconexiones por saturación de canal.

4.2 IoT Base de datos. Home-Assistant

Los datos registrados en Home-Assistant se pueden obtener de la base home-assistant_v2.db.

Los datos se pueden leer mediante SQLite3 y exportarse para ser tratados con alguna herramienta informática para estadística.

Referencia: Visualize your IoT data. https://www.home-assistant.io/blog/2016/07/19/visualizing-your-iot-data/

 

4.1 IoT Broker – Gestión con Home Assistant

En el esquema abierto, los mensajes de estado/acción con MQTT se administran (pub/sub) bastante bien con Mosquitto.

Cada mensaje genera un dato de estado, que con el transcurrir el tiempo podría ser revisado mediante las estadísticas de uso o pretender realizar acciones sobre los artefatos ante una secuencia de estados predeterminados, realizar una presentación en una página web. Estos nuevos requerimientos  implican una mayor integración en software.

Entre las versiones de software abierto para la gestión de los mensajes de estado/acción se encuentra Home Assistant, que junto a Mosquitto presentan una solución bastante aceptable de operar y personalizar.

Home-Assistant se suscribe a MQTT- Mosquitto y realiza la gestión de datos, para por ejemplo presentarla en una página web. La presentación puede ser como texto o de forma gráfica.

El acceso web se basa en la dirección IP del broker en el puerto 8123, también es valida el nombre de la maquina en la red (ej: miComputadorIoT:8123),

El proceso de instalación y configuración de Home-Assistant se detalla en la sección de Broker/Gestión, donde se detalla la conexión a MQTT de forma abierta, con validación de usuario y password, finalmente con SSL/TLS.

Esta sección se centra en la conexión de un dispositivo y la configuración de los parámetros del mensaje MQTT. Se supondrá que tiene ya configurado el servicio en algún «servidor/broker» con Raspberry Pi o en PC.

La configuración básica de un dispositivo se realiza en el archivo configuration.yaml que se puede editar desde una consola ssh con la instrucción:

sudo nano /home/homeassistant/.homeassistant/configuration.yaml

donde se añaden los parámetros de cada dispositivo, sus propiedades, formas de presentación, etc.

Por ejemplo, para observar el estado o valor del mensaje MQTT del tema «oficina/mensaje» es necesaria una suscripción al mosquitto. Se asume que ya se han realizado las pruebas de conectividad, por lo que para añadir el dispositivo y sus propiedades al archivo se añade:

binary_sensor:
  - platform: mqtt
    name: 'Sensor01'
    state_topic: "oficina/mensaje"

Reinicie Home Assistant en el menú de Configuración/Controles del Servidor. Recuerde siempre validar el cambio de configuración antes de reiniciar Home-Assistant. En la pagina de resumen de Home Assistant se obtendrá el estado del dispositivo.

 

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.

2.2 WiFi – Archivo.ino para ESP8266/ESP32

Referencia: ESP8266WiFi library. https://esp8266-arduino-spanish.readthedocs.io/es/latest/esp8266wifi/readme.html

Las instrucciones se presentan paso a paso, en caso que realice por primera vez éste proceso, en los próximos ejemplos bloques y pasos básicos repetidos solo se mencionarán y/o se hará referencia a éste ejemplo.


1. Bloque de inicio

1.1 Librerías

Las librerias contienen las instrucciones para los procesos como el de conexión, manejo de datos como direcciones IP, MAC,  o niveles de señal RSSI, valores de estado de conexión, etc.

Las librerías podrían variar entre modelos de placas de desarrollo principalmente por tipo de módulo o microcontrolador, sin embargo las instrucciones son las mismas. La siguiente tabla muestra la librería usada en cada caso:

Modelo libreria
ESP8266 <ESP8266WiFi.h>
ESP32 <WiFi.h>

Para el resto de las instrucciones no hay diferencias, las instrucciones son  las mismas manteniendo el uso de pines de la placa.

Esta selección de librerias se puede realizar con inclusión de condigo condicionado por la placa mediante la instrucción #ifdef #elif #endif. De esta manera se puede realizar un solo código general, al compilar en arduino, dependiendo de la placa que se tiene conectada se selecciona la librería necesaria.

// detectar placa al compilar
# ifdef defined(ESP8266)
  #include <ESP8266WiFi.h>
# elif defined(ESP32)
  #include <WiFi.h>
# endif
WiFiClient wificlient;

Referencia: http://www.cplusplus.com/doc/tutorial/preprocessor/

1.2 Parámetros y cliente de la red

Como en toda conexión Wifi se require de: Un identificador de router ‘ssid‘ y Una contraseña ‘password‘. En las instrucciones del ejemplo son valores de la red que se deben actualizar para poder conectarse en cada caso particular.

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

Con los parámetros anteriores, se inicializa el proceso conectarse a la red.

1.3 Pines a usar – Estado de conexión por parpadeo de LED

Para una versión simplificada de prueba de estado de conexión,se usan el parpadeo del LED incorporado en la placa de desarrollo, dado por el pin del modelo de placa usado (Revisar la hoja de datos)-

int LED_pin=2;

En el bloque de inicio también se establecen valores para otros parámetros. Las placas de desarrollo facilitan esta opción al encontrarse conectadas por el cable USB, por lo que se añade la opción de activar mensajes en cada bloque con la bandera serial_msg = true.

En el caso de que ya no se requieran, se destartan las instrucciones de mensajes usando el valor bandera serial_msg = false. También se usa esta opción con los módulos compactos como el ESP01, que no posible usar mensajes por USB por lo limitado de pines disponibles.


2. Bloque de configuración – setup()

El dispositivo se inicializa con el bloque setup(), primero indicando el modo uso como salida de pin LED_pin.

void setup() {
  if (serial_msg){
    Serial.begin(115200); //115200,74880
  }
  
  // LED interno, Enciende en LOW
  pinMode(LED_pin, OUTPUT);

  // conexión WIFI
  inicia_wifi();
}

Luego sigue las instrucciones del procedimiento inicia_wifi(), dedicada a establecer la conexión con el router. En teoría se debería ejecutar solo una vez, sin embargo podría requerir conexión, por ejemplo ante una falla de energía eléctrica en el sector.


3. Bucle o lazo de operación – loop()

La operación del dispositivo se realiza siguiendo las instrucciones del bucle ‘loop()’

El primer paso es verificar si se ha logrado una conexión, de no ser el caso, se repite el procedimientoinicia_wifi()en el que se realizan varios intentos previo a retomar las instrucciones para no dejar sin atender el resto de la operación del dispositivo, por ejemplo la lectura periódica de sensores.

Luego se tiene el bloque de parpadeo de LED como única operación del dispositivo.

Para la versión de placa con ESP8266, se usa la instrucción yield() que cede tiempo de procesamiento al microcontrolador para procesar los detalles de la parte inalámbrica, pues el ESP8266 se tiene un solo núcleo y los procesos se realizan en tiempo compartido.

En el caso de ESP32 que tiene dos núcleos, un núcleo se dedica a la parte del manejo inalámbrico, por lo que no es necesaria la instrucción anterior.

4. Procedimientos y Funciones

Los pasos para conexión al Router y reconexión se pueden requerir más de una vez, por lo que se separan en un procedimiento denominado inicia_wifi(){ }.

En esta sección se define el modo como estación para la conexión del dispositivo y se procede a la llamada del proceso inicial de conexión de la librería WiFi.

  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);

Se requiere de un intervalo de tiempo determinado por la variable espera para obtener el resultado del proceso y establecido en al menos 10.

En éste proceso el parpadeo del LED se definide en la tabla para «NO conectado» en la pagina anterior como 300 ms encendido  y 200 ms apagado.

Cuando se establece la conexión y se dispone de la bandera serial_msg = true, se puede mostrar los valores para algunos parámetros en la red como estado, MAC, IP, RSSI.

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

5. Instrucciones en Arduino IDE

Se compone de dos secciones separadas en pestañas: la sección principal y la de procedimiento de inicia_wifi().

5.1 Sección principal

/* WIFI Blink Ejemplo de conexión a WiFi con ESP8266/ESP32  
 * edelros@espol.edu.ec 2019
*/
// detectar placa al compilar
# ifdef defined(ESP8266)
  #include <ESP8266WiFi.h>
# elif defined(ESP32)
  #include <WiFi.h>
# endif
WiFiClient wificlient;

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

// LED interno, ESP01-pin=1, ESP07-pin=2
int LED_pin = 2;

// Mensajes por Puerto Serial. ESP01 usar false
volatile boolean serial_msg = true;

void setup() {
  if (serial_msg){
    Serial.begin(115200); //115200,74880
  }
  
  // LED interno, Enciende en LOW
  pinMode(LED_pin, OUTPUT);

  // conexión WIFI
  inicia_wifi();
}

void loop() {
  
  // Conectado, LED Parpadea, enciende en LOW
  if (WiFi.status() == WL_CONNECTED){
    digitalWrite(LED_pin, LOW);
    delay(1000); // un segundo
    
    #ifdef defined(ESP8266)
      yield();
    #endif
    
    digitalWrite(LED_pin, HIGH);
    delay(1000);
    }
    
  if (WiFi.status() != WL_CONNECTED){
    digitalWrite(LED_pin, LOW);
    delay(300);
    digitalWrite(LED_pin, HIGH);
    delay(200);
    
    #ifdef defined(ESP8266)
      yield();
    #endif
    }

  // WiFi reconectar si está inactivo
  if (WiFi.status() != WL_CONNECTED){
    inicia_wifi();
  }
}

5.2 Otras pestañas o procedimientos

Proceso en otra pestaña: wifi_inicia a continuación de las instrucciones anteriores.

Nota: Se ha usado el nombre de pestaña con las palabras intercambiadas para distinguir entre pestaña y procedimiento.

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){
    //Fin de "..."
    Serial.println();
    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();
      }
    }
  }

6. Compilar y subir las instrucciones

Una vez terminado el archivo de instrucciones, se graba en un directorio de trabajo, por ejemplo c:\IoT_Taller, con un nombre simple, sin espacios ni tildes, la extensión del archivo.ino se añade de forma automática.

Antes de realizar el proceso de envio del archivo compilado a la placa, verifique que se encuentra seleccionada la placa de desarrollo que está usando: ESP8266 o ESP32 en el menú de Herramientas/Placa.

Verifique que se ha seleccionado el ‘Puerto COM’ donde se encuentra conectada la placa usando el menú de herramientas, puerto asignado, semejante a lo mostrado en la figura.

Para pasar las instrucciones a la placa de desarrollo se usa el botón «subir», en el proceso primero se verifica que no existan errores o inconsistencias de sintaxis. De estar las instrucciones en orden, se transfieren al dispositivo.

En el caso de la placa ESP32 se requiere que se presione también el botón BOOT de la placa de desarrollo. En la versión ESP8266 este paso no es necesario.

En la parte inferior de la ventana se muestran mensajes del proceso de comunicación entre el computador y la placa de desarrollo,

Al terminar se reinicia por si misma la placa de desarrollo y se muestra el resultado de las instrucciones.

7. Estados de conexión con mensajes a puerto serial

Durante el desarrollo es favorable disponer de mensajes en el computador que muestren los estados o valores de las variables para una revisión paso a paso de lo que sucede en el dispositivo.

Las placas de desarrollo facilitan esta opción al encontrarse conectadas por el cable USB, por lo que se añade la opción de activar mensajes en cada bloque con la bandera serial_msg = true

Al inicializar el dispositivo se indica la velocidad de comunicación entre el dispositivo y el computador por el puerto USB mediante la instrucción:

Serial.begin(74880)

en adelante lo que se usa es mostrar un mensaje o valor de variable con las instrucciones:

    Serial.print(" WIFI Conectando a ");
    Serial.println(ssid);

obteniendo los resultados en la ventana del computador obtenida en el menú «Herramientas/Monitor Serie»

3.2 Resultado de mensajes recibidos en «Monitor Serie» con Arduino IDE

Se obtiene unos resultados semejantes a los mostrados en la ventana

..........
Mode: STA
PHY mode: N
Channel: 6
AP id: 0
Status: 1
Auto connect: 1
SSID (15): miRouter
Passphrase (10): miRouterClave
BSSID set: 0

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

Hasta aqui el proceso de las instrucciones para conexión, detallada paso a paso la estructura de programación, librerias y parámetros usados.

Las siguientes secciones amplian la funcionalidad del dispositivo conectandose con los otros componentes del esquema de IOT, añadiendo manejar mensajes hacia un broker y la gestión de los estados.