LoRaWAN-Kommunikation einrichten
Dieses Kapitel führt Sie durch die Einrichtung einer vollständigen LoRaWAN-Kommunikationskette. Themen umfassen
- die Hardware-Voraussetzungen,
- die Einrichtung von Devices in einer selbstgehosteten Chirpstack-Infrastruktur,
- das Verbinden eines RAK3272S-Geräts mittels OTAA,
- das kontinuierliche Senden und Dekodieren von Sensordaten (z. B. DHT11) über MQTT -
- das Simulieren des Sendens von Daten an die Chirpstack-Instanz, wenn kein LoRaWAN-Gateway vorhanden ist
Voraussetzungen
Diese Dokumentation geht davon aus, dass Sie die folgende Hard- und Software zur Verfügung haben:
Hardware
- Raspberry Pico mit der passenden MicroPython-Firmware
- Ein RAK3272S
- Breadboard und Jumper-Kabel zum Verbinden der Komponenten
Software
- Thonny IDE installiert auf Ihrem Computer oder:
- die VSCode-Extension MicroPico
- Zugang zu einem Chirpstack-Netzwerkserver
LoRaWAN
LoRaWAN (Long Range Wide Area Network) ist ein offener Standard, der auf der LoRa-Funktechnologie aufbaut und eine komplette Netzwerkarchitektur definiert. Er legt fest, wie Endgeräte, Gateways und Server zusammenspielen, wie Daten übertragen und gesichert werden und wie das Netzwerk verwaltet wird.
LoRaWAN-Geräte senden ihre Daten an sogenannte Gateways. Diese empfangen die LoRa-Funksignale und leiten sie verschlüsselt über das Internet an einen Netzwerkserver weiter. Dort werden die Daten organisiert, entschlüsselt und können von Anwendungen abgerufen oder weiterverarbeitet werden. Außerdem übernimmt LoRaWAN Aufgaben wie Verschlüsselung, Authentifizierung und Netzwerkmanagement.
Für die Nutzung von LoRaWAN gibt es zwei grundlegende Ansätze:
The Things Network
The Things Network (TTN) ist eine weltweite, community-betriebene Infrastruktur aus Tausenden von Gateways und einem gemeinsam genutzten Netzwerkserver. Man registriert sein Gerät und kann sofort loslegen, sofern ein TTN-Gateway in Reichweite ist. Man ist dabei jedoch auf die bestehende Infrastruktur angewiesen und teilt sich den Server mit allen anderen Nutzenden.
The Things Network ist weit verbreitet, in den Städten gibt es zahlreiche Gateways, die mitgenutzt werden können. Dennoch wurde aus vier Gründen für Chirpstack und gegen TTN entschieden:
- An allen Arbeitsorten war kein TTN-Gateway in der Nähe.
- Die TTN-Oberfläche ist für diese Lehrveranstaltung unnötig komplex, Chirpstack hat nur das Nötigste.
- Die Arbeit mit Chirpstack versetzt die Studierenden in die Rolle von Lehrenden, weil sie erweiterte Rechte haben können.
- Die Installation von Chirpstack auf einem Gateway und auf einem Server im Netz erhöhen das Verständnis für die technischen Zusammenhänge.
Chirpstack
Mit Chirpstack hingegen können ein eigener Netzwerkserver und eigene Gateways betrieben werden. Man hat volle Kontrolle über die gesamte Infrastruktur, ist unabhängig von Dritten.
Da die Freiheiten einer Chirpstack-Umgebung für die Lehre mehr Möglichkeiten bieten, wird dieser Ansatz im Folgenden ausführlich vorgestellt.
Eigene Chirpstack-Umgebung nutzen
Chirpstack ist eine Open-Source-Software, die es ermöglicht, ein eigenes LoRaWAN-Netzwerk zu betreiben. Sie bietet die Möglichkeit, eine komplette LoRaWAN-Infrastruktur mit eigenen Gateways und einem eigenen Netzwerkserver aufzubauen. Für die Lehrveranstaltung wird eine eigene Chirpstack-Instanz genutzt.

