2.5 LoRa Multipunto: errores de recepción en Gateway

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.

https://cdn-learn.adafruit.com/downloads/pdf/dht.pdf

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»

remite,msjID,mensaje,estado,Rssi,Snr
d2,173,ON,1,-75,12

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

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

2.4 LoRa Multipunto: MQTT- HA

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.

light:
  - platform: mqtt
    name: 'invernaderoD1'
    state_topic: 'invernadero/loraD1/valor'
    command_topic: 'invernadero/loraD1/cambia'
    optimistic: false
  - platform: mqtt
    name: 'invernaderoD2'
    state_topic: 'invernadero/loraD2/valor'
    command_topic: 'invernadero/loraD2/cambia'
    optimistic: false

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.

type: entities
entities:
  - entity: light.invernaderod1
  - entity: light.invernaderod2

2.2 LoRa Multipunto-Dispositivo.ino

Para prueba del concepto, se realiza un dispositivo simplificado, un dispositivo que emite un «parpadeo» binario como estado de sensor.

El estado del sensor, indica con los símbolos 1 para un encendido y 0 para apagado. El parpadeo (blink) se realiza a intervalos de tiempo aleatorio entre 1 a 3 segundos.

Direccionamiento

El direccionamiento se realiza usando un numero 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 algorimo esta realizado para una placa de desarrollo LoRa, la disponible es de marca Heltec que ofrece librerías simplificadas.

Un siguiente paso es generalizar usando un módulo LoRa y un arduino Uno por ejemplo, realizado con librerías más generales.

Instrucciones en Arduino

/*
  Dispositivo Sensor Blink Parpadeo ON/OFF
  Red ruta: LoRa/WiFi/Ethernet
  Broker: MQTT/Home-Assistant
  edelros@espol.edu.ec
  http://blog.espol.edu.ec/edelros/
  Referencia: Ejemplos de Aaron.Lee www.heltec.cn
*/
#include "heltec.h"

// SENSOR Parpadeo
String sensorBlink = "ON"; // inicializa on/off: 1/0

//Banda LoRa - ISM en Región 915Mhz
#define BAND  915E6 // 433E6,868E6,915E6

// Mensaje a enviar por direcciones
byte dir_local   = 0xD1; // Dispositivo  1
byte dir_destino = 0xC1; // Concentrador 1
// identificador de mensaje
byte msjContador = 0;
// tiempo entre lecturas
long t_anterior = 0;
int  t_intervalo = 5000;

// Mensaje Recibido
byte dir_envio = 0xC1; // Concentrador 1
int dir_remite = 0xD0; // Inicia Remitente
String paqueteRcb = "";
byte   paqrcbvID = 0;
byte   paqrcbEstado = 0;
  // 0:vacio, 1: nuevo, 2:incompleto
  // 3:otro destinatario, 4:Broadcast

 // Mensajes por Puerto Serial
volatile boolean serial_msj = true;

void setup(){
  Heltec.begin(false /*DisplayEnable Enable*/,
    true /*Heltec.Heltec.Heltec.LoRa Disable*/,
    serial_msj /*Serial Enable*/,
    true /*PABOOST Enable*/,
    BAND /*long BAND*/);
  // ranges from 6-12,default 7 see API docs
  LoRa.setSpreadingFactor(8);

  //LoRa.onReceive(cbk);
  LoRa.receive();
  }

