LoRaWAN, Chirpstack und Node-RED | Informatik GTW

Datenströme visualisieren mit Node-RED

Mon, 23 Mar 2026 10:50:13 +0100

Dieses Kapitel befasst sich mit der Visualisierung von Datenströmen durch die Software Node-RED. Mit Node-RED wird ein niedrigschwelliger Umgang mit Daten möglich, weil informatische Verarbeitungsschritte ohne umfangreiche Programmierkenntnisse umgesetzt und transparent nachvollzogen werden können.

Vorraussetzungen

Dieses Kapitel geht davon aus, dass Sie die folgende Hard- und Software zur Verfügung haben:

Hardware

einen Raspberry Pico W mit Micropython Firmware
einen DHT11-Sensor
ein WLAN Netzwerk, in dem sich alle beteiligten Geräte befinden und deren IP-Adressen bekannt sind

Software

Node-RED auf einem Computer oder Raspberry Pi

Datenströme visualisieren

Sensoren erfassen Messwerte als fortlaufende Datenströme. Damit diese Werte nutzbar werden, müssen sie in strukturierter Form übertragen, inhaltlich ausgewertet und so aufbereitet werden, dass sie schnell überprüfbar und verständlich dargestellt werden können. Dieses Kapitel befasst sich mit der Visualisierung von Datenströmen.

Für die Umsetzung wird die No-Code/Low-Code-Software Node-RED genutzt. Node-RED stellt eine browserbasierte Entwicklungsumgebung bereit, in der Datenflüsse aus vorgefertigten Bausteinen zusammengesetzt werden. Dadurch wird ein niedrigschwelliger Umgang mit Daten möglich, weil informatische Verarbeitungsschritte ohne umfangreiche Programmierkenntnisse umgesetzt und transparent nachvollzogen werden können.

Ziel

Ziel dieses Kapitels ist es, grundlegende Arbeitsschritte kennenzulernen, die in späteren Abschnitten erneut benötigt werden.

Daten werden:

in einem verbreiteten Austauschformat wie JSON bereitgestellt
in Node-RED eingelesen, gezielt gefiltert oder umgerechnet
in einem Dashboard visualisiert.

Dabei geht es nicht um eine vollständige Datenanalyse, sondern um ein Verständnis dafür, wie Messwerte als Datenfluss verarbeitet werden und wie aus Rohdaten eine übersichtliche Darstellung entstehen kann.

JSON-Daten verstehen und visualisieren

JSON als Datenformat für Datenströme

Viele Datenströme im Netz werden im Format Java Script Object Notation (JSON) übertragen. JSON ist ein textbasiertes Austauschformat, das sowohl für Menschen gut lesbar als auch von Maschinen verarbeitbar ist. Es ist zudem sprachunabhängig, wodurch sehr unterschiedliche Systeme Daten im gleichen Format senden und empfangen können. Einen kompakten Überblick bietet der Wikipedia-Artikel zu JSON.

Ein JSON-Objekt besteht aus Schlüssel-Wert-Paaren. Der Schlüssel ist ein Name in Anführungszeichen, der Wert kann zum Beispiel eine Zahl, ein Text, true oder false oder auch wieder ein weiteres Objekt sein. Dadurch sind auch verschachtelte Strukturen möglich. Hier ein Beispiel:

{
  "device_id": "sensor-node-42",
  "location": "Rooftop, Building A",
  "measurements": [
    {
      "timestamp": "2026-03-23T10:15:00Z",
      "temperature_c": 18.4,
      "humidity_pct": 62.7
    },
    {
      "timestamp": "2026-03-23T10:20:00Z",
      "temperature_c": 18.9,
      "humidity_pct": 61.2
    }
  ]
}

JSON in Node-RED simulieren und visualisieren

Um einen Datenstrom ohne Hardware zu simulieren, kann dieser in Node-RED erstellt und dann in einem Dashboard visualisiert werden. Laden Sie dazu den bereitgestellten Flow 01-mock-flow herunter und importieren Sie ihn in Node-RED. Beim Import kann es sein, dass Node-RED zusätzliche Nodes nachinstallieren muss, um den Flow korrekt darzustellen. Folgen Sie dazu den Anweisungen in Node-RED.

Beispiel-Flow in Node-RED zum Erzeugen von zufälligen “Messwerten”

Nach dem Import sehen Sie die drei Bausteine:

