Para visualizar los resultados en el broker Home-assistant, usando los valores del servidor MQTT, se añaden las siguientes lineas en el archivo configuration.yaml.
el ejemplo describe la configuración para dos dispositivos D1 y D2, con los valores de "ON" y "OFF".
Para la presentación en home-assistant, se añade una tarjeta de "entidades", indicando los elementos de cada sensor. Especificarlos como luz, permite disponer del estado "ON" y "OFF" junto al boton de control para encender y apagar.
El prototipo para un gateway simple se inicia con la función de recepción de mensajes que hay que procesar para enviarlos aun servidor MQTT. A partir de donde se gestionan los datos de los sensores.
Para el prototipo se usa placa de desarrollo que contiene: un módulo LoRa y un SoC ESP32. Si se reutiliza algunos componentes de algoritmos usados para los dispositivos con WiFi, la versión inicial se conecta un router IP via WiFi de donde se envia el mensaje MQTT.
El mensaje MQTT requiere la descripción de un tópico, por lo que en la conformación del tópico se usa la dirección de envío.
Los valores usados en el mensaje MQTT, son el estado del sensor u otro valor que se requiera. Para facilitar el seguimiento inicial de datos, se publica el identificador de mensaje, que es un contador ascendente que permite observar la secuencia del número de mensaje.
Gateway Multipunto - Recepción Lora y envío MQTT
Para el ejercicio se habilitan dos dispositivos "D1" y "D2", comprobando los mensajes recibidos de varias formas:
- mensajes por puerto serial - mensajes MQTT en servidor
Instrucciones en Arduino
Los bloques se crean a partir del ejemplo de LoRa Mutipunto para dispositivos, aprovechando que el módulo Heltec LoRa-ESP32 tiene incorporado WiFi. Aunque no se encuentran todos los canales disponibles al mismo tiempo para recibir todas las señales, se aprovecha que si el canal está libre se puede realizar la transmisión del estado del sensor desde LoRa hacia WiFi para llegar hasta el broker MQTT.
El ejercicio es una prueba de concepto, pues un gateway completo debe estar atento a todos los canales de transmisión y tener la capacidad de atención a cada uno de ellos simultáneamente.
Bloque principal
En el bloque principal se adjuntan los parámetros de conexión por WiFi, así como las instrucciones de inicio. Desde luego será necesario añadir los procedimientos de WiFi y MQTT.
/* Dispositivo Gateway: LoRa/WiFi/MQTT/Home-Assistant
* http://blog.espol.edu.ec/girni/lora-multipunto-esquema/
* Referencia: Aaron.Lee www.heltec.cn,
* https://github.com/Heltec-Aaron-Lee/WiFi_Kit_series
*/
#include "heltec.h"
#include <WiFi.h>
#include <PubSubClient.h>
// LoRa Banda ISM en Región 915Mhz
#define BAND 915E6 //433E6,868E6,915E6
byte spread_factor = 8; // rango 6-12,default 7
// Mensaje LoRa a enviar por direcciones
byte dir_local = 0xC1; // Dispositivo 1
byte dir_destino = 0xD1; // Dispositivo 2
byte id_msjLoRa = 0; // cuenta mensaje
String paqueteEnv = ""; // mensaje
// Mensaje LoRa recibido
byte dir_envio = 0xC1; // receptor
byte dir_remite = 0xD1; // emisor
String paqueteRcb = "OFF"; // mensaje LoRa
byte paqRcb_ID = 0;
byte paqRcb_Estado = 0;
// 0:vacio, 1: nuevo, 2:incompleto
// 3:otro destinatario, 4:Broadcast
// LED interno, ESP01-pin=1, ESP07-pin=2
int LED_pin = LED; //LED interno Heltec
// Mensajes por Puerto Serial
boolean serial_msj = true;
// tiempo entre lecturas
long tiempo_antes = 0;
int tiempo_intervalo = 6000;
long tiempo_espera = tiempo_intervalo + random(3000);
// 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 Sensor
char* MQTT_ID = "LoraGatewayC1";
String topico_base = "invernadero/lora";
String topico_valor = "/valor";
char MQTT_TOPIC[50] = ""; // construido en algoritmo
char MQTT_SensorEstado[10] = "OFF";
boolean mqtt_desconectado = true;
// MQTT: Dispositivo Actuador
String topico_accion = "/cambia";
char MQTT_COMMAND[50] = "";
char MQTT_ActuadorEstado[10] = "OFF";
boolean actuador_estado = false;
boolean actuador_bandera = false;
char* sensor_ON = "ON";
char* sensor_OFF = "OFF";
// Clientes WiFi y MQTT
WiFiClient wificlient;
PubSubClient mqttclient(wificlient);
void setup(){
Heltec.begin(false /*DisplayEnable Enable*/,
true /*Heltec.LoRa Disable*/,
serial_msj /*Serial Enable*/,
true /*PABOOST Enable*/,
BAND /*long BAND*/);
LoRa.setSpreadingFactor(spread_factor);
//LoRa.onReceive(cbk);
LoRa.receive();
inicia_wifi(); // conexión WIFI y MQTT
if (WiFi.status() == WL_CONNECTED){
inicia_mqtt();
}
}
void loop(){
// LoRa Revisa mensajes de dispositivos
int msjRcbLoRa = LoRa.parsePacket();
if (msjRcbLoRa !=0){
recibe_lora(msjRcbLoRa);
int rssi_lora = LoRa.packetRssi();
int snr_lora = LoRa.packetSnr();
if (serial_msj==true){
if (paqRcb_Estado == 1){
Serial.print("Recibido: ");
Serial.print(String(dir_remite,HEX));Serial.print(",");
Serial.print(String(dir_envio,HEX)); Serial.print(",");
Serial.print(paqRcb_ID); Serial.print(",");
Serial.print(paqueteRcb); Serial.print(",");
Serial.print(rssi_lora); Serial.print(",");
Serial.print(snr_lora); Serial.print(",");
Serial.println();
}else{
Serial.print("Paquete recibido Estado: ");
Serial.println(paqRcb_Estado);
}
}
// LED parpadea. Rebibido LoRa
digitalWrite(LED, HIGH); delay(50);
digitalWrite(LED, LOW ); delay(50);
digitalWrite(LED, HIGH); delay(50);
digitalWrite(LED, LOW );
}
// MQTT publica estado recibido desde LoRa
if (msjRcbLoRa !=0 && paqRcb_Estado == 1){
if (mqttclient.connected()==true){
publica_mqtt();
}
}
// LoRa Reenvia a dispositivo
if (actuador_bandera == true){
id_msjLoRa = id_msjLoRa +1;
envia_lora(dir_destino, dir_local,
id_msjLoRa, paqueteEnv);
actuador_bandera = false;
}
// Revisa estado WiFi y MQTT
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_mqtt();
mqtt_desconectado=false;
}
mqttclient.loop();
}
}
delay(100);
}
LoRa - envío de mensajes
void envia_lora(byte destino, byte remite,
byte paqueteID, String paquete){
// espera radio para enviar un paquete
while(LoRa.beginPacket() == 0){
if (serial_msj==true){
Serial.println("Esperando radio disponible...");
}
delay(100);
}
// envio del mensaje LoRa
LoRa.beginPacket();
LoRa.write(destino);
LoRa.write(remite);
LoRa.write(paqueteID);
LoRa.write(paquete.length());
LoRa.print(paquete);
LoRa.endPacket();
}
Para prueba del concepto, se implementa un dispositivo simplificado, un dispositivo que emite un "parpadeo" binario como estado de sensor.
Estado del sensor
El estado del sensor se indica con los valores "ON" encendido y "OFF" para apagado. El parpadeo se realiza a intervalos de tiempo de duración aleatoria entre 1 a 3 segundos.
Direccionamiento
El direccionamiento se realiza usando un número hexadecimal almacenado en un byte. Por facilidad de identificación, se usa como dirección :
Dispositivo usa "D1" por la inicial, los otros dispositivos serán "D2","D3", etc.
gateway usa la dirección "C1" cuya inicial es de Concentrador o coordinador, nombre también usado en otras tecnologías.
El algoritmo esta realizado para una placa de desarrollo LoRa, la disponible es de marca Heltec LoRa ESP32 que ofrece librerías simplificadas. Un siguiente paso de desarrollo consiste en usar un módulo LoRa y un Arduino Uno por ejemplo, realizado con librerías más generales.
Instrucciones
Las instrucciones de dividen en el bloque principal, el procedimiento de sensor, y los procedimientos LoRa para envío y recepción, separados en cada pestaña.
Bloque principal
Declara las librerías para el módulo o placa de desarrollo Heltec, se indica los parámetros LoRa como la Banda ISM que para Ecuador es US915, también se establecen las variables para el manejo de los mensajes de envío y recepción, tiempo de lecturas del sensor "simulado" para la prueba.
El bucle de configuración setup() inicializa el módulo y el de operación loop() revisa los tiempos en los que se debe realizar la lectura del sensor y el envío del mensaje LoRa. Luego revisa si se ha recibido un mensaje LoRa para mostrarlo en la ventana del "monitor serie".
/* Dispositivo Sensor Blink Parpadeo ON/OFF
* http://blog.espol.edu.ec/girni/lora-multipunto-esquema/
* Referencia: Ejemplos de Aaron.Lee www.heltec.cn
*/
#include "heltec.h"
// LoRa Banda ISM en Región 915Mhz
#define BAND 915E6 // 433E6,868E6,915E6
byte spread_factor = 8; // rango 6-12,default 7
// Mensaje LoRa a enviar por direcciones
byte dir_local = 0xD1; // Dispositivo 1
byte dir_destino = 0xC1; // Dispositivo 2
byte id_msjLoRa = 0; // cuenta mensaje
String paqueteEnv= ""; // mensaje
// Mensaje LoRa recibido
byte dir_envio = 0xD1; // receptor
byte dir_remite = 0xC1; // emisor
String paqueteRcb = ""; // mensaje LoRa
byte paqRcb_ID = 0;
byte paqRcb_Estado = 0;
// 0:vacio, 1: nuevo, 2:incompleto
// 3:otro destinatario, 4:Broadcast
// Mensajes por Puerto Serial activa
boolean serial_msj = true;
// SENSOR Parpadeo
String sensorEstado = "ON"; // ON/OFF: 1/0
// tiempo entre lecturas
long tiempo_antes = 0;
long tiempo_intervalo = 6000;
long tiempo_espera = tiempo_intervalo + random(3000);
void setup(){
Heltec.begin(false /*DisplayEnable Enable*/,
true /*Heltec.Heltec.Heltec.LoRa Disable*/,
serial_msj /*Serial Enable*/,
true /*PABOOST Enable*/,
BAND /*long BAND*/);
LoRa.setSpreadingFactor(spread_factor);
//LoRa.onReceive(cbk);
LoRa.receive();
}
void loop(){
int rssi_lora = 0; // nivel de señal
int snr_lora = 0;
// Enviar mensajes entre intervalos
long tiempo_ahora = millis();
long t_transcurrido = tiempo_ahora - tiempo_antes;
if (t_transcurrido >= tiempo_espera){
sensor_revisa(); //actualiza sensor
paqueteEnv = String(sensorEstado).c_str() ;
envia_lora(dir_destino, dir_local,
id_msjLoRa, paqueteEnv);
id_msjLoRa = id_msjLoRa + 1;
// mensaje a serial monitor
if (serial_msj == true){
Serial.print("Enviado: ");
Serial.print(String(dir_local,HEX));
Serial.print(",");
Serial.print(String(dir_destino,HEX));
Serial.print(",");
Serial.print(id_msjLoRa-1);
Serial.print(",");
Serial.println(paqueteEnv);
}
tiempo_antes = millis();
tiempo_espera = tiempo_intervalo + random(3000);
// LED parpadea. Envio LoRa
digitalWrite(LED, HIGH); delay(100);
digitalWrite(LED, LOW ); delay(100);
}
// Revisar mensajes LoRa entrantes
int msjRcbLoRa = LoRa.parsePacket();
if (msjRcbLoRa !=0){
recibe_lora(msjRcbLoRa);
rssi_lora = LoRa.packetRssi();
snr_lora = LoRa.packetSnr();
if (serial_msj == true){
if (paqRcb_Estado == 1){
Serial.print("Recibido: ");
Serial.print(String(dir_remite,HEX));
Serial.print(",");
Serial.print(String(dir_envio,HEX));
Serial.print(",");
Serial.print(paqRcb_ID); Serial.print(",");
Serial.print(paqueteRcb); Serial.print(",");
Serial.print(rssi_lora); Serial.print(",");
Serial.print(snr_lora); Serial.print(",");
Serial.println();
}else{
Serial.print("Paquete recibido Estado: ");
Serial.println(paqRcb_Estado);
}
}
// LED parpadea Rebibido Lora
digitalWrite(LED, HIGH); delay(50);
digitalWrite(LED, LOW ); delay(50);
digitalWrite(LED, HIGH); delay(50);
digitalWrite(LED, LOW );
}
delay(100);
}
Procedimiento de envío de paquete LoRa
Se toman los valores para destino, remitente, identificador de paquete y el mensaje o paquete a enviar, para realizar el paso de envio del mensaje con la instrucción LoRa.write().
void envia_lora(byte destino, byte remite,
byte paqueteID, String paquete){
// espera radio para enviar un paquete
while(LoRa.beginPacket() == 0){
if (serial_msj==true){
Serial.println("Esperando radio disponible...");
}
delay(100);
}
// envio del mensaje LoRa
LoRa.beginPacket();
LoRa.write(destino);
LoRa.write(remite);
LoRa.write(paqueteID);
LoRa.write(paquete.length());
LoRa.print(paquete);
LoRa.endPacket();
}
Procedimiento de recepción de paquete LoRa
Para recibir un paquete LoRa se procede en el mismo orden realizado para el envío, es decir primero se recibe la dirección de envío, la dirección del remitente, el identificador del mensaje, tamaño del mensaje en bytes, todo lo que viene luego es el mensaje transmitido.
Luego se revisa el tamaño del paquete recibido y se compara con el valor de la variable de tamaño del mensaje. Esto permite validar si el mensaje se ha recibido completo o requiere alguna retransmisión.
En el ejercicio el procedimiento para el sensor consiste en altenar los valores entre encendido y apagado, el valor cambia cada vez que se use el procedimiento sensor_revisa()
Para realizar pruebas punto a punto, es necesario usar todas las instrucciones anteriores y cambiar solamente la dirección local y destino del mensaje y en el bloque principal siguiendo el esquema:
En el caso de recepción, los valores se actualizan en el procedimiento, dado que las direcciones son parte de la trama de datos, por lo que los valores declarados son solo referenciales.
Con lo que se pueden intercambiar mensajes entre dispositivos, modalidad punto a punto, obteniendo el siguiente resultado si están conectados las dos placas de desarrollo.
El esquema básico de comunicación de mensajes en los ejemplos es de punto a punto.
El siguiente nivel de comunicación es a varios dispositivos donde se requiere identificación o dirección del cada dispositivo.
En comunicación multipunto, la dirección (local y destino) permite identificar al emisor y receptor. Con las direcciones se pueden enviar mensajes entre dispositivos: uno a uno, uno a varios.
Se usa un esquema simple de direcciones en hexadecimal con la nomenclatura:
- "D#" para dispositivos y - "C#" para concentradores o gateways en la red,
El símbolo "#" indica el número de dispositivo en la red. La dirección es numérica Hexadecimal donde se aprovecha los símbolos "D" y "C" para simplificar la asignación de direcciones en los prototipos, no es un limitante en la aplicación solo una forma didáctica de facilitar la identificación.
Una vez establecida la comunicación multipunto, el siguiente paso es conectar la red LoRa a otras redes, por lo que se designa un elemento de red como Gateway/Coordinador. La definición en este caso es semejante a otras redes inalámbricas como lo usado en Zigbee.
El dispositivo coordinador o gateway si es un módulo LoRa ESP32, permitirá enviar el mensaje por la red WiFi al broker. El formato del mensaje a emplear es MQTT aprovechando los conceptos descritos para dispositivos con WiFi.
El broker recibe los mensajes en MQTT y los gestiona con Home-Assistant. A partir de aquí, los datos se pueden visualizar en una página web (local o en nube).
en caso de existir otra dirección previa, se añade con una coma ‘,’
1.2. En el menú de Herramientas, Placas, Gestor de tarjetas, se añade “Heltec ESP32 Series Dev-boards”
Para facilitar la búsqueda de indica "Heltec" en la casilla y se procede a instalar la placa:
1.3. con lo que es posible usar las placas Heltec Lora con ESP32, seleccione el modelo que dispone para las pruebas. Recuerde seleccionar "LoRaWan Region" que para Ecuador es US915 que es la frecuencia de operación para el módulo.
2. Librerías
2.1 Librerías básicas
Las librerías se instalan en el menú «Programa/Incluir Librería/ Administrar Bibliotecas».
descargar la correspondiente para Heltec LoRa ESP32
Con lo que se pueden usar las librerías y ejemplos proporcionados para el modelo de placas de desarrollo.
2.2 Librerías para LoraWAN- descargando librería
Una alternativa para instalar las librerías en caso de no poder usar la anterior se usa la descarga del archivo libreria.zip desde el repositorio:
Añadir el archivo descargado a la librerías del IDE Arduino en el menú Programa/incluir_Librería/Añadir_biblioteca_.ZIP
Al añadir la librería se puede observar que se encuentra instalada usando el menú Programa/incluir_Librería/ Administrar Bibliotecas.
con esta acción es posible usar la librería mediante la instrucción:
#include<ESP32_LoRaWAN.h>
3. Identificador de Dispositivo- Chip-ID
Con la librería descargada en el paso anterior, se puede obtener el identificador de dispositivo Chip ID que también es la dirección física MAC.
Con éste número, también se genera un código de licencia que se valida en la librería Heltec al usar el módulo o placa de desarrollo.
int64_tchipid;voidsetup(){Serial.begin(115200);}voidloop(){//The chip ID is essentially its MAC address(length: 6 bytes).chipid=ESP.getEfuseMac();Serial.printf("ESP32 Chip ID = %04X",(uint16_t)(chipid>>32));//High 2 bytesSerial.printf("%08X\n",(uint32_t)chipid);// Low 4bytes.delay(3000);}
Recuerde hay que realizar este paso para cada módulo, es identificador que debe conservar para usar ese módulo específico.
El resultado depende de cada módulo, pero es semejante al siguiente:
ESP32 Chip ID = 8070AF286F35
ESP32 Chip ID = 8070AF286F35
Se puede usar los módulos LoRa emparejados con ESP32 como microcontrolador.
Aportan conexión a WIFI y viene en varias configuraciones, lo más relevante es que traen antenas de 915MHz
El módulo de desarrollo facilita realizar pruebas con tan solo unos cuantos elementos, tiene conexión USB para programación o acceso de datos y una pequeña pantalla para visualizar mensajes de estado.
Otro modelo del mismo fabricante es el Wireless-Stick-Lite que es muy semejante al anterior, pero no incorpora la pantalla OLED.
https://heltec.org/project/wireless-stick-v3/
2. Módulos Lora - Gateway
Los módulos para gateway permiten operar simultáneamente con varios canales, requieren añadir un controlador implementado con un Raspberry Pi. Se pueden usar para conectarse a un gestor de gateways, por ejemplo TTN o uno implementado de forma privada con elementos abiertos como ChirpStack.
La cobertura de los dispositivos IOT con un rango mayor al alcance con WiFi se logra al cambiar o incorporar otra red inalámbrica para implementación, por ejemplo LoRa.
La selección de tecnología LoRa responde al esquema de trabajo de Hardware y Software Abierto, la disponibilidad de componentes, que son la base para plantear esquemas de prueba de concepto, entrenamiento y desarrollo DIY.
De tener en operación la gestión de datos con un servidor MQTT y Home-Assistant, la integración con esta plataforma abierta simplifica los pasos al considerarse una extensión de lo implementado con redes locales con cobertura WiFi.
El uso de una plataforma abierta permite personalizar los dispositivos a requerimientos nuevos.
En el caso de solo realizar la conexión con "pocos" dispositivos, se puede recurrir a una conexión multipunto con LoRa. El esquema de integración simplificado se muestra en al figura.
Esquema LoRa: Dispositivo y Gateway Básico
La comunicación entre dispositivos y broker se simplifica considerando que:
Dispone de módulos Lora y/o Placas de Desarrollo
Implementa prototipos para una etapa inicial, no dispone de un gateway comercial y no requiere acceso directo a internet
Simplifica el esquema de comunicación entre pocos dispositivos, basado en direccionamiento
Interactúa con el Broker mediante MQTT, usando la red Ethernet o Wifi
En las siguientes secciones se describe en detalle los componentes básicos que se van implementando.
Esquema LoRaWAN
En caso de requerir una cobertura mayor se amplia el esquema para usar LoRaWAN e incorporar un LoRa Mini Gateway también en esquema abierto con ChirpStack. como gestor de Gateways-
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 Pi.
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:
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".
Como la versión del ESP8266-01 no dispone de muchos pines de trabajo, se define el uso de los pines como:
monitor de operación del dispositivo: LED interno, GPIO1 (TXD)
control Actuador en GPIO2, pin 3, que es usado para la modo de operación al iniciar el dispositivo. Luego de iniciado se lo puede reconfigurar.
Por el uso en operación de los pines de comunicación Serial (GPIO1 y GPIO3) se descartan las lineas Serial.print() convirtiéndolas 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.
2. Funciones repetitivas
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.
2.1 función para actuador
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 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 para 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 toma-corriente. Por ejemplo las lámparas de Jardín, Patio, balcón, etc.
Es dispositivo es la introducción para desarrollar actuadores, se utiliza toma-corriente único considerando las limitaciones de los pines en el módulo ESP-01.
De utilizar dos toma-corrientes independientes en la 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 re-configurar por software una vez iniciado el módulo en modo de operación. Sin embargo, al iniciar 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 toma-corriente.
2. Esquemático con ESP01
El esquemático se divide en varias secciones mostradas en la figura y descritas a continuación.
2.1 Actuador
Para controlar el estado de un toma-corriente 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.
2.2 Controlador
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.
2.3 Fuente DC
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.
3. Ensamble en Protoboard
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 consideró pasar al siguiente dispositivo, al combinar un interruptor con un toma-corriente que requieren un sensor y un actuador para trabajar en conjunto.
4. Circuito impreso – PCB
Una PCB de 4.5x4.5cm ocupa el menor espacio posible considerando el tamaño de los componentes.
Una Placa perforada de 5x7cm dispone de suficiente espacio para las partes distribuidas.
Es la versión simplificada del prototipo de interruptor que controla un toma-corriente o foco.
