LoRa Arduino: SX1278 Ra-02 Funkmodul mit ESP32 über Kilometer

LoRa mit Arduino ist der praktischste Weg, Daten zwischen zwei Boards über Kilometer zu senden, mit sehr wenig Energie und ohne Internet oder SIM-Karte. LoRa (Long Range) ist ein von Semtech entwickeltes Funkverfahren; mit günstigen Modulen wie dem Ra-02 mit SX1278-Chip erreichst du bei 433 MHz in der Stadt 1–3 km und im freien Gelände bis zu 10 km. Der Preis ist die Geschwindigkeit: zwischen einigen hundert Byte und wenigen Kilobit pro Sekunde. Deshalb ist LoRa nichts für Audio oder Video, aber ideal, um kleine Messwerte wie Temperatur, Feuchte, Wasserstand, Türzustand oder GPS-Position über große Entfernungen zu übertragen.

In dieser Anleitung erfährst du Schritt für Schritt, warum LoRa so weit kommt, welche Einstellungen SF, BW und CR die Reichweite bestimmen, welche Frequenz in deiner Region erlaubt ist, wie du das Ra-02 an Arduino Uno, ESP32 und Raspberry Pi Pico anschließt, wie Sender- und Empfängercode mit der LoRa-Bibliothek aussehen, wie du RSSI und SNR liest und wie ein echter Reichweitentest abläuft. Die letzten Abschnitte erklären den Unterschied zwischen LoRa und LoRaWAN, The Things Network (TTN) und ein Feldsensor-Projekt, das monatelang mit einer Batterie läuft.

Was ist LoRa und warum reicht es so weit?

LoRa nutzt ein Verfahren namens Chirp Spread Spectrum (CSS). Jedes Symbol wird als „Chirp“ gesendet, dessen Frequenz gleichmäßig durch das Band ansteigt; die Information steckt in der Frequenz, bei der der Chirp beginnt. Multipliziert der Empfänger das eingehende Signal mit der bekannten Chirp-Form und summiert auf, hebt sich das Rauschen auf, während sich das Signal aufaddiert. So kann LoRa Signale bis zu 20 dB unter dem Rauschpegel noch dekodieren. Einfache 433-MHz-ASK-Module brauchen ein deutlich stärkeres Signal als das Rauschen, LoRa dagegen versteht Signale, die kaum noch da sind; das ist das Geheimnis der großen Reichweite bei gleicher Sendeleistung.

Der Preis ist Zeit: Je länger ein Chirp dauert, desto mehr Energie sammelt der Empfänger und desto größer ist die Reichweite, aber dieselben Daten werden langsamer übertragen. Bei LoRa hängen Reichweite, Geschwindigkeit und Akkulaufzeit immer zusammen. Ein Messwert mit 20 Byte braucht bei der schnellsten Einstellung etwa 57 Millisekunden, bei der weitreichendsten 1,3 Sekunden. Die Tabelle vergleicht LoRa mit den anderen Funkoptionen aus der Arduino-Welt.

LoRa-Module: Ra-02, RFM95, E32 und fertige Boards

Die meisten LoRa-Module im Handel nutzen einen Chip aus Semtechs SX127x-Familie. Der SX1276 deckt 137–1020 MHz ab, der SX1278 137–525 MHz; deshalb findest du in 433-MHz-Modulen den SX1278 und in 868/915-MHz-Modulen den SX1276. Es gibt zwei Gruppen: „nackte“ Funkchips, die per SPI angesprochen werden, und fertige Module mit eigenem Prozessor, die du über UART wie eine serielle Schnittstelle nutzt.

Welche Frequenz: 433 MHz oder 868 MHz?

LoRa arbeitet in lizenzfreien ISM-Bändern, die sich aber von Land zu Land unterscheiden und jeweils Grenzen für Leistung und Duty Cycle (Sendezeitanteil) haben. In Deutschland, Österreich und der Schweiz werden für LoRa zwei Bänder genutzt: 433,05–434,79 MHz und 863–870 MHz. LoRaWAN-Netze und TTN verwenden in Europa 868 MHz, während 433 MHz für Punkt-zu-Punkt-Bastelverbindungen mit günstigen Ra-02-Modulen sehr verbreitet ist. Prüfe vor dem Kauf deine Region, denn Antenne und Chip sind auf eine bestimmte Frequenz abgestimmt; ein 868-MHz-Modul funktioniert nicht auf 433 MHz.

SF, BW und CR: die drei Einstellungen für die Reichweite

