LoRa Arduino : module SX1278 Ra-02 et ESP32 pour longue portée

Les projets LoRa avec Arduino sont le moyen le plus pratique d'envoyer des données entre deux cartes à plusieurs kilomètres, avec très peu d'énergie et sans internet ni carte SIM. LoRa (Long Range) est une modulation radio développée par Semtech ; avec des modules bon marché comme le Ra-02 à puce SX1278 en 433 MHz, tu peux atteindre 1 à 3 km en ville et jusqu'à 10 km en terrain dégagé. La contrepartie, c'est le débit : de quelques centaines d'octets à quelques kilobits par seconde. LoRa n'est donc pas fait pour l'audio ou la vidéo, mais il est idéal pour transporter de petites mesures comme la température, l'humidité, un niveau d'eau, l'état d'une porte ou une position GPS sur de longues distances.

Dans ce guide, tu vas voir pas à pas comment LoRa porte si loin, les réglages SF, BW et CR qui fixent la portée, la bonne fréquence pour ta région, le câblage du Ra-02 sur Arduino Uno, ESP32 et Raspberry Pi Pico, le code émetteur et récepteur avec la bibliothèque LoRa, la lecture du RSSI et du SNR, et un vrai test de portée. Les dernières parties expliquent la différence entre LoRa et LoRaWAN, The Things Network (TTN) et un projet de capteur de champ qui tient des mois sur batterie.

Qu'est-ce que LoRa et pourquoi porte-t-il si loin ?

LoRa utilise une technique appelée étalement de spectre par chirp (CSS). Chaque symbole est envoyé sous forme de « chirp » dont la fréquence monte régulièrement dans la bande ; l'information est cachée dans la fréquence à laquelle le chirp commence. Quand le récepteur multiplie le signal reçu par la forme de chirp connue et fait la somme, le bruit s'annule tandis que le signal s'accumule. LoRa peut ainsi décoder des signaux jusqu'à 20 dB sous le niveau de bruit. Les modules ASK 433 MHz classiques ont besoin d'un signal nettement plus fort que le bruit, alors que LoRa comprend des signaux presque inexistants : c'est le secret de sa portée bien plus grande à puissance égale.

La contrepartie, c'est le temps : plus un chirp dure longtemps, plus le récepteur accumule d'énergie et plus la portée augmente, mais les mêmes données partent plus lentement. Avec LoRa, portée, débit et autonomie sont toujours liés. Une mesure de 20 octets prend environ 57 millisecondes avec le réglage le plus rapide et 1,3 seconde avec celui qui porte le plus loin. Le tableau compare LoRa aux autres solutions sans fil du monde Arduino.

Modules LoRa : Ra-02, RFM95, E32 et cartes prêtes à l'emploi

La plupart des modules LoRa du commerce utilisent une puce de la famille SX127x de Semtech. Le SX1276 couvre 137 à 1020 MHz et le SX1278 137 à 525 MHz ; c'est pourquoi on trouve le SX1278 dans les modules 433 MHz et le SX1276 dans les modules 868/915 MHz. Il existe deux familles : des radios « nues » qui communiquent en SPI, et des modules dotés de leur propre processeur, qu'on utilise comme un port série en UART.

Quelle fréquence : 433 MHz ou 868 MHz ?

LoRa fonctionne dans les bandes ISM sans licence, mais ces bandes changent d'un pays à l'autre et chacune a des limites de puissance et de rapport cyclique (duty cycle). En France, en Belgique et en Suisse, deux bandes servent à LoRa : 433,05–434,79 MHz et 863–870 MHz ; au Québec, c'est 902–928 MHz. Les réseaux LoRaWAN et TTN utilisent 868 MHz en Europe et 915 MHz en Amérique du Nord, tandis que le 433 MHz est très répandu pour les liaisons point à point amateur avec des Ra-02 bon marché. Vérifie ta région avant d'acheter, car l'antenne et la puce sont accordées sur une fréquence donnée ; un module 868 MHz ne fonctionne pas en 433 MHz.

SF, BW et CR : les trois réglages qui fixent la portée

