LoRa Arduino: módulo SX1278 Ra-02 con ESP32 para largo alcance

Los proyectos LoRa con Arduino son la forma más práctica de enviar datos entre dos placas a kilómetros de distancia, con muy poca energía y sin internet ni tarjeta SIM. LoRa (Long Range) es una modulación de radio desarrollada por Semtech; con módulos baratos como el Ra-02 con chip SX1278 a 433 MHz puedes llegar a 1–3 km en ciudad y hasta 10 km en campo abierto. El precio es la velocidad: de unos cientos de bytes a unos pocos kilobits por segundo. Por eso LoRa no sirve para audio o vídeo, pero es ideal para llevar lecturas pequeñas como temperatura, humedad, nivel de agua, estado de una puerta o posición GPS a gran distancia.

En esta guía verás paso a paso cómo llega LoRa tan lejos, los ajustes SF, BW y CR que deciden el alcance, la frecuencia correcta para tu región, cómo conectar el Ra-02 a un Arduino Uno, un ESP32 y una Raspberry Pi Pico, el código emisor y receptor con la librería LoRa, cómo leer RSSI y SNR y una prueba de alcance real. Las últimas secciones explican la diferencia entre LoRa y LoRaWAN, The Things Network (TTN) y un proyecto de sensor de campo que funciona meses con una batería.

¿Qué es LoRa y cómo llega tan lejos?

LoRa usa una técnica llamada espectro ensanchado por chirp (CSS). Cada símbolo se envía como un «chirp» cuya frecuencia sube de forma continua dentro de la banda; la información se esconde en la frecuencia a la que empieza el chirp. Cuando el receptor multiplica la señal recibida por la forma de chirp conocida y suma, el ruido se cancela mientras la señal se acumula. Gracias a esto LoRa decodifica señales hasta 20 dB por debajo del nivel de ruido. Los módulos ASK de 433 MHz necesitan que la señal sea claramente más fuerte que el ruido, mientras que LoRa entiende señales casi inexistentes; ese es el secreto para llegar mucho más lejos con la misma potencia.

El precio es el tiempo: cuanto más dura un chirp, más energía recoge el receptor y mayor es el alcance, pero los mismos datos se envían más despacio. En LoRa, alcance, velocidad y duración de la batería están siempre ligados. Una lectura de 20 bytes tarda unos 57 milisegundos con el ajuste más rápido y 1,3 segundos con el de mayor alcance. La tabla compara LoRa con otras opciones inalámbricas del mundo Arduino.

Módulos LoRa: Ra-02, RFM95, E32 y placas listas

La mayoría de módulos LoRa del mercado usan un chip de la familia SX127x de Semtech. El SX1276 cubre de 137 a 1020 MHz y el SX1278 de 137 a 525 MHz; por eso en los módulos de 433 MHz encontrarás el SX1278 y en los de 868/915 MHz el SX1276. Hay dos grupos: radios «desnudas» que se comunican por SPI y módulos con su propio procesador que se usan como un puerto serie por UART.

¿Qué frecuencia: 433, 868 o 915 MHz?

LoRa funciona en bandas ISM sin licencia, pero estas bandas cambian de un país a otro y cada una tiene límites de potencia y de ciclo de trabajo (duty cycle). En España y el resto de Europa se usan dos bandas: 433,05–434,79 MHz y 863–870 MHz. En México y la mayor parte de América se usa 902–928 MHz. Las redes LoRaWAN y TTN usan 868 MHz en Europa y 915 MHz en América, mientras que 433 MHz es muy común en enlaces punto a punto de aficionados con módulos Ra-02 baratos. Comprueba tu región antes de comprar, porque la antena y el chip están ajustados a una frecuencia concreta; un módulo de 868 MHz no funciona a 433 MHz.

SF, BW y CR: los tres ajustes que deciden el alcance