void loop(){
  // Enviar mensajes entre intervalos
  long t_ahora = millis();
  long t_transcurrido = t_ahora - t_anterior;

  // parametros de recepción
  int rssi_lora = 0;
  int snr_lora = 0;
  
  if (t_transcurrido >= t_intervalo){

    sensorParpadea(); //actualiza sensor
    
    String paqueteEnv = String(sensorBlink).c_str() ;
    enviarlora(dir_destino, dir_local,
               msjContador, paqueteEnv);
    msjContador = msjContador + 1;
    // parametros de recepción
    rssi_lora = LoRa.packetRssi();
    snr_lora = LoRa.packetSnr();
    yield();
    
    // mensaje a serial
    if (serial_msj==true){
      Serial.print(String(dir_destino,HEX));
      Serial.print(",");
      Serial.print(String(dir_local,HEX));
      Serial.print(",");
      Serial.print(msjContador);Serial.print(",");
      Serial.print(paqueteEnv);Serial.print(",");
      Serial.print(rssi_lora);Serial.print(",");
      Serial.println(snr_lora);
    }
    
    t_anterior = millis();
    t_intervalo = 3000 + random(2000);
    
    // LED parpadea envio lora
    digitalWrite(LED, HIGH); delay(100);
    digitalWrite(LED, LOW);  delay(100);
    yield(); // procesa wifi
  }

  // Revisar mensajes LoRa entrantes
  int msjRcbLoRa = LoRa.parsePacket();
  if (msjRcbLoRa !=0){
    recibirlora(msjRcbLoRa);
    rssi_lora = LoRa.packetRssi();
    snr_lora = LoRa.packetSnr();
    
    if (serial_msj==true){
      if (paqrcbEstado == 1){
        Serial.println("Mensaje: " + paqueteRcb);
        Serial.println("RSSI: " + String(rssi_lora));
        Serial.println("Snr: " + String(snr_lora));
        Serial.println();
      }else{
        Serial.print("Paquete recibido Estado: ");
        Serial.println(paqrcbEstado);
      }
    }
    yield(); // procesa wifi
    
    // LED parpadea Rebibido Lora
    digitalWrite(LED, HIGH); delay(50);
    digitalWrite(LED, LOW); delay(50);
    digitalWrite(LED, HIGH); delay(50);
    digitalWrite(LED, LOW);
  }
  delay(100);
  yield(); // procesa wifi
}

void enviarlora(byte destino, byte remite,
                byte paqueteID, String paquete){
  // espera que el radio esté listo
  // para enviar un paquete
  while(LoRa.beginPacket() == 0){
    if (serial_msj==true){
      Serial.println("Esperando radio disponible...");
    }
    yield(); // procesa wifi
    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();
}

void recibirlora(int tamano){
  if (tamano == 0){ 
    paqrcbEstado = 0; //vacio
    return;
    }
    
  // lectura de paquete
  paqueteRcb = "";
  dir_envio = LoRa.read();
  dir_remite  = LoRa.read();
  paqrcbvID = LoRa.read();
  byte paqrcbTamano = LoRa.read();
  while(LoRa.available()){
    paqueteRcb += (char)LoRa.read();
  }
  
  if (paqrcbTamano != paqueteRcb.length()){
    paqrcbEstado = 2; // Tamaño incompleto
    return;
  }
  if (dir_envio != dir_local){
    paqrcbEstado = 3; // otro destino
    return;
  }
  if (dir_envio == 0xFF) {
    paqrcbEstado = 4; // Broadcast
    return;
  }
  paqrcbEstado = 1;  // mensaje Nuevo
}

// Sensor Simulado
void sensorParpadea(){
    if (sensorBlink == "ON"){
      sensorBlink = "OFF";
    }else{
      sensorBlink = "ON";
    }
}

2.1 LoRa Multipunto-Esquema

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 o varios a varios.

Se usa un esquema simple de direcciones: «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 limitantes en la aplicació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 Gateway/Coordinador. La definición en este caso es semejante a otras redes inalámbricas, ej. Zigbee.

El dispositivo coordinador o gateway permitirá enviar el mensaje al broker.

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

 

 

2.3 LoRa Multipunto-Gateway.ino

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

Pruebas de Gateway Multipunto – Recepción

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

/* Dispositivo Gateway
  Lora/Wifi/MQTT/Home-Assistant
  Envia información por red Lora/Gateway WiFi
  hacia un broker MQTT y gestionar datos en Home-Assistant
  edelros@espol.edu.ec
  http://blog.espol.edu.ec/edelros/
  
  Referencia: Aaron.Lee www.heltec.cn
  https://github.com/Heltec-Aaron-Lee/WiFi_Kit_series
*/
#include "heltec.h"
#include <WiFi.h>
#include <PubSubClient.h>

// DISPOSITIVO LORA Banda ISM en Región 915Mhz
#define BAND  915E6 //433E6,868E6,915E6
// ranges from 6-12,default 7 see API docs
byte spread_factor = 8;

// LoRa Mensaje a enviar por direcciones
String paqueteEnv = "";
byte dir_local   = 0xC1; // Concentrador 1
byte dir_destino = 0xD1; // Dispositivo 1
byte msjContador = 0; // identificador de mensaje
// tiempo entre lecturas
long t_anterior = 0;
int  t_intervalo = 4000;

// LoRa Mensaje Recibido
byte dir_envio = 0xC1; // Concentrador 1
int dir_remite = 0xD0; // Inicia Remitente
String paqueteRcb = "";
byte   paqrcbID = 0;
byte   paqrcbEstado = 0;
  // 0:vacio, 1: nuevo, 2:incompleto
  // 3:otro destinatario, 4:Broadcast

 // Mensajes por Puerto Serial
volatile boolean serial_msj = true;

// 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 Sensor
char* MQTT_ID = "LoraGatewayC1";
char MQTT_TOPIC[50] = "invernadero/loraD1/valor";
char MQTT_SensorEstado[10] = "OFF";
volatile boolean mqtt_desconectado = true;
// MQTT: Dispositivo Actuador
char* MQTT_COMMAND = "invernadero/loraD1/cambia";
char MQTT_ActuadorEstado[10] = "OFF";
volatile boolean actuador_estado = false;
volatile 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.Heltec.Heltec.LoRa Disable*/,
    serial_msj /*Serial Enable*/,
    true /*PABOOST Enable*/,
    BAND /*long BAND*/);
  // ranges from 6-12,default 7 see API docs
  LoRa.setSpreadingFactor(spread_factor);
  
  //LoRa.onReceive(cbk);
  LoRa.receive();
  
  // conexión WIFI y MQTT
  inicia_wifi();
  if (WiFi.status() == WL_CONNECTED){
    inicia_mqtt();
    }
}

