Langstreckenkommunikation mit LoRa SX1276 und ESP32

In diesem Tutorial lernst du, wie du eine Langstreckenkommunikation mit dem LoRa SX1276 Modul und dem ESP32 aufbaust. Zum Beispiel, wenn du Daten von weit entfernten Sensoren empfangen möchtest, wo kein WLAN verfügbar ist, z.B. ein Temperatursensor in der Ecke deines Gartens, kann LoRa helfen.

LoRa ist eine drahtlose Technologie, die für das Senden kleiner Datenmengen über große Entfernungen mit sehr geringem Stromverbrauch entwickelt wurde. Sie funktioniert gut in offenen Bereichen und kann mehrere Kilometer erreichen, viel weiter als WiFi oder Bluetooth. Das macht sie ideal für batteriebetriebene Geräte wie Sensoren auf Bauernhöfen, in Städten oder abgelegenen Gebieten, wo reguläres WiFi oder Bluetooth nicht reicht oder zu viel Energie verbraucht.

Wenn du dich mit LoRa bereits auskennst und nur wissen möchtest, wie man Umweltdaten wie Temperatur und Luftfeuchtigkeit sendet, schau dir das Send Environmental Data with LoRa Tutorial an.

Benötigte Teile

Unten findest du die für dieses Tutorial benötigten Komponenten. Ich habe ein älteres ESP32 Board verwendet, das zwar veraltet ist, aber noch sehr günstig erhältlich ist. Es gibt auch eine Version mit USB-C Anschluss. Allerdings funktioniert jedes andere ESP32 Board ebenfalls gut. Denk nur daran, dass du zwei davon und zwei SX1276 Module brauchst – eins zum Senden und eins zum Empfangen.

Achte bei den SX1276 LoRa Transceiver Modulen darauf, welche Version du kaufst! Die erlaubten Frequenzen, die diese Module nutzen dürfen, unterscheiden sich abhänging vom Land. Es sind 868 MHz für Europa, 915 MHz für Nordamerika und 433 MHz für Asien.

Die Modulbeschreibung listet entweder die Frequenz oder hat eine Zahl wie 868 oder 915 im Namen. Ich habe ein Modul mit 868 MHz verwendet, da ich in Europa bin. Du kannst dieses Modul aber auch für das 915 MHz Band bekommen.

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.

Was ist LoRa?

Wenn du Arduino- oder ESP32-Projekte baust und Daten drahtlos über große Entfernungen senden möchtest, könnte LoRa (kurz für Long Range) genau das Richtige für dich sein. Im Gegensatz zu WiFi und Bluetooth, die für schnelle, kurzreichweitige Kommunikation ausgelegt sind, ist LoRa für energiearme, langstreckige Datenübertragung gebaut – perfekt für entfernte Sensoren und Geräte, die monatelang oder jahrelang mit einer kleinen Batterie laufen müssen.

LoRa verwendet eine spezielle Funkmodulation namens Chirp Spread Spectrum (CSS). Das macht es sehr widerstandsfähig gegen Störungen und ermöglicht es Geräten, über mehrere Kilometer miteinander zu kommunizieren, selbst in lauten Umgebungen oder mit Hindernissen wie Bäumen und Gebäuden. LoRa arbeitet im unlicensed ISM frequency bands – typischerweise 868 MHz in Europa, 915 MHz in Nordamerika und 433 MHz in einigen asiatischen Ländern. Diese Frequenzen variieren je nach Region, haben aber alle den Vorteil, lizenzfrei genutzt werden zu können.

Der Kompromiss bei LoRa ist, dass es nicht für hohe Datenraten gemacht ist. Es eignet sich am besten für kleine Datenmengen, wie Sensordaten oder Statusupdates von Geräten. Die Datenraten liegen typischerweise zwischen 0,3 kbps und 50 kbps, abhängig vom spreading factor (SF), der Bandbreite und dem coding rate, die du wählst. Die Reichweite hängt ebenfalls von diesen Einstellungen und deiner Umgebung ab: Du kannst in städtischen Gebieten 2–5 km und in ländlichen oder Sichtverbindung 10–15 km erwarten – manchmal sogar mehr mit passenden Antennen.

LoRa vs WiFi und Bluetooth