Ein Inject-Node timer als Taktgeber, der alle 3 Sekunden auslöst.
Ein Function-Node generate JSON, der bei jedem Takt ein einfaches JSON-Objekt mit zwei Wertepaaren generiert. Die Werte werden mit jedem Takt neu generiert und leicht verändert, damit im Dashboard eine Bewegung im Verlauf sichtbar wird.
Zwei Dashboard-Chart-Nodes, die jeweils einen der beiden Werte aus dem Payload als Zeitreihe darstellen.

Weitere Informationen zum Umgang mit Node-RED finden Sie in der offiziellen Node-RED Dokumentation.

Darstellung von Messwerten in einem Dashboard. Quelle: Axel Dürkop

Datenfluss in Node-RED

Node-RED verarbeitet Daten als Nachrichtenobjekte msg, die von Node zu Node weitergereicht werden. Die eigentlichen Nutzdaten liegen dabei in der Regel in msg.payload, zum Beispiel als JSON-Objekt. Einzelne Werte können anschließend gezielt aus dem Payload entnommen und an Visualisierungs-Nodes übergeben werden.

Realitätsnahe JSON Daten und Base64 Payload

Im nächsten Beispiel wird ein komplexeres JSON-Objekt betrachtet, das sich am Aufbau realer LoRaWAN-Ereignisse orientiert. Solche Ereignisse enthalten viele Metadaten, z. B. zur Quelle, zum Empfang über Gateways oder zur Funkübertragung. Für die Weiterverarbeitung und Visualisierung sind davon in der Regel nur wenige Felder relevant. Ziel dieses Abschnitts ist es deshalb, aus einem großen JSON-Objekt gezielt nur die Daten herauszufiltern, die tatsächlich benötigt werden.

Flow importieren

Laden sie den Flow 02-mock2-flow herunter, und importieren Sie ihn in Node-RED.

Aufbau des Flows

Der Flow besteht aus den folgenden Elementen:

timer: löst alle 3 Sekunden aus und triggert damit den nachfolgenden Node.
generate JSON: erzeugt ein realtitätsnahes JSON-Objekt, was ein LoRaWAN-Uplink-Event simuliert.
change frm_payload: variiert den Wert frm_payload.
extract payload base64: filtert das JSON Objekt so, dass nur noch der Base64-String übrig bleibt.
decode base64 2x 2bytes: decodiert den Base64 String in zwei Werte.
Dashboard Charts und Gauges: dienen der Visualisierung.

JSON-Objekt untersuchen

Wenn Sie das JSON Objekt betrachten, sehen Sie, dass es sehr viele Felder enthält. Für die Visualisierung im Dashboard sind aber nur wenige davon relevant. In diesem Fall ist es der Wert payload.uplink_message.frm_payload, der die eigentlichen Nutzdaten enthält. Dieser Wert wurde als Base64-String codiert.

Base64

Base64 ist ein Kodierungsverfahren, das Daten in eine Zeichenkette umwandelt, die aus 64 verschiedenen Zeichen besteht. Es wird häufig verwendet, um binäre Daten wie Bilder, Zip-Dateien oder Emailanhänge in Textform zu übertragen, zum Beispiel in JSON Objekten. Durch die Codierung wird ein problemloser Transport über diese Textprotokolle ermöglicht.

Auch in diesem Beispiel werden die Nutzdaten variiert, damit bei der Visualisierung im Dashboard eine Veränderung zu sehen ist. Dieser Schritt dient nur dazu, die Nutzdaten durch Variation “echter” aussehen zu lassen. Diese Veränderung erfolgt in dem Node change frm_payload.

Alle anderen Felder außer dem Payload sind für die Visualisierung nicht notwendig. Deshalb wird das JSON-Objekt mit einem Change-Node extract payload base64 manipuliert, sodass nur noch der Wert payload.uplink_message.frm_payload als msg.payload übrig bleibt.

Im nächsten Schritt wird der Base64-String mit einem Function-Node decode base64 2x 2bytes in die ursprünglichen Nutzdaten zurückverwandelt. In diesem Fall handelt es sich um 2x 2 Byte Werte, die Temperatur und Luftfeuchtigkeit repräsentieren.

Diese Werte werden anschließend im Dashboard auf unterschiedliche Weise visualisiert.

Codierung

Das Wissen um die Codierung ist in diesem Fall notwendig, damit die Nutzdaten korrekt decodiert werden können.

Reale Sensordaten visualisieren

