Cómo conectar TTGO LoRa32 con el gateway Dragino LG02

En este tutorial te voy a mostrar cómo conectar una placa de desarrollo TTGO LoRa32 con un gateway LoRa Dragino LG02. Cabe aclarar que este tutorial también sirve para los gateways Dragino LG01, OLG01 y OLG02.

Los gateways de uno o dos canales no son recomendables para soluciones LoRaWAN con muchos nodos. Sin embargo, funcionan bien en redes LoRaWAN con pocos nodos (digamos hasta 50) o en redes LoRa.

Si no sabes la diferencia entre LoRa y LoRaWAN, te dejo este artículo donde lo explico.

LoRa vs LoRaWAN

Hardware que he utilizado

• El gateway Dragino LG02 (de dos canales LoRa). 
• Placa de desarrollo TTGO ESP32 V2. Hay muchas versiones de hardware y en función del modelo específico cambian algunos pines. Esta placa tiene conectividad WiFi, Bluetooth y LoRa. También trae un display OLED listo para usar.

Configuración LoRa del gateway

Como estamos usando un gateway de dos canales, es necesario configurar la frecuencia exacta que vamos a utilizar en el nodo. Uno de los canales se utiliza para uplink y el otro para downlink.

En esta ocasión solo utilizaremos el canal de uplink.

En nuestro caso la frecuencia es de 915000000 Hz. También configuramos los valores de SF, preámbulo, sincronización, coding rate y BW como muestro en la siguiente figura.

Configuración MQTT del gateway

Primero vamos a configurar el gateway para que reenvíe las tramas LoRa a un broker MQTT.

Por cuestiones de síntesis no voy a explicar en este artículo cómo realizar la configuración básica del gateway, sino que me voy a centrar en lo que respecta al modo MQTT.

La idea general es que el nodo TTGO ESP32 envíe mensajes que el gateway pueda identificar y reenviar a un tópico específico en el broker MQTT.

Para esto, el payload del mensaje LoRa debe tener un formato determinado, como se muestra en la figura siguiente.

En este ejemplo, el canal local 7456 (que identifica la información del nodo LoRa) se mapea con el canal remoto 367680. De este modo el cliente MQTT del gateway enviará la información del canal local 7456 al canal remoto 367680.

La configuración de MQTT en el gateway se realiza de la siguiente manera.

Primero configuramos la conexión con el broker, introduciendo la dirección, el puerto, el usuario y la contraseña. Si el broker trabaja con certificados

Luego configuramos el canal. En mi caso, para hacerlo fácil, asigné el número 0001 tanto al canal local como al remoto.

Programando TTGO LoRa32

Veamos ahora cómo programar la placa TTGO LoRa32 para que funcione con nuestro gateway Dragino LG02.

Para realizar esta prueba de concepto tomé como base el código de este tutorial y le hice algunos pequeños cambios.

Antes que nada, si todavía no has agregado los módulos de software de las placas ESP32 al entorno de Arduino, lo tendrás que hacer con la siguiente url:

https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json

Vamos con la programación de la placa.

En primer lugar, modifiqué la frecuencia de operación, ya que estoy usando la banda de 915 MHz.

//433E6 for Asia
//866E6 for Europe
#define BAND 915E6 
//#define BAND 866E6

En segundo lugar, verifiqué los pines que corresponden al control del display y del transceiver LoRa. Esto es importante, porque si los pines no son los correctos, obviamente no podremos controlar el display ni el transceiver.

En este foro hay varias referencias a placas de desarrollo de este tipo

https://www.thethingsnetwork.org/forum/t/big-esp32-sx127x-topic-part-3/18436

Tendrás que encontrar la tuya para realizar la configuración correcta.

En mi caso utilicé la placa TTGO LoRa32 V2, con la configuración para LoRa:

#define SCK 5
#define MISO 19
#define MOSI 27
#define SS 18
#define RST 14
#define DIO0 26

Mientras que para el display es la siguiente:

#define OLED_SDA 21
#define OLED_SCL 22 
#define OLED_RST 16

El código de prueba lo único que hace es correr un contador y enviar el número en una trama LoRa con el formato requerido por el gateway.

Configuramos el nodo para que funcione con los mismos parámetros que el gateway.

 LoRa.setSpreadingFactor(7);
 LoRa.setSignalBandwidth(125000);
 LoRa.setCodingRate4(5);
 LoRa.setSyncWord(0x34);

