LoRaWAN-Kommunikation einrichten

Didaktische Kommentare
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.

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

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.

Dashboard einer Chirpstack-Installation im Internet. Quelle: Axel Dürkop
Dashboard einer Chirpstack-Installation im Internet. Quelle: Axel Dürkop

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-1
  • Device 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 auf 0000000000000000setzen. 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.

Hinzugefügtes Device in der Application. Quelle: Axel Dürkop
Hinzugefügtes Device in der Application. Quelle: Axel Dürkop

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.

 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
# Bibliotheken laden
from machine import UART
import time

# LoRaWAN/Konfiguration für OTAA
DEVEUI = 'xxxxxxxxxxxxxxxx'
APPEUI = '0000000000000000'
APPKEY = 'xxxxxxxxxxxxxxxx'

# Daten in hexadezimaler Schreibweise
payload = '2A'

# Initialisierung: UART
uart = UART(0, baudrate=115200, tx=0, rx=1, bits=8, parity=None, stop=1, rxbuf=512)

# Funktion: AT-Kommando senden und Rückmeldung empfangen
def sendCmdAT (at_cmd, wait=1):
    char = ''
    dataString = ''
    uart.write(at_cmd + '\r\n')
    time.sleep(wait) # Warten nach dem Senden des AT-Kommandos
    while char is not None:
        char = uart.read(1)
        try: dataString += char.decode()
        except: pass
    if dataString == '': return 'Keine Rückmeldung. Bitte TX und RX prüfen.'
    return dataString

##
## Konfiguration: OTAA für RAK3272S
##

# Modul resetten
print('Resetting...')
print(sendCmdAT('ATZ', 2))

# Networkmode auf LoRaWAN setzen
print('Typ: LoRaWAN')
print(sendCmdAT('AT+NWM=1'))

# Klasse A (Standard, energiesparend)
print('Endgeräte-Klasse: A')
print(sendCmdAT('AT+CLASS=A'))

# Uplink mit Bestätigung (confirmed)
print('Sendebestätigung: Ja')
print(sendCmdAT('AT+CFM=1'))

# OTAA aktivieren (Join-Procedure)
print('Aktivierung: OTAA')
print(sendCmdAT('AT+NJM=1'))

# Region auf EU868 setzen
print('Region/Frequenzbereich: EU868')
print(sendCmdAT('AT+BAND=4'))

# Device EUI setzen (Geräte-ID)
print('Device EUI (DEVEUI)')
print(sendCmdAT('AT+DEVEUI=' + DEVEUI))

# Application/Join EUI setzen
print('Application EUI (APPEUI)')
print(sendCmdAT('AT+APPEUI=' + APPEUI))

# Application Key setzen (OTAA-Key)
print('Application Key (APPKEY)')
print(sendCmdAT('AT+APPKEY=' + APPKEY))

###
### Daten senden: JOIN + SEND
###

# Verbindung prüfen (AT antwortet mit OK)
print('Test: AT')
print(sendCmdAT('AT'))

# OTAA Join starten
print('OTAA: Chirpstack beitreten (Join)')
print(sendCmdAT('AT+JOIN=1:0:10:8', 10))

# Payload senden
print('Daten senden')
print(sendCmdAT('AT+SEND=2:' + payload, 10))

Erklärung zum Code


Detaillierte Informationen zu den verwendeten AT-Befehlen, sowie Bedeutungen von Parametern oder möglichen Fehlermeldungen finden Sie in der offiziellen Dokumentation der RUI3 AT Commands.

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.
Im folgenden wird davon ausgegangen, dass eine gültige Session besteht, also dass der Join-Prozess erfolgreich durchgeführt wurde und das Gerät mit dem Netzwerk verbunden ist. Falls nötig, müssen Sie erneut den OTAA-Join durchführen.

DHT11-Sensor anschließen

Schließen Sie das DHT11-Sensormodul wie folgt an Ihren Raspberry Pico an:

Anschluss eines DHT11-Sensors an den Raspberry Pico, um Daten über das RAK-Modul zu versenden. Schaltplan: Benjamin Blessing
Anschluss eines DHT11-Sensors an den Raspberry Pico, um Daten über das RAK-Modul zu versenden. Schaltplan: Benjamin Blessing
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”
Die DHT11-Sensor-Module werden mit unterschiedlichen Pinbelegungen verkauft. Bitte überprüfen Sie die Pinbelegung Ihres Moduls.

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.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
from machine import Pin
import dht
import time

# DHT11 Sensor an GPIO9 initialisieren
sensor = dht.DHT11(Pin(9))

while True:
    sensor.measure()
    print("T:", sensor.temperature(), "C  H:", sensor.humidity(), "%")
    time.sleep(2)

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:

  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
# Bibliotheken laden
from machine import Pin, UART
from time import sleep
from dht import DHT11
import time
import struct

# LoRaWAN/TTN-Konfiguration für OTAA
DEVEUI = '0000000000000000'
APPEUI = '0000000000000000'
APPKEY = '00000000000000000000000000000000'

