LoRa Arduino: modulo SX1278 Ra-02 con ESP32 a lungo raggio

I progetti LoRa con Arduino sono il modo più pratico per inviare dati tra due schede a chilometri di distanza, con pochissima energia e senza internet né SIM. LoRa (Long Range) è una modulazione radio sviluppata da Semtech; con moduli economici come il Ra-02 con chip SX1278 a 433 MHz puoi arrivare a 1–3 km in città e fino a 10 km in campo aperto. Il prezzo da pagare è la velocità: da qualche centinaio di byte a pochi kilobit al secondo. Per questo LoRa non serve per audio o video, ma è ideale per portare lontano piccole misure come temperatura, umidità, livello dell'acqua, stato di una porta o posizione GPS.

In questa guida vedrai passo passo perché LoRa arriva così lontano, le impostazioni SF, BW e CR che decidono la portata, la frequenza giusta per la tua zona, come collegare il Ra-02 ad Arduino Uno, ESP32 e Raspberry Pi Pico, il codice trasmettitore e ricevitore con la libreria LoRa, come leggere RSSI e SNR e un vero test di portata. Le ultime sezioni spiegano la differenza tra LoRa e LoRaWAN, The Things Network (TTN) e un progetto di sensore da campo che dura mesi con una batteria.

Cos'è LoRa e perché arriva così lontano?

LoRa usa una tecnica chiamata chirp spread spectrum (CSS). Ogni simbolo viene inviato come un «chirp» la cui frequenza sale in modo continuo nella banda; l'informazione è nascosta nella frequenza da cui parte il chirp. Quando il ricevitore moltiplica il segnale ricevuto per la forma del chirp nota e somma, il rumore si annulla mentre il segnale si accumula. Così LoRa riesce a decodificare segnali fino a 20 dB sotto il livello del rumore. I normali moduli ASK a 433 MHz vogliono un segnale nettamente più forte del rumore, mentre LoRa capisce segnali quasi inesistenti: è questo il segreto della portata molto maggiore a parità di potenza.

Il prezzo è il tempo: più dura un chirp, più energia raccoglie il ricevitore e maggiore è la portata, ma gli stessi dati partono più lentamente. In LoRa portata, velocità e autonomia sono sempre legate. Una misura da 20 byte richiede circa 57 millisecondi con l'impostazione più veloce e 1,3 secondi con quella a portata massima. La tabella confronta LoRa con le altre soluzioni wireless del mondo Arduino.

Moduli LoRa: Ra-02, RFM95, E32 e schede pronte

La maggior parte dei moduli LoRa in commercio usa un chip della famiglia SX127x di Semtech. L'SX1276 copre 137–1020 MHz e l'SX1278 137–525 MHz; per questo nei moduli a 433 MHz trovi l'SX1278 e in quelli a 868/915 MHz l'SX1276. Ci sono due gruppi: radio «nude» che comunicano via SPI e moduli con un proprio processore, da usare come una porta seriale via UART.

Quale frequenza: 433 MHz o 868 MHz?

LoRa lavora nelle bande ISM senza licenza, ma queste bande cambiano da paese a paese e ognuna ha limiti di potenza e di duty cycle (percentuale di tempo in trasmissione). In Italia e in Europa per LoRa si usano due bande: 433,05–434,79 MHz e 863–870 MHz. Le reti LoRaWAN e TTN usano 868 MHz in Europa, mentre i 433 MHz sono molto diffusi per i collegamenti punto-punto amatoriali con gli economici Ra-02. Controlla la tua zona prima di comprare, perché antenna e chip sono accordati su una frequenza precisa; un modulo a 868 MHz non funziona a 433 MHz.

SF, BW e CR: le tre impostazioni che decidono la portata

In LoRa tre parametri fissano portata e velocità. Lo Spreading Factor (SF) sceglie di quanti «chip» è fatto ogni simbolo: da SF7 a SF12 ogni passo raddoppia la durata del simbolo, permette al ricevitore di decodificare un segnale circa 2,5 dB più debole, ma quasi raddoppia il tempo in aria. La tabella è calcolata per banda da 125 kHz, codifica 4/5 e un pacchetto da 20 byte; l'ultima colonna è l'attesa minima tra due pacchetti per rispettare un duty cycle dell'1%.