Drei Parameter bestimmen bei LoRa Reichweite und Geschwindigkeit. Der Spreading Factor (SF) legt fest, aus wie vielen „Chips“ ein Symbol besteht: Von SF7 bis SF12 verdoppelt sich mit jeder Stufe die Symboldauer, der Empfänger dekodiert ein etwa 2,5 dB schwächeres Signal, aber die Sendezeit (Time on Air) verdoppelt sich fast. Die Tabelle gilt für 125 kHz Bandbreite, Coding Rate 4/5 und ein 20-Byte-Paket; die letzte Spalte ist die Mindestpause zwischen zwei Paketen bei 1 % Duty Cycle.

Die Bandbreite (BW) ist die Breite des belegten Frequenzbereichs: 125 kHz ist Standard; 250 und 500 kHz verdoppeln bzw. vervierfachen die Geschwindigkeit, kosten aber 3 bzw. 6 dB Empfindlichkeit, während 62,5 kHz und weniger die Reichweite erhöhen, aber empfindlich auf die Frequenzdrift billiger Quarze reagieren. Die Coding Rate (CR) ist der Anteil für die Fehlerkorrektur: 4/5 fügt auf 4 Bit ein Korrekturbit hinzu, 4/8 vier; das hilft in gestörter Umgebung, verlängert aber das Paket. Die Bitrate berechnet sich als Rb = SF × (BW / 2^SF) × 4 / (4 + CR); für SF9, 125 kHz und 4/5 ergibt das 9 × 125000 / 512 × 0,8 ≈ 1758 bit/s.

Ra-02 anschließen: Arduino Uno, ESP32 und Pico

Neben den vier SPI-Leitungen (SCK, MISO, MOSI, NSS) braucht das Ra-02 einen Reset- und einen Interrupt-Pin (DIO0). DIO0 geht auf HIGH, wenn ein Sendevorgang fertig ist oder ein neues Paket ankommt; die LoRa-Bibliothek nutzt ihn als Interrupt. Die Pins DIO1–DIO5 können für den Code dieser Anleitung frei bleiben. Ist SPI neu für dich, lies zuerst den Beitrag Was ist SPI.

Die Antenne ist genauso wichtig wie die Verdrahtung. Stecke an die IPEX-Buchse des Ra-02 eine auf 433 MHz abgestimmte Antenne. Selbst bauen ist einfach: Die Wellenlänge beträgt 300 / 433 = 0,693 Meter, für eine Lambda-Viertel-Antenne reicht ein gerader Draht von 17,3 cm (bei 868 MHz 8,6 cm). Halte die Antenne senkrecht, bau sie nicht in ein Metallgehäuse ein und achte darauf, dass beide Antennen gleich ausgerichtet sind (beide senkrecht); quer zueinander stehende Antennen verlieren den größten Teil des Signals.

Schritt für Schritt: Sender mit der LoRa-Bibliothek

1. Öffne in der Arduino IDE den Bibliotheksverwalter, gib LoRa ein und installiere die LoRa-Bibliothek von Sandeep Mistry.
2. Verdrahte das Modul wie in der Tabelle und sende nie ohne angeschlossene Antenne.
3. Lade den folgenden Code auf das Board, das Sender sein soll; er erkennt selbst, ob es ein ESP32 oder ein Uno ist, und wählt die Pins passend.
4. Öffne den seriellen Monitor mit 115200 Baud; alle 5 Sekunden sollte eine Zeile „Gonderildi / sent“ erscheinen.
5. Schlägt LoRa.begin() fehl, prüfe Kabel, 3,3-V-Versorgung sowie die Pins NSS und 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

Empfänger: Pakete lesen, RSSI und SNR

Der Empfängercode prüft in jedem Schleifendurchlauf mit LoRa.parsePacket(), ob ein neues Paket da ist; wenn ja, liefert die Funktion dessen Größe, und der Inhalt wird mit LoRa.read() Byte für Byte gelesen. Außerdem zählt der Code Lücken in den Paketnummern und berechnet so die Verlustrate, die Grundlage für den Reichweitentest weiter unten.

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

RSSI (Received Signal Strength Indicator) ist die Stärke des empfangenen Signals, eine negative Zahl in dBm: -40 dBm ist sehr stark, -120 dBm sehr schwach. SNR (Signal-Rausch-Verhältnis) zeigt, wie viel stärker das Signal als das Rauschen ist. Das Besondere an LoRa: Der SNR darf negativ werden, bei SF9 werden Pakete bis -12,5 dB noch dekodiert. Ob du dich dem Rand der Reichweite näherst, verrät eher der SNR als der RSSI; in einer verrauschten Stadt kann der SNR schon bei einem RSSI von -100 dBm am Limit sein.

LoRa mit dem ESP32: Brücke ins WLAN

