LoRaWAN: Unterschied zwischen den Versionen

Aus Hackerspace Ffm
Wechseln zu: Navigation, Suche
(LoRa Radio)
(Aktuell: Workshop zu LoRa und LoRaWAN)
 
(48 dazwischenliegende Versionen von 3 Benutzern werden nicht angezeigt)
Zeile 1: Zeile 1:
 +
= Vortrag auch zu LoRa, LoRaWAN und TheThingsNetwork auf der Make Darmstadt 2019 =
 +
Auf der  [http://make-darmstadt.de/ Make Darmstadt] hat Lutz Lisseck vom Hackerspace FFM ein Vortrag zum Thema "Die lizenzfreie Übertragung kleiner Datenmengen per Funk" gehalten, die Folien zum Vortrag gibt es auch hier: [[Datei:Die_lizenzfreie_Übertragung_kleiner_Datenmengen.pdf]]
 +
 +
= Rückblick: Workshop zu LoRa und LoRaWAN =
 +
 +
Am 25. Februar 2018 von 15 bis etwa 21 Uhr fand der 1. Teil des Workshops zu LoRa und LoRaWAN bei uns im Hackerspace statt.
 +
Der 2. Teil ist geplant an einem Sonntag im April, ebenfalls von 15 bis etwa 21 Uhr im Hackerspace.
 +
 +
Please note: The main language of the workshop will be German, so the presentations of the workshop will be held in German language. However, there will be a lot of people who can assist you if you have issues in understanding the language and of course I am open to answer your questions in English as well.
 +
 +
Folgendes steht/stand auf der Agenda:
 +
 +
== Agenda Teil 1 ==
 +
[[Datei:IMG_20180225_184530744.jpg|400px]]
 +
* Begrüßungsrunde
 +
** Anwendungfälle der Teilnehmer: Bienenstöcke vor Diebstahl schützen, Stratosphärenballon, Feinstaubmessungen
 +
* Vortrag Teil A: LoRa
 +
** Was ist LoRa und wie funktioniert es?
 +
** Verfügbare LoRa Module und mit LoRa ausgestattete Boards
 +
** Legale Nutzung von LoRa: Nutzbare Frequenzen, Duty-cycle und Bandbreite Beschränkungen, maximale Leistung
 +
** Wie macht man eine LoRa Punkt-zu-Punkt-Verbindungen mit Arduino?
 +
 +
* Workshop Teil A:
 +
** Ziel: Erreichen einer Punkt-zu-Punkt-Verbindung via LoRa unter Arduino
 +
** Anschluss von LoRa (RFM95) Modulen an Arduino-Boards (433MHz und 868MHz)
 +
** Konfiguration und Einstellungen für LoRa unter Arduino
 +
** Senden und Empfangen von LoRa Paketen
 +
 +
* Vortrag Teil B: LPWAN / LoRaWAN / The Things Network
 +
** Wozu LPWAN? Derzeitige Situation der konkurierenden Systeme
 +
** Was ist ein LoRaWAN?
 +
** The Things Network: [https://vimeo.com/136731514 Spoilervideo :-)]
 +
*** Was kann man damit alles machen?
 +
*** Wie baut man eine Node?
 +
*** Wie kommt man an die Daten und verarbeitet sie weiter?
 +
 +
* Workshop Teil B:
 +
** Ziel: Aus dem Setup von Teil A eine Node fürs TTN machen und die Daten im TTN empfangen
 +
** Zurechtfinden in der (leider etwas weniger intuitiven) Standard Node Software für Arduino (LMIC)
 +
** ABP Einstellungen, um die Node zum TTN hinzuzufügen
 +
** Empfang der Telegramme in der Console von thethingsnetwork.org
 +
 +
* Field-Day: Wir testen die Reichweite der Node
 +
 +
* Schlussbesprechung
 +
 +
== Vorläufige Agenda-Ideen Teil 2: (Termin steht noch nicht fest) ==
 +
* Mitmachen und Erweitern des TheThingsNetworks durch ein eigenes Gateway (=Basisstation, =Konzentrator)
 +
* Was ist ein LoRaWAN Konzentrator?
 +
* Aufbau des TheThingsNetwork
 +
* Standortanforderungen für Gateways
 +
* Komponenten zum Selbstbau oder Einkauf für LoRaWAN Gateways
 +
* Antennen (ggf. Selbstbau) für Gateways
 +
* Workshop: Aufbau eines Gateways und Verbinden mit dem TTN. Antennenbau und Reichweitentests
 +
 
= LoRa =
 
= LoRa =
 
== Was ist LoRa? ==
 
== Was ist LoRa? ==
Zeile 10: Zeile 65:
 
Datei:RFM95_LoRa_Modul_868_MHz_und_Antenne.jpg|RFM95 LoRa Modul - hier für 868 MHz mit Antenne
 
Datei:RFM95_LoRa_Modul_868_MHz_und_Antenne.jpg|RFM95 LoRa Modul - hier für 868 MHz mit Antenne
 
Datei:Ra-01_Ai-Thinker_LoRa_Modul_443_MHz_und_Antennen.jpg|Ra-01 Ai-Thinker LoRa Modul - hier für 433 MHz mit Antennen in unterschiedlichen Bauformen
 
Datei:Ra-01_Ai-Thinker_LoRa_Modul_443_MHz_und_Antennen.jpg|Ra-01 Ai-Thinker LoRa Modul - hier für 433 MHz mit Antennen in unterschiedlichen Bauformen
Datei:ESP32_mit_SSD1306_OLED_und_LoRa_und_Antenne.jpg|ESP32 mit OLED und LoRa und Antenne für 868 MHz
+
Datei:ESP32_mit_SSD1306_OLED_und_LoRa_und_Antenne.jpg|link=Heltec_Wifi_LoRa_32|ESP32 mit OLED und LoRa und Antenne für <strike>868 MHz</strike> 433 MHz (hat ein SX1278)
 +
Datei:LoRa TestBoards.jpg|link=MikroEckeBauteile|Zwei Testboards aus unserem Workshop sind in der [[MikroEcke]] zu finden
 
</gallery>
 
</gallery>
  
 
=== Ai-Thinker Ra-01 oder Ra-02 ===
 
=== Ai-Thinker Ra-01 oder Ra-02 ===
Der Unterschied zwischen Ra-01 und Ra-02 ist lediglich der, dass der Ra-01 die Antenne an einem der Pads herausgeführt hat (und meist eine Federantenne dabei liegt), während beim Ra-02 eine Buchse für einen Antennenstecker dran ist (IPEX).  
+
Der Unterschied zwischen Ra-01 und Ra-02 ist lediglich der, dass der Ra-01 die Antenne an einem der Pads herausgeführt hat (und meist eine Federantenne dabei liegt), während beim Ra-02 eine Buchse für einen Antennenstecker dran ist (IPEX).
  
=== Heltec Wifi LoRa 32 - ESP32 mit OLED und LoRa ===
+
== Antenne ==
==== Arduino ====
+
Um dieses sehr interessante Modul via Arduino nutzen zu können, reichte bei mir die [https://github.com/espressif/arduino-esp32 Standard-ESP32-Arduino Bibliothek], die man wie dort beschrieben installiert. Aus der recht großen Liste der Arduino Boards konnte ich gleich "Heltec_WIFI_LoRa_32" wählen und damit das Modul programmieren. Es gibt auch ein [http://www.heltec.cn/download/WIFI_LoRa_32_Diagram.pdf Dokument mit dem Heltec ESP32 Pinout].
+
  
==== Weisse LED ====
+
Antennen sind für eine bestimmte Frequenz optimiert. In Europa wird das ISM-Band mit 868 Mhz verwendet.<br>
Sollte an Pin 25 sein.
+
Die Wellenlänge berechnet sich nach folgender Formel: [[Datei:Wavelength.PNG]]<br>
 +
f = frequency in hertz (Hz) <br>
 +
λ = wavelength in meters (m)<br>
 +
c = speed of light (299.792.458 m/s)<br><br>
 +
[[Datei:Wavelength_of_868.PNG]]<br>
 +
Die Antenne muss also 34.5 cm lang sein oder ein 1/2λ = 17.25, 1/4λ = 8.63, 1/8λ = 4.31, ...
  
==== Display ====
+
== LoRa Bibliotheken ==
Verbaut ist ein OLED Display vom Typ SSD1306, es ist ein 128x64 Monochrom Display. Es ist NICHT an den Standard-I2C-Leitungen angeschlossen und braucht ein Reset-Signal. Bei manchen Bibliotheken sind daher kleine Modifikationen nötig, um das Display zu benutzen.  
+
Hier gibt es folgende Bibliotheken:
 +
* [https://github.com/sandeepmistry/arduino-LoRa LoRa by Sandeep Mistry] Einfach nur zur Ansteuerung des LoRa-Moduls in Arduino ohne viel Balast und ohne Schnick-Schnack. Sinnvoll daher für Punkt-zu-Punkt Verbindungen, aber nicht für Netzwerke.
 +
* [http://www.airspayce.com/mikem/arduino/RadioHead/ RadioHead] Hier die Bibliothek für sehr viele verschiedene Funkmodule. Hiermit können auch (Mesh-)Netzwerke aufgebaut werden und das IP-Protokoll über Funk abgewickelt werden. LoRaWAN fürs TTN wird allerdings hiermit nicht unterstützt.
  
'''Anschlussbelegung'''
+
== Hardware ==
* Pin 4 = SDA (ist nicht der Standard-I2C-Port vom ESP32)
+
* Pin 15 = SCL (ist nicht der Standard-I2C-Port vom ESP32)
+
* Pin 16 = RST (muss bei Start kurz auf Low, dann auf High gesetzt werden)
+
  
 +
{| class="wikitable" style="text-align:center"
 +
!RFM95
 +
!Arduino
 +
|-
 +
|VCC
 +
|3.3V
 +
|-
 +
|GND
 +
|GND
 +
|-
 +
|SCK
 +
|SCK
 +
|-
 +
|MISO
 +
|MISO
 +
|-
 +
|MOSI
 +
|MOSI
 +
|-
 +
|NSS
 +
|10
 +
|-
 +
|NRESET
 +
|9
 +
|-
 +
|DIO0
 +
|2
 +
|-
 +
|DIO2
 +
|3 (LoRaWan)
 +
|}
  
In Verbindung mit dem ESP32 gibt es hierzu mehrere '''Bibliotheken''' um es zu nutzen:
+
== Quellen ==
* '''[https://github.com/squix78/esp8266-oled-ssd1306 squix78 ssd1306.h]''' ist besonders auf den ESP8266 und ESP32 beliebt und bietet einen recht umfangreichen Funktionsumfang, erst recht sobald noch OLEDDisplayUi.h eingefügt wird. Dies gibt ein einfaches User-Interface, was darauf ausgelegt ist, Inhalte über mehrere Displayseiten anzuzeigen und diese nett hin- und her zu scrollen. 
+
[https://media.ccc.de/v/33c3-7945-decoding_the_lora_phy Decoding the LoRa PHY - Dissecting a Modern Wireless Network for the Internet of Things]<br>
** Klasse mit <pre>SSD1306  display(0x3c, 4, 15);</pre> instanzieren und in setup() das Reset-Signal erzeugen: <pre>pinMode(16,OUTPUT); digitalWrite(16, LOW); delay(50); digitalWrite(16, HIGH);</pre>
+
Ein Vortrag vom 33c3 der den physikalischen Layer von LoRa näher beleuchtet.
  
* '''[https://github.com/olikraus/u8g2 U8x8 und U8g2]''' - Nur für Monochrome Displays, optimiert auf geringen Ressourcenverbrauch
+
= LoRaWAN =
** U8x8: Minimalistische Version ohne Display-Puffer im uC, nur Textausgabe mit einem 8x8 Monospace Font
+
== Was ist LoRaWAN? ==
*** Der folgende Konstruktor funktioniert bei mir: <pre>U8X8_SSD1306_128X64_NONAME_SW_I2C u8x8(/* clock=*/ 15, /* data=*/ 4, /* reset=*/ 16);</pre>
+
LoRaWAN steht für Long Range Wide Area Network. Basierend auf der LoRa Modulation wird hier ein Netzwerk aufgebaut, dass wegen der hohen Reichweite mit relativ wenig Gateways recht große Flächen abdecken kann.
** U8g2: Erweiterte Version, enthält Fonts in vielen Größen, auch besonders kleine Fonts.
+
*** Der folgende Konstruktor funktioniert bei mir: <pre>U8G2_SSD1306_128X64_NONAME_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ 15, /* data=*/ 4, /* reset=*/ 16);</pre>
+
  
* '''[https://github.com/adafruit/Adafruit_SSD1306 Adafruit SSD1306]''' hat viele Funktionen und wird zusammen mit [https://github.com/adafruit/Adafruit-GFX-Library Adafruit_GFX] auch für farbige Displays benutzt.
+
[https://hackaday.com/2017/09/11/the-things-network-sets-702-km-distance-record-for-lorawan/ Reichweitenrekord von 702 Km.]
** Wichtig: Ich musste die Library auf der Platte patchen - konkret musste ich in Adafruit_SSD1306.cpp die Zeile auskommentieren, wo nochmal Wire.begin(); (Zeile 206) aufgerufen wurde. Um dann das Beispielprogram 'ssd1306_128x64_i2c' nutzen zu können, hab ich noch mit <pre>#define OLED_RESET 16</pre> die Display-Reset-Leitung angepasst und die Zeile mit dem display.begin(...) wie folgt erweitert: <pre>Wire.begin(4,15); display.begin(SSD1306_SWITCHCAPVCC, 0x3c);</pre>.
+
  
* '''[https://github.com/acrobotic/Ai_Ardulib_SSD1306 Ai_Ardulib_SSD1306]''' Grundtextfunktionen (Monospace Font only), braucht kein Display-Update-Befehl.
+
== Was ist das [https://www.thethingsnetwork.org/ The Things Network] (TTN) ==
** Hier muss in den Beispielen die Zeile wo sonst nur Wire.begin(); steht um folgendes erweitert werden:  
+
Das [https://www.thethingsnetwork.org/ The Things Network] biete basierend auf der LoRa Technologie ein Community betriebenes Wide Area Network. Im Empfangsbereich eines Gateways kann man so mit einer LoRa-Node gebührenfrei Daten ins Internet funken, allerdings nur einige Bytes jede Minute. Wenn noch kein Gateway im Empfangsbereich ist, kann man das Netzwerk selbst um eigene Gateways erweitern.
<pre> pinMode(16,OUTPUT);
+
 
   digitalWrite(16, LOW); // set GPIO16 low to reset OLED
+
[[Datei:LoRaGoPort_aufRPi.jpg|600px|LoRaWAN Gateway mit LoRaGo Port auf Raspberry Pi]]
   delay(50);  
+
 
   digitalWrite(16, HIGH); // while OLED is running, must set GPIO16 to high
+
=== Gateway Infos ===
   Wire.begin(4,15);
+
* <pre>sudo tcpdump -AUq port 1700</pre> zeigt Verkehr mit TTN an
 +
* Mehr über Antennen: https://www.thethingsnetwork.org/forum/t/the-big-and-small-antenna-topic-part-1/7880
 +
 
 +
=== Applikation einrichten ===
 +
Unter "Applications" mit "add application" eine neue Anwendung erstellen.<br>
 +
Danach die Application auswählen. Oben rechts den Reiter "Devices" anwählen und "register device" drücken z.B. "pondtempsensornode" als id eingeben.<br>
 +
Unter "Device Overview" die "Activation Method" von OTAA auf ABP stellen und "Frame counter checks" anhaken.
 +
 
 +
== LoRaWAN Bibliotheken ==
 +
Wichtig: '''Nicht''' die LoRaWAN Bibliothek aus dem Arduino Library Manager verwenden, sonder manuel diese hier installieren:
 +
* [https://github.com/matthijskooijman/arduino-lmic LMIC für Arduino von Matthijs Kooijman] Am meisten beim TTN referenziert.
 +
 
 +
Kann auch interessant sein (ungetestet):
 +
* [https://github.com/mcci-catena/arduino-lorawan MCCI Catena Arduino-Lorawan]
 +
 
 +
Nicht so wichtige Infos:
 +
<pre>
 +
   // Enable data rate adaptation (only useful for nodes with fixed location)
 +
   LMIC_setAdrMode(1);
 +
 
 +
   // Increase RX1 Windows by 1% in case of clock error on board (crystal shift)
 +
  // This clearly increase son OTAA Join request to works first time even with SF7
 +
   LMIC_setClockError(MAX_CLOCK_ERROR * 1 / 100);
 
</pre>
 
</pre>
  
==== LoRa Radio ====
+
Kurzer LMIC Code (ungetestet): [https://github.com/SensorsIot/LoRa/blob/master/Nodes/Dragino/HelloWorld/HelloWorld.ino]
'''Anschlussbelegung'''
+
* '''SX1276 (pin) – ESP32 (pin)'''
+
* SCK - GPIO5
+
* MISO - GPIO19
+
* MOSI - GPIO27
+
* CS - GPIO18
+
* RESET - GPIO14
+
* DIO0 (8) – GPIO26 (15)
+
* DIO1 (9) – GPIO33 (13)
+
* DIO2 (10) – GPIO32 (12)
+
  
 +
=== Erweiterung um Packete zu empfangen ===
 +
<pre>
 +
        case EV_TXCOMPLETE:
 +
            Serial.print(F("EV_TXCOMPLETE: "));
 +
            if (LMIC.txrxFlags & TXRX_ACK) {
 +
              //rxcounter++;
 +
              Serial.println(F("Received ack."));
 +
            }
 +
            if (LMIC.dataLen) {
 +
              Serial.print(F("Received "));
 +
              Serial.print(LMIC.dataLen);
 +
              Serial.print(F(" bytes of payload: "));
 +
              for(int d=0; d<LMIC.dataLen; d++) {
 +
                Serial.print(*(uint8_t *)(LMIC.frame+LMIC.dataBeg+d), HEX);
 +
                Serial.print(" ");
 +
              }
 +
              //rxcounter2 += LMIC.dataLen;
 +
            }
 +
            // Schedule next transmission
 +
            Serial.print(F(" txChn1 "));
 +
            Serial.print(LMIC.txChnl);
 +
            Serial.print(F(", datarate "));
 +
            Serial.println(LMIC.datarate);           
 +
            os_setTimedCallback(&sendjob, os_getTime()+sec2osticks(TX_INTERVAL), do_send);
 +
            break;
 +
</pre>
 +
 +
== Konfiguration für bestimmte Hardware ==
 +
=== ESP32 ===
 +
Der ESP32 hat eine sog. Schaltmatrix und man kann damit sämtliche wichtigen IO-Funktionen auf andere Pinne "umbiegen". Das Umbiegen gelingt unter Arduino meist indem beim XXX.begin() die Pinne als Parameter übergeben werden (wo normalerweise nix übergeben wird).
 +
 +
Um typische ESP32 + OLED + LoRA-Module richtig zu befeuern, muss man daher im Setup noch vor dem LMIC-Init eine Zeile hinzufügen, die die Pinne entsprechend für die SPI zuordnet - bei mir ging das mit folgender Zeile:
 +
<pre>
 +
SPI.begin(5, 19, 27, 18);
 +
</pre>
 +
 +
Die Syntax ergibt sich dabei übrigens aus den Headern des ESP32 Arduino Moduls - hier mal einige Zeilen aus den Headern, aus denen hervorgeht, wie man Pinne umbelegen kann:
 +
<pre>
 +
void begin(int8_t sck=-1, int8_t miso=-1, int8_t mosi=-1, int8_t ss=-1); // SPI.h
 +
void begin(int sda=-1, int scl=-1, uint32_t frequency=100000); // Wire.h
 +
void begin(unsigned long baud, uint32_t config=SERIAL_8N1, int8_t rxPin=-1, int8_t txPin=-1, bool invert=false); // Hardware-Serial
 +
</pre>
 +
 +
Folgendes Pinmapping wurde dann noch LMIC übergeben:
 
<pre>
 
<pre>
// Pin mapping for lmic
 
 
const lmic_pinmap lmic_pins = {
 
const lmic_pinmap lmic_pins = {
 
     .nss = 18,
 
     .nss = 18,
Zeile 76: Zeile 217:
 
</pre>
 
</pre>
  
Hier weiterlesen: https://hackaday.io/project/27791/logs
+
Damit war die Belegung für den LoRa-Chip wie folgt:
 +
{| class="wikitable" style="text-align:center"
 +
! RFM95 Pin
 +
! ESP32 GPIO#
 +
|-
 +
|DIO2
 +
|32
 +
|-
 +
|DIO1
 +
|33
 +
|-
 +
|DIO0
 +
|26
 +
|-
 +
|MISO
 +
|19
 +
|-
 +
|MOSI
 +
|27
 +
|-
 +
|SCK
 +
|5
 +
|-
 +
|NSS
 +
|18
 +
|-
 +
|RESET
 +
|14
 +
|}
  
== LoRa Bibliotheken ==
+
Achtung: GPIO5 (SCK) kollidiert manchmal mit I2C was für OLED Displays benutzt wird!
Hier gibt es folgende Bibliotheken:
+
* [https://github.com/sandeepmistry/arduino-LoRa LoRa] Einfach nur zur Ansteuerung des LoRa-Moduls in Arduino ohne viel Balast und ohne Schnick-Schnack. Sinnvoll daher für Punkt-zu-Punkt Verbindungen, aber nicht für Netzwerke.
+
* [http://www.airspayce.com/mikem/arduino/RadioHead/ RadioHead] Hier die Bibliothek für sehr viele verschiedene Funkmodule. Hiermit können auch (Mesh-)Netzwerke aufgebaut werden und das IP-Protokoll über Funk abgewickelt werden. LoRaWAN fürs TTN wird allerdings hiermit nicht unterstützt.
+
  
= LoRaWAN =
+
=== ESP8266 ===
== Was ist LoRaWAN? ==
+
Hier hat der TTN Zugang mit folgender Konfiguration geklappt:
LoRaWAN steht für Long Range Wide Area Network. Basierend auf der LoRa Modulation wird hier ein Netzwerk aufgebaut, dass wegen der hohen Reichweite mit relativ wenig Gateways recht große Flächen abdecken kann.
+
 
 +
{| class="wikitable" style="text-align:center"
 +
! RFM95 Pin
 +
! ESP8266 GPIO#
 +
! ESP8266 D#
 +
|-
 +
|DIO1
 +
|4
 +
|D2
 +
|-
 +
|DIO0
 +
|5
 +
|D1
 +
|-
 +
|MISO
 +
|12
 +
|D6
 +
|-
 +
|MOSI
 +
|13
 +
|D7
 +
|-
 +
|SCK
 +
|14
 +
|D5
 +
|-
 +
|NSS
 +
|15
 +
|D8
 +
|-
 +
|RESET
 +
|16
 +
|D0
 +
|}
 +
 
 +
<pre>
 +
const lmic_pinmap lmic_pins = {
 +
    .nss = D8,
 +
    .rxtx = LMIC_UNUSED_PIN,
 +
    .rst = D0,
 +
    .dio = {D1, D2, LMIC_UNUSED_PIN},
 +
};
 +
</pre>
 +
 
 +
=== Lora32u4 ===
 +
 
 +
Dieses Board gibts von BSFrance und auch als feather32u4 von Adafruit.
 +
Wenn man mit PlatformIO das Board in Betrieb nehmen will braucht man folgendes Target in der platformio.ini (Port durch lokale Eintellung ersetzen):
 +
<pre>
 +
[env:feather32u4]
 +
platform = atmelavr
 +
board = feather32u4
 +
framework = arduino
 +
upload_flags = -P$UPLOAD_PORT
 +
upload_port = /dev/ttyACM3
 +
monitor_port = /dev/ttyACM3
 +
monitor_baud = 9600
 +
</pre>
 +
 
 +
Das Pinmapping für die LMIC Bücherei ist wie folgt:
 +
<pre>
 +
const lmic_pinmap lmic_pins = {
 +
    .nss = 8,
 +
    .rxtx = LMIC_UNUSED_PIN,
 +
    .rst = 4,
 +
    .dio = {7, 6, LMIC_UNUSED_PIN},
 +
};
 +
</pre>
 +
 
 +
'''Obacht, uffbasse:'''
 +
 
 +
Auf dem Board eine Brücke zwischen Pin 6 und DIO1 (IO-Pin 6 und der IO1 des LoRa-Moduls) setzen/löten!!1!einself
 +
 
 +
Wenn die fehlt, dann kann kein LoRaWAN-Paket erfolgreich übermittelt werden, weil ein Interrupt fehlt.
 +
 
 +
== Sonstige Bibliotheken ==
 +
* [https://github.com/rocketscream/Low-Power Low-Power Library für Arduino]
 +
* [https://lcd-web.nl/ttngenerator/ TTN Generator]

Aktuelle Version vom 23. Februar 2019, 23:44 Uhr

Vortrag auch zu LoRa, LoRaWAN und TheThingsNetwork auf der Make Darmstadt 2019

Auf der Make Darmstadt hat Lutz Lisseck vom Hackerspace FFM ein Vortrag zum Thema "Die lizenzfreie Übertragung kleiner Datenmengen per Funk" gehalten, die Folien zum Vortrag gibt es auch hier: Datei:Die lizenzfreie Übertragung kleiner Datenmengen.pdf

Rückblick: Workshop zu LoRa und LoRaWAN

Am 25. Februar 2018 von 15 bis etwa 21 Uhr fand der 1. Teil des Workshops zu LoRa und LoRaWAN bei uns im Hackerspace statt. Der 2. Teil ist geplant an einem Sonntag im April, ebenfalls von 15 bis etwa 21 Uhr im Hackerspace.

Please note: The main language of the workshop will be German, so the presentations of the workshop will be held in German language. However, there will be a lot of people who can assist you if you have issues in understanding the language and of course I am open to answer your questions in English as well.

Folgendes steht/stand auf der Agenda:

Agenda Teil 1

IMG 20180225 184530744.jpg

  • Begrüßungsrunde
    • Anwendungfälle der Teilnehmer: Bienenstöcke vor Diebstahl schützen, Stratosphärenballon, Feinstaubmessungen
  • Vortrag Teil A: LoRa
    • Was ist LoRa und wie funktioniert es?
    • Verfügbare LoRa Module und mit LoRa ausgestattete Boards
    • Legale Nutzung von LoRa: Nutzbare Frequenzen, Duty-cycle und Bandbreite Beschränkungen, maximale Leistung
    • Wie macht man eine LoRa Punkt-zu-Punkt-Verbindungen mit Arduino?
  • Workshop Teil A:
    • Ziel: Erreichen einer Punkt-zu-Punkt-Verbindung via LoRa unter Arduino
    • Anschluss von LoRa (RFM95) Modulen an Arduino-Boards (433MHz und 868MHz)
    • Konfiguration und Einstellungen für LoRa unter Arduino
    • Senden und Empfangen von LoRa Paketen
  • Vortrag Teil B: LPWAN / LoRaWAN / The Things Network
    • Wozu LPWAN? Derzeitige Situation der konkurierenden Systeme
    • Was ist ein LoRaWAN?
    • The Things Network: Spoilervideo :-)
      • Was kann man damit alles machen?
      • Wie baut man eine Node?
      • Wie kommt man an die Daten und verarbeitet sie weiter?
  • Workshop Teil B:
    • Ziel: Aus dem Setup von Teil A eine Node fürs TTN machen und die Daten im TTN empfangen
    • Zurechtfinden in der (leider etwas weniger intuitiven) Standard Node Software für Arduino (LMIC)
    • ABP Einstellungen, um die Node zum TTN hinzuzufügen
    • Empfang der Telegramme in der Console von thethingsnetwork.org
  • Field-Day: Wir testen die Reichweite der Node
  • Schlussbesprechung

Vorläufige Agenda-Ideen Teil 2: (Termin steht noch nicht fest)

  • Mitmachen und Erweitern des TheThingsNetworks durch ein eigenes Gateway (=Basisstation, =Konzentrator)
  • Was ist ein LoRaWAN Konzentrator?
  • Aufbau des TheThingsNetwork
  • Standortanforderungen für Gateways
  • Komponenten zum Selbstbau oder Einkauf für LoRaWAN Gateways
  • Antennen (ggf. Selbstbau) für Gateways
  • Workshop: Aufbau eines Gateways und Verbinden mit dem TTN. Antennenbau und Reichweitentests

LoRa

Was ist LoRa?

LoRa steht für Long Range und ist eine proprietäre Chirp Spread Spectrum Modulationstechnik, mit der sich deutlich höhere Reichweiten als mit klassischen Modulationsverfahren erreichen lassen. Bei gleicher Sendeleistung und im gleichen Frequenzbereich lassen sich damit Reichweiten im km-Bereich realisieren, wo mit klassischen Modulationsverfahren nur ca. 100m erreicht werden. Der Kompromiss ist dabei allerdings eine deutlich reduzierte Übertragungsgeschwindigkeit gegenüber den klassischen Modulationsverfahren. Dieser kann über den sogenannten Spreizfaktor je nach Situation eingestellt werden - mit dem höchsten Spreizfaktor (SF12) kann die größte Reichweite erziehlt werden, allerdings liegt die Datenrate dann auch nur noch bei ca. 300 bit/s.

Wie nutze ich das?

Für LoRa gibt es einerseits relativ kleine Funkmodule, die man unter den Namen RFM95 oder nach dem typischerweise verwendeten Chip SX1276 (868MHz) bzw. SX1278 (433MHz) oder andererseits gleich als Kombo mit ESP32 und Display kaufen kann. Es gibt sie in einschlägigen Shops und auch aus China (aus der "Bucht") relativ günstig (ab 6 EUR/Stk). Die RFM95 werden mit einem Stückchen Draht als Antenne versehen und über SPI an einen von Arduino unterstütztes Mikrocontrollerboard angeschlossen. Da das Modul nur mit 3.3V Pegeln arbeitet, empfiehlt es sich auch ein mit 3.3V arbeitendes Mikrocontrollerboard einzusetzen.

Ai-Thinker Ra-01 oder Ra-02

Der Unterschied zwischen Ra-01 und Ra-02 ist lediglich der, dass der Ra-01 die Antenne an einem der Pads herausgeführt hat (und meist eine Federantenne dabei liegt), während beim Ra-02 eine Buchse für einen Antennenstecker dran ist (IPEX).

Antenne

Antennen sind für eine bestimmte Frequenz optimiert. In Europa wird das ISM-Band mit 868 Mhz verwendet.
Die Wellenlänge berechnet sich nach folgender Formel: Wavelength.PNG
f = frequency in hertz (Hz)
λ = wavelength in meters (m)
c = speed of light (299.792.458 m/s)

Wavelength of 868.PNG
Die Antenne muss also 34.5 cm lang sein oder ein 1/2λ = 17.25, 1/4λ = 8.63, 1/8λ = 4.31, ...

LoRa Bibliotheken

Hier gibt es folgende Bibliotheken:

  • LoRa by Sandeep Mistry Einfach nur zur Ansteuerung des LoRa-Moduls in Arduino ohne viel Balast und ohne Schnick-Schnack. Sinnvoll daher für Punkt-zu-Punkt Verbindungen, aber nicht für Netzwerke.
  • RadioHead Hier die Bibliothek für sehr viele verschiedene Funkmodule. Hiermit können auch (Mesh-)Netzwerke aufgebaut werden und das IP-Protokoll über Funk abgewickelt werden. LoRaWAN fürs TTN wird allerdings hiermit nicht unterstützt.

Hardware

RFM95 Arduino
VCC 3.3V
GND GND
SCK SCK
MISO MISO
MOSI MOSI
NSS 10
NRESET 9
DIO0 2
DIO2 3 (LoRaWan)

Quellen

Decoding the LoRa PHY - Dissecting a Modern Wireless Network for the Internet of Things
Ein Vortrag vom 33c3 der den physikalischen Layer von LoRa näher beleuchtet.

LoRaWAN

Was ist LoRaWAN?

LoRaWAN steht für Long Range Wide Area Network. Basierend auf der LoRa Modulation wird hier ein Netzwerk aufgebaut, dass wegen der hohen Reichweite mit relativ wenig Gateways recht große Flächen abdecken kann.

Reichweitenrekord von 702 Km.

Was ist das The Things Network (TTN)

Das The Things Network biete basierend auf der LoRa Technologie ein Community betriebenes Wide Area Network. Im Empfangsbereich eines Gateways kann man so mit einer LoRa-Node gebührenfrei Daten ins Internet funken, allerdings nur einige Bytes jede Minute. Wenn noch kein Gateway im Empfangsbereich ist, kann man das Netzwerk selbst um eigene Gateways erweitern.

LoRaWAN Gateway mit LoRaGo Port auf Raspberry Pi

Gateway Infos

Applikation einrichten

Unter "Applications" mit "add application" eine neue Anwendung erstellen.
Danach die Application auswählen. Oben rechts den Reiter "Devices" anwählen und "register device" drücken z.B. "pondtempsensornode" als id eingeben.
Unter "Device Overview" die "Activation Method" von OTAA auf ABP stellen und "Frame counter checks" anhaken.

LoRaWAN Bibliotheken

Wichtig: Nicht die LoRaWAN Bibliothek aus dem Arduino Library Manager verwenden, sonder manuel diese hier installieren:

Kann auch interessant sein (ungetestet):

Nicht so wichtige Infos:

  // Enable data rate adaptation (only useful for nodes with fixed location)
  LMIC_setAdrMode(1);

  // Increase RX1 Windows by 1% in case of clock error on board (crystal shift)
  // This clearly increase son OTAA Join request to works first time even with SF7
  LMIC_setClockError(MAX_CLOCK_ERROR * 1 / 100);

Kurzer LMIC Code (ungetestet): [1]

Erweiterung um Packete zu empfangen

        case EV_TXCOMPLETE:
            Serial.print(F("EV_TXCOMPLETE: "));
            if (LMIC.txrxFlags & TXRX_ACK) {
              //rxcounter++;
              Serial.println(F("Received ack."));
            }
            if (LMIC.dataLen) {
              Serial.print(F("Received "));
              Serial.print(LMIC.dataLen);
              Serial.print(F(" bytes of payload: "));
              for(int d=0; d<LMIC.dataLen; d++) {
                Serial.print(*(uint8_t *)(LMIC.frame+LMIC.dataBeg+d), HEX);
                Serial.print(" ");
              }
              //rxcounter2 += LMIC.dataLen;
            }
            // Schedule next transmission
            Serial.print(F(" txChn1 "));
            Serial.print(LMIC.txChnl);
            Serial.print(F(", datarate "));
            Serial.println(LMIC.datarate);            
            os_setTimedCallback(&sendjob, os_getTime()+sec2osticks(TX_INTERVAL), do_send);
            break;

Konfiguration für bestimmte Hardware

ESP32

Der ESP32 hat eine sog. Schaltmatrix und man kann damit sämtliche wichtigen IO-Funktionen auf andere Pinne "umbiegen". Das Umbiegen gelingt unter Arduino meist indem beim XXX.begin() die Pinne als Parameter übergeben werden (wo normalerweise nix übergeben wird).

Um typische ESP32 + OLED + LoRA-Module richtig zu befeuern, muss man daher im Setup noch vor dem LMIC-Init eine Zeile hinzufügen, die die Pinne entsprechend für die SPI zuordnet - bei mir ging das mit folgender Zeile:

SPI.begin(5, 19, 27, 18);

Die Syntax ergibt sich dabei übrigens aus den Headern des ESP32 Arduino Moduls - hier mal einige Zeilen aus den Headern, aus denen hervorgeht, wie man Pinne umbelegen kann:

void begin(int8_t sck=-1, int8_t miso=-1, int8_t mosi=-1, int8_t ss=-1); // SPI.h
void begin(int sda=-1, int scl=-1, uint32_t frequency=100000); // Wire.h
void begin(unsigned long baud, uint32_t config=SERIAL_8N1, int8_t rxPin=-1, int8_t txPin=-1, bool invert=false); // Hardware-Serial

Folgendes Pinmapping wurde dann noch LMIC übergeben:

const lmic_pinmap lmic_pins = {
    .nss = 18,
    .rxtx = LMIC_UNUSED_PIN,
    .rst = 14,
    .dio = {26, 33, 32},
};

Damit war die Belegung für den LoRa-Chip wie folgt:

RFM95 Pin ESP32 GPIO#
DIO2 32
DIO1 33
DIO0 26
MISO 19
MOSI 27
SCK 5
NSS 18
RESET 14

Achtung: GPIO5 (SCK) kollidiert manchmal mit I2C was für OLED Displays benutzt wird!

ESP8266

Hier hat der TTN Zugang mit folgender Konfiguration geklappt:

RFM95 Pin ESP8266 GPIO# ESP8266 D#
DIO1 4 D2
DIO0 5 D1
MISO 12 D6
MOSI 13 D7
SCK 14 D5
NSS 15 D8
RESET 16 D0
const lmic_pinmap lmic_pins = {
    .nss = D8,
    .rxtx = LMIC_UNUSED_PIN,
    .rst = D0,
    .dio = {D1, D2, LMIC_UNUSED_PIN},
};

Lora32u4

Dieses Board gibts von BSFrance und auch als feather32u4 von Adafruit. Wenn man mit PlatformIO das Board in Betrieb nehmen will braucht man folgendes Target in der platformio.ini (Port durch lokale Eintellung ersetzen):

[env:feather32u4]
platform = atmelavr
board = feather32u4
framework = arduino
upload_flags = -P$UPLOAD_PORT
upload_port = /dev/ttyACM3
monitor_port = /dev/ttyACM3
monitor_baud = 9600

Das Pinmapping für die LMIC Bücherei ist wie folgt:

const lmic_pinmap lmic_pins = {
    .nss = 8,
    .rxtx = LMIC_UNUSED_PIN,
    .rst = 4,
    .dio = {7, 6, LMIC_UNUSED_PIN},
};

Obacht, uffbasse:

Auf dem Board eine Brücke zwischen Pin 6 und DIO1 (IO-Pin 6 und der IO1 des LoRa-Moduls) setzen/löten!!1!einself

Wenn die fehlt, dann kann kein LoRaWAN-Paket erfolgreich übermittelt werden, weil ein Interrupt fehlt.

Sonstige Bibliotheken