Gerät zum Chirpstack hinzufügen
Nachdem Sie die Zugangsdaten für Ihren Account auf der Chirpstack-Instanz erhalten haben, können Sie ein erstes Device hinzufügen.
Application erstellen
Bevor ein Gerät hinzugefügt werden kann, muss zunächst eine Application (Anwendung) erstellt werden. Eine Application ist eine logische Gruppierung von Geräten, die einem gemeinsamen Zweck, also z. B. einem Projekt oder einer inhaltlichen Gruppe, zugeordnet sind. Ein Gerät kann nur einer Application zugeordnet werden. Eine Application kann beliebig viele Geräte enthalten.
Melden Sie sich bei Ihrem Chirpstack-Server an. Wählen Sie oben links ggf. Ihren Tenant aus. Navigieren Sie dann zu Applications (links unten) und klicken Sie auf Add application. Vergeben Sie einen Namen und optional eine Beschreibung, und bestätigen Sie mit Submit.
Device Profil erstellen
Um ein Gerät hinzufügen zu können, muss zunächst noch ein Device Profil erstellt werden. Dort werden technische Parameter definiert und können als Profil für mehrere Geräte verwendet werden.
Navigieren Sie zu Device profiles und klicken Sie auf Add device profile. Vergeben Sie einen sinnvollen Namen z. B. RAK3272S. Die meisten Parameter können auf den Standardwerten belassen werden. Stellen Sie jedoch sicher, dass folgende Werte korrekt eingestellt sind:
- Region: EU868
- MAC version: LoRaWAN 1.0.3
- Regional parameter revision: A
- ADR algorithm: Default ADR algorithm
Wechseln Sie auf den Reiter Join (OTAA / ABP) und stellen Sie sicher, dass Device supports OTAA aktiviert ist.
Schließen Sie das Einrichten des Device profiles mit Submit ab.
Gerät hinzufügen
Als nächstes können Sie ein Gerät hinzufügen. Wechseln Sie dazu in Ihre zuvor erstellte Application. Dort können Sie mit Add device ein neues Gerät hinzufügen. Füllen Sie dazu die folgenden Felder aus:
Name: Ein beliebiger Name für Ihr Gerät, z. B.Mein-RAK-1Device profile: Wählen Sie das zuvor erstellte Profil aus.DevEUI: Ist eine eindeutige 8-Byte-Kennung für Ihr Gerät. Sie können sich hier eine zufällige DevEUI generieren lassen. Wichtig ist, dass dieser Wert später auch im RAK-Modul hinterlegt wird.JoinEUI: Auch hier können Sie einen beliebigen Wert generieren lassen oder auch einfach auf0000000000000000setzen. Auch dieser Wert muss mit dem übereinstimmen, was auf dem RAK-Modul gespeichert wird.
Nachdem Sie das Gerät mit Submit hinzugefügt haben, müssen Sie sich noch einen 128-Bit Application Key generieren. Dieser geheime Schlüssel dient dazu, beim Beitreten des Geräts zum Netzwerk (Join-Prozess) die Identität des Geräts zu bestätigen. Auch dieser Wert muss später im RAK-Modul hinterlegt werden.