Damit die Visualisierung nicht nur auf fiktiven Daten basiert, werden in diesem Kapitel reale Sensordaten von einem DHT11-Sensor verwendet. Der Sensor wird vom Raspberry Pico ausgelesen und über einen Webserver bereitgestellt, der wiederum von Node-RED abgefragt wird.

DHT11 verkabeln

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

Der Sensor DHT11 mit dem Raspberry Pico verbunden. Darstellung mit fritzing: Benjamin Blessing

Raspberry Pico		DHT11
3,3 V	Pin 36	+
GND	Pin 38	-
GPIO9	(Pin12)	Out

Webserver mit Sensordaten bereitstellen

Führen Sie den folgenden Code auf ihrem Raspberry Pico aus. Ersetzen Sie dabei die SSID und das Passwort durch die Zugangsdaten ihres WLANs:

# Import necessary modules
import network
import socket
import time
import json
import dht
from machine import Pin

# Wi-Fi credentials
ssid = 'WLAN_SSID_EINTRAGEN'
password = 'WLAN_PASSWORT_EINTRAGEN'

# DHT11 initialisieren
sensor = dht.DHT11(Pin(9))

# Connect to WLAN
wlan = network.WLAN(network.STA_IF)
wlan.active(True)
wlan.connect(ssid, password)

# Wait for Wi-Fi connection
connection_timeout = 10
while connection_timeout > 0:
    if wlan.status() >= 3:
        break
    connection_timeout -= 1
    print('Waiting for Wi-Fi connection...')
    time.sleep(1)

# Check if connection is successful
if wlan.status() != 3:
    raise RuntimeError('Failed to establish a network connection')
else:
    print('Connection successful!')
    network_info = wlan.ifconfig()
    print('IP address:', network_info[0])

# Set up socket and start listening
addr = socket.getaddrinfo('0.0.0.0', 80)[0][-1]
s = socket.socket()
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
s.bind(addr)
s.listen()

print('Listening on', addr)

# Variable initialisieren
sensor_werte = {
    "temp": 20,
    "hum": 40
}

# Liest den Sensor und updated das Dict.
def read_dht11():
    try:
        sensor.measure()
        temperatur = sensor.temperature()
        luftfeuchtigkeit = sensor.humidity()

        sensor_werte["temp"] = temperatur
        sensor_werte["hum"] = luftfeuchtigkeit
        
    except Exception:
        pass

    return sensor_werte

# Main loop to listen for connections
while True:
    conn = None
    try:
        conn, addr = s.accept()
        print("Connection from", addr)

        # Request Daten vom Client lesen
        request = conn.recv(1024)
        if not request:
            conn.close()
            continue

        # Pfad extrahieren (z.B. GET / HTTP/1.1)
        first_line = request.split(b"\r\n")[0]
        # Holt Index 1 also b"/" und decodiert zu einem String "/"
        path = first_line.split()[1].decode()

        if path == "/":
            # Sensor lesen
            data = read_dht11()
            # JSON erstellen
            body = json.dumps(data)

            # HTTP Response senden
            conn.send("HTTP/1.1 200 OK\r\n")
            # Header (Content-Typ)
            conn.send("Content-Type: application/json\r\n")
            # Leerzeichen (Trennt Header von Body)
            conn.send("Connection: close\r\n\r\n")
            # Der Body
            conn.send(body)

        else:
            conn.send("HTTP/1.1 404 Not Found\r\n\r\n")

        conn.close()

    except OSError as e:
        conn.close()
        print('Connection closed')

Sobald die Verbindung zum WLAN hergestellt ist und der Webserver läuft, sehen Sie die IP-Adresse die der Router dem Pico zugewiesen hat. Und wenn Sie diese IP-Adresse in einem Browser eingeben, sollten Sie die aktuellen Sensordaten als JSON Objekt sehen. Zum Beispiel: {"temp": 21, "hum": 45}.

Sensordaten in Node-RED visualisieren

Laden Sie den Flow 03-piko-dht11 herunter und importieren Sie ihn in Node-RED. Der Flow besteht aus den folgenden Schritten:

Taktgeber: löst alle 2 Sekunden aus und triggert damit den nachfolgenden Node
HTTP-Request: sendet eine GET Anfrage an den Webserver des Raspberry Pico und erhält ein JSON-Objekt mit den aktuellen Sensordaten
zwei Change-Nodes, um die Daten für die Visualisierung aufzubereiten
Dashboard Charts und Gauges: dienen der Visualisierung

IP-Adresse anpassen

