Placa OLED TTGO LoRa32 SX1276: Primeros pasos con Arduino IDE

Las placas OLED TTGO LoRa32 SX1276 son dispositivos versátiles y potentes que permiten la comunicación a larga distancia mediante la tecnología LoRa. En este artículo, te guiaremos a través de los primeros pasos para programar esta placa utilizando el entorno de desarrollo Arduino IDE. ¡Descubre todo lo que puedes lograr con esta increíble placa en tus proyectos de IoT!

El TTGO LoRa32 SX1276 OLED Es una placa de desarrollo ESP32 con un chip LoRa integrado y una pantalla OLED SSD1306 de 0,96 pulgadas. En esta guía, le mostraremos cómo enviar y recibir paquetes LoRa (comunicación punto a punto) y utilizar la pantalla OLED con Arduino IDE.

Placa OLED TTGO LoRa32 SX1276: Primeros pasos con Arduino IDE

Para obtener una introducción a la comunicación LoRa, consulte: ESP32 con LoRa usando Arduino IDE.

TTGO LoRa32 SX1276 OLED Descripción general

La TTGO LoRa32 SX1276 OLED es una placa de desarrollo con ESP32, un chip LoRa incorporado y una pantalla OLED SSD1306. Este es el modelo de pantalla OLED que utilizamos en la mayoría de nuestros proyectos de electrónica (Pantalla OLED con instrucciones ESP32).

Placa OLED TTGO LoRa32 SX1276: Primeros pasos con Arduino IDE

La placa también cuenta con múltiples GPIO para conectar periféricos, botones PRG (BOOT) y RST y un conector para batería de litio. Puede encontrar una descripción más detallada de esta placa aquí: Revisión de TTGO LoRa32 SX1276 OLED.

¿Donde comprar?

Puedes ir al… Página de TTGO LoRa32 SX1276 OLED en Maker Advisor para encontrar el mejor precio en diferentes tiendas. Para completar este tutorial necesitarás dos Tarjetas TTGO LoRa32.

Placa OLED TTGO LoRa32 SX1276: Primeros pasos con Arduino IDE

TTGO LoRa32 SX1276 OLED

La siguiente figura muestra la distribución de pines de la placa OLED TTGO LoRa32.

Placa OLED TTGO LoRa32 SX1276: Primeros pasos con Arduino IDE

Las pantallas OLED se comunican mediante el protocolo de comunicación I2C. Están conectados internamente al ESP32 a través de los siguientes pines:

OLED (incorporado) ESP32
ASD GPIO4
SCL GPIO 15
primero GPIO 16

El chip SX1276 LoRa se comunica a través del protocolo de comunicación SPI y está conectado internamente al ESP32 a través de los siguientes GPIO:

SX1276 LoRa ESP32
MISO GPIO 19
MOSI GPIO27
SCK GPIO5
ÉL GPIO 18
IRQ GPIO26
primero GPIO 14

Recomendaciones de literatura: Guía de referencia de distribución de pines ESP32

Instalar placas ESP32 en Arduino IDE

Para programar la placa TTGO LoRa32 utilizamos Arduino IDE. Por lo tanto, debe tener instalado Arduino IDE y el complemento ESP32. Siga la siguiente guía para instalar el paquete ESP32 en Arduino IDE si aún no lo ha hecho:

  • Instalación de la placa ESP32 en el IDE Arduino (Windows, Mac OS X, Linux)

Instalación de bibliotecas OLED

Hay varias bibliotecas disponibles para controlar la pantalla OLED con el ESP32. En este tutorial usaremos dos bibliotecas de Adafruit: Biblioteca Adafruit_SSD1306 Y Biblioteca Adafruit_GFX.

Siga los siguientes pasos para instalar estas bibliotecas.

1. Abra su IDE de Arduino y vaya a Bosquejo > incluir biblioteca > Administrar bibliotecas. El administrador de la biblioteca debería abrirse.

2. Ingrese «SSD1306”en el cuadro de búsqueda e instale la biblioteca SSD1306 de Adafruit.

Placa OLED TTGO LoRa32 SX1276: Primeros pasos con Arduino IDE

3. Después de instalar la biblioteca SSD1306 de Adafruit, escriba «gráfico“ en el campo de búsqueda e instale la biblioteca.

Placa OLED TTGO LoRa32 SX1276: Primeros pasos con Arduino IDE

Instalación de la biblioteca LoRa

Existen varias bibliotecas para enviar y recibir paquetes LoRa fácilmente con el ESP32. En este ejemplo utilizamos el Biblioteca Arduino LoRa de Sandeep Mistry.