En LoRa, tres parámetros fijan el alcance y la velocidad. El factor de ensanchamiento (SF) elige de cuántos «chips» se compone cada símbolo: de SF7 a SF12, cada paso duplica la duración del símbolo, permite al receptor decodificar una señal unos 2,5 dB más débil, pero casi duplica el tiempo en el aire. La tabla está calculada para 125 kHz de ancho de banda, codificación 4/5 y un paquete de 20 bytes; la última columna es la espera mínima entre dos paquetes para respetar un ciclo de trabajo del 1 %.

El ancho de banda (BW) es la anchura de frecuencia que ocupa la señal: 125 kHz es lo estándar; 250 y 500 kHz duplican y cuadruplican la velocidad pero pierden 3 y 6 dB de sensibilidad, mientras que 62,5 kHz o menos aumentan el alcance pero se vuelven sensibles a la deriva de los cristales baratos. La tasa de codificación (CR) es el margen de corrección de errores: 4/5 añade 1 bit de corrección por cada 4 bits y 4/8 añade 4; ayuda en entornos ruidosos pero alarga el paquete. La fórmula de la velocidad es Rb = SF × (BW / 2^SF) × 4 / (4 + CR); para SF9, 125 kHz y 4/5 da 9 × 125000 / 512 × 0,8 ≈ 1758 bit/s.

Conexión del Ra-02: Arduino Uno, ESP32 y Pico

Además de las cuatro líneas SPI (SCK, MISO, MOSI, NSS), el Ra-02 necesita un pin de reset y uno de interrupción (DIO0). DIO0 se pone en HIGH cuando termina una transmisión o llega un paquete nuevo; la librería LoRa lo usa como interrupción. Los pines DIO1–DIO5 pueden quedar libres para el código de esta guía. Si SPI es nuevo para ti, lee antes el artículo Qué es SPI.

La antena es tan importante como el cableado. Pon en el conector IPEX del Ra-02 una antena ajustada a 433 MHz. Hacerla tú mismo es muy fácil: la longitud de onda es 300 / 433 = 0,693 metros y para una antena de cuarto de onda basta un cable recto de 17,3 cm (8,6 cm para 868 MHz y 8,2 cm para 915 MHz). Mantén la antena vertical, no la metas en una caja metálica y procura que las antenas de ambos lados apunten igual (las dos verticales); dos antenas en ángulo recto pierden la mayor parte de la señal.

Paso a paso: emisor con la librería LoRa

1. Abre el Gestor de Librerías del Arduino IDE, escribe LoRa e instala la librería LoRa de Sandeep Mistry.
2. Conecta el módulo como en la tabla y nunca transmitas sin la antena puesta.
3. Sube el código de abajo a la placa que hará de emisor; detecta si es un ESP32 o un Uno y elige los pines según eso.
4. Abre el Monitor Serie a 115200 baudios; deberías ver una línea «Gonderildi / sent» cada 5 segundos.
5. Si LoRa.begin() falla, revisa los cables, la alimentación de 3,3 V y los pines NSS y RESET.

1#include <SPI.h>
2#include <LoRa.h>
3
4#if defined(ESP32)
5const int PIN_SS = 5, PIN_RST = 14, PIN_DIO0 = 26;   // ESP32 (VSPI: SCK 18, MISO 19, MOSI 23)
6#else
7const int PIN_SS = 10, PIN_RST = 9, PIN_DIO0 = 2;    // Uno (SCK 13, MISO 12, MOSI 11) + seviye dönüştürücü / level shifter
8#endif
9
10const long FREKANS = 433E6;      // Ra-02: 433 MHz; RFM95 için 868E6 / 868E6 for an RFM95
11unsigned long sayac = 0;
12
13void setup() {
14  Serial.begin(115200);
15  LoRa.setPins(PIN_SS, PIN_RST, PIN_DIO0);
16  if (!LoRa.begin(FREKANS)) {               // SX1278 bulunamadı / SX1278 not found
17    Serial.println("LoRa baslatilamadi / LoRa init failed");
18    while (true) delay(1000);
19  }
20  LoRa.setSpreadingFactor(9);               // SF9: menzil ile hız dengesi / range vs speed balance
21  LoRa.setSignalBandwidth(125E3);           // 125 kHz bant genişliği / bandwidth
22  LoRa.setCodingRate4(5);                   // hata düzeltme 4/5 / error coding 4/5
23  LoRa.setSyncWord(0xF3);                   // iki tarafta aynı olmalı / must match on both sides
24  LoRa.enableCrc();                         // bozuk paketi ele / drop corrupted packets
25  LoRa.setTxPower(10);                      // 10 dBm (433 MHz bandında yasal sınır) / legal limit on 433 MHz
26  Serial.println("Verici hazir / sender ready");
27}
28
29void loop() {
30  LoRa.beginPacket();
31  LoRa.print("BG #");
32  LoRa.print(sayac);                        // paket numarası / packet number
33  LoRa.endPacket();                         // gönderim bitene kadar bekler / blocks until sent
34  Serial.print("Gonderildi / sent #");
35  Serial.println(sayac);
36  sayac++;
37  delay(5000);                              // havada kalma süresine göre bekle / wait according to airtime
38}
39

