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

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

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

LoRa - Recibe mensajes

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

MQTT- inicia

void inicia_mqtt(void){
  int esperamqtt = 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(recibe_mqtt);
  
  while (!mqttclient.connected() && (cuentamqtt<=esperamqtt)) {
    cuentamqtt = cuentamqtt + 1;
    if (serial_msj){
      Serial.print(".");
    }
    // LED Monitor parpadeo MQTT
    digitalWrite(LED_pin, HIGH); delay(200);
    digitalWrite(LED_pin, LOW);  delay(200);
  }
  
  if (mqttclient.connected()){
    // publica_mqtt();
    // suscribe a todos los topicos base
  }
  
  if (serial_msj){
    //Fin de "...."
    Serial.print("\n MQTT Conectado: ");
    Serial.print(mqttclient.connected());
    Serial.print("\t Estado: ");
    Serial.println(mqttclient.state());
  }
}

MQTT- publica mensaje

void publica_mqtt() { 
  paqueteRcb.toCharArray(MQTT_SensorEstado,
                         paqueteRcb.length()+1);

  // MQTT Construye tópico por remitente
  String remite = String(dir_remite, HEX);
  remite.toUpperCase();
  String topico = topico_base + remite + topico_valor;
  topico.toCharArray(MQTT_TOPIC,topico.length()+1);
  if (serial_msj==true){
    Serial.print("  ");
    Serial.print(topico); Serial.print("/");
    Serial.println(MQTT_SensorEstado);
  }
  // MQTT Construye tópico por remitente
    String topico_cmd = "";
    topico_cmd += topico_base + remite +"/cambia";
    topico_cmd.toCharArray(MQTT_COMMAND,topico_cmd.length()+1);
    if (serial_msj==true){
      Serial.print("  sucrito: ");
      Serial.println(MQTT_COMMAND);
    }
    
  if (mqttclient.connected()==true){
    mqttclient.publish(MQTT_TOPIC,MQTT_SensorEstado,true);
    mqttclient.subscribe(MQTT_COMMAND);
  }else{
    mqtt_desconectado = true;
  }
}

MQTT- Recibe mensaje

// llega mensaje MQTT, callback mqtt sin confirmación
void recibe_mqtt(char* p_topic, byte* p_payload,
                  unsigned int p_length) {
  if (serial_msj){
    Serial.println("Recibe 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]);
    }
  paqueteEnv = payload;
  
  // direccion destino
  char dispositivo[3] = "D0";
  int desde = topico_base.length();
  dispositivo[0] = p_topic[desde];
  dispositivo[1] = p_topic[desde+1];
  dir_destino = (int) strtol(dispositivo,NULL,16);

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

WiFi - inicio

void inicia_wifi(void) {
  int esperawifi = 10;  // >=10 para conectar
  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 < esperawifi)){
    cuentawifi = cuentawifi + 1;
    if (serial_msj){
      Serial.print(".");
    }
    // Parpadeo de Monitor Wifi
    digitalWrite(LED_pin, HIGH); delay(300);
    digitalWrite(LED_pin, LOW);  delay(200);
  }
  
  if (serial_msj){
    // mensaje a serial, Fin de "..."
    Serial.println();
    if (WiFi.status() == WL_CONNECTED){
      Serial.print(" Estado: ");
      Serial.println(WiFi.status());
      Serial.print(" MAC: ");
      Serial.println(WiFi.macAddress());
      Serial.print(" IP: ");
      Serial.println(WiFi.localIP());
      Serial.print(" RSSI: ");
      Serial.println(WiFi.RSSI());
      Serial.println();
    }
    if (WiFi.status() != WL_CONNECTED){
        WiFi.printDiag(Serial);
        Serial.println();
    }
  }
}

.

Referencia: https://github.com/Heltec-Aaron-Lee/WiFi_Kit_series

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.

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

Procedimiento para el sensor

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

// Sensor Simulado
void sensor_revisa(){
    if (sensorEstado == "ON"){
      sensorEstado = "OFF";
    }else{
      sensorEstado = "ON";
    }
}

Para subir todas las instrucciones recuerde primero seleccionar la placa de desarrollo correspondiente y verificar el puerto com al que se conecta

Resultados en monitor serie

El resultado observable en monitor serie es semejante al mostrado:

Serial initial done
LoRa Initial success!
Enviado:  d1,c1,0,OFF
Enviado:  d1,c1,1,ON
Enviado:  d1,c1,2,OFF
Enviado:  d1,c1,3,ON

Pruebas punto a punto

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:

// LoRa envia paquete, direccion, contador
byte dir_local    = 0xC1; // Dispositivo 1
byte dir_destino  = 0xD1; // Dispositivo 2

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.

// LoRa recibe paquete
byte dir_envio  = 0xC1;  // receptor
byte dir_remite = 0xD1;  // emisor

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

Referencia: https://www.semtech.com/lora/what-is-lora