El sensor numérico más sencillo de implementar es temperatura-Humedad con el sensor DHT-11 o DHT-22. Un requerimiento para el dispositivo es operar a batería, con opción de carga con un panel solar.
El uso de la batería limita el consumo de energía, los módulos LoRa al ser de bajo consumo son los seleccionados.
El punto de partida es la configuración LoRa Multipunto, que modificando e valor del sensor enviado y los elementos correspondientes en MQTT, permite visualizar en la página del broker Home-assistant el valor del sensor.
El primer prototipo se realiza usando una placa de desarrollo Heltec Lora 32. EL punto de partida es LoRa multipunto añadiendo los siguientes componentes:
Sensor de Temperatura y Humedad DHT-11, puede ser actualizado a DHT-22 para mayor precisión. Se empieza con DHT-11 por tenerlo disponible al inicio.
Batería para añadir portabilidad
Panel solar para alimentación, usando un módulo de carga de batería.
Usando el ejemplo de comunicación multipunto, se revisa la secuencia de paquetes (msjID) enviada por cada uno de los nodos/dispositivos con mensajes que se envían con intervalos aleatorios entre [2-4 segundos].
La base de tiempo de 2 segundos se considera como tiempo que toma un sensor de temperatura DHT11 en dar una nueva lectura.
Para la lectura de los datos desde el gateway se usa la comunicación por puerto serial (USB). de los datos de cada mensaje se usa el identificador de mensaje (msjID) que indica el orden del mensaje enviado.
Ejemplo de mensaje obtenido por puerto serial desde el "gateway simple"
Usando como factor LoRa.setSpreadingFactor(8), se reduce la tasa de errores desde 0.36 en modo predeterminado de los dispositivos.
Ejemplo de resultados obtenidos.
ID [1 2]
cuenta [1879 1871]
errores [254 312]
increm [1 1]
antes [190 173]
%error [0.14 0.17]
Instrucciones en Python
# prueba de recepción de mensajes
# en Gateway LoRa mutipunto
# edelros@espol.edu.ec
import numpy as np
import serial, time
# INGRESO
puerto = 'com8'
baudios = 115200
n = 2
encabezado =['ID','cuenta',
'errores','increm',
'antes']
m = len(encabezado)
tabla = np.zeros(shape=(n+1,m),dtype=int)
d_error = np.zeros(n+1,dtype=float)
for f in range(1,n+1,1):
tabla[f,0]=f
# PROCEDIMIENTO
arduino = serial.Serial(puerto, baudios)
arduino.setDTR(False)
time.sleep(0.3)
# limpia buffer de datos anteriores
arduino.flushInput()
arduino.setDTR()
time.sleep(0.3)
print('\nEstado del puerto: ',arduino.isOpen())
print('Nombre del dispositivo conectado: ', arduino.name)
print('Dump de la configuración:\n ',arduino)
print('\n###############################################\n')
np.set_printoptions(precision=2)
# Lectura de datos
while True:
# espera hasta recibir un dato
while (arduino.inWaiting()==0):
pass
# lee binario del puerto serial
lectura = arduino.readline()
# binario a texto, elimina /r/n
texto = lectura.decode().strip()
print(texto)
tamano = len(texto)
if tamano>=3:
if (texto[0]=='d' and texto[2]==','):
partes = texto.split(',')
msjID = int(partes[0][1])
# incremento
antes = tabla[msjID,4]
ahora = int(partes[1])
tabla[msjID,4] = ahora
incremento = ahora - antes
tabla[msjID,3] = incremento
# cuenta
if antes>0 and incremento>0:
tabla[msjID,1]=tabla[msjID,1] + incremento
# error
if (tabla[msjID,1]>1 and incremento>1):
tabla[msjID,2] = tabla[msjID,2]+incremento-1
if (tabla[msjID,1]>0):
d_error[msjID]=float(tabla[msjID,2])/tabla[msjID,1]
for i in range(0,m,1):
print(encabezado[i]+"\t",tabla[1:,i])
print("%error \t",d_error[1:])
# Cerrar el puerto serial.
serial.Serial.close
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
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-