Receptor: leer paquetes, RSSI y SNR

El código receptor comprueba en cada vuelta con LoRa.parsePacket() si ha llegado un paquete nuevo; si es así, devuelve su tamaño y el contenido se lee byte a byte con LoRa.read(). Además, el código cuenta los saltos en los números de paquete para calcular la tasa de pérdida, que es la base de la prueba de alcance que haremos enseguida.

1#include <SPI.h>
2#include <LoRa.h>
3
4#if defined(ESP32)
5const int PIN_SS = 5, PIN_RST = 14, PIN_DIO0 = 26;
6#else
7const int PIN_SS = 10, PIN_RST = 9, PIN_DIO0 = 2;
8#endif
9
10long sonNo = -1;                 // son alınan paket numarası / last packet number
11unsigned long alinan = 0, kayip = 0;
12
13void setup() {
14  Serial.begin(115200);
15  LoRa.setPins(PIN_SS, PIN_RST, PIN_DIO0);
16  if (!LoRa.begin(433E6)) {
17    Serial.println("LoRa baslatilamadi / LoRa init failed");
18    while (true) delay(1000);
19  }
20  LoRa.setSpreadingFactor(9);    // verici ile aynı ayarlar / same settings as the sender
21  LoRa.setSignalBandwidth(125E3);
22  LoRa.setCodingRate4(5);
23  LoRa.setSyncWord(0xF3);
24  LoRa.enableCrc();
25  Serial.println("Alici hazir / receiver ready");
26}
27
28void loop() {
29  int boyut = LoRa.parsePacket();           // paket geldi mi? / did a packet arrive?
30  if (boyut == 0) return;
31
32  String mesaj = "";
33  while (LoRa.available()) mesaj += (char)LoRa.read();
34
35  int diyez = mesaj.indexOf('#');           // "BG #123" içinden numara / number from "BG #123"
36  long no = (diyez >= 0) ? mesaj.substring(diyez + 1).toInt() : -1;
37  if (sonNo >= 0 && no > sonNo + 1) kayip += no - sonNo - 1;   // atlanan numaralar kayıp / skipped numbers are lost
38  if (no >= 0) sonNo = no;
39  alinan++;
40
41  Serial.print(mesaj);
42  Serial.print("  RSSI: ");
43  Serial.print(LoRa.packetRssi());          // dBm, -120'ye yaklaştıkça zayıf / weaker towards -120
44  Serial.print(" dBm  SNR: ");
45  Serial.print(LoRa.packetSnr(), 1);        // dB, eksi değerler de çözülebilir / negative values still decode
46  Serial.print(" dB  kayip / lost: ");
47  Serial.print(100.0 * kayip / (alinan + kayip), 1);
48  Serial.println(" %");
49}
50

El RSSI (Received Signal Strength Indicator) es la potencia de la señal recibida, un número negativo en dBm: -40 dBm es muy fuerte y -120 dBm muy débil. El SNR (relación señal-ruido) indica cuánto más fuerte es la señal que el ruido. Lo especial de LoRa es que el SNR puede ser negativo: con SF9 los paquetes se siguen decodificando hasta -12,5 dB. Para saber si estás cerca del límite de alcance, fíjate más en el SNR que en el RSSI; en una ciudad ruidosa el SNR puede estar ya en el límite con un RSSI de -100 dBm.