WiFi bietet hohe Geschwindigkeiten, verbraucht aber viel Energie und deckt meist weniger als 100 Meter ab. Bluetooth hat eine noch kürzere Reichweite und eignet sich besser für Wearables und persönliche Geräte. Die folgende Tabelle vergleicht die Hauptmerkmale von LoRa mit WiFi und Bluetooth:

Merkmal	LoRa	WiFi	Bluetooth
Stromverbrauch	Sehr niedrig (μA im Schlaf, ~10–50 mA aktiv)	Hoch (~70–300 mA aktiv)	Niedrig (~10–30 mA aktiv)
Reichweite	2–15 km (ländlich), 0,5–5 km (städtisch)	~50–100 Meter (innen), ~200 Meter (frei)	~10–100 Meter
Typische Datenrate	0,3–50 kbps	Bis zu 100–600 Mbps (ESP32: ~150 Mbps)	~1–3 Mbps (Classic), ~125–200 kbps (BLE)
Latenz	Hoch (100 ms bis mehrere Sekunden)	Niedrig (~1–10 ms)	Niedrig (~3–50 ms BLE)

In diesem Beitrag zeigen wir, wie man LoRa mit ESP32 Boards und Modulen wie dem SX1276 verwendet und wie man Nachrichten zwischen Geräten über große Entfernungen sendet – ganz ohne WiFi, Mobilfunkmasten oder viel Strom.

SX1276 LoRa Modul

Das SX1276 ist ein beliebtes LoRa Transceiver Modul von Semtech und einer der am häufigsten verwendeten Chips für langreichweitige, energiearme drahtlose Kommunikation in DIY- und IoT-Projekten. Es unterstützt LoRa-Modulation sowie traditionelle FSK/OOK Modi, was es flexibel für viele Anwendungen macht.

Das SX1276 steckt in vielen LoRa Modulen, darunter das bekannte HopeRF RFM95W, das dem Modul in diesem Tutorial sehr ähnlich ist. Das folgende Bild zeigt die Vorderseite des SX1276 LoRa Moduls mit dem SX1276 Chip, dem Quarzkristall und dem Spannungsregler.

Der Chip arbeitet im Bereich von 137 MHz bis 1020 MHz, aber die meisten Module sind für 433 MHz (Asien), 868 MHz (Europa) oder 915 MHz (Nordamerika) konfiguriert, je nach Region. Auf der Rückseite des Moduls findet man meist eine kleine Tabelle, in der die Betriebsfrequenz des Moduls markiert ist. Das Bild unten zeigt ein Modul, das im 915 MHz Band arbeitet und daher in Nordamerika verwendet werden kann:

Achte darauf, ein Modul mit der richtigen Übertragungsfrequenz für dein Land zu kaufen und zu verwenden. Sonst könntest du Probleme mit der zuständigen Behörde für Funkübertragungen bekommen!

Das Modul kann über Entfernungen von 2 bis über 15 Kilometer kommunizieren, abhängig von Antennenqualität, Gelände und Einstellungen. Das SX1276 unterstützt Datenraten von 0,018 kbps bis 37,5 kbps im LoRa-Modus und bis zu 300 kbps im FSK-Modus und bietet feine Kontrolle über Parameter wie Bandbreite, Spreizfaktor und Codierungsrate, sodass du Reichweite, Stromverbrauch oder Zuverlässigkeit optimieren kannst.

Technische Details des SX1276

Die folgende Liste zeigt die Hauptmerkmale des SX1276 LoRa Moduls:

• Betriebsspannung: 1,8 – 3,7V
• Frequenzband: 868 MHz / 915 MHz
• Ausgangsleistung: 20 dBm / 100 mW
• Empfindlichkeit: -139 dBm @146B
• Modulation: LORA / GFSK
• Dateninterface: 4-Draht SPI
• Modulgröße: 16*16 mm, Pinabstand 2,0 mm
• Sendestrom: 120 mA @ 100 mW / 3,3 V
• Empfangsstrom: 10 mA / 3,3 V
• Schlafstrom: 0,2 μA

Für weitere Details siehe das unten verlinkte Datenblatt:

Pinbelegung des SX1276 LoRa Moduls