Registrierung auch per ABP möglich
Die hier beschriebene Registrierung und das anschließende Join mit OTAA ist eine der gängigsten Methoden zur sicheren Gerätesteuerung. Beachten Sie jedoch, dass LoRaWAN auch einen Anmeldeprozess ohne OTAA (z. B. mittels ABP - Activation by Personalization) unterstützt. Die Einrichtung eines entsprechenden LoRaWAN-Simulators wird im Abschnitt Senden ohne Gateway behandelt.
Gerät mit OTAA in das Netzwerk einbinden
Nachdem Sie Ihr Gerät im Chirpstack hinzugefügt haben, können Sie es nun mit dem Netzwerk verbinden. Dazu müssen Sie den OTAA-Join-Prozess durchführen. OTAA steht für Over The Air Authentication.
Python-Code anpassen
Speichern Sie den folgenden Code als join_and_send.py auf Ihrem Computer ab und führen Sie diesen auf ihrem Pico aus. Ersetzen Sie dabei die Platzhalter DEVEUI und APPKEY durch die entsprechenden Werte, die Sie bei der Registrierung des Geräts eingegeben bzw. generiert haben.
Der Code erfüllt drei Funktionen:
- Er konfiguriert das RAK-Modul mit den notwendigen Einstellungen und Schlüsseln.
- Er startet den OTAA-Join-Prozess, um das Gerät mit dem Chirpstack-Netzwerk zu verbinden.
- Er sendet eine Testnachricht (Payload) an das Netzwerk.
APPEUI = JoinEIU
Je nach LoRaWAN-Version oder Hersteller wird dieser Wert unterschiedlich bezeichnet. Das RAK-Modul nennt ihn AppEUI, Chirpstack verwendet den neueren Begriff JoinEUI. Gemeint ist immer derselbe Wert.
|
|
Erklärung zum Code
Nach einem Reset des Moduls (ATZ) wird zunächst die grundlegende Konfiguration für die Verbindung mit dem Chirpstack vorgenommen: Das Modul wird in den LoRaWAN-Modus versetzt (AT+NWM=1), die Endgeräteklasse wird auf A gesetzt (AT+CLASS=A), und die Sendebestätigung (confirmed uplinks) wird aktiviert (AT+CFM=1), damit Sie eine Rückmeldung vom Server erhalten, ob eine Nachricht erfolgreich empfangen wurde.
Danach wird der Join-Modus auf OTAA eingestellt (AT+NJM=1), die Region auf EU868 gesetzt (AT+BAND=4) und schließlich die für den Join-Prozess benötigten Schlüssel und IDs auf dem Modul gespeichert (AT+DEVEUI, AT+APPEUI, AT+APPKEY).
Abschließend wird mit AT+JOIN der Join-Prozess gestartet. Das Modul versucht nun, sich mit dem Chirpstack-Netzwerk zu verbinden. Wenn der Join erfolgreich war, können Sie mit AT+SEND Daten an das Netzwerk senden.
Wenn alles korrekt konfiguriert ist, sollten Sie vom Modul folgende Bestätigung erhalten:
OTAA: Chirpstack beitreten (Join)
OK
+EVT:JOINED
Das +EVT:JOINED Ereignis zeigt an, dass der Join-Prozess erfolgreich war und das Gerät nun mit dem Netzwerk verbunden ist.
Im Chirpstack-Webinterface können Sie nun unter Applications > Ihre Application > Devices > Ihr Gerät > Events den Join-Prozess als ein Event sehen.
Events
Neben dem Join-Event gibt es noch weitere Events. Uplink Events zeigen an, wenn das Gerät eine Nachricht an den Server gesendet hat. Downlink Events zeigen an, wenn der Server eine Nachricht an das Gerät sendet. Zum Beispiel eine Empfangsbestätigung bei confirmed Uplinks.
Eine noch detailliertere Ansicht, was passiert ist, bekommen Sie unter LoRaWAN frames. Für den Join-Prozess sollten dort konkret der JoinRequest (vom Gerät) und der JoinAccept (vom Server) als zwei separate Frames zu sehen sein.
Sensordaten senden
In der Vorbereitung bis hierher haben Sie einen fest codierten Wert als Payload an den Server gesendet. Nun werden Sie die Messwerte eines DHT11-Sensors auslesen und sie kontinuierlich ans Netzwerk senden.
Konfiguration, Join und Senden
Im vorangegangenen Abschnitt haben Sie mit dem join_and_send.py-Skript alle nötigen Schritte durchgeführt, um Ihr Gerät mit dem Chirpstack-Netzwerk zu verbinden und eine Testnachricht zu senden. Nicht alle Teile dieses Skripts sind jedoch notwendig um Daten zu senden.
- Die Konfiguration des RAK-Moduls muss nur einmal durchgeführt werden. Die Daten bleiben auf dem Modul gespeichert.
- Der OTAA-Join Prozess muss nur nach einem Neustart oder Reset des Moduls durchgeführt werden. Sobald das Gerät erfolgreich gejoint ist, bleibt die Session bis zum nächsten Reset oder Neustart aktiv.
- Das Senden von Daten kann beliebig oft durchgeführt werden, solange die Session aktiv ist.
DHT11-Sensor anschließen
Schließen Sie das DHT11-Sensormodul wie folgt an Ihren Raspberry Pico an:

| Raspberry Pico | RAK3272S | ||
|---|---|---|---|
| UART0 TX | Pin 1 | UART2 RX | J4 Pin 8 |
| UART0 RX | Pin 2 | UART2 TX | J4 Pin 7 |
| 3,3 V | Pin 36 | 3V3 | J4 Pin 9 |
| GND | Pin 38 | GND | J4 Pin 4 |
| Raspberry Pico | DHT11 | |
|---|---|---|
| 3,3 V | Pin 36 | “+” |
| GND | Pin 38 | “-” |
| GPIO9 | (Pin12) | “Out” |
DHT11-Sensor auslesen
Mit dem folgenden Code können Sie testweise die Temperatur und die Luftfeuchte auslesen und so sicherstellen, dass ihre Verkabelung korrekt ist.
Sensordaten an den Chirpstack senden
Der DHT11 liefert Temperatur und Luftfeuchte als ganzzahlige Werte, also ohne Nachkommastellen. Die Methoden temperature() und humidity() geben entsprechend Integer zurück. Um die Werte als Payload zu übertragen, kodieren Sie nun jeden Messwert in 2 Byte Hexadezimal. Das gibt Ihnen jeweils einen Wertebereich von 0 bis 65535, was für die Messwerte des DHT11 mehr als ausreichend ist und bei Bedarf auch Raum lässt, um später z. B. negative Werte darzustellen.
Speichern Sie den folgenden Code als send_dht11.py auf Ihrem Computer ab und führen Sie ihn auf Ihrem Pico aus:
|
|
Damit sendet der Pico die Sensordaten kontinuierlich in regelmäßigen Abständen an den Chirpstack-Server. In der Weboberfläche unter Events sollten die eingehenden Uplinks als einzelne Events erscheinen.
Klickt man ein Event an, sieht man eine Vielzahl an Informationen: Unter anderem, über welches Gateway die Nachricht empfangen wurde, sowie die Signalstärke (RSSI) und das Signal-Rausch-Verhältnis (SNR) — beides gibt Aufschluss über die Qualität der Funkverbindung.
Hier findet man auch den gesendeten Payload unter data:. Dieser wird jedoch nicht als Hexadezimalwert angezeigt, sondern als Base64-kodierter String. Das ist die Darstellungsform, die Chirpstack intern verwendet Der Inhalt ist identisch mit dem ursprünglich gesendeten Payload, nur anders kodiert.
Payload weiterverarbeiten
Nachdem Ihr Gerät erfolgreich mit dem Chirpstack-Netzwerk verbunden ist und Daten sendet, können Sie nun die empfangenen Daten weiterverarbeiten.
Payload dekodieren
Um die Daten sinnvoll zu interpretieren, müssen sie dekodiert werden. Dazu wird ein Payload Codec benötigt. Das sind kleine Skripte, die spezifisch für ein Gerät geschrieben werden und den rohen Byte-Payload in lesbare Werte umwandeln.
Chirpstack bietet dies innerhalb eines Device profils an. Gehen Sie dazu auf das Device profile was Sie erstellt haben, und wechseln Sie auf den Reiter Codec. Wählen Sie dort aus dem Dropdown-Menü JavaScript functions aus.
Fügen Sie nun folgenden Code in das Textfeld ein:
Als Ergebnis erhalten Sie in der Chirpstack-Oberfläche unter Events nun ein dekodiertes Objekt mit den beiden Messwerten:
{
"temperature": 22,
"humidity": 58
}
Daten über MQTT abrufen
Nachdem die Daten dekodiert werden, lassen sie sich auch außerhalb von Chirpstack weiterverwenden. Chirpstack stellt dafür einen integrierten MQTT-Broker bereit. Über MQTT können verschiedene sogenannte Topics abonniert werden, zum Beispiel ein Uplink-Topic, das bei jeder eingehenden Nachricht veröffentlicht wird. Diese Nachricht enthält neben dem rohen Base64-Payload auch den eben dekodierten Payload als lesbares Objekt. Damit lassen sich die Messwerte direkt in anderen Anwendungen weiterverarbeiten, zum Beispiel in Node-RED zur Visualisierung oder für weiterführende Automatisierungen.
Um den Uplink eines bestimmten Geräts zu abonnieren:
application/{application_id}/device/{dev_eui}/event/up
Um alle Events aller Geräte einer Application zu abonnieren:
application/{application_id}/device/+/event/+
Senden ohne Gateway
Die folgende Simulation wurde noch nicht in der Lehre getestet, weil sie sich erst im Laufe des ersten Durchlaufs als wichtig ergeben hat.
Bisher ist sie nur auf dem Raspberry Pi (nicht Pico) und einem PC lauffähig. Eine Version für den Pico, die echte Messwerte senden kann, folgt.
Mit dem folgenden Tutorial wird ein softwarebasierter Simulator für das LoRaWAN-Gateway eingerichtet. Ziel ist es, dass Lernende auch zuhause, wo sie keinen Zugang zu einem Hardware-Gateway haben, Sensordaten erheben und an ihre Chirpstack-Application schicken können.
Als Beispiel dient das Senden eines statischen Temperaturwerts an ein registriertes Device in einer Application in Chirpstack. Für das Device wird zuvor ein Device profile angelegt, in dem auch der entsprechende Codec zum Dekodieren der empfangenen Daten hinterlegt wird.
Besonders an der Kommunikation ist bei dieser Simulation, dass das Device über ABP (Activation By Personalization) und nicht über OTAA (Over The Air Activation) aktiviert wird. Es muss also kein erfolgreicher Join stattgefunden haben, um das Device zu aktivieren. Das ginge ja auch nicht, weil es dafür ja eben ein Hardware-Gateway braucht. Stattdessen werden im Python-Code Zugangsschlüssel hinterlegt, mit denen sich der Uplink gegenüber Chirpstack authentifiziert.
Python-Umgebung einrichten
Die folgenden Schritte sollten auf einem Pi oder einem Laptop laufen. Eine Version für den Pico folgt.
- Richten Sie mit
python -m venv venvzunächst eine virtuelle Python-Umgebung in Ihrem Arbeitsverzeichnis ein. - Aktivieren Sie die virtuelle Umgebung mit
source ./venv/bin/activate. - Installieren Sie ein Package zum Verschlüsseln mit
pip install pycryptodome.
Chirpstack einrichten
Um die Simulation sauber von produktiven Anwendungen zu trennen, erstellen Sie im Folgenden eine eigene Umgebung in Chirpstack.
-
Erstellen Sie zunächst eine neue Application. Nennen Sie sie Simulation.
-
Erstellen Sie nun ein neues Device profile.
- General: Nennen Sie es Simulation profile.
- Join (OTAA / ABP): Deaktivieren Sie Device supports OTAA. Damit wird es möglich, Devices ohne Join zu aktivieren.
- Codec: Wählen Sie in der Liste JavaScript functions aus. Ersetzen Sie anschließend den Inhalt des Feldes vollständig mit folgendem Code. Er dekodiert einen empfangenen Temperaturwert:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32// Decode uplink: called by ChirpStack for every received frame function decodeUplink(input) { var bytes = input.bytes; // Need at least 2 bytes if (bytes.length < 2) { return { errors: ["payload too short, expected at least 2 bytes"] }; } // Big-endian unsigned 16-bit integer, value = temperature × 100 var raw = (bytes[0] << 8) | bytes[1]; var temperature = raw / 100.0; return { data: { temperature: temperature }, warnings: [], errors: [] }; } // Encode downlink: called when you schedule a downlink in ChirpStack function encodeDownlink(input) { // Not used in this simulation — return empty payload return { bytes: [], fPort: 1, warnings: [], errors: [] }; }
-
Fügen Sie Ihrer Application nun ein neues Device hinzu. Nennen Sie es Simulation device.
-
Erzeugen Sie Device EUI (EUI64), Join EUI (EUI64)
-
Wählen Sie das neue Device profile Simulation profile aus und schließen Sie den Vorgang mit Submit ab.
-
Wählen Sie auf der Seite des neuen Device den Reiter Activation aus. Hier können Sie nun Werte für Device address, Network session key (LoRaWAN 1.0) und Application session key (LoRaWAN 1.0) erzeugen.
+++ Diese Werte brauchen Sie gleich in Ihrem Python-Code! +++Schließen Sie den Vorgang ab mit (Re)activate device.
Python-Code auf dem Client anpassen
- Erstellen Sie in Ihrer virtuellen Python-Umgebung eine Datei
app.py. - Fügen Sie den folgenden Code ein und ergänzen Sie im Anschluss die notwendigen Angaben in den Platzhaltern:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114import socket import json import base64 import struct import random import time from Crypto.Cipher import AES # ── ChirpStack Gateway Bridge ──────────────────────── GATEWAY_BRIDGE_HOST = "IP-of-Chirpstack-server-here" GATEWAY_BRIDGE_PORT = 1700 # Get this EUI from your admin. For our context it's GATEWAY_EUI = bytes.fromhex("0016c001f116efaa") # ── Device ABP session keys (ChirpStack → Device → Activation tab) ─── DEV_ADDR = bytes.fromhex("00000000") NWK_S_KEY = bytes.fromhex("00000000000000000000000000000000") APP_S_KEY = bytes.fromhex("00000000000000000000000000000000") def encrypt_frm_payload(app_s_key: bytes, payload: bytes, dev_addr: bytes, fcnt: int) -> bytes: """AES-128 CTR encryption of FRMPayload (LoRaWAN spec section 4.3.3).""" encrypted = bytearray() for i in range(1, (len(payload) + 15) // 16 + 1): # A block: 0x01 + 4×0x00 + dir(0=up) + DevAddr(LE) + FCnt(LE,32bit) + 0x00 + block index a_block = (b"\x01\x00\x00\x00\x00\x00" + bytes(reversed(dev_addr)) + struct.pack("<I", fcnt) + b"\x00" + bytes([i])) s_block = AES.new(app_s_key, AES.MODE_ECB).encrypt(a_block) encrypted += s_block return bytes(x ^ y for x, y in zip(payload, encrypted)) def compute_mic(nwk_s_key: bytes, mhdr: bytes, fhdr: bytes, fport: bytes, frm_payload: bytes, dev_addr: bytes, fcnt: int) -> bytes: """AES-128 CMAC MIC over the LoRaWAN B0 block + message.""" from Crypto.Hash import CMAC msg = mhdr + fhdr + fport + frm_payload b0 = (b"\x49\x00\x00\x00\x00\x00" + bytes(reversed(dev_addr)) + struct.pack("<I", fcnt) + b"\x00" + bytes([len(msg)])) cobj = CMAC.new(nwk_s_key, ciphermod=AES) cobj.update(b0 + msg) return cobj.digest()[:4] def build_phy_payload(payload: bytes, fcnt: int, fport: int = 1) -> str: """Construct a valid signed LoRaWAN ABP uplink frame.""" mhdr = b"\x40" # unconfirmed data up dev_addr_le = bytes(reversed(DEV_ADDR)) fctrl = b"\x00" fcnt_le = struct.pack("<H", fcnt & 0xFFFF) fhdr = dev_addr_le + fctrl + fcnt_le fport_b = bytes([fport]) encrypted = encrypt_frm_payload(APP_S_KEY, payload, DEV_ADDR, fcnt) mic = compute_mic(NWK_S_KEY, mhdr, fhdr, fport_b, encrypted, DEV_ADDR, fcnt) return (mhdr + fhdr + fport_b + encrypted + mic).hex() def build_push_data(phy_payload_hex: str) -> bytes: """Wrap a PHYPayload in a Semtech UDP PUSH_DATA packet.""" phy_bytes = bytes.fromhex(phy_payload_hex) payload_b64 = base64.b64encode(phy_bytes).decode() rxpk = [{ "time": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()), "tmst": int(time.time() * 1000) & 0xFFFFFFFF, "freq": 868.1, "chan": 0, "rfch": 0, "stat": 1, "modu": "LORA", "datr": "SF7BW125", "codr": "4/5", "rssi": -70, "lsnr": 7.0, "size": len(phy_bytes), "data": payload_b64 }] json_body = json.dumps({"rxpk": rxpk}).encode() token = random.randint(0, 0xFFFF).to_bytes(2, "big") header = b"\x02" + token + b"\x00" + GATEWAY_EUI return header + json_body def send_uplink(payload: bytes, fcnt: int, fport: int = 1): phy_hex = build_phy_payload(payload, fcnt, fport) packet = build_push_data(phy_hex) sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) try: sock.sendto(packet, (GATEWAY_BRIDGE_HOST, GATEWAY_BRIDGE_PORT)) print(f"[{time.strftime('%H:%M:%S')}] FCnt={fcnt} | " f"payload={payload.hex()} | PHY={phy_hex}") finally: sock.close() # ── Main loop ────────────────────────────────────────────────────────────────── if __name__ == "__main__": fcnt = 0 while True: sensor_payload = struct.pack(">H", 2350) # 23.50 °C × 100 send_uplink(sensor_payload, fcnt, fport=1) fcnt += 1 time.sleep(30)
Anmerkung: Der Code wurde in Zusammenarbeit mit Claude Sonnet 4.6 entwickelt und für den Lehrzusammenhang angepasst.
Code ausführen
Führen Sie nun das Skript aus:
|
|
Ankommende Daten beobachten
Sehen Sie nun bei den Events in Ihrem Device nach. In den Uplinks sollte der Wert 23.5 für die fiktive Temperatur erscheinen.
Mögliche Fehler beheben
- Wenn das Skript nach einiger Zeit erneut gestartet wird, kann es zu einem Fehler mit dem Uplink Counter kommen. Der Chirpstack zählt mit, bei welchem Frame count er stehengeblieben ist. Um den Uplink Frame counter zurückzusetzen, gibt es im Reiter Activation des Device ein Formularfeld. Dort eine
0eintragen. Alternativ kann im Reiter Configuration die Option Disable frame-counter validation aktiviert werden, dann wird gar nicht mehr mitgezählt.
In diesen grünen Kästen sind Hinweise, Gedanken, Tipps und Erfahrungen aufgeschrieben, die sich aus dem Einsatz des Materials in der Lehre ergeben haben.
Die Kommentare können mit dem Button unsichtbar geschaltet werden.