Damit der Flow funktioniert, müssen Sie den HTTP Request-Node öffnen und die URL anpassen. Geben Sie im Feld URL die IP-Adresse ein, die der Router ihrem Pico zugewiesen hat.

Serielle Kommunikation einrichten

Sun, 10 May 2026 10:50:13 +0100

In diesem Kapitel wird ein Computer mit einem LoRa-Sende- und Empfangsmodul verbunden und gesteuert. Als Computer wird ein Raspberry Pico verwendet, der mit MicroPython programmiert wird. Als LoRa-Modul wird das RAK3272S Breakout Board von RAK-Wireless verwendet. Die hier verwendete Hardware ist nicht zwingend notwendig, wird hier auf Grund der Verwendung von MicroPython und der einfachen Verfügbarkeit benutzt.

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

Sie haben die Möglichkeit, MicroPython-Code auf dem Raspberry Pico auszuführen. Dazu benötigen Sie:

Thonny IDE installiert auf Ihrem Computer

oder:

Die VSCode Extension MicroPico

UART-Kommunikation einrichten

UART (Universal Asynchronous Receiver/Transmitter) ist ein Protokoll zur seriellen Kommunikation. Es ermöglicht die Übertragung von Daten zwischen Geräten über eine serielle Schnittstelle. In diesem Abschnitt schauen Sie sich die UART-Schnittstelle Ihres Raspberry Pico an, und wie Sie diese nutzen können, um Daten über weite Strecken mit LoRa zu senden und zu empfangen.

Eine UART Schnittstelle besteht aus zwei Leitungen: TX (Transmit) und RX (Receive). Außerdem wird eine gemeinsame Masseleitung (GND) benötigt, um die Signale korrekt zu referenzieren.

UART auf dem Raspberry Pico

Der Raspberry Pico verfügt über zwei UART-Schnittstellen (UART0 und UART1), die Sie nutzen können. Im Folgenden verwenden Sie jedoch nur UART0, das standardmäßig auf den GPIO Pins 0 (TX) und 1 (RX) liegt.

Board-Layout eines Raspberry Pico mit WLAN. Quelle: Offizielle Dokumentation Raspberry Pico

Verkabelung

Um die UART Kommunikation zwischen zwei Geräten einzurichten, verbinden Sie die TX-Leitung des sendenden Geräts mit der RX-Leitung des empfangenden Geräts. Testen Sie zunächst nur die UART0-Schnittstelle und lassen Sie den Pico mit sich selbst reden. Das ist ein sogenannter Loopback.

Verbinden Sie dazu den TX-Pin (GPIO 0) mit dem RX-Pin (GPIO 1). Das Verbinden der GND-Leitungen ist in diesem Fall nicht notwendig, da Sie nur den einen Pico verwenden.

Loopback-Schaltung auf dem Pico. Die serielle Schnittstelle spricht mit sich selbst. Schaltplan: Benjamin Blessing

MicroPython Code

Der folgende MicroPython Code initialisiert die UART-Schnittstelle und sendet eine Nachricht. Anschließend wird geprüft, ob Daten empfangen wurden, und diese werden ausgegeben.

Speichern Sie diesen Code als uart_loopback.py auf Ihrem Computer ab und führen Sie ihn auf Ihrem Pico aus.

from machine import UART
import time
uart = UART(0, baudrate=115200, tx=0, rx=1)  # Initialisiere UART0

for i in range(5):
    tx_data = f"Test nummer {i}"
    uart.write(tx_data)
    time.sleep(1)

    rx_data = uart.read().decode('utf-8')
    print(f"Empfange Nachricht: {rx_data}")

Sobald Sie den Code ausgeführt haben, sollten Sie in der Ausgabe die gesendeten und empfangenen Nachrichten sehen. Damit wissen Sie, dass die UART0-Schnittstelle korrekt funktioniert.

Die UART-Klasse

Die UART Klasse in MicroPython, die Sie eben benutzt haben, bietet verschiedene Methoden, um die UART-Schnittstelle zu nutzen. Weiterführende Informationen finden Sie in der offiziellen Dokumentation der UART Klasse

RAK3272S-Modul und AT-Befehle

Das RAK3272S ist ein LoRa-Modul, das über eine UART-Schnittstelle mit dem Raspberry Pico kommuniziert. In diesem Abschnitt lernen Sie, wie Sie das Modul anschließen und grundlegende AT-Befehle verwenden können, um mit dem Modul zu interagieren.