Trois paramètres déterminent la portée et le débit en LoRa. Le facteur d'étalement (SF) choisit de combien de « chips » se compose chaque symbole : de SF7 à SF12, chaque palier double la durée du symbole, permet au récepteur de décoder un signal environ 2,5 dB plus faible, mais double presque le temps d'émission. Le tableau est calculé pour 125 kHz de bande passante, un codage 4/5 et un paquet de 20 octets ; la dernière colonne donne l'attente minimale entre deux paquets pour respecter un rapport cyclique de 1 %.

La bande passante (BW) est la largeur de fréquence occupée par le signal : 125 kHz est le standard ; 250 et 500 kHz doublent et quadruplent le débit mais coûtent 3 et 6 dB de sensibilité, tandis que 62,5 kHz et moins augmentent la portée mais deviennent sensibles à la dérive des quartz bon marché. Le taux de codage (CR) est la part de correction d'erreurs : 4/5 ajoute 1 bit de correction pour 4 bits, 4/8 en ajoute 4 ; utile en milieu perturbé, mais le paquet s'allonge. La formule du débit est Rb = SF × (BW / 2^SF) × 4 / (4 + CR) ; pour SF9, 125 kHz et 4/5, cela donne 9 × 125000 / 512 × 0,8 ≈ 1758 bit/s.

Câblage du Ra-02 : Arduino Uno, ESP32 et Pico

En plus des quatre lignes SPI (SCK, MISO, MOSI, NSS), le Ra-02 a besoin d'une broche de reset et d'une broche d'interruption (DIO0). DIO0 passe à HIGH quand une émission est terminée ou qu'un nouveau paquet arrive ; la bibliothèque LoRa l'utilise comme interruption. Les broches DIO1 à DIO5 peuvent rester libres pour le code de ce guide. Si le SPI est nouveau pour toi, lis d'abord l'article Qu'est-ce que le bus SPI.

L'antenne compte autant que le câblage. Branche sur le connecteur IPEX du Ra-02 une antenne accordée sur 433 MHz. La fabriquer soi-même est très simple : la longueur d'onde vaut 300 / 433 = 0,693 mètre, et un fil droit de 17,3 cm suffit pour une antenne quart d'onde (8,6 cm en 868 MHz, 8,2 cm en 915 MHz). Garde l'antenne verticale, ne la mets pas dans un boîtier métallique et veille à ce que les antennes des deux côtés soient orientées de la même façon (toutes deux verticales) ; deux antennes à angle droit perdent l'essentiel du signal.

Pas à pas : un émetteur avec la bibliothèque LoRa

1. Ouvre le gestionnaire de bibliothèques de l'Arduino IDE, tape LoRa et installe la bibliothèque LoRa de Sandeep Mistry.
2. Câble le module comme dans le tableau et n'émets jamais sans antenne branchée.
3. Téléverse le code ci-dessous sur la carte qui servira d'émetteur ; il détecte s'il tourne sur un ESP32 ou un Uno et choisit les broches en conséquence.
4. Ouvre le moniteur série à 115200 bauds ; une ligne « Gonderildi / sent » doit apparaître toutes les 5 secondes.
5. Si LoRa.begin() échoue, vérifie les fils, l'alimentation 3,3 V et les broches NSS et 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

Récepteur : lire les paquets, RSSI et SNR

Le code récepteur vérifie à chaque tour de boucle avec LoRa.parsePacket() si un nouveau paquet est arrivé ; si oui, la fonction renvoie sa taille et le contenu se lit octet par octet avec LoRa.read(). Le code compte aussi les trous dans les numéros de paquet pour calculer le taux de perte, la base du test de portée qu'on fera juste après.

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

Le RSSI (Received Signal Strength Indicator) est la puissance du signal reçu, un nombre négatif en dBm : -40 dBm est très fort, -120 dBm très faible. Le SNR (rapport signal sur bruit) indique de combien le signal dépasse le bruit. La particularité de LoRa, c'est que le SNR peut devenir négatif : en SF9, les paquets sont encore décodés jusqu'à -12,5 dB. Pour savoir si tu approches de la limite de portée, regarde plutôt le SNR que le RSSI ; dans une ville bruyante, le SNR peut déjà être à la limite avec un RSSI de -100 dBm.

LoRa avec l'ESP32 : une passerelle vers le Wi-Fi