La larghezza di banda (BW) è l'ampiezza di frequenza occupata dal segnale: 125 kHz è lo standard; 250 e 500 kHz raddoppiano e quadruplicano la velocità ma perdono 3 e 6 dB di sensibilità, mentre 62,5 kHz e meno aumentano la portata ma diventano sensibili alla deriva dei quarzi economici. Il Coding Rate (CR) è la quota di correzione degli errori: 4/5 aggiunge 1 bit di correzione ogni 4 bit, 4/8 ne aggiunge 4; aiuta negli ambienti disturbati ma allunga il pacchetto. La formula della velocità è Rb = SF × (BW / 2^SF) × 4 / (4 + CR); per SF9, 125 kHz e 4/5 si ottiene 9 × 125000 / 512 × 0,8 ≈ 1758 bit/s.

Collegare il Ra-02: Arduino Uno, ESP32 e Pico

Oltre alle quattro linee SPI (SCK, MISO, MOSI, NSS), il Ra-02 vuole un pin di reset e uno di interrupt (DIO0). DIO0 va HIGH quando una trasmissione termina o arriva un nuovo pacchetto; la libreria LoRa lo usa come interrupt. I pin DIO1–DIO5 possono restare liberi per il codice di questa guida. Se SPI ti è nuovo, leggi prima l'articolo Cos'è SPI.

L'antenna conta quanto i collegamenti. Monta sul connettore IPEX del Ra-02 un'antenna accordata a 433 MHz. Costruirla da solo è facile: la lunghezza d'onda è 300 / 433 = 0,693 metri e per un'antenna a quarto d'onda basta un filo dritto di 17,3 cm (8,6 cm per 868 MHz). Tieni l'antenna verticale, non chiuderla in una scatola di metallo e fai in modo che le antenne dei due lati abbiano lo stesso orientamento (entrambe verticali); due antenne ad angolo retto perdono gran parte del segnale.

Passo passo: trasmettitore con la libreria LoRa

1. Apri il Gestore librerie dell'Arduino IDE, scrivi LoRa e installa la libreria LoRa di Sandeep Mistry.
2. Collega il modulo come in tabella e non trasmettere mai senza antenna montata.
3. Carica il codice qui sotto sulla scheda che farà da trasmettitore; riconosce da solo se è un ESP32 o un Uno e sceglie i pin di conseguenza.
4. Apri il Monitor seriale a 115200 baud; ogni 5 secondi dovresti vedere una riga «Gonderildi / sent».
5. Se LoRa.begin() fallisce, controlla i cavi, l'alimentazione a 3,3 V e i pin NSS e 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

Ricevitore: leggere i pacchetti, RSSI e SNR

Il codice del ricevitore controlla a ogni giro con LoRa.parsePacket() se è arrivato un nuovo pacchetto; in caso affermativo ne restituisce la dimensione e il contenuto si legge byte per byte con LoRa.read(). Il codice conta anche i salti nei numeri di pacchetto per calcolare la percentuale di perdita, la base del test di portata che faremo tra poco.

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

L'RSSI (Received Signal Strength Indicator) è la potenza del segnale ricevuto, un numero negativo in dBm: -40 dBm è fortissimo, -120 dBm molto debole. L'SNR (rapporto segnale/rumore) indica quanto il segnale supera il rumore. La particolarità di LoRa è che l'SNR può diventare negativo: con SF9 i pacchetti si decodificano fino a -12,5 dB. Per capire se sei vicino al limite della portata guarda più l'SNR che l'RSSI; in una città rumorosa l'SNR può essere già al limite con un RSSI di -100 dBm.

LoRa con l'ESP32: un ponte verso il Wi-Fi