LoRa con el ESP32: puente hacia el Wi-Fi

El ESP32 es la placa más cómoda para LoRa: sus pines ya son de 3,3 V, el pin 3V3 aguanta la corriente del módulo y el bus VSPI (GPIO 18, 19, 23) se usa directamente. Los códigos emisor y receptor de arriba compilan en el ESP32 sin cambios; la línea #if defined(ESP32) elige NSS = 5, RESET = 14 y DIO0 = 26. Conectamos DIO0 al GPIO 26 y no al GPIO 2 porque el GPIO 2 es un pin de arranque (strapping) que influye en cómo arranca el chip. La verdadera fuerza del ESP32 es hacer de puente: puede reenviar por Wi-Fi a una página web, un servidor MQTT o Telegram los datos que llegan por LoRa desde los sensores del campo. Placas como la TTGO LoRa32 y la Heltec LoRa 32 traen ESP32, chip LoRa y pantalla OLED en una sola placa; sus números de pin son distintos, así que mira el esquema de la placa.

LoRa con la Raspberry Pi Pico (MicroPython)

En la Pico conectas el Ra-02 al bus SPI0 (GP16 MISO, GP18 SCK, GP19 MOSI, GP17 NSS). El repositorio oficial micropython-lib incluye un driver LoRa para chips SX127x; puedes instalarlo desde el gestor de paquetes de Thonny o con mpremote mip install lora-sync lora-sx127x. El driver recibe la configuración como un diccionario; mientras SF, ancho de banda y sync word coincidan con el lado Arduino, la Pico lee sin problemas los paquetes del emisor Arduino de arriba. El driver entrega el SNR tal como está en el registro del chip, cuatro veces el valor en dB, por eso el código lo divide entre 4. Como la antena del Ra-02 está en la salida PA_BOOST del chip, el ajuste tx_ant debe ser "PA_BOOST"; si no, la transmisión será muy débil.

1from machine import Pin, SPI
2from lora import SX1278          # mip: lora-sync + lora-sx127x paketleri / packages
3import time
4
5lora_cfg = {
6    "freq_khz": 433000,          # Ra-02: 433 MHz
7    "sf": 9,                     # Arduino tarafıyla aynı / same as the Arduino side
8    "bw": "125",                 # kHz
9    "coding_rate": 5,            # 4/5
10    "preamble_len": 8,
11    "syncword": 0xF3,
12    "tx_ant": "PA_BOOST",        # Ra-02 anteni PA_BOOST çıkışında / Ra-02 antenna is on PA_BOOST
13    "output_power": 10,          # dBm
14}
15
16spi = SPI(0, baudrate=2_000_000, sck=Pin(18), mosi=Pin(19), miso=Pin(16))
17modem = SX1278(spi=spi, cs=Pin(17), dio0=Pin(21), reset=Pin(20), lora_cfg=lora_cfg)
18
19while True:
20    paket = modem.recv(timeout_ms=10000)       # 10 sn dinle / listen for 10 s
21    if paket and paket.valid_crc:
22        # snr kayıtta 4 katı tutulur / snr is stored as 4x in the register
23        print(bytes(paket), "RSSI:", paket.rssi, "dBm  SNR:", paket.snr / 4, "dB")
24    elif paket:
25        print("CRC hatali paket / bad CRC")
26    else:
27        print("Paket yok / no packet")
28    time.sleep_ms(10)
29

Prueba de alcance: ¿cuántos km llega LoRa?

La única forma de saber el alcance real es probarlo. Coloca el emisor junto a una ventana o en el tejado de casa, conecta el receptor a un portátil o a un ESP32 + OLED alimentado con una batería externa y apunta RSSI, SNR y tasa de pérdida mientras te alejas. Cuando la pérdida supere el 10 % o el SNR se acerque al límite del SF, habrás llegado al final del alcance práctico. Cambia solo una cosa en cada prueba (SF, antena, altura) para saber de dónde viene la diferencia. Puedes medir la distancia en línea recta entre dos puntos con una app de mapas del móvil.

