Grupo de Investigación de Redes de iNformación Inalámbricas
El dispositivo sensor de Puerta Ventana se implementa usando tres componentes principales: 
2.1 Sensor magnético
2.2 Microcontrolador con Wifi: ESP8266 - versión ESP01
2.3. Instrucciones en IDE Arduino
Los pasos de integración de los componentes se describen en la sección:
IoT WiFi Sensor Puerta-Ventana
En el proceso, para realizar los diagramas de circuito, conexiones con protoboard y placas PCB se utiliza el programa Fritzing que es de software abierto.
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:
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.
Se complementa con la instrucción de control para el dispositivo (command_topic) identificada en el formato: "oficina/luz1/switch".
light:
- platform: mqtt
name: 'oficina_luz1'
state_topic: 'oficina/luz1/estado'
command_topic: 'oficina/luz1/cambia'
optimistic: false
Para monitorear señal desde consola Raspberry usando MQTT, usar la instrucción:
mosquitto_sub -h 192.168.10.100 -t oficina/luz1/estado
Como la versión del ESP8266-01 no dispone de muchos pines de trabajo, se define el uso de los pines como:
Por el uso en operación de los pines de comunicación Serial (GPIO1 y GPIO3) se descartan las lineas Serial.print() convirtiendolas en comentarios "//".
El diseño realizado permite conectar un módulo USB-TTL a la placa PCB. Revise la configuración de las botoneras Reset, PROG y los Jumpers para realizar la carga del archivo.ino.
Si la subida del archivo.ino al módulo ESP01 se realiza fuera de la placa PCB revise nuevamente la configuración de PCB para que trabaje en modo «Ejecutar» luego de insertar el módulo ESP01.
Para las acciones repetitivas como la conexión a WIFI y comunicación por MQTT se realizan en funciones para simplificar las instrucciones en la configuración inicial (setup) y la ejecución principal (loop).
Al inicio se definen las librerías y los valores para la conexión WIFI y los datos para comunicarse con el servidor MQTT-Mosquitto implementado en el Raspberry. Revisar de ser necesario al sección Broker.
Para procesar las instrucciones enviadas por el Broker en MQTT se añade la función callback().
Para el control del Relé se usa la función ACTUADORactivaestado() que realiza acciones semejantes a la de activar el monitor LED, y permite en futuro mantener separadas las acciones sobre el ACTUADOR o Relé.)
/* ESP8266 Interruptor AC. edelros@espol.edu.ec
* Sensor-Actuador Binario, control de un Relay con Tomacorriente o foco.
* 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 <PubSubClient.h>
// WIFI: conexión a Router
char* ssid = "iotirni19";
char* password = "anera2018";
// MQTT: Servidor
char* MQTT_IP = "192.168.10.100";
uint16_t MQTT_puerto = 1883;
char* MQTT_usuario = "usuarioprueba";
char* MQTT_contrasena = "usuarioclave";
// MQTT: Dispositivo Interruptor
char* MQTT_ID = "oficina_luz1";
char* MQTT_TOPIC = "oficina/luz1/estado";
char* MQTT_COMMAND = "oficina/luz1/cambia";
char MQTT_SensorEstado[10] = "OFF";
char MQTT_ActuadorEstado[10] = "OFF";
volatile boolean mqtt_desconectado = true;
char* sensor_ON = "ON";
char* sensor_OFF = "OFF";
// Actuador Tomacorriente-Luz
const uint8_t actuador_pin = 3;
volatile boolean actuador_estado = false;
volatile boolean actuador_bandera = true;
// LED monitor //interno: ESP01-pin=1, ESP07-pin=2
const uint8_t LED_pin=0;
const uint8_t LED_actuador = 2;
// Clientes WiFi y MQTT
WiFiClient wifiClient;
PubSubClient mqttclient(wifiClient);
void setup() {
// ACTUADOR Tomacorriente
pinMode(actuador_pin, OUTPUT);
pinMode(LED_actuador, OUTPUT);
// 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() {
// Revisa cambios en interruptor
if (actuador_bandera){
ACTUADORactivaestado();
if (mqttclient.connected()){
publica_estado();
}
actuador_bandera = false;
}
yield(); // procesa wifi
if (WiFi.status() != WL_CONNECTED){
inicia_wifi();
}else{
if (!mqttclient.connected()){
mqtt_desconectado = true;
inicia_mqtt();
}else{
mqttclient.loop();
if (mqtt_desconectado==true){
publica_estado();
mqtt_desconectado==false;
}
}
}
yield(); // procesa wifi
}
// Actuador activar estado
void ACTUADORactivaestado(){
if (actuador_estado){
// ACTUADOR ACTIVA EN LOW
// LED actuador ilumina en apagado
digitalWrite(actuador_pin, LOW);
digitalWrite(LED_actuador, HIGH);
}else{
digitalWrite(actuador_pin, HIGH);
digitalWrite(LED_actuador, LOW);
}
}
// Publicar el estado del dispositivo
void publica_estado() {
if (actuador_estado){
snprintf (MQTT_ActuadorEstado,10, sensor_ON);
}else{
snprintf (MQTT_ActuadorEstado,10, sensor_OFF);
}
mqttclient.publish(MQTT_TOPIC,MQTT_ActuadorEstado,true);
mqttclient.subscribe(MQTT_COMMAND);
}
void inicia_wifi(){
int intentos = 20;
int cuenta = 0;
WiFi.begin(ssid, password);
while ((WiFi.status() != WL_CONNECTED) && (cuenta<=intentos)){
cuenta = cuenta+1;
// Parpadeo de Monitor enciende en LOW
digitalWrite(LED_pin, LOW);
delay(250);
digitalWrite(LED_pin, HIGH);
delay(250);
}
}
void inicia_mqtt(){
int intentos = 4;
int cuenta = 0;
mqttclient.setServer(MQTT_IP, MQTT_puerto);
mqttclient.connect(MQTT_ID, MQTT_usuario, MQTT_contrasena);
mqttclient.setCallback(callback);
while (!mqttclient.connected() && (cuenta<=intentos)) {
cuenta = cuenta + 1;
// Parpadeo de Monitor enciende en LOW
digitalWrite(LED_pin, LOW);
delay(600);
digitalWrite(LED_pin, HIGH);
delay(400);
}
if (mqttclient.connected()){
publica_estado();
}
}
// llega mensaje MQTT
void callback(char* p_topic, byte* p_payload, unsigned int p_length) {
// convierte a texto
String payload;
for (uint8_t i = 0; i < p_length; i++) {
payload.concat((char)p_payload[i]);
}
// revisa mensaje por topico
if (String(MQTT_COMMAND).equals(p_topic)) {
if (payload.equals(String(sensor_ON))) {
if (actuador_estado != true) {
actuador_estado = true;
}
}
if (payload.equals(String(sensor_OFF))) {
if (actuador_estado != false) {
actuador_estado = false;
}
}
actuador_bandera = true;
}
}
El esquemático se divide en varias secciones mostradas en la figura y descritas a continuación.
Para controlar el estado de un tomacorriente y la carga conectada se usa un relé. 
La capacidad de carga del relé determina la capacidad de carga en Amperios del dispositivo, para el prototipo se usa el más básico de los relés controlados por 5 VDC y contactor a 110VAC nominalmente a 10A. No se usará la capacidad máxima del relé.
Para la operación del Relé se usa un optoacoplador que permite acoplar la salida digital del ESP8266 con la corriente demandada por la operación del Relé de aproximadamente 10mA.
El relé se activa con una señal de control de 5VDC que es diferente al voltaje de operación del controlador de 3.3VDC. La diferencia de voltajes se maneja por medio de un optoacoplador como una simplificación para separar los circuitos. Dado que la corriente del optoacoplador disponible no es suficiente para manejar el relé, se usa un Transistor NPN para impulsar la bobina del relé.
El relé tiene dos salidas en estado normalmente cerrado (NC)y la otra normalmente abierto (NO). La alimentación de estas salidas se realiza por medio de la línea de alimentación, por lo que éste dispositivo tienen un conector de 3 entradas para cada actuador. Seleccione la salida que sea de interés para el control del aparato (COSA) con el dispositivo.
El pin para el actuador es GPIO3, RXD, que también se usó con el sensor magnético de puerta -ventana, configurado como salida (OUTPUT).
Se usa un LED monitor para el estado del interruptor/actuador en GPIO2 y un LED monitor para mostrar el estado durante conexión a la red en GIPO0. El diseño considera mantener GPIO0 y GPIO2 en el estado ALTO al inicio del dispositivo, luego establecer el modo de salida (OUTPUT, INPUT) en las instrucciones de configuración (setup()).
El reinicio del dispositivo se controla con la botonera «Reset» al cambiar el pin a estado BAJO (GND). El estado predeterminado es ALTO por medio de R1 y C1 minimiza los rebotes del pulsador.
La placa del circuito permite solo el estado de operación del ESP-01, la programación del módulo ESP-01 se debe realizar fuera del tablero. Revise la opción de programar con la «Conexión USB-TTL».
La activación del módulo se realiza de acuerdo a lo descrito en el manual del módulo. Revisar en la sección «Módulos» ESP8266 versión ESP-01.
Conformada por el Regulador d 110VAC a 5VDC, y el Regulador de 5VDC a 3.3VDC usando el módulo AMS1117.
Los componentes usados o sus sus componentes alternos se describen en la sección de Fuentes de Alimentación para Módulos.
http://blog.espol.edu.ec/edelros/fuente-de-alimentacion-a-3-3vdc/
Para probar el circuito se ensambla en un protoboard teniendo como guía el diagrama del circuito del punto anterior.
Para el desarrollo de la placa se condideró pasar al siguiente dispositivo, al combinar un interruptor con un tomacorriente que requieren un sensor y un actuador para trabajar en conjunto.
3.1 PCB de 4.5x4.5cm. Ocupa el menor espacio posible considerando el tamaño de los componentes.
3.2 Placa de 5x7. Usa el espacio y partes distribuidas considerando el tamaño de las placas perforadas para realizar prototipos. Es la versión simplificada del prototipo de interruptor que controla un tomacorriente o foco.
Como la versión del ESP8266-01 no dispone de muchos pines de trabajo, se define el uso de los pines como:
Por el uso en operación de los pines de comunicación Serial (GPIO1 y GPIO3) se descartan las lineas Serial.print() convirtiendolas en comentarios //. La instrucción para encender el LED de monitor también activa para TXD, por lo que de tener conectado la comunicación serial podría mostrar caracteres ilegibles.
El diseño realizado permite conectar un módulo USB-TTL a la placa PCB. Revise la configuración de las botoneras Reset, PROG y los Jumpers para realizar la carga del archivo.ino. Si la subida del archivo.ino al módulo ESP01 se realiza fuera de la placa PCB revise nuevamente la configuración de PCB para que trabaje en modo "Ejecutar" luego de insertar el módulo ESP01.
Para las acciones repetitivas como la conexión a WIFI y comunicación por MQTT se realizan en funciones para simplificar las instrucciones en la configuración inicial (setup) y la ejecución principal (loop).
Al inicio se definen las librerías y los valores para la conexión WIFI y los datos para comunicarse con el servidor MQTT-Mosquitto implementado en el Raspberry. Revisar de ser necesario al sección Broker.
/* ESP8266 Sensor de Puerta. edelros@espol.edu.ec * 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 <PubSubClient.h> // WIFI: conexión a Router char* ssid = "xxxx"; char* password = "xxxx"; // MQTT: Servidor char* MQTT_IP = "192.168.xx.xx"; uint16_t MQTT_puerto = 1883; char* MQTT_usuario = "usuarioprueba"; char* MQTT_contrasena = "usuarioclave"; // MQTT: Dispositivo Interruptor char* MQTT_ID = "oficina_puerta1"; char* MQTT_TOPIC = "oficina/puerta1/estado"; char MQTT_SensorEstado[10] = "OFF"; volatile boolean mqtt_desconectado = true; char* sensor_ON = "ON"; char* sensor_OFF = "OFF"; // Sensor Interruptor const uint8_t sensor_pin = 1; volatile boolean sensor_estado = false; volatile boolean sensor_bandera = true; // Actuador LED volatile boolean actuador_estado = false; const uint8_t LED_actuador = 2; // LED monitor //interno: ESP01-pin=1, ESP07-pin=2 const uint8_t LED_pin=0; // Clientes WiFi y MQTT WiFiClient wifiClient; PubSubClient mqttclient(wifiClient); void setup() { // SENSOR Interruptor pinMode(sensor_pin, INPUT); attachInterrupt(digitalPinToInterrupt(sensor_pin),sensorActivado,CHANGE); // ACTUADOR LED pinMode(LED_actuador, OUTPUT); // 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() { // Revisa cambios en interruptor if (sensor_bandera){ delay(10); sensor_estado = digitalRead(sensor_pin); if (sensor_estado==LOW){ actuador_estado = true; } if (sensor_estado ==HIGH){ actuador_estado = false; } ACTUADORactivaestado(); publica_estado(); sensor_bandera = false; } yield(); // procesa wifi if (WiFi.status() != WL_CONNECTED){ inicia_wifi(); }else{ if (mqttclient.connected()==false){ mqtt_desconectado = true; inicia_mqtt(); // reintento } if (mqttclient.connected()==true){ if (mqtt_desconectado==true){ publica_estado(); mqtt_desconectado=false; } mqttclient.loop(); } } yield(); // procesa wifi } // ISR interrupción activada ICACHE_RAM_ATTR void sensorActivado(){ sensor_bandera = true; } // Actuador activar estado void ACTUADORactivaestado(){ if (actuador_estado){ // LED actuador ilumina en apagado digitalWrite(LED_actuador, HIGH); }else{ digitalWrite(LED_actuador, LOW); } } // Publicar el estado del dispositivo void publica_estado() { if (actuador_estado){ snprintf (MQTT_SensorEstado,10, sensor_ON); }else{ snprintf (MQTT_SensorEstado,10, sensor_OFF); } if (mqttclient.connected()==true){ mqttclient.publish(MQTT_TOPIC,MQTT_SensorEstado,true); }else{ mqtt_desconectado = true; } } void inicia_wifi(){ int intentos = 10; int cuenta = 0; WiFi.mode(WIFI_STA); WiFi.begin(ssid, password); while ((WiFi.status() != WL_CONNECTED) && (cuenta<intentos)){ cuenta = cuenta+1; // Parpadeo de Monitor enciende en LOW digitalWrite(LED_pin, LOW); delay(300); digitalWrite(LED_pin, HIGH); delay(200); } } void inicia_mqtt(){ int intentos = 2; int cuenta = 0; mqttclient.setServer(MQTT_IP, MQTT_puerto); mqttclient.connect(MQTT_ID, MQTT_usuario, MQTT_contrasena); while (!mqttclient.connected() && (cuenta<intentos)) { cuenta = cuenta + 1; // Parpadeo de Monitor enciende en LOW digitalWrite(LED_pin, LOW); delay(200); digitalWrite(LED_pin, HIGH); delay(200); } publica_estado(); }
El esquemático se divide en varias secciones mostradas en la figura y descritas a continuación.
El sensor es un interruptor magnético, de los que se usa en los sistemas de seguridad como sensor de puertas y ventanas.
Centrado en ESP8266-01 con conector para sensor. La activación del módulo se realiza de acuerdo a lo descrito en el manual del módulo. Revisar en la sección "Módulos" ESP8266 versión ESP-01.
El reinicio del dispositivo se controla con la botonera "Reset" al cambiar el pin a estado BAJO (GND). El estado predeterminado es ALTO por medio de R1 y C1 minimiza los rebotes del pulsador.
La operación predeterminada es "Ejecutar Programa" por medio de R3 hacia estado ALTO (pullup HIGH) y un jumper entre los Pines Sensor-RX. El Jumper conecta el Pin RXD a la entrada del sensor magnético.
Para tomar la lectura de estado del sensor, se usa el pin RX configurado como entrada y estado predeterminado en ALTO con R5. El capacitor C2 se usa para minimizar las señales de rebote que se presentan en los interruptores.
La carga de las instrucciones en archivo.ino se la realiza fuera de la placa mostrada.
La botonera Reset dispone de R1 hacia estado predeterminado ALTO y C1 se usa para minimizar los rebotes.
La configuración se completa manteniendo el estado de GPIO2 en estado ALTO (pullup HIGH) con R2 y el pin de CH_PD a estado ALTO mediante R4.
Conformada por el Regulador d 110VAC a 5VDC, y el Regulador de 5VDC a 3.3VDC usando el módulo AMS1117.
Los componentes usados o sus sus componentes alternos se describen en la sección de Fuentes de Alimentación para Módulos.
http://blog.espol.edu.ec/edelros/fuente-de-alimentacion-a-3-3vdc/
Para probar el circuito se ensambla en un protoboard teniendo como guía el diagrama del circuito del punto anterior.
Considere que como guía se incluye la parte de conexión AC. Se recomienda realizarla separada y tomando las precauciones de aislamiento que correspondan.
El diseño se ha realizado en dos placas por flexibilidad de ensamble. La placa de fuente de alimentación se puede reemplazar por un cargador USB, conectando a la primera placa del dispositivo a los conetores +5VDC-.
Para el archivo de producción de placa, escribir al email de contacto al final de la página.
Alternativas durante el proceso de desarrrollo
Durante el desarrollo del prototipo se usó una placas perforadas de circuito impreso de 4x6 cm.
Luego de algunas pruebas, se presenta la versión 2 del circuito impreso.
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.
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.
Referencia: MQTT, https://mqtt.org/ . Mosquitto, https://mosquitto.org/
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.
| 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-envía 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.
Los mensajes MQTT en los dispositivos tienen dos tipos de procesos:
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.
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.
| 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.
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.
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);
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.
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();
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.
El dispositivo inalámbrico se usa para registrar el estado abierto o cerrado de una puerta o ventana. 
Se conoce como sensor binario por determinar estados ON/OFF.
El dispositivo es de tipo inalámbrico-WIFI, usa protocolo MQTT para la comunicación con el broker y se implementa con ESP8266, en modalidad DIY (Do It Yourself).
En éste caso el diseño usa la versión ESP-01.
La versión 1 mostrada en la imagen se ha instalado en una puerta en una caja sobrepuesta plástica.
El sensor es un interruptor magnético y la alimentación se realiza con una fuente 110VAC a 5VDC obtenida de un cargador de celular (económico). Se ha usado una placa perforada para ensamblar el prototipo, sin embargo al final se presenta el diseño de la placa de circuito.
Una segunda versión en placa perforada, probando los espacios para el diseño de la PCB.
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 sensor puerta-ventana en el broker MQTT y observar los resultados.
Se plantea observar los estados del dispositivo en dos formas:
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 sensor, que en el caso del sensor de puerta ventana se clasifica como un sensor de dos estados (binary sensor).
El sensor trabaja con MQTT, se le asigna un nombre más sencillo de reconocer como "puerta oficina"y se complementa con la instrucción de identificación en el formato: lugar/cosa/estado.
mqtt:
- binary_sensor:
name: 'oficina_puerta1'
state_topic: "oficina/puerta1/estado"
expire_after: 10 # segundos, estado de NO disponible
Se graba el archivo, y se pasa al procedimiento de prueba desde la página de Home-Assistant, sección de
Herramientas para desarrolladores/Comprobar configuración
Si obtiene el resultado de:
¡La configuración no impedirá que se inicie Home Assistant!
caso contrario, revise nuevamente el archivo configuration.yaml
procede a la Recarga la configuración YAML
con el botón: ENTIDADES MQTT MANUALMENTE CONFIGURADAS
El resultado se observa desde una página en un navegador como se muestra en las figuras: para las posiciones de puerta cerrada y abierta
Observe el estado de la puerta y la gráfica mostrada en la pantalla del equipo.
Referencia: https://www.home-assistant.io/components/binary_sensor.mqtt/
Para monitorear señal desde consola Raspberry usando MQTT, usar la instrucción:
mosquitto_sub -h 192.168.10.100 -t oficina/puerta1/estado
Se observarán los valores de cambio de estado cada vez que se realice un cambio en el sensor.