Das SX1276 LoRa Modul hat 16 Pins. Einen für die Antenne (ANT), einen für die Stromversorgung (VCC), mehrere Massepins (GND), die Pins für SPI (RST, NSS, SCK, MOSI, MISO) und sechs konfigurierbare Digital IO Pins (DIO):

Beachte, dass das SX1276 mit 3,3 V Logik arbeitet und du es daher nicht direkt an ein Arduino UNO anschließen kannst, das mit 5 V Logik arbeitet. Wenn du ein Arduino Board statt eines ESP32 verwenden möchtest, musst du entweder einen logic level shifter oder einen Arduino der 3.3V Logik verwenden.

Das SX1276 LoRa Modul breadboard-freundlich machen

Die Pinlöcher des SX1276 LoRa Moduls sind 2 mm auseinander, was bedeutet, dass Pins, die du anlötest, nicht zum 2,54 mm Raster eines Standard-Breadboards passen. Da wir aber nicht alle Pins des Moduls brauchen, kannst du die Stifte eines Standard 2,54 mm Pin-Headers biegen, damit es passt.

Das Bild unten zeigt GND, DIO3, DIO4, VCC und DIO0, die an einen 2,54 mm Pin-Header angeschlossen sind. Ich habe die Stifte oben am Header gebogen, um zum kleineren 2 mm Abstand der Pinlöcher des Moduls zu passen:

Beachte, dass DIO1 und DIO2 nicht verbunden sind. Du könntest auch DIO3 und DIO4 weglassen, da sie nicht benötigt werden, aber es geht schneller, den kompletten Pin-Header anzulöten als einzelne Pins.

Auf der anderen Seite des Moduls machen wir das Gleiche. Dort verbinden wir RST, NSS, SCK, MOSI und MISO und lassen die zwei GND Pins und DIO5 unverbunden:

Mit diesem einfachen Trick kannst du das SX1276 LoRa Modul auf ein Breadboard stecken. Das Bild unten zeigt die Unterseite des Moduls mit beiden Pin-Headern und der angelöteten Antenne:

Du musst nur beim Verdrahten aufpassen, da die Beschriftungen auf dem Siebdruck und die Pins leicht versetzt sind.

Beachte auch, dass deine Antenne je nach Modul und Frequenzeinstellung anders aussehen kann (länger, nur ein Draht).

Anschluss des SX1276 an ESP32

Das SX1276 wird über eine SPI-Schnittstelle gesteuert. Beim Anschluss an einen ESP32 musst du folgende Verbindungen herstellen:

SX1276	ESP32
MOSI	23
MSIO	19
SCK	18
RST	17
NSS	5
DIO0	4
GND	GND
VCC	3,3 V

Achte darauf, dass du VCC an den 3,3 V Ausgang deines ESP32 anschließt. Wenn du die breadboard-freundliche Version des Moduls verwendest, beachte, dass nur der GND-Pin neben dem Antennenpin ANT verbunden ist – die anderen zwei sind es nicht! Schließlich sollte DIO0 an einen interruptfähigen Pin des ESP32 angeschlossen werden. Das Bild unten zeigt das komplette Schaltbild:

Wenn du ein anderes ESP32 Board verwendest, können die Pins für die Hardware-SPI, auf die sich die obige Verdrahtung stützt, abweichen. Wenn du nicht sicher bist, welche Pins du verwenden sollst, schau dir das Find I2C and SPI default pins Tutorial an.

Das nächste Foto zeigt, wie das auf meinem Breadboard aussieht, wenn alles verdrahtet ist:

Beachte schließlich, dass wir DIO0 im folgenden Code eigentlich nicht verwenden. Du könntest diese Verbindung also weglassen. DIO0 kann jedoch genutzt werden, um per Interrupthandler zu signalisieren, dass Daten angekommen sind, was in deiner Anwendung nützlich sein kann.

Code für LoRa-Kommunikation

In diesem Abschnitt schreiben wir den Code für den LoRa-Sender und -Empfänger. Die Hardware und Verdrahtung für Sender und Empfänger ist identisch (ein ESP32 mit angeschlossenem SX1276), aber der Code ist unterschiedlich.