L'ESP32 est la carte la plus pratique pour LoRa : ses broches sont déjà en 3,3 V, sa broche 3V3 fournit le courant du module et le bus VSPI (GPIO 18, 19, 23) s'utilise directement. Les codes émetteur et récepteur ci-dessus compilent sur l'ESP32 sans modification ; la ligne #if defined(ESP32) choisit NSS = 5, RESET = 14 et DIO0 = 26. On relie DIO0 au GPIO 26 plutôt qu'au GPIO 2, car le GPIO 2 est une broche de configuration au démarrage (strapping). La vraie force de l'ESP32, c'est de servir de passerelle : il peut transmettre en Wi-Fi vers une page web, un serveur MQTT ou Telegram les données arrivées en LoRa depuis les capteurs du champ. Des cartes comme la TTGO LoRa32 et la Heltec LoRa 32 réunissent ESP32, puce LoRa et écran OLED sur une seule carte ; leurs numéros de broches sont différents, regarde le schéma de la carte.

LoRa avec le Raspberry Pi Pico (MicroPython)

Sur le Pico, on branche le Ra-02 sur le bus SPI0 (GP16 MISO, GP18 SCK, GP19 MOSI, GP17 NSS). Le dépôt officiel micropython-lib propose un pilote LoRa pour les puces SX127x ; tu peux l'installer depuis le gestionnaire de paquets de Thonny ou avec mpremote mip install lora-sync lora-sx127x. Le pilote reçoit ses réglages sous forme de dictionnaire ; tant que SF, bande passante et sync word sont les mêmes que côté Arduino, le Pico lit sans souci les paquets de l'émetteur Arduino ci-dessus. Le pilote renvoie le SNR tel qu'il est stocké dans le registre de la puce, soit quatre fois la valeur en dB, c'est pourquoi le code le divise par 4. Comme l'antenne du Ra-02 est reliée à la sortie PA_BOOST de la puce, le réglage tx_ant doit valoir "PA_BOOST" ; sinon l'émission reste très faible.

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 de portée : combien de km pour LoRa ?

Le seul moyen de connaître la portée réelle, c'est d'essayer. Place l'émetteur à une fenêtre ou sur le toit, branche le récepteur sur un ordinateur portable ou sur un ESP32 + OLED alimenté par une batterie externe, et note le RSSI, le SNR et le taux de perte en t'éloignant. Quand la perte dépasse 10 % ou que le SNR approche la limite du SF, tu as atteint la limite pratique. Ne change qu'une chose à chaque essai (SF, antenne, hauteur) pour voir d'où vient la différence. Une application de cartes sur ton téléphone permet de mesurer la distance à vol d'oiseau entre deux points.

• Monte l'antenne : rien n'augmente autant la portée que la hauteur de l'antenne. Une antenne à 5 mètres au lieu de 1 mètre allonge plusieurs fois la ligne de vue.
• Une vraie antenne : les petites antennes ressort livrées avec les modules sont pratiques mais peu efficaces ; un fil quart d'onde de 17,3 cm ou une antenne fouet extérieure fait une vraie différence.
• Augmente le SF : passer de SF9 à SF12 apporte environ 8 dB, soit en terrain dégagé à peu près plus du double de distance.
• Réduis la bande passante : passer de 125 kHz à 62,5 kHz fait gagner 3 dB, mais la dérive des quartz des deux modules peut poser problème.
• Dégage la zone de Fresnel : même si la ligne de vue semble libre, des arbres ou des bâtiments dans la zone en forme d'ellipse entre les deux antennes affaiblissent le signal ; surélever un peu les antennes règle le problème.
• Soigne l'alimentation : le pic de courant à l'émission peut faire chuter une ligne 3,3 V faible et réinitialiser le module ; ajoute un condensateur de 100 µF sur l'alimentation.

LoRa et LoRaWAN : qu'est-ce que TTN ?

Ces deux termes sont souvent confondus. LoRa n'est que la modulation radio, la couche physique : deux modules s'envoient des paquets directement, et c'est toi qui décides qui envoie quoi à qui. Tous les exemples de ce guide sont du LoRa point à point. LoRaWAN est un protocole réseau construit au-dessus de LoRa : les appareils (nœuds) envoient leurs paquets aux passerelles (gateways) voisines, qui les transmettent par internet à un serveur réseau, d'où les données arrivent à ton application. LoRaWAN gère lui-même l'identité des appareils, le chiffrement AES-128, l'adaptation automatique de la fréquence et du SF (ADR) et les règles de rapport cyclique.