Der ESP32 ist das bequemste Board für LoRa: Seine Pins arbeiten schon mit 3,3 V, der 3V3-Pin liefert genug Strom für das Modul, und der VSPI-Bus (GPIO 18, 19, 23) wird direkt genutzt. Sender- und Empfängercode oben kompilieren unverändert für den ESP32; die Zeile #if defined(ESP32) wählt NSS = 5, RESET = 14 und DIO0 = 26. DIO0 hängt an GPIO 26 statt an GPIO 2, weil GPIO 2 ein Strapping-Pin ist, der das Startverhalten beeinflusst. Die eigentliche Stärke des ESP32 ist die Rolle als Brücke: Er kann Daten, die per LoRa von Sensoren auf dem Feld kommen, über WLAN an eine Webseite, einen MQTT-Server oder Telegram weitergeben. Boards wie TTGO LoRa32 und Heltec LoRa 32 vereinen ESP32, LoRa-Chip und OLED-Display auf einer Platine; dort sind die Pinnummern anders, schau in den Schaltplan des Boards.

LoRa mit dem Raspberry Pi Pico (MicroPython)

Am Pico schließt du das Ra-02 an den SPI0-Bus an (GP16 MISO, GP18 SCK, GP19 MOSI, GP17 NSS). Das offizielle micropython-lib-Repository enthält einen LoRa-Treiber für SX127x-Chips; du installierst ihn über den Paketmanager von Thonny oder mit mpremote mip install lora-sync lora-sx127x. Der Treiber erhält seine Einstellungen als Dictionary; solange SF, Bandbreite und Sync Word mit der Arduino-Seite übereinstimmen, liest der Pico die Pakete des Arduino-Senders problemlos. Der Treiber liefert den SNR so, wie er im Register des Chips steht, also als Vierfaches des dB-Werts, daher teilt der Code durch 4. Da die Antenne des Ra-02 am PA_BOOST-Ausgang des Chips hängt, muss tx_ant auf "PA_BOOST" stehen, sonst wird nur sehr schwach gesendet.

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

Reichweitentest: Wie viele Kilometer schafft LoRa?

Die echte Reichweite erfährst du nur durch Ausprobieren. Stell den Sender zu Hause ans Fenster oder aufs Dach, verbinde den Empfänger mit einem Laptop oder einem ESP32 + OLED an einer Powerbank und notiere beim Entfernen RSSI, SNR und Verlustrate. Steigt die Verlustrate über 10 % oder nähert sich der SNR der SF-Grenze, ist das Ende der praktischen Reichweite erreicht. Ändere pro Test nur eine Sache (SF, Antenne, Höhe), damit du siehst, woher der Unterschied kommt. Die Luftlinie zwischen zwei Punkten misst du mit einer Karten-App auf dem Handy.

• Antenne höher setzen: Nichts steigert die Reichweite so sehr wie die Antennenhöhe. Eine Antenne in 5 statt 1 Meter Höhe verlängert die Sichtverbindung um ein Vielfaches.
• Richtige Antenne: Die kleinen Spiralantennen, die den Modulen beiliegen, sind bequem, aber ineffizient; ein 17,3-cm-Lambda-Viertel-Draht oder eine Außenstabantenne bringt einen deutlichen Unterschied.
• SF erhöhen: Von SF9 auf SF12 gewinnst du etwa 8 dB, im freien Gelände grob mehr als die doppelte Entfernung.
• Bandbreite verringern: Von 125 kHz auf 62,5 kHz bringt 3 dB, aber die Quarzdrift zwischen den beiden Modulen kann Probleme machen.
• Fresnelzone freihalten: Auch wenn die Sichtlinie frei wirkt, schwächen Bäume oder Gebäude in der ellipsenförmigen Zone zwischen den Antennen das Signal; etwas höhere Antennen lösen das.
• Stromversorgung nicht vergessen: Der Stromstoß beim Senden kann eine schwache 3,3-V-Schiene einbrechen lassen und das Modul zurücksetzen; setz einen 100-µF-Kondensator an die Versorgung.

LoRa und LoRaWAN: Was ist TTN?

Die beiden Begriffe werden oft verwechselt. LoRa ist nur das Funkverfahren, also die physikalische Schicht: Zwei Module senden sich direkt Pakete, und du entscheidest, wer wem was schickt. Alle Beispiele dieser Anleitung sind Punkt-zu-Punkt-LoRa. LoRaWAN ist ein Netzwerkprotokoll, das auf LoRa aufsetzt: Geräte (End Nodes) senden ihre Pakete an Gateways in der Umgebung, die Gateways leiten sie über das Internet an einen Netzwerkserver weiter, und von dort kommen die Daten zu deiner Anwendung. LoRaWAN kümmert sich selbst um Geräte-IDs, AES-128-Verschlüsselung, automatische Anpassung von Frequenz und SF (ADR) und die Duty-Cycle-Regeln.