In der offiziellen Dokumentation des Moduls finden Sie weitere Informationen.

Verkabelung

Das RAK3272S Modul verfügt über zwei UART-Schnittstellen: UART1 und UART2. In diesem Beispiel verwenden wir nur die UART2-Schnittstelle.

Das RAK Modul muss immer mit einer Antenne betrieben werden, da sonst das Modul beschädigt werden kann.

Anschluss des RAK3272S an den Raspberry Pico über UART. Schaltplan: Benjamin Blessing

Verbinden Sie die folgenden Pins des RAK3272S mit dem Raspberry Pico:

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

AT-Befehle

Mit den sogenannten AT-Befehlen (Attention Commands) können Sie das RAK-Modul konfigurieren und steuern, also auch Daten senden und empfangen. Diese Befehle werden über die UART-Schnittstelle gesendet, und das Modul antwortet mit entsprechenden Rückmeldungen.

Hier finden sie die offizielle Liste der AT-Befehle für das RAK3272S-Modul.

Aufbau der AT-Befehle

AT-Befehle haben folgende Form AT+XXX, wobei XXX dabei der spezifische Befehl ist. Enden muss jeder Befehl mit einem carriage return und line feed (stammt noch aus den Zeiten der Schreibmaschine): \r\n.

Manchen Befehlen können Sie Parameter mitgeben und manche Befehle geben Ihnen einen Rückgabewert zurück. Was Sie auf jeden Fall immer vom Modul bekommen, ist ein Return Code wie z. B. OK oder ein bestimmter ERROR der anzeigt, dass ein Befehl nicht erfolgreich war.

Der folgende Code initialisiert ein UART-Objekt und sendet dann den AT-Befehl AT+VER=?, der die Firmware-Version des Moduls zurückgibt (siehe Beschreibung dieses Befehls). Das RAK-Modul antwortet wieder auf der UART-Schnittstelle, wo Sie die Nachricht auslesen können.

Speichern Sie diesen Code als at_command_test.py auf Ihrem Computer ab und führen Sie ihn auf ihrem Pico aus:

from machine import UART
import time
uart = UART(0, baudrate=115200, tx=0, rx=1, bits=8, parity=None, stop=1, rxbuf=512)
uart.write("AT+VER=?" + "\r\n")
time.sleep(1)
print(uart.read())

Wenn alles geklappt hat, sollten Sie eine Antwort ähnlich der folgenden erhalten:

b'AT+VER=RUI_4.0.6_RAK3172-E\r\nOK\r\n'

Sie sehen hier die Firmware-Version RUI_4.0.6_RAK3172-E und den Return Code OK, der anzeigt, dass der Befehl erfolgreich ausgeführt wurde. Das vorangestellte b'...' zeigt an, dass es sich um eine Byte-String-Antwort handelt. Auch das Modul antwortet mit \r\n am Ende jeder Zeile.

LoRaWAN-Kommunikation einrichten

Sun, 10 May 2026 10:50:13 +0100

Dieses Kapitel führt Sie durch die Einrichtung einer vollständigen LoRaWAN-Kommunikationskette. Themen umfassen die Hardware-Voraussetzungen, das Einrichten einer eigenen Chirpstack-Infrastruktur, das Verbinden eines RAK3272S-Geräts mittels OTAA und schließlich das kontinuierliche Senden und Dekodieren von Sensordaten (z. B. DHT11) über MQTT.

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.

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 in Betrieb nehmen

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.

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

Chirpstack-Server aufsetzen

Die Chirpstack-Software stellt verschiedene Komponenten bereit. Eine davon ist der Chirpstack-Netzwerkserver, der dieser Anleitung folgend mit Docker Compose aufgesetzt wurde.

Gerät zum Chirpstack 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

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.

# 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

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.

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:

# Bibliotheken laden
from machine import UART
from machine import Pin
import time
import dht

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

# Initialisierung: DHT11 Sensor
sensor = dht.DHT11(Pin(9))

# 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

while True:
    # Sensor auslesen
    sensor.measure()
    temperatur = sensor.temperature()
    luftfeuchte = sensor.humidity()

    # Umrechnung in 2 Byte Hexadezimal
    temp_in_hex = "{:04x}".format(temperatur)
    luftfeuchte_in_hex = "{:04x}".format(luftfeuchte)

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

    # Warten bis zum nächsten Sendevorgang
    time.sleep(20)

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 weiterverwenden

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:

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/+