• Sube la antena: nada aumenta tanto el alcance como la altura de la antena. Una antena a 5 metros en lugar de a 1 metro alarga la línea de vista muchas veces.
• Antena adecuada: las pequeñas antenas de muelle que traen los módulos son cómodas pero poco eficientes; un cable de cuarto de onda de 17,3 cm o una antena de exterior marca una diferencia clara.
• Sube el SF: pasar de SF9 a SF12 da unos 8 dB de ganancia, lo que en campo abierto supone aproximadamente más del doble de distancia.
• Estrecha el ancho de banda: bajar de 125 kHz a 62,5 kHz gana 3 dB, aunque la deriva de los cristales de los dos módulos puede dar problemas.
• Despeja la zona de Fresnel: aunque la línea de vista parezca libre, los árboles o edificios en la zona elíptica entre las dos antenas debilitan la señal; subir un poco las antenas lo soluciona.
• No descuides la alimentación: el pico de corriente al transmitir puede hundir una línea de 3,3 V débil y reiniciar el módulo; añade un condensador de 100 µF a la alimentación.

LoRa frente a LoRaWAN: ¿qué es TTN?

Estos dos términos se confunden a menudo. LoRa es solo la modulación de radio, la capa física: dos módulos se envían paquetes directamente y tú decides quién envía qué a quién. Todos los ejemplos de esta guía son LoRa punto a punto. LoRaWAN es un protocolo de red construido sobre LoRa: los dispositivos (nodos) envían sus paquetes a los gateways cercanos, los gateways los pasan por internet a un servidor de red y desde allí los datos llegan a tu aplicación. LoRaWAN se encarga por sí mismo de las identidades de los dispositivos, el cifrado AES-128, el ajuste automático de frecuencia y SF (ADR) y las reglas del ciclo de trabajo.

The Things Network (TTN) es una red LoRaWAN gratuita y comunitaria formada por gateways que instalan voluntarios. Si hay un gateway de TTN cerca, puedes registrar tu dispositivo y leer sus datos en internet sin montar tu propio gateway. El uso gratuito tiene una política de uso justo: unos 30 segundos de transmisión al día por dispositivo y como mucho 10 mensajes de bajada al día. Como TTN usa EU868 en Europa y US915 o AU915 en América, un Ra-02 de 433 MHz no sirve para esta red; para TTN necesitas un RFM95 de tu banda o un módulo LoRaWAN listo. Si no hay gateway cerca, LoRa punto a punto es mucho más sencillo.

Proyecto: sensor de campo y jardín a pilas

El uso clásico de LoRa es recoger datos de un campo sin luz ni Wi-Fi o de un invernadero al fondo del jardín. El código ESP32 de abajo mide la humedad del suelo, envía un paquete pequeño con el formato «T1,42,37» (ID del nodo, número de paquete, porcentaje de humedad), duerme tanto el módulo LoRa como el ESP32 y vuelve a despertar 10 minutos después. El sensor solo se alimenta por el GPIO 25 durante la medida; así no consume en reposo y, en los sensores resistivos, se reduce además la corrosión de los electrodos. La calibración del sensor está en el artículo Sensor de humedad del suelo y el sueño profundo en ESP32 Deep Sleep. El receptor de casa puede usar el código receptor de arriba y separar los valores por las comas.