De este modo, las líneas de código que generan el payload LoRa son las siguientes:

 LoRa.beginPacket();
  LoRa.print("<0001>");
  LoRa.print("count=");
  LoRa.print(counter);
  LoRa.endPacket();

El código completo es el siguiente:

//Libraries for LoRa
#include <SPI.h>
#include <LoRa.h>

//Libraries for OLED Display
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

//define the pins used by the LoRa transceiver module
#define SCK 5
#define MISO 19
#define MOSI 27
#define SS 18
#define RST 14
#define DIO0 26

//433E6 for Asia
//866E6 for Europe
#define BAND 915E6 
//#define BAND 866E6

//OLED pins
#define OLED_SDA 21
#define OLED_SCL 22 
#define OLED_RST 16
#define SCREEN_WIDTH 128 // OLED display width, in pixels
#define SCREEN_HEIGHT 64 // OLED display height, in pixels

//packet counter
int counter = 0;

Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RST);

void setup() {

  //reset OLED display via software
  pinMode(OLED_RST, OUTPUT);
  digitalWrite(OLED_RST, LOW);
  delay(20);
  digitalWrite(OLED_RST, HIGH);

  //initialize OLED
  Wire.begin(OLED_SDA, OLED_SCL);
  if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3c, false, false)) { // Address 0x3C for 128x32
    Serial.println(F("SSD1306 allocation failed"));
    for(;;); // Don't proceed, loop forever
  }
  
  display.clearDisplay();
  display.setTextColor(WHITE);
  display.setTextSize(2);
  display.setCursor(0,5);
  display.print("LORA SENDER ");
  display.display();
  
  //initialize Serial Monitor
  Serial.begin(115200);
  
  Serial.println("LoRa Sender Test");

  //SPI LoRa pins
  SPI.begin(SCK, MISO, MOSI, SS);
  //setup LoRa transceiver module
  LoRa.setPins(SS, RST, DIO0);
  
  if (!LoRa.begin(BAND)) {
    Serial.println("Starting LoRa failed!");
    while (1);
  }

  LoRa.setSpreadingFactor(7);
  LoRa.setSignalBandwidth(125000);
  LoRa.setCodingRate4(5);
  LoRa.setSyncWord(0x34);
  
  Serial.println("LoRa Initializing OK!");
  display.setCursor(0,20);
  display.print("LoRa Initializing OK!");
  display.display();
  delay(2000);
}

void loop() {
   
  Serial.print("Sending packet: ");
  Serial.println(counter);

  //Send LoRa packet to receiver
  LoRa.beginPacket();
  LoRa.print("<0001>");
  LoRa.print("count=");
  LoRa.print(counter);
  LoRa.endPacket();
  
  display.clearDisplay();
  display.setCursor(0,5);
  //display.println("LORA SENDER");
  display.setCursor(0,20);
  display.setTextSize(2);
  display.print("LoRa packet sent.");
  display.setCursor(0,10);
  display.print("Counter:");
  display.setCursor(80,50);
  display.print(counter);      
  display.display();

  counter++;
  
  delay(60000);
}

Probando, probando . . .

Ahora toca verificar que el nodo esté enviando los mensajes LoRa y que el gateway los esté decodificando y enviando al broker MQTT.

Primero vamos a ver si nuestro gateway está recibiendo los mensajes LoRa. Para esto vamos a la solapa de debug, como muestro en la siguiente figura.

Para decodificar el mensaje, que está en hexadecimal, podemos utilizar una calculadora online que nos permita obtener los caracteres ASCII.

El sitio https://www.binaryhexconverter.com/hex-to-ascii-text-converter puede servir para tal fin. Simplemente copiamos y pegamos el código hexa y le damos al botón de convertir.

Si la recepción LoRa está funcionando, ahora toca verificar el envío de los mensajes MQTT.

Para esto utilicé el software MQTT Explorer, me conecté al broker y verifiqué que estuvieran llegando los mensajes en el tópico correspondiente.

Conclusión

En este tutorial hemos visto cómo realizar una conexión entre una placa TTGO LoRa32 y un gateway Dragino de uno o dos canales, en particular, el LG02.

Si eres nuevo en IoT y necesitas aprender sobre MQTT, LoRa, o cualquier otro concepto relacionado, no dejes de revisar el material de este blog.

Finalmente, te invito a dejar tus dudas, consultas o comentarios más abajo. Estaré encantado de leerte.