Abra su IDE de Arduino y vaya a Bosquejo > incluir biblioteca > Administrar bibliotecas y busca “lora“. Seleccione e instale la biblioteca LoRa resaltada en la imagen a continuación.

Placa OLED TTGO LoRa32 SX1276: Primeros pasos con Arduino IDE

Después de instalar las bibliotecas, reinicie su IDE de Arduino.

Bosquejo del transmisor LoRa

Copie el siguiente código en su IDE de Arduino. Este código envía un mensaje de «Hola» cada 10 segundos, seguido de un contador a través de LoRa. El contador también se muestra en la pantalla OLED.

/*********
  Rui Santos
  Complete project details at https://RandomNerdTutorials.com/ttgo-lora32-sx1276-arduino-ide/
*********/

//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
//915E6 for North America
#define BAND 866E6

//OLED pins
#define OLED_SDA 4
#define OLED_SCL 15 
#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() {
  //initialize Serial Monitor
  Serial.begin(115200);

  //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(1);
  display.setCursor(0,0);
  display.print("LORA SENDER ");
  display.display();
  
  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);
  }
  Serial.println("LoRa Initializing OK!");
  display.setCursor(0,10);
  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("hello ");
  LoRa.print(counter);
  LoRa.endPacket();
  
  display.clearDisplay();
  display.setCursor(0,0);
  display.println("LORA SENDER");
  display.setCursor(0,20);
  display.setTextSize(1);
  display.print("LoRa packet sent.");
  display.setCursor(0,30);
  display.print("Counter:");
  display.setCursor(50,30);
  display.print(counter);      
  display.display();

  counter++;
  
  delay(10000);
}

Ver código sin formato

Así es como funciona el código

Comience integrando las bibliotecas para interactuar con el chip LoRa.

#include <SPI.h>
#include <LoRa.h>

Luego agregue las bibliotecas para interactuar con la pantalla OLED I2C.

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

Defina los pines utilizados por el módulo transceptor LoRa:

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

Seleccione la frecuencia LoRa:

#define BAND 866E6

Defina los pines OLED.

#define OLED_SDA 4
#define OLED_SCL 15 
#define OLED_RST 16

Defina el tamaño de OLED.

#define SCREEN_WIDTH 128 // OLED display width, in pixels
#define SCREEN_HEIGHT 64 // OLED display height, in pixels

Crear un… Cambiar Variable para rastrear la cantidad de paquetes LoRa enviados.

int counter = 0;

Crea uno Adafruit_SSD1306 Objeto nombrado Anuncio.

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

configuración()

En el configuración()Para usar la pantalla OLED, debe realizar un reinicio manual mediante software usando el pin RST. Para hacer esto necesitas declarar el pin RST como salida, encenderlo BAJO durante unos milisegundos y luego configúrelo ALTO de nuevo.

pinMode(OLED_RST, OUTPUT);
digitalWrite(OLED_RST, LOW);
delay(20);
digitalWrite(OLED_RST, HIGH);

Iniciar una comunicación I2C con el definido OLED_SDA Y OLED_SCL Pines con Cable.comenzar().

Wire.begin(OLED_SDA, OLED_SCL);

Luego inicialice la pantalla con los siguientes parámetros. Los parámetros como INCORRECTO Asegúrese de que la biblioteca no utilice los pines I2C estándar, sino los pines definidos en el código (GPIO4 Y GPIO 15).

if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3c, false, false)) { // Address 0x3C for 128x32
  Serial.println(F("SSD1306 allocation failed"));
  for(;;); // Don't proceed, loop forever
}

Luego puede utilizar los métodos de la biblioteca de Adafruit para interactuar con la pantalla OLED. Para obtener más información, consulte nuestro tutorial sobre la pantalla OLED I2C con ESP32.

Escriba el mensaje “LORA SENDER” en la pantalla.

display.clearDisplay();
display.setTextColor(WHITE);
display.setTextSize(1);
display.setCursor(0,0);
display.print("LORA SENDER ");
display.display();

Inicialice el monitor serie para fines de depuración.

Serial.begin(115200);
Serial.println("LoRa Sender Test");

Defina los pines SPI utilizados por el chip LoRa.

SPI.begin(SCK, MISO, MOSI, SS);

Y configure el módulo transceptor LoRa.

LoRa.setPins(SS, RST, DIO0);

Finalmente, inicialice el módulo transceptor LoRa con el comenzar() método en el lora objeto y pasar la frecuencia como argumento.

if (!LoRa.begin(BAND)) {
  Serial.println("Starting LoRa failed!");
  while (1);
}

Si la inicialización de la pantalla es exitosa, escribimos un mensaje de éxito en la pantalla OLED.