L'ESP32 è la scheda più comoda per LoRa: i suoi pin sono già a 3,3 V, il pin 3V3 regge la corrente del modulo e il bus VSPI (GPIO 18, 19, 23) si usa direttamente. Il codice del trasmettitore e del ricevitore qui sopra compila sull'ESP32 senza modifiche; la riga #if defined(ESP32) sceglie NSS = 5, RESET = 14 e DIO0 = 26. Colleghiamo DIO0 al GPIO 26 invece che al GPIO 2 perché il GPIO 2 è un pin di strapping che influisce sull'avvio del chip. La vera forza dell'ESP32 è fare da ponte: può inoltrare via Wi-Fi a una pagina web, a un server MQTT o a Telegram i dati che arrivano via LoRa dai sensori in campo. Schede come TTGO LoRa32 e Heltec LoRa 32 riuniscono ESP32, chip LoRa e display OLED su un'unica scheda; i numeri dei pin sono diversi, quindi controlla lo schema della scheda.

LoRa con il Raspberry Pi Pico (MicroPython)

Sul Pico colleghi il Ra-02 al bus SPI0 (GP16 MISO, GP18 SCK, GP19 MOSI, GP17 NSS). Il repository ufficiale micropython-lib contiene un driver LoRa per i chip SX127x; puoi installarlo dal gestore pacchetti di Thonny oppure con mpremote mip install lora-sync lora-sx127x. Il driver riceve le impostazioni come dizionario; finché SF, larghezza di banda e sync word coincidono con il lato Arduino, il Pico legge senza problemi i pacchetti del trasmettitore Arduino qui sopra. Il driver restituisce l'SNR così come sta nel registro del chip, cioè quattro volte il valore in dB, per questo il codice lo divide per 4. Poiché l'antenna del Ra-02 è collegata all'uscita PA_BOOST del chip, l'impostazione tx_ant deve essere "PA_BOOST"; altrimenti la trasmissione resta debolissima.

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

Test di portata: quanti km fa LoRa?

L'unico modo per conoscere la portata reale è provare. Metti il trasmettitore alla finestra o sul tetto di casa, collega il ricevitore a un portatile o a un ESP32 + OLED alimentato da un power bank e annota RSSI, SNR e percentuale di perdita mentre ti allontani. Quando la perdita supera il 10% o l'SNR si avvicina al limite dello SF, sei arrivato alla fine della portata pratica. Cambia una sola cosa per volta (SF, antenna, altezza) così capisci da dove arriva la differenza. La distanza in linea d'aria tra due punti si misura con un'app di mappe sul telefono.

• Alza l'antenna: nulla aumenta la portata quanto l'altezza dell'antenna. Un'antenna a 5 metri invece che a 1 metro allunga di molte volte la linea di vista.
• Antenna adatta: le piccole antenne a molla fornite con i moduli sono comode ma poco efficienti; un filo a quarto d'onda da 17,3 cm o un'antenna a stilo da esterno fa una netta differenza.
• Alza lo SF: passare da SF9 a SF12 dà circa 8 dB di guadagno, che in campo aperto significa grosso modo più del doppio della distanza.
• Restringi la banda: scendere da 125 kHz a 62,5 kHz guadagna 3 dB, ma la deriva dei quarzi dei due moduli può creare problemi.
• Libera la zona di Fresnel: anche se la linea di vista sembra libera, alberi o edifici nella zona a forma di ellisse tra le due antenne indeboliscono il segnale; alzare un po' le antenne risolve.
• Non trascurare l'alimentazione: il picco di corrente in trasmissione può far crollare una linea a 3,3 V debole e resettare il modulo; aggiungi un condensatore da 100 µF all'alimentazione.

LoRa e LoRaWAN: cos'è TTN?

I due termini vengono spesso confusi. LoRa è solo la modulazione radio, il livello fisico: due moduli si inviano pacchetti direttamente e sei tu a decidere chi invia cosa a chi. Tutti gli esempi di questa guida sono LoRa punto-punto. LoRaWAN è invece un protocollo di rete costruito sopra LoRa: i dispositivi (nodi) inviano i pacchetti ai gateway vicini, i gateway li passano via internet a un server di rete e da lì i dati arrivano alla tua applicazione. LoRaWAN gestisce da solo identità dei dispositivi, crittografia AES-128, adattamento automatico di frequenza e SF (ADR) e regole del duty cycle.