void loop(){
  // parametros de recepción
  int rssi_lora = 0;
  int snr_lora = 0;
  
  // Revisa mensajes LoRa entrantes
  int msjRcbLoRa = LoRa.parsePacket();
  if (msjRcbLoRa !=0){
    
    recibirlora(msjRcbLoRa);
    rssi_lora = LoRa.packetRssi();
    snr_lora = LoRa.packetSnr();
       
    if (serial_msj==true){
      Serial.println("remite,msjID,mensaje,estado,Rssi,Snr");
      Serial.print(String(dir_remite, HEX)); Serial.print(",");
      Serial.print(paqrcbID); Serial.print(",");
      Serial.print(paqueteRcb); Serial.print(",");
      Serial.print(paqrcbEstado); Serial.print(",");
      Serial.print(rssi_lora); Serial.print(",");
      Serial.println(snr_lora);
    }
    yield(); // procesa wifi
    
    // LED parpadea Rebibido Lora
    digitalWrite(LED, HIGH); delay(50);
    digitalWrite(LED, LOW); delay(50);
    digitalWrite(LED, HIGH); delay(50);
    digitalWrite(LED, LOW);
    yield(); // procesa wifi
    delay(100);
  }
  // Procesa a MQTT mensaje completo
  if (msjRcbLoRa !=0 && paqrcbEstado == 1){
    // procesa tópico MQTT
    String topico = "invernadero/lora";
    String remite = String(dir_remite, HEX);
    remite.toUpperCase();
    topico = topico + remite + "/valor";
    topico.toCharArray(MQTT_TOPIC,topico.length()+1);
    Serial.println(topico);
    publica_estado();
  }
  yield(); // procesa wifi
  delay(20);

  // reenviar a dispositivo
  if (actuador_bandera == true){
    msjContador = msjContador +1;
    enviarlora(dir_destino, dir_local, 
               msjContador, paqueteEnv);
    actuador_bandera = false;
  }
  yield(); // procesa wifi
  delay(20);
  
  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
}

