LoRaWAN-Kommunikation einrichten

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.

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.

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.

 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

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.

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:

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.

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:

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