Der Sender sendet alle zwei Sekunden einen inkrementierenden Zählerwert, während der Empfänger auf die Nachricht vom Sender wartet und den Zählerwert im Serial Monitor ausgibt, wenn er empfangen wird. Der Sender lässt außerdem die eingebaute LED blinken, wenn er eine Nachricht sendet, während der Empfänger seine LED blinken lässt, wenn er eine Nachricht empfängt.

Wir beginnen mit dem Code für den Sender. Schau dir den kompletten Code kurz an, dann gehen wir auf die Details ein.

Sender

#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);  
}

Zuerst binden wir die zwei benötigten Bibliotheken ein:

#include <SPI.h>
#include <LoRa.h>

Die SPI.h Bibliothek ermöglicht dem ESP32 die Kommunikation mit dem LoRa Transceiver über SPI (Serial Peripheral Interface). Die LoRa.h Bibliothek bietet uns eine einfache Schnittstelle zum Senden und Empfangen von LoRa-Paketen. Du kannst die LoRa library by Sandeep Mistry über den Library Manager in der Arduino IDE installieren. Das Bild unten zeigt eine erfolgreiche Installation der Bibliothek:

Als nächstes definieren wir die GPIO-Pins, die mit den Steuerleitungen des Moduls für die SPI-Schnittstelle verbunden sind:

#define SS 5
#define RST 17
#define DIO0 4
#define LED_BUILTIN 22

SS, RST und DIO0 werden vom LoRa Modul benötigt. Wir definieren auch LED_BUILTIN, um die eingebaute LED zu steuern, die uns während der Übertragung visuelles Feedback gibt. Beim WEMOS LOLIN32 Lite ist die eingebaute LED an Pin 22 angeschlossen.

setup

Jetzt steigen wir in die setup() Funktion ein. Dieser Teil läuft einmal, wenn das Board eingeschaltet oder zurückgesetzt wird:

void setup() {
  Serial.begin(115200);

  pinMode(LED_BUILTIN, OUTPUT);
  LoRa.setPins(SS, RST, DIO0);

Wir starten mit der Initialisierung des Serial Monitors für Debugging. Dann setzen wir den LED-Pin als Ausgang. Danach verwenden wir LoRa.setPins(), um der Bibliothek mitzuteilen, welche Pins mit dem LoRa Modul verbunden sind.

Dann initialisieren wir das LoRa-Radio auf 868 MHz, das in Europa verwendet wird. Denk daran, dass du die für dein Land erlaubte Frequenz für LoRa-Übertragungen nutzen musst!

  while (!LoRa.begin(868E6)) {  
    Serial.println(".");
    delay(500);
  }

Wenn das LoRa Modul nicht startet, versuchen wir es in einer Schleife immer wieder und geben jedes Mal einen Punkt aus. Das hilft bei der Diagnose von Startproblemen wie Verdrahtungsfehlern.

Sobald das Modul bereit ist, konfigurieren wir es für zuverlässige Langstreckenkommunikation:

  LoRa.setSyncWord(0x34);
  LoRa.setSpreadingFactor(12);
  LoRa.setSignalBandwidth(125E3);
  LoRa.setCodingRate4(8);
  LoRa.enableCrc();
}

Hier ist, was jede Einstellung bewirkt:

• setSyncWord(0x34) sorgt dafür, dass nur Geräte mit demselben Sync-Wort miteinander kommunizieren können. Es ist wie eine einfache Netzwerk-ID.
• setSpreadingFactor(12) erhöht die Reichweite und Zuverlässigkeit, indem das Signal stärker gespreizt wird. Werte reichen von 6 bis 12 – höher bedeutet bessere Reichweite, aber langsamere Datenübertragung.
• setSignalBandwidth(125E3) setzt die Funkbandbreite auf 125 kHz. Eine schmalere Bandbreite erhöht die Reichweite und verringert die Datenrate.
• setCodingRate4(8) verstärkt die Fehlerkorrektur, sodass Daten auch über störungsbehaftete Verbindungen intakt ankommen.
• enableCrc() fügt jedem Paket eine Prüfsumme hinzu, um Übertragungsfehler zu erkennen.

loop

Jetzt wechseln wir zur loop() Funktion, die kontinuierlich läuft:

void loop() {
  static int counter = 0;

  Serial.print("Sending counter: ");
  Serial.println(++counter);

Wir verwenden eine static int, um zu zählen, wie viele Pakete wir gesendet haben. Dann geben wir den Wert jedes Mal zum Debuggen im Serial Monitor aus.

Bevor wir ein Paket senden, schalten wir die LED an, damit wir wissen, dass gesendet wird:

  digitalWrite(LED_BUILTIN, HIGH);

Dann bauen wir das LoRa-Paket (=Nachricht):

  LoRa.beginPacket();
  LoRa.print("Counter=");
  LoRa.print(counter);
  LoRa.endPacket();

Das erzeugt ein Paket mit dem Inhalt "Counter=1", "Counter=2" und so weiter. Der Empfänger erhält diesen String und kann entscheiden, was er damit macht.

Nach dem Senden schalten wir die LED aus und warten eine Sekunde vor der nächsten Übertragung:

  delay(1000);
  digitalWrite(LED_BUILTIN, LOW);
  delay(1000);  
}

Jeder Zyklus dauert etwa zwei Sekunden – eine für die Übertragung und eine für die Pause. Du kannst die Verzögerung an deine Bedürfnisse anpassen.

Und das war’s! Dieser Sketch sendet alle zwei Sekunden LoRa-Pakete und lässt eine LED blinken, um die Aktivität anzuzeigen. Im Serial Monitor solltest du jedes Mal eine Nachricht sehen, wenn ein Paket gesendet wird:

Im nächsten Abschnitt schreiben wir den passenden Code für den Empfänger.

Empfänger

Der Empfänger wartet auf die Übertragung vom Sender und gibt sie im Serial Monitor aus. Hier ist der komplette Code:

#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);
  }
}

Wie zuvor binden wir die gleichen zwei wichtigen Bibliotheken ein:

#include <SPI.h>
#include <LoRa.h>

Das ist identisch zum Sender. SPI.h ermöglicht die Kommunikation über den SPI-Bus, und LoRa.h gibt uns alle Funktionen, die wir zum Empfangen von Paketen brauchen.

Als nächstes definieren wir die gleichen Pinbelegungen für den WEMOS LOLIN32 Lite:

#define SS 5
#define RST 17
#define DIO0 4

#define LED_BUILTIN 22

Das richtet die Kommunikation mit dem LoRa Modul ein, und wieder weisen wir Pin 22 für die eingebaute LED zu. Hardware und der Großteil des Codes sind für Sender und Empfänger identisch, aber du könntest auch unterschiedliche Hardware verwenden, z.B. verschiedene Mikrocontroller oder Pins.

setup

Jetzt gehen wir in die setup() Funktion, die fast identisch zum Sender ist:

void setup() {
  Serial.begin(115200);

  pinMode(LED_BUILTIN, OUTPUT);
  LoRa.setPins(SS, RST, DIO0);

Wir öffnen die serielle Verbindung mit 115200 Baud, um eingehende Nachrichten auszugeben. Dann setzen wir den LED-Pin als Ausgang und weisen die LoRa-Steuerpins mit LoRa.setPins() zu.

Wie beim Sender initialisieren wir LoRa auf der 868 MHz Frequenz, die in Europa verwendet wird:

  while (!LoRa.begin(868E6)) {
    Serial.println(".");
    delay(500);
  }

Natürlich müssen Sender und Empfänger auf derselben Frequenz arbeiten. Wenn das Modul nicht erfolgreich initialisiert wird, versuchen wir es alle 500 Millisekunden erneut und geben Punkte im Serial Monitor zur Rückmeldung aus.

Dann folgt die exakt gleiche LoRa-Konfiguration wie beim Sender:

  LoRa.setSyncWord(0x34);          
  LoRa.setSpreadingFactor(12);     
  LoRa.setSignalBandwidth(125E3);  
  LoRa.setCodingRate4(8);          
  LoRa.enableCrc();                
}

Indem wir die Konfiguration vom Sender spiegeln, stellen wir sicher, dass beide Geräte sich verstehen. Wenn auch nur ein Parameter nicht übereinstimmt – wie Sync-Wort oder Bandbreite – kann der Empfänger das Paket nicht dekodieren.

loop

Jetzt schauen wir uns das Herzstück des Empfängers an, die loop() Funktion:

void loop() {
  if (LoRa.parsePacket()) {

Hier prüft LoRa.parsePacket(), ob ein Paket angekommen ist. Wenn nichts empfangen wird, gibt die Funktion 0 zurück und der Rest der Schleife wird übersprungen.

Wenn ein Paket empfangen wird, schalten wir sofort die LED an, um das Ereignis zu signalisieren.

    digitalWrite(LED_BUILTIN, LOW);

Beachte, dass die Logik für die eingebaute LED umgekehrt ist. LOW bedeutet LED an und HIGH bedeutet LED aus.

Als nächstes lesen wir den Inhalt des Pakets Byte für Byte aus und geben ihn als Zeichen im Serial Monitor aus:

    while (LoRa.available()) {
      Serial.print((char)LoRa.read());
    }

Hier erscheinen die "Counter=1", "Counter=2" Nachrichten, die vom Sender geschickt wurden.LoRa.available() prüft, ob noch weitere Bytes verfügbar sind, und LoRa.read() holt jedes Byte aus dem Paket. Wir casten es zu char, damit es als lesbarer Text ausgegeben wird.

Dann geben wir den RSSI (Received Signal Strength Indicator) aus, der uns sagt, wie stark das Signal war:

    Serial.printf("    (%d)\n", LoRa.packetRssi());

Das ist nützlich, um die Funkreichweite zu debuggen. Je negativer die Zahl, desto schwächer das Signal. Zum Beispiel ist -45 dB stark, während -120 dB fast nicht lesbar ist.

Zum Schluss machen wir eine kurze Pause, damit man sieht, dass die LED an ist, und schalten sie dann aus, was anzeigt, dass der Code jetzt auf das nächste Paket wartet.

    delay(100);
    digitalWrite(LED_BUILTIN, HIGH);
  }
}

Mit diesem Code hört dein ESP32 LoRa Empfänger auf Nachrichten wie "Counter=3", die vom Sender gesendet werden. Du bekommst eine visuelle Bestätigung über die LED und Live-Updates im Serial Monitor mit Signalstärkewerten in Klammern:

Und das war’s. Jetzt kannst du Daten von Sensoren senden, die Kilometer entfernt sind, und dank des niedrigen Stromverbrauchs von LoRa können solche Sensoren lange mit Batteriebetrieb laufen.

Fazit

In diesem Tutorial hast du gelernt, wie man Langstreckenkommunikation mit dem LoRa SX1276 Modul und dem ESP32 realisiert.

Wenn du statt eines ESP32 ein Arduino verwenden möchtest, brauchst du entweder einen Pegelwandler oder ein Arduino, das mit 3,3 Volt arbeitet, da das SX1276 Modul nicht mit 5 V funktioniert! Schau dir das Interface Arduino Uno with ST7735 TFT using Level Shifter Tutorial an, wenn du lernen möchtest, wie man einen Pegelwandler verwendet.

Eine typische LoRa-Anwendung ist das Senden von Temperatur-, Feuchtigkeits- und anderen Umweltdaten über große Entfernungen. Siehe unser Send Environmental Data with LoRa Tutorial, wenn du das machen möchtest.

Für schnelle und einfache Kurzstreckenkommunikation ist Bluetooth besser geeignet. Informationen dazu findest du in den ESP32 And Bluetooth Module- HC-05 und How To Connect ESP32 Bluetooth With A Smartphone Tutorials.

Und wenn du Informationen über das Internet übertragen möchtest, könnte der ESP32 send Telegram Message nützlich sein.

LoRa ist super für die Übertragung zwischen wenigen Sensoren. Wenn du viele Sensoren verwalten und Messwerte ins Internet senden möchtest, ist LoRaWAN der richtige Weg. Siehe das LoRaWAN with Thinknode G1 Gateway Tutorial für mehr Informationen zu diesem Thema.

Zum Schluss empfehle ich dir, die Informationen auf https://www.thethingsnetwork.org zu durchstöbern, um mehr über LoRa und den Beispielcode des LoRa library zu lernen. In diesem Blogpost haben wir nur an der Oberfläche gekratzt.

Wenn du Fragen hast, kannst du sie gerne im Kommentarbereich stellen.

Viel Spaß beim Tüfteln ; )