display.setCursor(0,10);
display.print("LoRa Initializing OK!");
display.display();

Cinta()

En el Cinta() es donde enviamos los paquetes. Inicializas un paquete con el comenzar paquete() Método.

LoRa.beginPacket();

Escribe datos en el paquete con el prensa() Método. Como puede ver en las dos líneas siguientes, enviamos un mensaje de saludo seguido del contador.

LoRa.print("hello ");
LoRa.print(counter);

Luego selle el paquete con el finalizar el paquete() Método.

LoRa.endPacket();

A continuación, escribe el Cambiar en la pantalla OLED

display.clearDisplay();
display.setCursor(0,0);
display.println("LORA SENDER");
display.setCursor(0,20);
display.setTextSize(1);
display.print("LoRa packet sent.");
display.setCursor(0,30);
display.print("Counter:");
display.setCursor(50,30);
display.print(counter);
display.display();

Después de eso será Cambiar El mensaje se incrementa en uno en cada bucle, lo que ocurre cada 10 segundos.

counter++;
delay(10000);

Probando el transmisor LoRa

Sube el código a tu tablero. Debe seleccionar la placa y el puerto COM correctos que está utilizando.

Para seleccionar la placa, vaya a en el IDE de Arduino Herramientas > tablón y seleccione el TTGO LoRa32-OLED V1 Tablón.

Placa OLED TTGO LoRa32 SX1276: Primeros pasos con Arduino IDE

Después de cargar el código en su placa, debería comenzar a enviar paquetes LoRa.

Placa OLED TTGO LoRa32 SX1276: Primeros pasos con Arduino IDE

Bosquejo del receptor LoRa

Ahora cargue el boceto del receptor en otra placa OLED TTGO LoRa32. Este boceto escucha paquetes LoRa dentro de su rango e imprime el contenido de los paquetes, así como el RSSI (intensidad relativa de la señal recibida) en el OLED.

/*********
  Rui Santos
  Complete project details at https://RandomNerdTutorials.com/ttgo-lora32-sx1276-arduino-ide/
*********/

//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
//915E6 for North America
#define BAND 866E6

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

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

String LoRaData;

void setup() { 
  //initialize Serial Monitor
  Serial.begin(115200);
  
  //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(1);
  display.setCursor(0,0);
  display.print("LORA RECEIVER ");
  display.display();

  Serial.println("LoRa Receiver 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);
  }
  Serial.println("LoRa Initializing OK!");
  display.setCursor(0,10);
  display.println("LoRa Initializing OK!");
  display.display();  
}

void loop() {

  //try to parse packet
  int packetSize = LoRa.parsePacket();
  if (packetSize) {
    //received a packet
    Serial.print("Received packet ");

    //read packet
    while (LoRa.available()) {
      LoRaData = LoRa.readString();
      Serial.print(LoRaData);
    }

    //print RSSI of packet
    int rssi = LoRa.packetRssi();
    Serial.print(" with RSSI ");    
    Serial.println(rssi);

   // Dsiplay information
   display.clearDisplay();
   display.setCursor(0,0);
   display.print("LORA RECEIVER");
   display.setCursor(0,20);
   display.print("Received packet:");
   display.setCursor(0,30);
   display.print(LoRaData);
   display.setCursor(0,40);
   display.print("RSSI:");
   display.setCursor(30,40);
   display.print(rssi);
   display.display();   
  }
}

Ver código sin formato

Este boceto es muy similar al anterior. Sólo necesitamos cambiar algunas líneas para recibir paquetes LoRa en lugar de enviarlos.

En el Cinta()comprobamos si hay nuevos paquetes para recibir con el analizarpaquete() Método.

int packetSize = LoRa.parsePacket();

Cuando existe un nuevo paquete, leemos su contenido. Para leer los datos entrantes, utilice el leerCadena() Método. Los datos recibidos se almacenan en el LoRaData Variable.