The Things Network (TTN) ist ein kostenloses, von der Community betriebenes LoRaWAN-Netz aus Gateways, die Freiwillige aufgestellt haben. Steht ein TTN-Gateway in deiner Nähe, kannst du dein Gerät registrieren und seine Daten im Internet lesen, ohne ein eigenes Gateway zu bauen. Für die kostenlose Nutzung gilt eine Fair Use Policy: etwa 30 Sekunden Sendezeit pro Gerät und Tag und höchstens 10 Downlink-Nachrichten pro Tag. Da TTN in Europa EU868 nutzt, ist ein 433-MHz-Ra-02 dafür ungeeignet; für TTN brauchst du ein 868-MHz-RFM95 oder ein fertiges LoRaWAN-Modul. Ohne Gateway in der Nähe ist Punkt-zu-Punkt-LoRa viel einfacher.

Projekt: batteriebetriebener Feld- und Gartensensor

Der Klassiker für LoRa ist, Daten von einem Feld ohne Strom und WLAN oder aus einem Gewächshaus am Ende des Gartens zu holen. Der ESP32-Code unten misst die Bodenfeuchte, sendet ein kleines Paket im Format „T1,42,37“ (Knoten-ID, Paketnummer, Feuchte in Prozent), legt dann LoRa-Modul und ESP32 schlafen und wacht 10 Minuten später wieder auf. Der Sensor wird nur während der Messung über GPIO 25 versorgt; so verbraucht er im Schlaf keinen Strom, und bei resistiven Sensoren korrodieren die Elektroden weniger. Die Kalibrierung des Sensors steht im Beitrag Bodenfeuchtesensor, Details zum Tiefschlaf im Beitrag ESP32 Deep Sleep. Der Empfänger zu Hause kann den Empfängercode oben verwenden und die Werte an den Kommas trennen.

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

Schätzen wir die Batterielaufzeit grob ab. Alle 10 Minuten (600 Sekunden) wacht der Knoten etwa 0,5 Sekunden auf und zieht dabei im Mittel rund 100 mA; im Schlaf brauchen ein nacktes ESP32-Modul und das Ra-02 zusammen etwa 15 µA. Der Durchschnittsstrom beträgt (0,5 × 100) / 600 + 0,015 ≈ 0,1 mA; eine 18650-Zelle mit 2000 mAh hielte theoretisch 20.000 Stunden, also über zwei Jahre. In der Praxis verkürzen Selbstentladung und Reglerverluste diese Zeit. Achtung: Fertige ESP32-DevKit-Boards können wegen USB-Seriell-Chip und Regler selbst im Schlaf mehrere Milliampere ziehen; 5 mA Schlafstrom senken die Laufzeit derselben Zelle auf 17 Tage. Für lange Laufzeiten nimm einen Regler mit geringem Ruhestrom oder ein nacktes Modul. Mit deinen eigenen Werten rechnest du im Akkulaufzeit-Rechner.

Projektideen mit LoRa

• Füllstand eines entfernten Wassertanks: Miss mit einem Wasserstandssensor, wie voll ein entfernter Tank ist, und schick den Wert nach Hause.
• Briefkasten-Melder: Erkenne mit einem Reedschalter, wenn der Briefkasten am Gartentor geöffnet wird, und zeig es drinnen auf einem Display an.
• Bienenstockwaage: Sende das Gewicht des Stocks mehrmals täglich mit einer HX711-Wägezelle.
• GPS-Tracker: Verfolge mit einem NEO-6M-GPS ein Fahrrad oder Tiere aus Kilometern Entfernung.
• Gewächshaus-Klima: Empfange Temperatur und Feuchte aus dem Gewächshaus per LoRa und lös zu Hause einen Alarm aus, wenn ein Grenzwert überschritten wird.
• Eigenes Gateway: Leite die Daten mehrerer LoRa-Sensoren mit einem einzigen ESP32 ins WLAN und beobachte sie auf dem Handy.

Häufige Fehler und Lösungen

Ein LoRa-Modul ist der günstigste Weg, Arduino-Projekte aus dem Haus aufs Feld, in den Garten und ins Nachbargebäude zu bringen: Mit der richtigen Frequenz, einem passenden SF und einer guten Antenne baust du Sensoren, die kilometerweit entfernt monatelang mit einer Batterie laufen. Für schnelle Daten über kürzere Distanzen passen nRF24L01 oder ESP-NOW eventuell besser. In der BlueGrays-App findest du Projekte zur einseitigen und zweiseitigen Kommunikation zwischen zwei Arduinos, zur intelligenten Bewässerung und zum ESP32-Tiefschlaf, Schritt für Schritt mit Schaltplan und Code, und kannst LoRa darauf aufbauen.