In questo tutorial imparerai come abilitare la comunicazione a lunga distanza usando il modulo LoRa SX1276 e l’ESP32. Ad esempio, se vuoi ricevere dati da sensori lontani dove non hai copertura Wi-Fi, come un sensore di temperatura nell’angolo del tuo giardino, LoRa può aiutarti.
LoRa è una tecnologia wireless progettata per inviare piccole quantità di dati su lunghe distanze consumando pochissima energia. Funziona bene in aree aperte e può raggiungere diversi chilometri, molto più lontano di WiFi o Bluetooth. Questo la rende ideale per dispositivi alimentati a batteria come sensori in fattorie, città o zone remote dove il WiFi o il Bluetooth tradizionali non arrivano o consumano troppa energia.
Se conosci già LoRa e vuoi solo sapere come inviare dati ambientali come temperatura e umidità, dai un’occhiata al Send Environmental Data with LoRa tutorial.
Componenti necessari
Di seguito trovi i componenti necessari per questo tutorial. Ho usato una vecchia scheda ESP32, ormai obsoleta ma ancora reperibile a basso costo. Nota che esiste anche una versione con porta USB-C. Comunque, qualsiasi altro ESP32 andrà bene. Ricorda solo che ti serviranno due schede e due moduli SX1276 – uno per inviare e uno per ricevere.
Per quanto riguarda i moduli transceiver LoRa SX1276, fai attenzione alla versione che acquisti! Depending on the country le frequenze consentite per questi moduli variano. Sono 868MHz per l’Europa, 915MHz per il Nord America e 433MHz per l’Asia.
La descrizione del modulo indica la frequenza o ha un numero come 868 o 915 nel nome. Ho elencato un modulo a 868MHz, dato che sono in Europa. Ma puoi trovare anche moduli per la banda 915MHz.
2 x Modulo LoRa 868/915M SX1276
2 x ESP32 lite
Cavo dati USB
Set di fili Dupont
2x Breadboard
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.
Cos’è LoRa?
Se stai realizzando progetti con Arduino o ESP32 e hai bisogno di inviare dati wireless su lunghe distanze, LoRa (abbreviazione di Long Range) potrebbe essere proprio quello che ti serve. A differenza di WiFi e Bluetooth, progettati per comunicazioni veloci e a corto raggio, LoRa è pensata per trasmissioni a bassa potenza e lunga distanza — perfetta per sensori remoti e dispositivi che devono funzionare per mesi o anni con una piccola batteria.
LoRa usa una particolare modulazione radio chiamata Chirp Spread Spectrum (CSS). Questo la rende molto resistente alle interferenze e permette ai dispositivi di comunicare su diversi chilometri, anche in ambienti rumorosi o con ostacoli come alberi e edifici. LoRa opera in unlicensed ISM frequency bands — tipicamente 868 MHz in Europa, 915 MHz in Nord America e 433 MHz in alcuni paesi asiatici. Queste frequenze variano per regione ma hanno tutte il vantaggio di essere libere da licenze.
Il compromesso con LoRa è che non è fatta per dati ad alta velocità. Funziona meglio con piccoli payload, come letture di sensori o aggiornamenti di stato. Le velocità dati variano tipicamente da 0,3 kbps a 50 kbps, a seconda del spreading factor (SF), della larghezza di banda e del coding rate scelti. La portata dipende anche da queste impostazioni e dall’ambiente: puoi aspettarti 2–5 km in aree urbane e 10–15 km in zone rurali o in linea di vista — a volte anche di più con antenne adeguate.
LoRa vs WiFi e Bluetooth
Il WiFi offre velocità elevate ma consuma molta energia e copre solitamente meno di 100 metri. Il Bluetooth ha una portata ancora più corta ed è più adatto a dispositivi indossabili e personali. La tabella seguente confronta le caratteristiche principali di LoRa con WiFi e Bluetooth:
| Caratteristica | LoRa | WiFi | Bluetooth |
|---|---|---|---|
| Consumo energetico | Molto basso (μA in sleep, ~10–50 mA attivo) | Alto (~70–300 mA attivo) | Basso (~10–30 mA attivo) |
| Portata | 2–15 km (rurale), 0.5–5 km (urbano) | ~50–100 metri (interno), ~200 metri (aperto) | ~10–100 metri |
| Velocità dati tipica | 0.3–50 kbps | Fino a 100–600 Mbps (ESP32: ~150 Mbps) | ~1–3 Mbps (Classic), ~125–200 kbps (BLE) |
| Latenza | Alta (100 ms fino a diversi secondi) | Bassa (~1–10 ms) | Bassa (~3–50 ms BLE) |
In questo post vedremo come usare LoRa con schede ESP32 e moduli come lo SX1276, e ti mostreremo come iniziare a inviare messaggi tra dispositivi distanti chilometri — senza bisogno di WiFi, torri cellulari o molta energia.
Modulo LoRa SX1276
Lo SX1276 è un popolare modulo transceiver LoRa prodotto da Semtech, ed è uno dei chip più usati per comunicazioni wireless a lunga distanza e basso consumo in progetti DIY e IoT. Supporta la modulazione LoRa e anche modalità tradizionali FSK/OOK, rendendolo versatile per molte applicazioni.
Lo SX1276 è al centro di molti moduli LoRa, incluso il noto HopeRF RFM95W, molto simile al modulo che uso in questo tutorial. L’immagine seguente mostra il fronte del modulo LoRa SX1276 con il chip SX1276, il quarzo e il regolatore di tensione.
Questo chip opera nella gamma da 137 MHz a 1020 MHz, ma la maggior parte dei moduli è configurata per 433 MHz (Asia), 868 MHz (Europa) o 915 MHz (Nord America), a seconda della regione. Sul retro del modulo di solito c’è una piccola tabella che indica la frequenza operativa specifica. L’immagine sotto mostra un modulo che opera nella banda 915 MHz e quindi può essere usato in Nord America:
Assicurati di acquistare e usare un modulo con la frequenza di trasmissione corretta per il tuo paese. Altrimenti potresti avere problemi con l’ente che regola le trasmissioni radio nel tuo paese!
Il modulo può comunicare su distanze da 2 a oltre 15 chilometri, a seconda della qualità dell’antenna, del terreno e delle impostazioni. Lo SX1276 supporta velocità dati da 0,018 kbps a 37,5 kbps in modalità LoRa e fino a 300 kbps in modalità FSK, offrendo un controllo preciso su parametri come larghezza di banda, fattore di spreading e tasso di codifica, permettendoti di ottimizzare per portata, consumo o affidabilità.
Dettagli tecnici dello SX1276
La lista seguente mostra le caratteristiche principali del modulo LoRa SX1276:
- Tensione operativa: 1.8 – 3.7V
- Banda di frequenza: 868MHZ/915MH
- Potenza in uscita: 20dBm/100mW
- Sensibilità di ricezione: -139dBm@146B
- Modulazione: LORA/GFSK
- Interfaccia dati: SPI a 4 fili
- Dimensioni modulo: 16*16mm, passo interfaccia 2.0mm
- Corrente in trasmissione: 120mA@100mw/ 3.3V
- Corrente in ricezione: 10mA/3.3V
- Corrente in sleep: 0.2uA
Per maggiori dettagli consulta il datasheet linkato qui sotto:
Pinout del modulo LoRa SX1276
Il modulo LoRa SX1276 ha 16 pin. Uno per l’antenna (ANT), uno per l’alimentazione (VCC), diversi pin di massa (GND), i pin per SPI (RST, NSS, SCK, MOSI, MISO) e sei pin configurabili Digital IO (DIO):
Nota che lo SX1276 usa logica a 3.3V e quindi non puoi collegarlo direttamente a un Arduino UNO, per esempio, che usa livelli logici a 5V. Se vuoi usare una scheda Arduino invece di un ESP32 devi usare un logic level shifter o un Arduino that uses 3.3V logic.
Rendere il modulo LoRa SX1276 compatibile con breadboard
I fori dei pin del modulo LoRa SX1276 sono distanziati di 2 mm, quindi se saldi i pin non si adattano al passo standard da 2.54 mm di una breadboard. Tuttavia, dato che non servono tutti i pin del modulo, puoi piegare i poli di un normale header da 2.54 mm per farlo funzionare.
L’immagine sotto mostra GND, DIO3, DIO4, VCC e DIO0 collegati a un header da 2.54 mm. Ho piegato i poli sulla parte superiore dell’header per adattarli al passo più piccolo di 2 mm dei fori del modulo:
Nota che DIO1 e DIO2 non sono collegati. Potresti anche saltare DIO3, DIO4, dato che non servono, ma è più veloce saldare l’header completo invece di pin singoli.
Sul lato opposto del modulo facciamo lo stesso. Lì colleghiamo RES, NSS, SCK, MOSI e MISO e lasciamo scollegati i due pin GND e DIO5:
Con questo semplice trucco puoi far entrare il modulo LoRa SX1276 su una breadboard. L’immagine sotto mostra il retro del modulo con entrambi gli header saldati e l’antenna collegata:
Devi solo fare attenzione quando colleghi i fili perché le etichette sul silkscreen e i pin sono leggermente spostati.
Nota anche che la tua antenna potrebbe avere un aspetto diverso (più lunga, solo un filo) a seconda del modulo e della frequenza impostata.
Collegare SX1276 all’ESP32
Lo SX1276 è controllato tramite interfaccia SPI. Quando lo colleghi a un ESP32 devi fare le seguenti connessioni:
| SX1276 | ESP32 |
|---|---|
| MOSI | 23 |
| MSIO | 19 |
| SCK | 18 |
| RST | 17 |
| NSS | 5 |
| DIO0 | 4 |
| GND | GND |
| VCC | 3.3V |
Assicurati di collegare VCC al pin 3.3V del tuo ESP32. Inoltre, se usi la versione breadboard-friendly del modulo ricorda che solo il pin GND accanto all’antenna ANT è collegato – gli altri due no! Infine DIO0 dovrebbe essere collegato a un pin interruptabile dell’ESP32. L’immagine sotto mostra lo schema completo dei collegamenti:
Se usi una scheda ESP32 diversa, i pin per l’SPI hardware, su cui si basa il collegamento sopra, potrebbero variare. Se non sei sicuro di quali pin usare, dai un’occhiata al Find I2C and SPI default pins tutorial.
La foto seguente mostra come appare sulla mia breadboard, completamente cablato:
Infine, nota che nel codice seguente non useremo effettivamente DIO0. Quindi potresti anche non collegarlo. Tuttavia, DIO0 può essere usato per segnalare l’arrivo di dati tramite un interrupt, cosa che potrebbe tornarti utile.
Codice per comunicazione LoRa
In questa sezione scriviamo il codice per il trasmettitore e il ricevitore LoRa. L’hardware e i collegamenti per trasmettitore e ricevitore sono identici (un ESP32 con un SX1276 collegato) ma il codice è diverso.
Il trasmettitore invia un contatore incrementale ogni due secondi, mentre il ricevitore aspetta il messaggio e stampa il valore del contatore sul Monitor Seriale quando lo riceve. Il trasmettitore fa lampeggiare il LED integrato durante l’invio, mentre il ricevitore fa lampeggiare il suo LED quando riceve un messaggio.
Iniziamo con il codice del trasmettitore. Dai un’occhiata veloce al codice completo e poi ne analizziamo i dettagli.
Trasmettitore
#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);
}
Per prima cosa includiamo le due librerie necessarie:
#include <SPI.h> #include <LoRa.h>
La libreria SPI.h permette all’ESP32 di comunicare con il transceiver LoRa tramite SPI (Serial Peripheral Interface). Mentre la libreria LoRa.h ci offre un’interfaccia semplice per inviare e ricevere pacchetti LoRa. Puoi installare la libreria LoRa library by Sandeep Mistry usando il Library Manager nell’IDE Arduino. L’immagine sotto mostra l’installazione riuscita della libreria:
Poi definiamo i pin GPIO collegati alle linee di controllo del modulo per l’interfaccia SPI:
#define SS 5 #define RST 17 #define DIO0 4 #define LED_BUILTIN 22
SS, RST e DIO0 sono richiesti dal modulo LoRa. Definiamo anche LED_BUILTIN per controllare il LED onboard, che ci dà un feedback visivo durante la trasmissione. Sul WEMOS LOLIN32 Lite il LED onboard è collegato al pin 22.
setup
Ora entriamo nella funzione setup(). Questa parte viene eseguita una volta all’accensione o al reset della scheda:
void setup() {
Serial.begin(115200);
pinMode(LED_BUILTIN, OUTPUT);
LoRa.setPins(SS, RST, DIO0);
Iniziamo inizializzando il monitor seriale per il debug. Poi impostiamo il pin del LED come output. Successivamente usiamo LoRa.setPins() per indicare alla libreria quali pin sono collegati al modulo LoRa.
Poi inizializziamo la radio LoRa a 868 MHz, usata in Europa. Ricorda che devi usare la frequenza specifica consentita per le trasmissioni LoRa nel tuo paese!
while (!LoRa.begin(868E6)) {
Serial.println(".");
delay(500);
}
Se il modulo LoRa non si avvia, continuiamo a riprovare in un ciclo, stampando un punto ogni volta. Questo aiuta a diagnosticare problemi di avvio come errori di cablaggio.
Una volta che il modulo è pronto, lo configuriamo per una comunicazione affidabile a lunga distanza:
LoRa.setSyncWord(0x34); LoRa.setSpreadingFactor(12); LoRa.setSignalBandwidth(125E3); LoRa.setCodingRate4(8); LoRa.enableCrc(); }
Ecco cosa fa ogni impostazione:
setSyncWord(0x34)assicura che solo dispositivi con la stessa sync word possano comunicare tra loro. È come un semplice ID di rete.setSpreadingFactor(12)aumenta la portata e l’affidabilità diffondendo maggiormente il segnale. I valori vanno da 6 a 12—più alto significa maggiore portata ma dati più lenti.setSignalBandwidth(125E3)imposta la larghezza di banda radio a 125 kHz. Una banda più stretta aumenta la portata e riduce la velocità dati.setCodingRate4(8)potenzia la correzione degli errori, aiutando i dati ad arrivare integri anche su link rumorosi.enableCrc()aggiunge un checksum a ogni pacchetto per rilevare errori di trasmissione.
loop
Ora passiamo alla funzione loop(), che gira continuamente:
void loop() {
static int counter = 0;
Serial.print("Sending counter: ");
Serial.println(++counter);
Usiamo una static int per tenere traccia di quanti pacchetti abbiamo inviato. Poi stampiamo il valore sul monitor seriale ogni volta per il debug.
Prima di inviare un pacchetto, accendiamo il LED così sappiamo che sta trasmettendo:
digitalWrite(LED_BUILTIN, HIGH);
Poi costruiamo il pacchetto LoRa (=messaggio):
LoRa.beginPacket();
LoRa.print("Counter=");
LoRa.print(counter);
LoRa.endPacket();
Questo crea un pacchetto con il contenuto "Counter=1", "Counter=2", e così via. Il ricevitore riceverà questa stringa e potrà decidere cosa farne.
Dopo l’invio spegniamo il LED e aspettiamo un secondo prima della trasmissione successiva:
delay(1000); digitalWrite(LED_BUILTIN, LOW); delay(1000); }
Ogni ciclo dura circa due secondi—uno per la trasmissione e uno per la pausa. Puoi regolare il delay in base alle tue esigenze.
E questo è tutto! Questo sketch invia pacchetti LoRa ogni due secondi lampeggiando un LED per mostrare l’attività. Sul Monitor Seriale vedrai un messaggio stampato ogni volta che un pacchetto viene inviato:
Nella sezione successiva scriviamo il codice corrispondente per il ricevitore.
Ricevitore
Il ricevitore aspetta la trasmissione dal trasmettitore e la stampa sul Monitor Seriale. Ecco il codice 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);
}
}
Come prima iniziamo includendo le stesse due librerie essenziali:
#include <SPI.h> #include <LoRa.h>
È identico al trasmettitore. SPI.h abilita la comunicazione sul bus SPI, e LoRa.h ci fornisce tutte le funzioni necessarie per ricevere pacchetti.
Poi definiamo le stesse mappature dei pin per il WEMOS LOLIN32 Lite:
#define SS 5 #define RST 17 #define DIO0 4 #define LED_BUILTIN 22
Questo configura la comunicazione con il modulo LoRa e, di nuovo, assegniamo il pin 22 per il LED integrato. Hardware e gran parte del codice sono identici per trasmettitore e ricevitore, ma potresti usare configurazioni hardware diverse, ad esempio microcontrollori o pin differenti.
setup
Ora entriamo nella funzione setup(), che è quasi identica a quella del trasmettitore:
void setup() {
Serial.begin(115200);
pinMode(LED_BUILTIN, OUTPUT);
LoRa.setPins(SS, RST, DIO0);
Apriamo la connessione seriale a 115200 baud per stampare i messaggi in arrivo. Poi impostiamo il pin del LED come output e assegniamo i pin di controllo LoRa con LoRa.setPins().
Proprio come nel trasmettitore, inizializziamo LoRa alla frequenza 868 MHz, usata in Europa:
while (!LoRa.begin(868E6)) {
Serial.println(".");
delay(500);
}
Ovviamente, trasmettitore e ricevitore devono operare sulla stessa frequenza. Se il modulo non si inizializza correttamente, riproviamo ogni 500 millisecondi, stampando punti sul Monitor Seriale per feedback.
Segue la stessa configurazione LoRa usata nel trasmettitore:
LoRa.setSyncWord(0x34); LoRa.setSpreadingFactor(12); LoRa.setSignalBandwidth(125E3); LoRa.setCodingRate4(8); LoRa.enableCrc(); }
Ripetendo la configurazione del trasmettitore, assicuriamo che entrambi i dispositivi si capiscano. Se anche un solo parametro non corrisponde – come sync word o larghezza di banda – il ricevitore non riuscirà a decodificare il pacchetto.
loop
Ora vediamo il cuore del ricevitore, la funzione loop():
void loop() {
if (LoRa.parsePacket()) {
Qui, LoRa.parsePacket() controlla se è arrivato un pacchetto. Se non riceve nulla, la funzione ritorna 0 e il resto del loop viene saltato.
Quando un pacchetto viene ricevuto, accendiamo subito il LED per segnalare l’evento.
digitalWrite(LED_BUILTIN, LOW);
Nota che la logica del LED integrato è invertita. LOW significa LED acceso e HIGH LED spento.
Poi leggiamo il contenuto del pacchetto byte per byte e lo stampiamo come caratteri sul Monitor Seriale:
while (LoRa.available()) {
Serial.print((char)LoRa.read());
}
Qui appaiono i messaggi "Counter=1", "Counter=2" inviati dal trasmettitore.LoRa.available() controlla se ci sono altri byte disponibili, e LoRa.read() prende ogni byte dal pacchetto. Lo convertiamo in char così viene stampato come testo leggibile.
Poi stampiamo il RSSI (Received Signal Strength Indicator), che indica la forza del segnale:
Serial.printf(" (%d)\n", LoRa.packetRssi());
Questo è utile per il debug della portata radio. Più il numero è negativo, più il segnale è debole. Per esempio, -45 dB è forte, mentre -120 dB è quasi illeggibile.
Infine, facciamo una breve pausa per vedere il LED acceso e poi lo spegniamo, indicando che ora il codice aspetta il prossimo pacchetto.
delay(100);
digitalWrite(LED_BUILTIN, HIGH);
}
}
Con questo codice, il tuo ricevitore ESP32 LoRa ascolta messaggi come "Counter=3" inviati dal trasmettitore. Hai conferma visiva tramite il LED e aggiornamenti in tempo reale nel Monitor Seriale con la forza del segnale tra parentesi:
E questo è tutto. Ora puoi inviare dati da sensori a chilometri di distanza e, grazie al basso consumo di LoRa, far funzionare questi sensori a batteria per molto tempo.
Conclusioni
In questo tutorial hai imparato come ottenere comunicazioni a lunga distanza usando il modulo LoRa SX1276 e l’ESP32.
Se vuoi usare un Arduino invece di un ESP32 devi usare un convertitore di livello logico o un Arduino che funzioni a 3.3 Volt, perché il modulo SX1276 non funziona a 5V! Dai un’occhiata al Interface Arduino Uno with ST7735 TFT using Level Shifter tutorial se vuoi imparare a usare un convertitore di livello logico.
Un’applicazione tipica di LoRa è inviare dati ambientali come temperatura e umidità su lunghe distanze. Vedi il nostro Send Environmental Data with LoRa tutorial, se è quello che vuoi fare.
Per comunicazioni veloci e semplici a corto raggio il Bluetooth è più adatto. Puoi trovare informazioni in ESP32 And Bluetooth Module- HC-05 e nel How To Connect ESP32 Bluetooth With A Smartphone tutorial.
E se vuoi trasmettere informazioni su internet, il ESP32 send Telegram Message potrebbe esserti utile.
LoRa è ottimo per trasmettere tra pochi sensori. Ma se hai molti sensori da gestire e vuoi inviare misurazioni su internet, LoRaWAN è la soluzione. Vedi il LoRaWAN with Thinknode G1 Gateway tutorial per maggiori informazioni.
Infine, ti consiglio di esplorare le informazioni su https://www.thethingsnetwork.org per saperne di più su LoRa e il codice di esempio del LoRa library. In questo post abbiamo solo grattato la superficie.
Se hai domande, sentiti libero di lasciarle nei commenti.
Buon divertimento con il tinkering ; )
