3.1 LoRa Temperatura-Humedad

Presentación

El sensor numérico más sencillo de implementar es del de temperatura-Humedad con el DHT-11 o DHT-22.

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.

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

1. LoRa – Integración con broker MQTT-HA

La cobertura de los dispositivos con un rango mayor a WiFi se logra al cambiar o incorporar otro de red inalambrica para implementación por ejemplo LoRa.

La selección de tecnología LoRa responde al esquema de trabajo de Hardware y Software Abierto, disponibilidad de componentes, como base para plantear esquemas de prueba de concepto, entrenamiento y desarrollo.

https://www.semtech.com/lora/why-lora

Al tener en operación la gestión de datos con un servidor MQTT y Home-Assistant, la integración con esta plataforma abierta simplifica la implementación.

El uso de una plataforma abierta permite personalizar los dispositivos a requerimientos nuevos. 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.

Referencias:

https://lora-developers.semtech.com/

 

3.5 Interruptor-Tomacorriente: Esquemático ESP01-Config

También posible construir una placa con los elementos necesarios para controlar el modo de operación del Módulo ESP-01 por medio de un DIP-Switch:

  • Modo Operación:  DIP-switch en 0111
  • Modo Programación: DIP-Switch en 1000

La operación es semejante al presentado en ésta sección, la diferencia es que no se requiere retirar el ESP01 de la placa. De ésta manera no se requiere retirar el módulo ESP-01 de la placa para realizar la carga del archivo.ino con la programación con un USB-TTL.

1. Esquemático con ESP01

2. Ensamble en Protoboard

3. Circuito impreso – PCB

4. Implementación en Placa perforada

Realizado para verificar las dimensiones y espacio usados en el diseño de la PCB. La versión es previa a la mostrada en la sección 3.

 

ESP8266 Conexión WiFi-MQTT

La conexión de un módulo ESP8266 a un «broker Mosquitto» se puede describir como una conversación en la que se habla (publish) y escucha (subscribe). En la conversación hay un intermediario (broker) que gestiona los mensajes, recibe mensajes de actualización de estados (publish) y los re-envía a los subscriptores.

Para la conexión a un broker MQTT, se supondrá que ya ha dispone de un servidor MQTT en forma básica, semejante a la descrita en la sección «Broker-MQTT Mosquitto instalar».

http://blog.espol.edu.ec/edelros/3-mqtt-mosquitto-instalar/

Adicionalmente, ya ha establecido la conexión a la red WiFi semejante al ejemplo del siquiente enlace.

http://blog.espol.edu.ec/edelros/esp8266-conexion-wifi/

Verificada la conexión a la red WiFi, se procede describir el proceso de conexión al broker MQTT,

Instrucciones en Arduino IDE

Se inicia con las librerias para la conexión WiFi, y comunicación MQTT.

#include <ESP8266WiFi.h>
#include <PubSubClient.h>

Datos MQTT- servidor

Para establecer la conexión con el broker, se requieren la dirección IP, usuario y contraseña MQTT.

Actualice los datos correspondientes a la configuración de su broker.

// MQTT: Servidor
char* MQTT_IP = "192.168.xxx.xxx";
uint16_t MQTT_puerto = 1883;
char* MQTT_usuario = "usuarioprueba";
char* MQTT_contrasena = "usuarioclave";

Datos MQTT-dispositivo

Para cada dispositivo se asigna un identificador, tópico, instrucción de activación (command) y los valores de estado posibles. Ejemplo: ON, OFF.

// MQTT: Dispositivo Actuador Luz
char* MQTT_ID = "oficina_luz1";
char* MQTT_TOPIC = "oficina/luz1/estado";
char* MQTT_COMMAND = "oficina/luz1/cambia";
char MQTT_ActuadorEstado[10] = "OFF";

char* sensor_ON  = "ON";
char* sensor_OFF = "OFF";

Activar los clientes WiFi y MQTT

// Clientes WiFi y MQTT
WiFiClient wifiClient;
PubSubClient mqttclient(wifiClient);

Configuración de inicio

Para el bloque de configuración (setup) se verifica el estado de la conexión WiFi antes de intentar conectarse al broker MQTT-Mosquitto.