# Initialisierung GPIO und DHT11
sleep(1)
dht11_sensor = DHT11(Pin(9, Pin.IN, Pin.PULL_UP))

# Initialisierung: UART
uart = UART(0, baudrate=115200, tx=0, rx=1, bits=8, parity=None, stop=1, rxbuf=512)

# Funktion: AT-Kommando senden und Rückmeldung empfangen
def sendCmdAT (at_cmd, wait=1):
    char = ''
    dataString = ''
    uart.write(at_cmd + '\r\n')
    time.sleep(wait) # Warten nach dem Senden des AT-Kommandos
    while char is not None:
        char = uart.read(1)
        try: dataString += char.decode()
        except: pass
    if dataString == '': return 'Keine Rückmeldung. Bitte TX und RX prüfen.'
    return dataString


##
## Konfiguration: TTN mit OTAA für RAK3272S
##

# Modul resetten
print('Resetting...')
print(sendCmdAT('ATZ', 2))

# Networkmode auf LoRaWAN setzen
print('Typ: LoRaWAN')
print(sendCmdAT('AT+NWM=1'))

# Klasse A (Standard, energiesparend)
print('Endgeräte-Klasse: A')
print(sendCmdAT('AT+CLASS=A'))

# Uplink mit Bestätigung (confirmed)
print('Sendebestätigung: Ja')
print(sendCmdAT('AT+CFM=0'))

# OTAA aktivieren (Join-Procedure)
print('Aktivierung: OTAA')
print(sendCmdAT('AT+NJM=1'))

# Region auf EU868 setzen
print('Region/Frequenzbereich: EU868')
print(sendCmdAT('AT+BAND=4'))

# Device EUI setzen (Geräte-ID)
print('Device EUI (DEVEUI)')
print(sendCmdAT('AT+DEVEUI=' + DEVEUI))

# Application/Join EUI setzen
print('Application EUI (APPEUI)')
print(sendCmdAT('AT+APPEUI=' + APPEUI))

# Application Key setzen (OTAA-Key)
print('Application Key (APPKEY)')
print(sendCmdAT('AT+APPKEY=' + APPKEY))

###
### Daten senden: JOIN + SEND
###

# Verbindung prüfen (AT antwortet mit OK)
print('Test: AT')
print(sendCmdAT('AT'))

# OTAA Join starten
print('OTAA: TTN beitreten (Join)')
print(sendCmdAT('AT+JOIN=1:0:10:8', 10))

# Wiederholung (Endlos-Schleife)
while True:
    # Messung durchführen
    dht11_sensor.measure()
    # Werte lesen
    temp = dht11_sensor.temperature()
    humi = dht11_sensor.humidity()
    
    temp_int = int(round(temp * 10))
    humi_int = int(round(humi * 10))

    print("temp_int:", temp_int)        # e.g. 235
    print("humi_int:", humi_int)        # e.g. 652
    packed = struct.pack('>hH', temp_int, humi_int)
    hex_payload = packed.hex()
    print("hex_payload:", hex_payload)  # e.g. "00eb028c"
    print("length:", len(hex_payload))  # must be 8 (= 4 bytes)

    print(sendCmdAT('AT+SEND=2:' + hex_payload, 30))
    
  
    # Werte ausgeben
    print('Temperatur:', temp_int, '°C')
    print('Luftfeuchtigkeit:', humi_int, '%')

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.

Base64 ist ein weit verbreitetes Verfahren, um binäre Daten als Text darzustellen und wird häufig verwendet, um Daten sicher über das Internet zu übertragen. Chirpstack kodiert den empfangenen Payload automatisch in Base64.

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:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
function decodeUplink(input) {
  var bytes = input.bytes;
  var temperature = (bytes[0] << 8) | bytes[1];
  var humidity = (bytes[2] << 8) | bytes[3];
  return {
    data: {
      temperature: temperature,
      humidity: humidity
    }
  };
}

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.

  1. Richten Sie mit python -m venv venv zunächst eine virtuelle Python-Umgebung in Ihrem Arbeitsverzeichnis ein.
  2. Aktivieren Sie die virtuelle Umgebung mit source ./venv/bin/activate.
  3. 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.

  1. Erstellen Sie zunächst eine neue Application. Nennen Sie sie Simulation.

  2. 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: []
          };
        }  
      
  3. Fügen Sie Ihrer Application nun ein neues Device hinzu. Nennen Sie es Simulation device.

  4. Erzeugen Sie Device EUI (EUI64), Join EUI (EUI64)

  5. Wählen Sie das neue Device profile Simulation profile aus und schließen Sie den Vorgang mit Submit ab.

  6. 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

  1. Erstellen Sie in Ihrer virtuellen Python-Umgebung eine Datei app.py.
  2. 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
    114
    
    import 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:

1
python app.py

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 0 eintragen. Alternativ kann im Reiter Configuration die Option Disable frame-counter validation aktiviert werden, dann wird gar nicht mehr mitgezählt.
Zurück