En este tutorial aprenderás cómo habilitar la comunicación de largo alcance usando el módulo LoRa SX1276 y el ESP32. Por ejemplo, si quieres recibir datos de sensores lejanos donde no tienes cobertura Wi-Fi, como un sensor de temperatura en un rincón de tu jardín, LoRa puede ayudarte.
LoRa es una tecnología inalámbrica diseñada para enviar pequeñas cantidades de datos a largas distancias usando muy poca energía. Funciona bien en áreas abiertas y puede alcanzar varios kilómetros, mucho más lejos que WiFi o Bluetooth. Esto la hace ideal para dispositivos alimentados por batería, como sensores en granjas, ciudades o zonas remotas donde el WiFi o Bluetooth convencional no llegan o consumen demasiada energía.
Si ya conoces LoRa y solo quieres saber cómo enviar datos ambientales como temperatura y humedad, echa un vistazo al Send Environmental Data with LoRa tutorial.
Partes necesarias
A continuación encontrarás los componentes necesarios para este tutorial. Usé una placa ESP32 antigua, que ya está obsoleta pero aún puedes conseguirla a muy bajo precio. Ten en cuenta que también existe una versión con puerto USB-C. Sin embargo, cualquier otro ESP32 funcionará perfectamente. Solo recuerda que necesitarás dos de ellos y dos módulos SX1276: uno para enviar y otro para recibir.
En cuanto a los módulos transceptores LoRa SX1276, ¡cuidado con la versión que compres! Depending on the country las frecuencias permitidas que estos módulos pueden usar varían. Es 868 MHz para Europa, 915 MHz para Norteamérica y 433 MHz para Asia.
La descripción del módulo suele indicar la frecuencia o tiene un número como 868 o 915 en el nombre. Yo listé un módulo con 868 MHz, ya que estoy en Europa. Pero también puedes conseguir este módulo para la banda de 915 MHz.
2 x Módulo LoRa 868/915M SX1276
2 x ESP32 lite
Cable de datos USB
Juego de cables Dupont
2x Protoboard
Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.
¿Qué es LoRa?
Si estás construyendo proyectos con Arduino o ESP32 y necesitas enviar datos inalámbricos a largas distancias, LoRa (abreviatura de Long Range) podría ser justo lo que necesitas. A diferencia de WiFi y Bluetooth, diseñados para comunicación rápida y de corto alcance, LoRa está pensado para transmisión de datos a baja potencia y larga distancia — perfecto para sensores remotos y dispositivos que deben funcionar durante meses o años con una batería pequeña.
LoRa usa un tipo especial de modulación de radio llamada Chirp Spread Spectrum (CSS). Esto lo hace muy resistente a interferencias y permite que los dispositivos se comuniquen a varios kilómetros, incluso en entornos ruidosos o con obstáculos como árboles y edificios. LoRa opera en unlicensed ISM frequency bands — típicamente 868 MHz en Europa, 915 MHz en Norteamérica y 433 MHz en algunos países asiáticos. Estas frecuencias varían según la región, pero todas tienen la ventaja de ser libres de licencia.
La desventaja de LoRa es que no está hecho para datos de alta velocidad. Funciona mejor con cargas pequeñas, como lecturas de sensores o actualizaciones de estado de dispositivos. Las tasas de datos suelen variar entre 0.3 kbps y 50 kbps, dependiendo del spreading factor (SF), ancho de banda y coding rate que elijas. El alcance también depende de estos ajustes y del entorno: puedes esperar 2–5 km en zonas urbanas y 10–15 km en áreas rurales o con línea de vista — a veces incluso más con antenas adecuadas.
LoRa vs WiFi y Bluetooth
WiFi ofrece velocidades rápidas pero consume mucha energía y suele cubrir menos de 100 metros. Bluetooth tiene un alcance aún menor y es más adecuado para dispositivos personales y wearables. La siguiente tabla compara las características principales de LoRa con WiFi y Bluetooth:
| Característica | LoRa | WiFi | Bluetooth |
|---|---|---|---|
| Consumo de energía | Muy bajo (μA en reposo, ~10–50 mA activo) | Alto (~70–300 mA activo) | Bajo (~10–30 mA activo) |
| Alcance | 2–15 km (rural), 0.5–5 km (urbano) | ~50–100 metros (interior), ~200 metros (exterior) | ~10–100 metros |
| Velocidad típica de datos | 0.3–50 kbps | Hasta 100–600 Mbps (ESP32: ~150 Mbps) | ~1–3 Mbps (Classic), ~125–200 kbps (BLE) |
| Latencia | Alta (100 ms a varios segundos) | Baja (~1–10 ms) | Baja (~3–50 ms BLE) |
En este post, profundizaremos en cómo usar LoRa con placas ESP32 y módulos como el SX1276, y te mostraremos cómo empezar a enviar mensajes entre dispositivos separados por kilómetros — sin necesidad de WiFi, torres celulares o mucho consumo de energía.
Módulo LoRa SX1276
El SX1276 es un módulo transceptor LoRa popular fabricado por Semtech, y es uno de los chips más usados para comunicación inalámbrica de largo alcance y bajo consumo en proyectos DIY e IoT. Soporta modulación LoRa así como modos tradicionales FSK/OOK, lo que lo hace flexible para una amplia gama de aplicaciones.
El SX1276 está en el corazón de muchos módulos LoRa, incluyendo el conocido HopeRF RFM95W, muy similar al módulo que uso en este tutorial. La siguiente imagen muestra el frente del módulo LoRa SX1276 con el chip SX1276, el cristal de cuarzo y el regulador de voltaje.
Este chip opera en el rango de 137 MHz a 1020 MHz, pero la mayoría de los módulos están configurados para 433 MHz (Asia), 868 MHz (Europa) o 915 MHz (Norteamérica), según tu región. En la parte trasera del módulo suele haber una pequeña tabla donde se indica la frecuencia de operación del módulo específico. La imagen siguiente muestra un módulo que opera en la banda de 915 MHz y por lo tanto podría usarse en Norteamérica:
Asegúrate de comprar y usar un módulo con la frecuencia de transmisión correcta para tu país. ¡De lo contrario podrías tener problemas con la organización que regula las transmisiones de radio en tu país!
El módulo puede comunicarse a distancias de 2 a más de 15 kilómetros, dependiendo de la calidad de la antena, el terreno y la configuración. El SX1276 soporta tasas de datos desde 0.018 kbps hasta 37.5 kbps en modo LoRa y hasta 300 kbps en modo FSK, y ofrece control detallado sobre parámetros como ancho de banda, factor de dispersión y tasa de codificación, permitiéndote optimizar para alcance, consumo o fiabilidad.
Detalles técnicos del SX1276
La siguiente lista muestra las características principales del módulo LoRa SX1276:
- Voltaje de operación: 1.8 – 3.7V
- Banda de frecuencia: 868MHZ/915MH
- Potencia de salida: 20dBm/100mW
- Sensibilidad de recepción: -139dBm@146B
- Modulación: LORA/GFSK
- Interfaz de datos: SPI de 4 hilos
- Tamaño del módulo: 16*16mm Espaciado de interfaz 2.0mm
- Corriente de transmisión: 120mA@100mw/ 3.3V
- Corriente de recepción: 10mA/3.3V
- Corriente en reposo: 0.2uA
Para más detalles consulta la hoja de datos enlazada abajo:
Pinout del módulo LoRa SX1276
El módulo LoRa SX1276 tiene 16 pines. Uno para la antena (ANT), uno para alimentación (VCC), varios pines de tierra (GND), los pines para SPI (RST, NSS, SCK, MOSI, MISO) y seis pines configurables Digital IO (DIO):
Ten en cuenta que el SX1276 usa lógica de 3.3V y por lo tanto no puedes conectarlo directamente a un Arduino UNO, por ejemplo, que opera con niveles lógicos de 5V. Si quieres usar una placa Arduino en lugar de un ESP32, debes usar un logic level shifter o un Arduino that uses 3.3V logic.
Haciendo el módulo LoRa SX1276 compatible con protoboard
Los agujeros de los pines del módulo LoRa SX1276 están separados 2 mm, lo que significa que si sueldas pines no encajan en el espaciado estándar de 2.54 mm de una protoboard. Sin embargo, como no necesitamos todos los pines del módulo, puedes doblar las patas de un header estándar de 2.54 mm y hacerlo funcionar.
La imagen siguiente muestra los pines GND, DIO3, DIO4, VCC y DIO0 conectados a un header de 2.54 mm. Doblé las patas en la parte superior del header para que encajaran en el espaciado más pequeño de 2 mm de los agujeros del módulo:
Ten en cuenta que DIO1 y DIO2 no están conectados. También podrías omitir DIO3 y DIO4, ya que no son necesarios, pero es más rápido soldar el header completo que pines individuales.
En el otro lado del módulo podemos hacer lo mismo. Allí conectamos RST, NSS, SCK, MOSI y MISO y dejamos sin conectar los dos pines GND y DIO5:
Con este sencillo truco puedes hacer que el módulo LoRa SX1276 encaje en una protoboard. La imagen siguiente muestra la parte inferior del módulo con ambos headers y la antena soldada:
Solo debes tener cuidado al cablear la placa, ya que las etiquetas en la serigrafía y los pines están ligeramente desplazados.
También ten en cuenta que tu antena podría verse diferente (más larga, solo un cable) dependiendo del módulo y su configuración de frecuencia.
Conectando SX1276 al ESP32
El SX1276 se controla mediante una interfaz SPI. Al conectarlo a un ESP32 debes hacer las siguientes conexiones:
| SX1276 | ESP32 |
|---|---|
| MOSI | 23 |
| MSIO | 19 |
| SCK | 18 |
| RST | 17 |
| NSS | 5 |
| DIO0 | 4 |
| GND | GND |
| VCC | 3.3V |
Asegúrate de conectar VCC al pin de salida de 3.3V de tu ESP32. Además, si usas la versión compatible con protoboard del módulo, recuerda que solo el pin GND junto al pin de antena ANT está conectado — los otros dos no lo están. Finalmente, DIO0 debe conectarse a un pin del ESP32 que pueda manejar interrupciones. La imagen siguiente muestra el diagrama completo de conexiones:
Si usas una placa ESP32 diferente, los pines para SPI hardware, en los que se basa el cableado anterior, pueden variar. Si no estás seguro de qué pines usar en tu placa, echa un vistazo al Find I2C and SPI default pins tutorial.
La siguiente foto muestra cómo queda en mi protoboard, completamente cableado:
Finalmente, ten en cuenta que en el código siguiente en realidad no usaremos DIO0. Esto significa que podrías omitir esta conexión. Sin embargo, DIO0 puede usarse para señalar que ha llegado un dato mediante un manejador de interrupciones, lo cual puede ser útil en tu aplicación.
Código para comunicación LoRa
En esta sección escribimos el código para el transmisor y receptor LoRa. El hardware y cableado para transmisor y receptor es idéntico (un ESP32 con un SX1276 conectado) pero el código es diferente.
El transmisor envía un valor contador incremental cada dos segundos, mientras que el receptor espera el mensaje del transmisor y muestra el valor del contador en el Monitor Serial cuando lo recibe. El transmisor también parpadea el LED integrado al enviar un mensaje, mientras que el receptor parpadea su LED al recibir un mensaje.
Comenzamos con el código para el transmisor. Echa un vistazo rápido al código completo y luego analizamos sus detalles.
Transmisor
#include <SPI.h>
#include <LoRa.h>
// WEMOS LOLIN32 Lite
// MOSI -> 23
// MISO -> 19
// SCK -> 18
#define SS 5
#define RST 17
#define DIO0 4
#define LED_BUILTIN 22
void setup() {
Serial.begin(115200);
pinMode(LED_BUILTIN, OUTPUT);
LoRa.setPins(SS, RST, DIO0);
// 433E6: Asia, 868E6: Europe, 915E6: North America
while (!LoRa.begin(868E6)) {
Serial.println(".");
delay(500);
}
LoRa.setSyncWord(0x34); // 0-0xFF sync word to match the receiver
LoRa.setSpreadingFactor(12); // (6-12) higher value increases range but decreases data rate
LoRa.setSignalBandwidth(125E3); // lower value increases range but decreases data rate
LoRa.setCodingRate4(8); // higher value increases range but decreases data rate
LoRa.enableCrc(); // improves data reliability
}
void loop() {
static int counter = 0;
Serial.print("Sending counter: ");
Serial.println(++counter);
digitalWrite(LED_BUILTIN, HIGH);
LoRa.beginPacket();
LoRa.print("Counter=");
LoRa.print(counter);
LoRa.endPacket();
delay(1000);
digitalWrite(LED_BUILTIN, LOW);
delay(1000);
}
Primero, incluimos las dos librerías que necesitamos:
#include <SPI.h> #include <LoRa.h>
La librería SPI.h permite que el ESP32 se comunique con el transceptor LoRa a través de SPI (Interfaz Serial Periférica). Mientras que la librería LoRa.h nos da una interfaz sencilla para enviar y recibir paquetes LoRa. Puedes instalar la librería LoRa library by Sandeep Mistry usando el Library Manager en el IDE de Arduino. La imagen siguiente muestra una instalación exitosa de la librería:
Luego definimos los pines GPIO conectados a las líneas de control del módulo para la interfaz SPI:
#define SS 5 #define RST 17 #define DIO0 4 #define LED_BUILTIN 22
SS, RST y DIO0 son requeridos por el módulo LoRa. También definimos LED_BUILTIN para controlar el LED integrado, que nos da retroalimentación visual durante la transmisión. En el WEMOS LOLIN32 Lite, el LED integrado está conectado al pin 22.
setup
Ahora entremos en la función setup(). Esta parte se ejecuta una vez cuando la placa se enciende o reinicia:
void setup() {
Serial.begin(115200);
pinMode(LED_BUILTIN, OUTPUT);
LoRa.setPins(SS, RST, DIO0);
Comenzamos inicializando el monitor Serial para depuración. Luego, configuramos el pin del LED como salida. Después usamos LoRa.setPins() para indicarle a la librería qué pines están conectados al módulo LoRa.
Luego inicializamos la radio LoRa a 868 MHz, que es la frecuencia usada en Europa. Recuerda que debes usar la frecuencia específica permitida para transmisiones LoRa en tu país.
while (!LoRa.begin(868E6)) {
Serial.println(".");
delay(500);
}
Si el módulo LoRa no arranca, seguimos intentando en un bucle, imprimiendo un punto cada vez. Esto ayuda a diagnosticar problemas de arranque como fallos en el cableado.
Una vez que el módulo está listo, lo configuramos para comunicación confiable de largo alcance:
LoRa.setSyncWord(0x34); LoRa.setSpreadingFactor(12); LoRa.setSignalBandwidth(125E3); LoRa.setCodingRate4(8); LoRa.enableCrc(); }
Esto es lo que hace cada ajuste:
setSyncWord(0x34)asegura que solo dispositivos con la misma palabra de sincronización puedan comunicarse entre sí. Es como un ID de red simple.setSpreadingFactor(12)aumenta el alcance y la fiabilidad al dispersar más la señal. Los valores van de 6 a 12—más alto significa mejor alcance pero datos más lentos.setSignalBandwidth(125E3)establece el ancho de banda de radio a 125 kHz. Un ancho de banda más estrecho aumenta el alcance y reduce la tasa de datos.setCodingRate4(8)mejora la corrección de errores, ayudando a que los datos lleguen intactos incluso en enlaces ruidosos.enableCrc()añade una suma de verificación a cada paquete para detectar errores de transmisión.
loop
Ahora pasemos a la función loop(), que se ejecuta continuamente:
void loop() {
static int counter = 0;
Serial.print("Sending counter: ");
Serial.println(++counter);
Usamos una variable static int para llevar la cuenta de cuántos paquetes hemos enviado. Luego imprimimos ese valor en el monitor Serial cada vez para depuración.
Antes de enviar un paquete, encendemos el LED para saber que está transmitiendo:
digitalWrite(LED_BUILTIN, HIGH);
Luego construimos el paquete LoRa (=mensaje):
LoRa.beginPacket();
LoRa.print("Counter=");
LoRa.print(counter);
LoRa.endPacket();
Esto crea un paquete con el contenido "Counter=1", "Counter=2", y así sucesivamente. El receptor recibirá esta cadena y podrá decidir qué hacer con ella.
Después de enviar, apagamos el LED y esperamos un segundo antes de la siguiente transmisión:
delay(1000); digitalWrite(LED_BUILTIN, LOW); delay(1000); }
Cada ciclo dura unos dos segundos—uno para la transmisión y otro para la pausa. Puedes ajustar el retardo según tus necesidades.
¡Y eso es todo! Este sketch envía paquetes LoRa cada dos segundos mientras parpadea un LED para mostrar actividad. En el Monitor Serial deberías ver un mensaje impreso cada vez que se envía un paquete:
En la siguiente sección escribimos el código correspondiente para el receptor.
Receptor
El receptor espera la transmisión del transmisor y las imprime en el Monitor Serial. Aquí está el código completo:
#include <SPI.h>
#include <LoRa.h>
// WEMOS LOLIN32 Lite
// MOSI -> 23
// MISO -> 19
// SCK -> 18
#define SS 5
#define RST 17
#define DIO0 4
#define LED_BUILTIN 22
void setup() {
Serial.begin(115200);
pinMode(LED_BUILTIN, OUTPUT);
LoRa.setPins(SS, RST, DIO0);
// 433E6: Asia, 868E6: Europe, 915E6: North America
while (!LoRa.begin(868E6)) {
Serial.println(".");
delay(500);
}
LoRa.setSyncWord(0x34); // 0-0xFF sync word to match the receiver
LoRa.setSpreadingFactor(12); // (6-12) higher value increases range but decreases data rate
LoRa.setSignalBandwidth(125E3); // lower value increases range but decreases data rate
LoRa.setCodingRate4(8); // higher value increases range but decreases data rate
LoRa.enableCrc(); // improves data reliability
}
void loop() {
if (LoRa.parsePacket()) {
digitalWrite(LED_BUILTIN, LOW);
while (LoRa.available()) {
Serial.print((char)LoRa.read());
}
Serial.printf(" (%d)\n", LoRa.packetRssi());
delay(100);
digitalWrite(LED_BUILTIN, HIGH);
}
}
Como antes, comenzamos incluyendo las mismas dos librerías esenciales:
#include <SPI.h> #include <LoRa.h>
Esto es idéntico al transmisor. SPI.h habilita la comunicación por el bus SPI, y LoRa.h nos da todas las funciones necesarias para recibir paquetes.
Luego definimos el mismo mapeo de pines para el WEMOS LOLIN32 Lite:
#define SS 5 #define RST 17 #define DIO0 4 #define LED_BUILTIN 22
Esto configura la comunicación con el módulo LoRa, y de nuevo asignamos el pin 22 para el LED integrado. El hardware y la mayor parte del código son idénticos para transmisor y receptor, pero podrías usar configuraciones de hardware diferentes, por ejemplo, distintos microcontroladores o pines.
setup
Ahora entramos en la función setup(), que es casi idéntica a la del transmisor:
void setup() {
Serial.begin(115200);
pinMode(LED_BUILTIN, OUTPUT);
LoRa.setPins(SS, RST, DIO0);
Abrimos la conexión serial a 115200 baudios para poder imprimir los mensajes entrantes. Luego configuramos el pin del LED como salida y asignamos los pines de control LoRa con LoRa.setPins().
Al igual que en el transmisor, inicializamos LoRa en la frecuencia de 868 MHz, usada en Europa:
while (!LoRa.begin(868E6)) {
Serial.println(".");
delay(500);
}
Obviamente, tanto transmisor como receptor deben operar en la misma frecuencia. Si el módulo no se inicializa correctamente, reintentamos cada 500 milisegundos, imprimiendo puntos en el Monitor Serial para dar feedback.
Luego viene la misma configuración LoRa usada en el transmisor:
LoRa.setSyncWord(0x34); LoRa.setSpreadingFactor(12); LoRa.setSignalBandwidth(125E3); LoRa.setCodingRate4(8); LoRa.enableCrc(); }
Al reflejar la configuración del transmisor, aseguramos que ambos dispositivos puedan entenderse. Si aunque sea un parámetro no coincide —como la palabra de sincronización o el ancho de banda— el receptor no podrá decodificar el paquete.
loop
Ahora veamos el corazón del receptor, la función loop():
void loop() {
if (LoRa.parsePacket()) {
Aquí, LoRa.parsePacket() verifica si ha llegado un paquete. Si no se recibe nada, la función devuelve 0 y se salta el resto del bucle.
Cuando un paquete es recibido, encendemos inmediatamente el LED para señalar el evento.
digitalWrite(LED_BUILTIN, LOW);
Ten en cuenta que la lógica del LED integrado está invertida. LOW significa que el LED está encendido y HIGH que está apagado.
Luego leemos el contenido del paquete byte a byte y lo imprimimos como caracteres en el Monitor Serial:
while (LoRa.available()) {
Serial.print((char)LoRa.read());
}
Aquí es donde aparecen los mensajes "Counter=1", "Counter=2" enviados por el transmisor.LoRa.available() verifica si hay más bytes disponibles, y LoRa.read() obtiene cada byte del paquete. Lo convertimos a char para que se imprima como texto legible.
Luego imprimimos el RSSI (Indicador de intensidad de señal recibida), que nos dice qué tan fuerte fue la señal:
Serial.printf(" (%d)\n", LoRa.packetRssi());
Esto es útil para depurar el alcance de tu radio. Cuanto más negativo sea el número, más débil es la señal. Por ejemplo, -45 dB es fuerte, mientras que -120 dB es casi ilegible.
Finalmente, hacemos una breve pausa para poder ver el LED encendido y luego lo apagamos, indicando que el código ahora espera el siguiente paquete.
delay(100);
digitalWrite(LED_BUILTIN, HIGH);
}
}
Con este código, tu receptor LoRa ESP32 escucha mensajes como "Counter=3" enviados desde tu transmisor. Obtienes confirmación visual a través del LED y actualizaciones en vivo en el Monitor Serial con lecturas de intensidad de señal entre paréntesis:
Y eso es todo. Ahora puedes enviar datos desde sensores que están a kilómetros de distancia y, gracias al bajo consumo de LoRa, esos sensores pueden funcionar mucho tiempo con batería.
Conclusiones
En este tutorial aprendiste cómo lograr comunicación de largo alcance usando el módulo LoRa SX1276 y el ESP32.
Si quieres usar un Arduino en lugar de un ESP32, necesitas usar un convertidor de nivel lógico o un Arduino que opere a 3.3 Voltios, ya que el módulo SX1276 no funciona con 5V. Echa un vistazo al Interface Arduino Uno with ST7735 TFT using Level Shifter tutorial si quieres aprender a usar un convertidor de nivel lógico.
Una aplicación típica de LoRa es enviar datos de temperatura, humedad y otros datos ambientales a largas distancias. Consulta nuestro Send Environmental Data with LoRa tutorial si eso es lo que quieres hacer.
Para comunicación rápida y simple de corto alcance, Bluetooth es más adecuado. Puedes encontrar información sobre eso en los tutoriales ESP32 And Bluetooth Module- HC-05 y How To Connect ESP32 Bluetooth With A Smartphone.
Y si quieres transmitir información por internet, el ESP32 send Telegram Message puede ser útil.
LoRa es genial para transmitir entre unos pocos sensores. Pero si tienes muchos sensores que gestionar y quieres enviar mediciones a internet, LoRaWAN es el camino a seguir. Consulta el tutorial LoRaWAN with Thinknode G1 Gateway para más información sobre este tema.
Finalmente, te recomiendo que explores la información en https://www.thethingsnetwork.org para aprender más sobre LoRa y el código de ejemplo del LoRa library. En este post solo hemos tocado la superficie.
Si tienes alguna pregunta, no dudes en dejarla en la sección de comentarios.
¡Feliz bricolaje ; )
