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.
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).
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.
TTGO LoRa32 SX1276 OLED
La siguiente figura muestra la distribución de pines de la placa OLED TTGO LoRa32.
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.
3. Después de instalar la biblioteca SSD1306 de Adafruit, escriba «gráfico“ en el campo de búsqueda e instale la biblioteca.
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.
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);
}
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.
Después de cargar el código en su placa, debería comenzar a enviar paquetes LoRa.
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();
}
}
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.
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.
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.
¡Gracias por este tutorial! Me siento más seguro/a ahora de empezar a utilizar el TTGO LoRa32 con Arduino. ¡A probar se ha dicho!
¡Interesante! Me encantaría probarlo en mi próximo proyecto.
¡Buena guía para comenzar a utilizar el TTGO LoRa32 con Arduino! Me ha resultado fácil de seguir y muy útil. ¡Gracias por compartir!
¡Genial! Me gusta cómo explican paso a paso cómo utilizar el TTGO LoRa32 con Arduino. ¡Voy a ponerlo en práctica ya mismo! ¡Gracias por compartir!