1#include <SPI.h>
2#include <LoRa.h>
3
4const int PIN_SS = 5, PIN_RST = 14, PIN_DIO0 = 26;
5const int NEM_PIN = 34;                      // toprak nem sensörü AO (yalnız giriş pini) / soil sensor AO (input-only pin)
6const int SENSOR_GUC = 25;                   // sensörü yalnız ölçerken besle / power the sensor only while measuring
7const int KURU = 3000, ISLAK = 1200;         // kendi sensörünle kalibre et / calibrate with your sensor
8const uint64_t UYKU_US = 10ULL * 60 * 1000000;   // 10 dakika / 10 minutes
9
10RTC_DATA_ATTR uint32_t paketNo = 0;          // derin uykuda korunur / kept during deep sleep
11
12void setup() {
13  pinMode(SENSOR_GUC, OUTPUT);
14  digitalWrite(SENSOR_GUC, HIGH);
15  delay(200);                                // sensör otursun / let the sensor settle
16  int ham = analogRead(NEM_PIN);
17  digitalWrite(SENSOR_GUC, LOW);
18  int nem = constrain(map(ham, KURU, ISLAK, 0, 100), 0, 100);   // % nem / % moisture
19
20  LoRa.setPins(PIN_SS, PIN_RST, PIN_DIO0);
21  if (LoRa.begin(433E6)) {
22    LoRa.setSpreadingFactor(10);             // uzak tarla için daha yüksek SF / higher SF for a distant field
23    LoRa.setSignalBandwidth(125E3);
24    LoRa.setSyncWord(0xF3);
25    LoRa.enableCrc();
26    LoRa.setTxPower(10);
27    LoRa.beginPacket();
28    LoRa.print("T1,");                       // düğüm kimliği / node id
29    LoRa.print(paketNo++);
30    LoRa.print(",");
31    LoRa.print(nem);                         // ör. "T1,42,37" / e.g. "T1,42,37"
32    LoRa.endPacket();
33    LoRa.sleep();                            // SX1278 uykuda 1 uA altı / under 1 uA asleep
34  }
35  esp_sleep_enable_timer_wakeup(UYKU_US);
36  esp_deep_sleep_start();                    // 10 dk sonra setup() baştan başlar / setup() restarts after 10 min
37}
38
39void loop() {}
40

Calculemos a grandes rasgos la duración de la batería. Cada 10 minutos (600 segundos) el nodo despierta unos 0,5 segundos y consume de media unos 100 mA; en reposo, un módulo ESP32 desnudo y el Ra-02 juntos rondan los 15 µA. La corriente media es (0,5 × 100) / 600 + 0,015 ≈ 0,1 mA; una pila 18650 de 2000 mAh duraría en teoría 20 000 horas, más de dos años. En la práctica la autodescarga de la pila y las pérdidas del regulador acortan ese tiempo. Ojo: las placas ESP32 DevKit pueden consumir varios miliamperios incluso en reposo por el chip USB-serie y el regulador; una corriente de reposo de 5 mA deja la misma pila en 17 días. Para una batería de larga duración, usa un regulador de bajo consumo en reposo o un módulo desnudo. Puedes hacer la cuenta con tus valores en la calculadora de duración de batería.

Ideas de proyectos con LoRa

• Nivel de un depósito lejano: mide con un sensor de nivel de agua lo lleno que está un depósito lejano y envíalo a casa.
• Aviso del buzón: detecta con un interruptor reed cuando se abre el buzón de la verja y muéstralo en una pantalla dentro de casa.
• Báscula de colmena: envía el peso de la colmena varias veces al día con una célula de carga HX711.
• Rastreador GPS: sigue una bici o animales a kilómetros de distancia con un GPS NEO-6M.
• Clima del invernadero: recibe por LoRa la temperatura y humedad del invernadero y lanza un aviso en casa si se supera un umbral.
• Tu propio gateway: reenvía al Wi-Fi los datos de varios sensores LoRa con un solo ESP32 y consúltalos en el móvil.

Errores frecuentes y soluciones

Un módulo LoRa es la forma más barata de sacar los proyectos Arduino de casa al campo, al jardín y al edificio de al lado: con la frecuencia correcta, un SF adecuado y una buena antena puedes montar sensores que funcionan meses con pilas a kilómetros de distancia. Para datos rápidos a menor distancia, quizá te convenga más el nRF24L01 o ESP-NOW. En la app BlueGrays encontrarás proyectos de comunicación en uno y dos sentidos entre dos Arduino, riego inteligente y sueño profundo del ESP32, paso a paso con esquema y código, y podrás añadirles LoRa.