if (packetSize) {
  //received a packet
  Serial.print("Received packet ");

  //read packet
  while (LoRa.available()) {
    LoRaData = LoRa.readString();
    Serial.print(LoRaData);
  }

También obtenemos el RSSI del paquete recibido usando el PaqueteRSSI() Método.

int rssi = LoRa.packetRssi();

Finalmente, muestra el mensaje recibido y el RSSI.

display.clearDisplay();
display.setCursor(0,0);
display.print("LORA RECEIVER");
display.setCursor(0,20);
display.print("Received packet:");
display.setCursor(0,30);
display.print(LoRaData);
display.setCursor(0,40);
display.print("RSSI:");
display.setCursor(30,40);
display.print(rssi);
display.display();

Probando el receptor LoRa

Sube el código a tu tablero. No lo olvides TTGO LoRa32-OLED V1 en el menú Tableros.

Después de cargar el código, debería comenzar a recibir los paquetes LoRa de la otra placa.

Placa OLED TTGO LoRa32 SX1276: Primeros pasos con Arduino IDE

Envolver

Este artículo fue una guía rápida para comenzar. Tablero TTGO LoRa32 Instrucciones: envíe paquetes LoRa en comunicación punto a punto y utilice la pantalla OLED.

Ahora es el momento de combinar lo aprendido y crear proyectos de IoT. LoRa puede resultar especialmente útil cuando desea recibir valores de sensores que no están cubiertos por su red WiFi y que se encuentran a varios metros de distancia. Además, también podrás conectar tu placa a la TTN (The Things Network).

Esperamos que este tutorial te haya resultado útil. Obtenga más información sobre el ESP32 con nuestros recursos:

  • Aprenda ESP32 con Arduino IDE (libro electrónico + curso en vídeo)
  • Programación MicroPython con ESP32 y ESP8266 (libro electrónico)
  • ESP32 con chip LoRa RFM95 usando Arduino IDE – Primeros pasos
  • Más proyectos ESP32…

Gracias por leer.

Error 403 The request cannot be completed because you have exceeded your quota. : quotaExceeded







Placa OLED TTGO LoRa32 SX1276: Primeros pasos con Arduino IDE

Introducción al TTGO LoRa32 SX1276 OLED

El TTGO LoRa32 SX1276 OLED es una placa de desarrollo ESP32 con un chip LoRa incorporado y una pantalla OLED SSD1306 de 0.96 pulgadas. En esta guía, te mostraremos cómo enviar y recibir paquetes LoRa (comunicación punto a punto) y utilizar la pantalla OLED con Arduino IDE.

Aspectos destacados del TTGO LoRa32 SX1276 OLED

El TTGO LoRa32 SX1276 OLED es una placa de desarrollo con un ESP32, un chip LoRa incorporado y una pantalla OLED SSD1306. Esta es la pantalla OLED que utilizamos en la mayoría de nuestros proyectos electrónicos. La placa también cuenta con varios GPIO para conectar periféricos, botones PRG (BOOT) y RST, y un conector de batería de litio.

¿Dónde comprar?

Puedes visitar la página del TTGO LoRa32 SX1276 OLED en Maker Advisor para encontrar el mejor precio en diferentes tiendas. Para completar este tutorial, necesitarás dos placas TTGO LoRa32.

Instalación de Placas ESP32 en Arduino IDE

Para programar la placa TTGO LoRa32, utilizaremos Arduino IDE. Asegúrate de tener Arduino IDE instalado, así como el complemento ESP32. Sigue la guía para instalar el paquete ESP32 en Arduino IDE si aún no lo has hecho.

Instalación de Bibliotecas para OLED y LoRa

Existen varias bibliotecas disponibles para controlar la pantalla OLED y enviar y recibir paquetes LoRa con el ESP32. En este tutorial utilizaremos las bibliotecas de Adafruit: Adafruit_SSD1306 y Adafruit_GFX. Sigue los pasos para instalar esas bibliotecas en tu Arduino IDE.

Sketch del Emisor LoRa

Aquí tienes un ejemplo de código para enviar paquetes LoRa y mostrar el contador en la pantalla OLED. Sigue las instrucciones paso a paso para cargar y ejecutar el código en tu placa TTGO LoRa32.

Funcionamiento del Código

El código incluye las bibliotecas necesarias para interactuar con el chip LoRa, definir los pines de la pantalla OLED, inicializar la comunicación LoRa y enviar los paquetes de datos. Sigue las instrucciones detalladas para entender cómo funciona el código.

Sketch del Receptor LoRa

Con este código, el segundo TTGO LoRa32 actuará como receptor, mostrando los paquetes recibidos en la pantalla OLED junto con la fuerza de la señal RSSI. Sube este sketch a tu segunda placa TTGO LoRa32 y observa cómo se reciben los paquetes LoRa.

Conclusión

Esta guía te ha proporcionado los primeros pasos para trabajar con el TTGO LoRa32 SX1276 OLED, permitiéndote enviar y recibir datos de forma inalámbrica a través de LoRa y visualizar información en la pantalla OLED. Ahora, puedes explorar más proyectos de IoT utilizando estas capacidades.

Agradecimientos

Gracias por leer. Para obtener más información sobre el ESP32, visita nuestros recursos y tutoriales relacionados.


4 comentarios en «Placa OLED TTGO LoRa32 SX1276: Primeros pasos con Arduino IDE»

Deja un comentario