Para revisar el proceso por medio del monitor serie de Arduino IDE, se establece la variable serial_msg=true. Si los pines Tx-Rx se encuentran ocupados como entrada o salida, serial_msg=false para evitar conflictos entre mensajes y valores del proceso.

  // conexión WIFI y MQTT
  inicia_wifi(serial_msg);
  if (WiFi.status() == WL_CONNECTED){
    inicia_mqtt(serial_msg);
    }

La subrutina de inicio se resume en establecer los valores de servidor, la conexión y la interpretación de instrucción recibida (callback). Al establecer la conexión se procede a publicar el estado del dispositivo.

void inicia_mqtt(boolean SerialMensajes){
  int intentos = 5;
  int cuenta = 0;
  
  if (SerialMensajes){
    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(callback);
  
  while (!mqttclient.connected() && (cuenta<=intentos)) {
    if (SerialMensajes){
      Serial.print(".");
    }
    cuenta = cuenta + 1;
    // LED Monitor parpadeo MQTT, enciende LOW
    digitalWrite(LED_pin, LOW);
    delay(600);
    digitalWrite(LED_pin, HIGH);
    delay(400);
    }
  if (mqttclient.connected()){
      publica_estado();
  }
  if (SerialMensajes){
    //Fin de "...."
    Serial.println();
    Serial.print(" MQTT Conectado: ");
    Serial.println(mqttclient.connected());
    Serial.print(" MQTT Estado: ");
    Serial.println(mqttclient.state());
    }
  }

Publicación, subscripción y Recepción de intrucción

Estas operaciones se deben personalizar para cada caso. Las siguientes partes se presentan como ejemplo, donde se deben seleccionar los tópicos, valores, comándos y actualizarlos para la aplicación específica que se encuentre desarrollando.

Publicación o Subscripción de estados

La publicación de estados y subscripción se realiza como una función.

// 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);

Recibir una Instrucción (callback)

Para recibir una instrucción (command) se procesa mediante la función «callback», que consiste en analizar  la instrucción y el valor recibidos con los parámetros del dispositivo para establecer la acción a seguir en el dispositivo (actuador).

/ llega mensaje MQTT
void callback(char* p_topic, byte* p_payload, unsigned int p_length) {
  // procesa valor de cambio a texto
  String valor;
  for (uint8_t i = 0; i < p_length; i++) {
    valor.concat((char)p_payload[i]);
    }
  // compara mensaje recibido y actualiza estado
  if (String(MQTT_COMMAND).equals(p_topic)) {
    if (valor.equals(String(sensor_ON))) {
      if (actuador_estado != true) {
        actuador_estado = true;
        }
      }
    if (valor.equals(String(sensor_OFF))) {
      if (actuador_estado != false) {
          actuador_estado = false;
        }
      }
    LEDactivaestado();
    ACTUADORactivaestado();
    publica_estado();
    }
    if (serial_msg){
      Serial.println(" MQTT recibido ");
      Serial.print(MQTT_COMMAND);
      Serial.print(" ");
      Serial.println(valor);
    }
  }

ESP8266 Conexión WiFi

Prueba básica de conexión a WiFi, para el ejemplo se presenta con módulo ESP-01 y conexión con un USB-TTL. La conexión a otros módulos es semejante en el uso de los pines de configuración.

El ejemplo, el módulo en operación  realiza un parpadeo de un LED por un segundo (1000 ms). mientras que para el modo de conexión realiza parpadeos más rápido s(250ms).

Esquematico

La alimentación del circuito  mostrada sigue las indicaciones de la sección: Fuente de alimentación 3.3VDC

El control para el modo de «operación/Programación» y «reset» se implementa por medio de botoneras. El modo predeterminado de inicio es «operación»  por medio de  GPIO0 a estado +VCC (HIGH) con una resistencia (pullup), al  presionar la botonera se cambia el estado a GND (LOW).

Para programar se presiona la botonera «programar» y luego un pulso de «reset», el módulo está listo para «subir» instrucciones desde IDE Arduino.

Para referencia se muestran las conexiones usando un protoboard.

Instrucciones en Arduino IDE

Se usa la libreria < ESP8266WiFi.h> personalizada para los módulos ESP8266, permite obtener datos como MAC, IP, RSSI, y algunos valores de estado de conexión.

Las variables ssid y password se usan para el identificador de red y contraseña del router a conectarse, reemplace con el valor apropiado para la red a usar.

Una versión simplificada de instrucciones permite la conexión y observación por medio de los parpadeos del led del módulo.

/* ESP8266/ESP-01 WIFI Blink 
 *  edelros@espol.edu.ec 2019
 *  Ejemplo de conexión a WiFi
 *  Para usar, actualice las secciones de:
 *  - WIFI:Router
*/
#include 

// WIFI: conexión a Router
char* ssid = "aaaaa";
char* password = "aaaaa";

// LED monitor //interno: ESP01-pin=1, ESP07-pin=2
int LED_pin=1;

WiFiClient wifiClient;

void setup() {
  // LED monitor, Enciende en LOW
  pinMode(LED_pin, OUTPUT);

  // conexión WIFI y MQTT
  inicia_wifi();
  }

void loop() {
  // revisa estado de WiFi
  if (WiFi.status() != WL_CONNECTED){
    inicia_wifi();
    }

    // LED Monitor Parpadea, enciende en LOW
    digitalWrite(LED_pin, LOW);
    delay(1000); // un segundo
    digitalWrite(LED_pin, HIGH);
    delay(1000);
    
    // Tiempo para procesar señal WiFi
    delay(100);
}

void inicia_wifi(){
  int intentos = 20;
  int cuenta = 0;
     
  WiFi.begin(ssid, password);
  
  while((WiFi.status() != WL_CONNECTED)&&(cuenta<=intentos)){
    cuenta = cuenta+1;
    // LED Monitor Parpadea, enciende en LOW
    digitalWrite(LED_pin, LOW);
    delay(250);
    digitalWrite(LED_pin, HIGH);
    delay(250);
    }
  }

Instrucciones con mensajes a monitor Serial

El proceso se puede observar mediante desde el IDE Arduino para el módulo ESP-07. En la versión ESP-01 el LED interno se encuentra conectado al pin de TX usado para la comunicación Serial y causaría un conflicto.

En ésta versión se puede cambiar el led a otro pin configurado como salida GPIO2, lo que permite conectar Tx y Rx y observar los mensajes del proceso de conexión.

/* ESP8266/ESP-01 WIFI Blink 
 *  edelros@espol.edu.ec 2019
 *  Ejemplo de conexión a WiFi
 *  Para usar, actualice las secciones de:
 *  - WIFI:Router
 *  ESP-01: desactive los Mensajes seriales
 *  ESP-07: Active los Mensajes por serial
 *  usando serial_msg = false o true
*/
#include <ESP8266WiFi.h>

// WIFI: conexión a Router
char* ssid = "aaaaa";
char* password = "aaaaa";

// LED monitor //interno: ESP01-pin=1, ESP07-pin=2
int LED_pin=1;

// Mensajes por Puerto Serial
volatile boolean serial_msg = false;

WiFiClient wifiClient;

void setup() {
  if (serial_msg){
    // Conexion serial // ESP01 muestra reinicio en 74880
    Serial.begin(74880);//115200,74880
  }

  // LED monitor, Enciende en LOW
  pinMode(LED_pin, OUTPUT);

  // conexión WIFI y MQTT
  inicia_wifi(serial_msg);
  }

void loop() {
  // revisa estado de WiFi
  if (WiFi.status() != WL_CONNECTED){
    inicia_wifi(serial_msg);
    }

    // LED Monitor Parpadea, enciende en LOW
    digitalWrite(LED_pin, LOW);
    delay(1000); // un segundo
    digitalWrite(LED_pin, HIGH);
    delay(1000);
    
    // Tiempo para procesar señal WiFi
    delay(100);
}

void inicia_wifi(boolean SerialMensajes){
  int intentos = 20;
  int cuenta = 0;
  
  if (SerialMensajes){
    Serial.print(" WIFI Conectando a ");
    Serial.println(ssid);
    }
    
  WiFi.begin(ssid, password);
  
  while((WiFi.status() != WL_CONNECTED)&&(cuenta<=intentos)){
    if (SerialMensajes){
      Serial.print(".");
      }
    cuenta = cuenta+1;
    // LED Monitor Parpadea, enciende en LOW
    digitalWrite(LED_pin, LOW);
    delay(250);
    digitalWrite(LED_pin, HIGH);
    delay(250);
    }

  if (SerialMensajes){
    //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://esp8266-arduino-spanish.readthedocs.io/es/latest/esp8266wifi/readme.html