void enviarlora(byte destino, byte remite,
                byte paqueteID, String paquete){
  // espera que el radio esté listo
  // para enviar un paquete
  while(LoRa.beginPacket() == 0){
    if (serial_msj==true){
      Serial.println("Esperando radio disponible...");
    }
    yield(); // procesa wifi
    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();
}

void recibirlora(int tamano){
  if (tamano == 0){ 
    paqrcbEstado = 0; //vacio
    return;
  }
    
  // lectura de paquete
  paqueteRcb = "";
  dir_envio = LoRa.read();
  dir_remite  = LoRa.read();
  paqrcbID = LoRa.read();
  byte paqrcbTamano = LoRa.read();
  while(LoRa.available()){
    paqueteRcb += (char)LoRa.read();
  }
  
  if (paqrcbTamano != paqueteRcb.length()){
    paqrcbEstado = 2; // Tamaño incompleto
    return;
  }
  if (dir_envio != dir_local){
    paqrcbEstado = 3; // otro destino
    return;
  }
  if (dir_envio == 0xFF) {
    paqrcbEstado = 4; // Broadcast
    return;
  }
  paqrcbEstado = 1;  // mensaje Nuevo
}

void inicia_wifi(void) {
  int intentoswifi = 10;
  int cuentawifi = 0;
  
  if (serial_msj){
    Serial.print(" WiFi Conectando a ");
    Serial.println(ssid);
    }
  
  WiFi.disconnect(true);
  delay(1000);
  WiFi.mode(WIFI_STA);
  WiFi.setAutoConnect(true);
  WiFi.begin(ssid,password);
  delay(100);
  
  while(WiFi.status() != WL_CONNECTED && 
             cuentawifi < intentoswifi){
    if (serial_msj){
      Serial.print(".");
      }
    cuentawifi = cuentawifi + 1;
    // Parpadeo de Monitor Wifi
    digitalWrite(LED, HIGH);delay(300);
    digitalWrite(LED, LOW);delay(200);
  }
  if (serial_msj){
    // mensaje a serial
    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();
    }
  }
}

void inicia_mqtt(void){
  int intentosmqtt = 5;
  int cuentamqtt = 0;
  
  if (serial_msj){
    Serial.print(" MQTT Conectando a ");
    Serial.println(MQTT_IP);
    }

  mqttclient.setServer(MQTT_IP, MQTT_puerto);
  mqttclient.connect(MQTT_ID, MQTT_usuario, MQTT_contrasena);
  mqttclient.setCallback(recibirmqtt);
  
  while (!mqttclient.connected() && (cuentamqtt<=intentosmqtt)) {
    if (serial_msj){
      Serial.print(".");
    }
    cuentamqtt = cuentamqtt + 1;
    // LED Monitor parpadeo MQTT
    digitalWrite(LED, HIGH); delay(200);
    digitalWrite(LED, LOW); delay(200);
  }
  if (mqttclient.connected()){
      publica_estado();
  }
  if (serial_msj){
    //Fin de "...."
    Serial.println();
    Serial.print(" MQTT Conectado: ");
    Serial.print(mqttclient.connected());
    Serial.print("\t MQTT Estado: ");
    Serial.println(mqttclient.state());
  }
}

void publica_estado() { 
  paqueteRcb.toCharArray(MQTT_SensorEstado,paqueteRcb.length()+1);
  if (mqttclient.connected()==true){
    mqttclient.publish(MQTT_TOPIC,MQTT_SensorEstado,true);
    mqttclient.subscribe(MQTT_COMMAND);
  }else{
    mqtt_desconectado = true;
  }
}

// llega mensaje MQTT, callback mqtt
void recibirmqtt(char* p_topic, byte* p_payload,
                  unsigned int p_length) {
  Serial.println("un mensaje mqtt");
  Serial.println(p_topic);
  // convierte a texto
  String payload;
  for (uint8_t i = 0; i < p_length; i++) {
    payload.concat((char)p_payload[i]);
    }
  // String dispositivo = p_topic[16] + String(p_topic[17]);
  char dispositivo[3] = "D0";
  dispositivo[1]=p_topic[17];
  dir_destino = (int) strtol(dispositivo,NULL,16);
  paqueteEnv = payload;
  actuador_bandera = true;

  if (mqttclient.connected()==true){
    mqttclient.subscribe(MQTT_COMMAND);
  }else{
    mqtt_desconectado = true;
  }
}