The Things Network (TTN) est un réseau LoRaWAN gratuit et communautaire, composé de passerelles installées par des bénévoles. S'il y a une passerelle TTN près de chez toi, tu peux enregistrer ton appareil et lire ses données sur internet sans installer ta propre passerelle. L'usage gratuit est soumis à une politique d'utilisation équitable : environ 30 secondes d'émission par appareil et par jour et au plus 10 messages descendants par jour. Comme TTN utilise EU868 en Europe, un Ra-02 433 MHz ne convient pas ; pour TTN, prends un RFM95 en 868 MHz ou un module LoRaWAN prêt à l'emploi. Sans passerelle à proximité, le LoRa point à point est bien plus simple.

Projet : capteur de champ et de jardin sur batterie

L'usage classique de LoRa, c'est de récupérer des données d'un champ sans électricité ni Wi-Fi, ou d'une serre au fond du jardin. Le code ESP32 ci-dessous mesure l'humidité du sol, envoie un petit paquet au format « T1,42,37 » (identifiant du nœud, numéro de paquet, pourcentage d'humidité), puis endort le module LoRa et l'ESP32 et se réveille 10 minutes plus tard. Le capteur n'est alimenté par le GPIO 25 que pendant la mesure ; il ne consomme donc rien en veille et, sur les capteurs résistifs, la corrosion des électrodes diminue aussi. L'étalonnage du capteur est expliqué dans l'article Capteur d'humidité du sol et le sommeil profond dans ESP32 Deep Sleep. Le récepteur à la maison peut reprendre le code récepteur ci-dessus et séparer les valeurs aux virgules.

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

Estimons grossièrement l'autonomie. Toutes les 10 minutes (600 secondes), le nœud se réveille environ 0,5 seconde et consomme en moyenne 100 mA pendant ce temps ; en veille, un module ESP32 nu et le Ra-02 consomment ensemble environ 15 µA. Le courant moyen vaut (0,5 × 100) / 600 + 0,015 ≈ 0,1 mA ; un accu 18650 de 2000 mAh tiendrait en théorie 20 000 heures, soit plus de deux ans. En pratique, l'autodécharge et les pertes du régulateur raccourcissent cette durée. Attention : les cartes ESP32 DevKit peuvent consommer plusieurs milliampères même en veille à cause de la puce USB-série et du régulateur ; 5 mA en veille ramènent le même accu à 17 jours. Pour une longue autonomie, utilise un régulateur à faible courant de repos ou un module nu. Tu peux refaire le calcul avec tes propres valeurs dans le calculateur d'autonomie.

Idées de projets avec LoRa

• Niveau d'une cuve éloignée : mesure le remplissage d'une cuve lointaine avec un capteur de niveau d'eau et envoie-le à la maison.
• Alerte boîte aux lettres : détecte l'ouverture de la boîte aux lettres du portail avec un interrupteur reed et affiche-la sur un écran à l'intérieur.
• Balance de ruche : envoie le poids de la ruche plusieurs fois par jour avec un capteur de force HX711.
• Traceur GPS : suis un vélo ou des animaux à plusieurs kilomètres avec un GPS NEO-6M.
• Climat de la serre : reçois en LoRa la température et l'humidité de la serre et déclenche une alerte à la maison en cas de dépassement de seuil.
• Ta propre passerelle : relaie vers le Wi-Fi les données de plusieurs capteurs LoRa avec un seul ESP32 et suis-les sur ton téléphone.

Erreurs fréquentes et solutions

Un module LoRa est le moyen le moins cher de faire sortir les projets Arduino de la maison, vers le champ, le jardin ou le bâtiment voisin : avec la bonne fréquence, un SF adapté et une bonne antenne, tu peux construire des capteurs qui tiennent des mois sur batterie à plusieurs kilomètres. Pour des données rapides sur de plus courtes distances, le nRF24L01 ou ESP-NOW peuvent mieux convenir. Dans l'application BlueGrays, tu trouveras des projets de communication unidirectionnelle et bidirectionnelle entre deux Arduino, d'arrosage intelligent et de sommeil profond de l'ESP32, pas à pas avec schéma et code, auxquels tu peux ajouter LoRa.