The Things Network (TTN) è una rete LoRaWAN gratuita e comunitaria, fatta di gateway installati da volontari. Se c'è un gateway TTN vicino a te, puoi registrare il dispositivo e leggere i suoi dati su internet senza costruire un gateway tuo. L'uso gratuito segue una fair use policy: circa 30 secondi di trasmissione al giorno per dispositivo e al massimo 10 messaggi in downlink al giorno. Poiché in Europa TTN usa EU868, un Ra-02 a 433 MHz non va bene; per TTN prendi un RFM95 a 868 MHz o un modulo LoRaWAN pronto. Senza gateway nelle vicinanze, il LoRa punto-punto è molto più semplice.

Progetto: sensore da campo e da giardino a batteria

L'uso classico di LoRa è raccogliere dati da un campo senza corrente né Wi-Fi o da una serra in fondo al giardino. Il codice ESP32 qui sotto misura l'umidità del terreno, invia un piccolo pacchetto nel formato «T1,42,37» (ID del nodo, numero del pacchetto, percentuale di umidità), poi mette a dormire sia il modulo LoRa sia l'ESP32 e si risveglia 10 minuti dopo. Il sensore è alimentato dal GPIO 25 solo durante la misura; così a riposo non consuma e, nei sensori resistivi, si riduce anche la corrosione degli elettrodi. La calibrazione del sensore è nell'articolo Sensore di umidità del terreno e i dettagli del deep sleep in ESP32 Deep Sleep. Il ricevitore di casa può usare il codice del ricevitore qui sopra separando i valori alle virgole.

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

Stimiamo a grandi linee l'autonomia. Ogni 10 minuti (600 secondi) il nodo si sveglia per circa 0,5 secondi e in quel tempo assorbe in media 100 mA; a riposo un modulo ESP32 nudo e il Ra-02 insieme stanno intorno ai 15 µA. La corrente media è (0,5 × 100) / 600 + 0,015 ≈ 0,1 mA; una cella 18650 da 2000 mAh durerebbe in teoria 20.000 ore, cioè più di due anni. Nella realtà autoscarica e perdite del regolatore accorciano questo tempo. Attenzione: le schede ESP32 DevKit possono assorbire diversi milliampere anche a riposo per via del chip USB-seriale e del regolatore; una corrente di riposo di 5 mA riduce la stessa cella a 17 giorni. Per una lunga autonomia usa un regolatore a basso consumo a vuoto o un modulo nudo. Puoi rifare il conto con i tuoi valori nel calcolatore di autonomia della batteria.

Idee di progetto con LoRa

• Livello di una cisterna lontana: misura quanto è piena una cisterna lontana con un sensore di livello dell'acqua e invia il dato a casa.
• Avviso cassetta della posta: rileva con un interruttore reed l'apertura della cassetta al cancello e mostralo su un display in casa.
• Bilancia per arnia: invia il peso dell'arnia più volte al giorno con una cella di carico HX711.
• Localizzatore GPS: segui una bici o degli animali a chilometri di distanza con un GPS NEO-6M.
• Clima della serra: ricevi via LoRa temperatura e umidità della serra e fai scattare un avviso in casa quando si supera una soglia.
• Il tuo gateway: inoltra al Wi-Fi i dati di diversi sensori LoRa con un solo ESP32 e seguili dal telefono.

Errori comuni e soluzioni

Un modulo LoRa è il modo più economico per portare i progetti Arduino fuori casa, nel campo, in giardino e nell'edificio accanto: con la frequenza giusta, uno SF adatto e una buona antenna puoi costruire sensori che durano mesi a batteria a chilometri di distanza. Per dati veloci su distanze più brevi possono andare meglio l'nRF24L01 o ESP-NOW. Nell'app BlueGrays trovi progetti di comunicazione monodirezionale e bidirezionale tra due Arduino, di irrigazione intelligente e di deep sleep con l'ESP32, passo passo con schema e codice, a cui puoi aggiungere LoRa.