Het Netatmo weerstation meet CO2 waarden en slaat deze op in de centrale Netatmo database. De waarden die hier zijn opgeslagen kunnen met een API worden opgevraagd. Dit proces bestaat uit het aanvragen en uitwisselen van sleutels, instellingen en specifieke aanroepen. Dat is redelijk bewerkelijk en ik heb me er maar eens over gebogen om dat handen en voeten te geven.

Mijn doel is om in het vakantiehuis een compact internet-gekoppeld display op te hangen met de actuele CO2 waarde in het huis. Dat is handig omdat in dezelfde ruimte zowel gekookt, gestookt als verbrandt wordt (resp. gasfornuis, CV-installatie en open haard). De CO2 waarde verloopt dan ook nogal eens tussen 450 en 2200.

Netatmo heeft haar API goed gedocumenteerd. De belangrijkste informatiebronnen zijn:

• Netatmo richtlijnen, aanmelden als ontwikkelaar
• Leg je eigen applicatie vast
• Hoe werkt authenticatie (hint: met sleutels of met user/pw)
• Probeer de weerstation API uit (Swagger-ish dashboard)

Het MAC-adres van je weerstation vind je in Mijn Station beheren.

Ik ga dit project als een Proof of Concept benaderen. Dat betekent de meest pragmatische route tussen idee en werkend voorbeeld, niet lettend op de hoeveelheid technical debt die intussen ontstaat:

• M5StickC met MicroPython en UI Flow, data op het ingebouwde schermpje, stroomvoorziening via de USB aansluiting, nieuwe (foamboard?) behuizing om het binnenwerk van de M5StickC heen
• Gebruik maken van de 'test' credentials: username en password, in plaats van verversende sleutels
• Alleen een weergave van de CO2 waarden, geen gemiddelde, of signalering

Ik kocht vorig jaar via AliExpress een tweetal low-cost Heltec ESP32 modules met ingebouwde SX1276 LoRa radio en een OLED display. Het doel was om hiermee een mobiele CO₂ detector te maken, maar ik kwam er niet aan toe om ervaring met de modules op te doen. Gisteravond had ik die gelegenheid wel en kwam tot de conclusie dat het nog niet zo rechtlijnig aansluiten was.

De Heltec WiFi LoRa 32 is een ESP32 development module met Bluetooth, WiFi, LoRa en USB connectiviteit. Voor Bluetooth en WiFi zijn antennes ingebouwd, voor LoRa is een MHF (U.FL, I-PEX) socket aanwezig. Je kunt de Heltec modules via AliExpress verkrijgen; let erop dat je voor de in Nederland ondersteunde 868MHz versie gaat. Het huidige versienummer is V2, ik maak nog gebruik van V1. Op sommige plaatsen in de software moet hiervoor iets worden aangepast.

De module heeft een 0,96" blauw-zwart OLED display ingebouwd met een resolutie van 128 x 64 pixels. Hiernaast kan er een LiPo accu worden aangesloten en ook in ingebouwde acculader is voorzien, waarbij de accu dan via USB wordt opgeladen. De Heltec module is voorzien van een Arduino bootloader en wordt via de Arduino omgeving geprogrammeerd, hoewel voor de ESP32 microcontroller ook andere alternatieven voorhanden zijn.

De Heltec WiFi LoRa 32 modules zijn op dit moment de goedkoopste manier om een LoRaWAN oplossing te maken: voor een kleine 15 euro heb je een volledig werkende oplossing om bijvoorbeeld een sensor met The Things Network (KPN LoRa zal even goed werken) te verbinden.

Voorbereiden van The Things Network

Om gebruik te maken van The Things Network is een account nodig. Maak deze aan als je dat nog niet eerder had gedaan. In je account kun je naar de Console, waar je kunt kiezen tussen Applications en Gateways (als je zoals ik een eigen gateway tot je beschikking hebt).

Ga naar Applications en maak indien nodig een nieuwe Application aan. Je kunt meerdere Devices, zoals de Heltec module, binnen een Application gebruiken, maar als je een specifieke toepassing hebt is het handig hiervoor een aparte Application aan te maken. Heel veel informatie is hier niet voor nodig: een technische naam (kleine letters, geen spaties) en een omschrijving is voldoende. Klik dan op Add application. De technische naam moet uniek zijn binnen The Things Network. Omdat je niet kunt inzien welke namen al in gebruik zijn, zul je wat moeten experimenteren. The Things Network genereert nu een Application EUI.

Na het toevoegen van je Application kom je in het overzichtsscherm terecht, waar je een Device aan je Application kunt toevoegen. Ook zie je hier het door The Things Network gegenereerde Application EUI, een reeks van acht hexadecimale getallen, in het voorbeeld 70 B3 D5 7E D0 02 0E BB.

Gebruik Register device om de Heltec WiFi LoRa 32 module aan The Things Network toe te voegen. Ieder device moet worden voorzien van een Device ID, een identificerende technische naam. Later kan hier ook een 'human friendly' Description aan worden toegevoegd. Klik in het Register device scherm op het icoon gelijk onder Device EUI. De tekst in het vak wordt dan 'this field will be generated'. Device EUI, App Key en App EUI worden later gebruikt in de software van de Heltec WiFi LoRa 32 module. Klik voor nu op Register.

Nadat het Device is toegevoegd kunnen enkele eigenschappen worden aangepast in het Settings scherm. Geef hier een begrijpbare naam aan als Description. Laat Activation Method op OTAA (Over The Air Activation) staan. We gaan straks naar dit scherm terug om de Device EUI, Application EUI en App Key over te nemen in de software van de Heltec module.

Voorbereiden van de Arduino omgeving

Begin met het aansluiten van de LoRa antenne op de module; het inschakelen van de module zonder, of met een verkeerde antenne kan schadelijk zijn voor de LoRa radio. De voor LoRa gebruikte frequentie in Nederland is 868 MHz.

Download de codebibliotheek als .ZIP bestand van Heltec en voeg dit .ZIP bestand toe aan de bibliotheken in de Arduino ontwikkelomgeving met Schets > Bibliotheek gebruiken > Voeg .ZIP bibliotheek toe...

Er moeten 3 zaken ingesteld worden, voor we met de software aan de slag kunnen:

• Om gebruik te kunnen maken van de Heltec codebibliotheek, is per module een licentie van Heltec nodig. V2 modules kunnen de code elektronisch vinden, voor V1 modules moet je een email naar Heltec sturen. In beide gevallen moet eerst het Chip ID met een Arduino sketch worden opgevraagd
• In het bestand Commissioning.h moeten de Device EUI, Application EUI en App Key worden opgenomen (voor iedere volgende module moet dit bestand opnieuw worden aangepast)
• In het bestand LoRaMac-definitions.h moet de juiste frequentieband worden ingesteld

Kies in de Arduino omgeving de juiste poort en het juiste bord (Heltec WiFi LoRa 32). Laad de volgende sketch om de Chip ID op te vragen:

uint64_t chipid;

void setup() {
  Serial.begin(115200);
}

void loop() {
  chipid = ESP.getEfuseMac(); // 6 bytes
  Serial.printf("ESP32 Chip ID = %04X", (uint16_t) (chipid>>32));
  Serial.printf("%08X\n", (uint32_t) chipid);
  delay(3000);
}

In de Seriële monitor van de Arduino omgeving wordt iedere drie seconden het Chip ID van de module getoond, in mijn geval:

ESP32 Chip ID = A01B56A4AE30

Ga in het geval van een V2 module (op de printplaat staat duidelijk 'V2') naar de Heltec website, waar het licentienummer voor dit Chip ID wordt getoond. In het geval van een V1 module dien je een email aan Heltec te sturen. Ik had binnen een half uurtje een reply email met de volgende tekst:

Zoek het bestand Commissioning.h. Dit staat waarschijnlijk in Arduino\libraries\ESP32_LoRaWAN-master\src. Wijzig de volgende definities in dit bestand:

#define LORAWAN_DEVICE_EUI
#define LORAWAN_APPLICATION_EUI
#define LORAWAN_APPLICATION_KEY

Geef hier de waarden op uit het Settings scherm van het Device van The Things Network:

Bewaar dit bestand en open het bestand LoRaMac-definitions.h dat in dezelfde map staat als Commissioning.h. Wijzig de regel met #define USE_BAND_470 in #define USE_BAND_868. Bewaar het bestand.

Verbinding maken met The Things Network

Laad de voorbeeldsketch Bestand > Voorbeelden > ESP32_LoRaWAN > OTAA. Wijzig in de sketch de regel met LICENSE[4] naar het licentienummer dat van Heltec, voor deze module, is verkregen:

Compileer de sketch en stuur de gecompileerde code naar de Heltec WiFi LoRa 32 module. In de Seriële monitor van de Arduino omgeving is te zien dat de module verbinding probeert te maken. LoRaWAN vindt plaats op diverse frequenties in de 868 MHz band, met Tx Freq sordt aangegeven, welke frequentie is gebruikt. Met Received Signal Strength Indication (RSSI) wordt het ontvangen vermogen aangegeven in dBm, een negatief getal. Hoe dichter bij 0, hoe beter het signaal. De ervaring leert dat het minimum RSSI op -120 dBm zit (een heel zwak signaal), en dat -30 een sterk signaal aangeeft. De -45 dBm in het voorbeeld is niet zo'n heel sterk signaal en voor een gateway op enkele meters afstand voor verbetering vatbaar.

In de terminal van The Things Network is na een paar seconden te zien dat de module verbinding heeft gemaakt en data heeft verstuurd ('Frames up') en data heeft ontvangen ('Frames down'):

Eigen data versturen en ontvangen

De voorbeeldsketch van Heltec verstuurt data, maar zonder dat daar iets voor is ingeregeld. Om eigen data te versturen dienen drie variabelen in de sketch te worden aangepast:

• AppPort: default 2 voor demonstraties, ieder ander getal is prima
• AppData: array, maximaal 16 bytes
• AppDataSize: aantal bytes eigen data

Met de aanpassing hierboven wordt de eigen data (de 'payload') de drie getallen 1, 2 en 3. Die zie je dan ook op The Things Network binnenkomen:

Conclusie

De Heltec WiFi LoRa 32 ESP32 development kit werkt eenvoudig samen met The Things Network, als je de juiste stappen in de goede volgorde uitvoert. De module vormt een goedkope en flexibele oplossing om sensoren met LoRaWAN aan het internet te koppelen. Om de typische LoRa-kilometers-afstanden te bereiken is het zaaks om een goede antenne (en kabel) te gebruiken. De signaalsterkte RSSI zal anders maar matig zijn.

Rondom de ESP32 microcontroller van Espressif zijn verschillende development boards ontstaan, programmeerbaar in Processing met een Arduino firmware, of in Python met een microPython firmware. 'M5Stack' is een prototype-development suite van handzame internet-of-things apparaatjes-en-accessoires in een 5x5 centimeter vormfactor die door het gelijknamige bedrijf op de markt worden gebracht, vooral via AliExpress. De M5StickC is hiervan een kleine variant van 5x2,5 centimeter, voorzien van accu, OLED display, diverse sensoren en andere in- en uitgangen, en een USB-C interface.

Het aantal sensoren, verbindingen en mogelijkheden van de M5StickC zijn verbluffend en en er is niet veel nodig om het apparaatje als een end-user device toe te passen. Er worden een polsband en wat bevestigingsbeugeltjes meegeleverd zodat verschillende toepassingen zo te realiseren zijn. Het bedrijf M5Stick, die deze apparaatjes op de markt brengt, heeft zijn zaakjes aardig op orde. Naast een keur een accessoires is er ook een Git pagina, waar alle software voor iedereen te downloaden is.

Het hart van de M5StickC wordt gevormd door een ESP32 microcontroller van Espressiv. Bovenop de firmware van Espressiv draait een bootloader, in het geval van de M5StickC eentje voor het Arduino framework. Andere mogelijkheden zijn MicroPython en UIFlow.

Het Arduino framework wordt goed ondersteund, met een keurige en goedgedocumenteerde API waarmee alle sensoren en actuatoren kunnen worden aangestuurd. Je vind hier routines voor het display (inclusief ingebouwde fonts), het uitlezen van de accelerometer, enzovoorts.

Om aan de slag te gaan met het Arduino framework moeten de volgende stappen worden gevolgd:

• Download en installeer de Arduino programmeeromgeving ('IDE')
• Download en installeer de Slicon Labs CP210 USB driver
• Gebruik de instructies op deze pagina om in de Arduino IDE een third party board manger toe te voegen en gebruik hiervoor deze url: https://dl.espressif.com/dl/package_esp32_index.json
• Voeg in de Arduino IDE het ESP32 platform toe via Hulpmiddelen > Board > Board Beheer en installeer hier ESP32 by Espressiv Systems
• Voeg de url van M5Stack toe om in de Arduino IDE de M5Stack en M5StickC als apparaat toe te kunnen voegen
• Voeg in de Arduino programmeeromgeving de benodigde modules toe
• Sluit een M5StickC op de computer aan
• Stel in de Arduino IDE de M5StickC in als doelplatform
• Vraag het M5StickC programma 'Hello World' op
• Stuur 'Hello World' naar de M5StickC

A Badgerboard is a small Arduino-compatible LoRaWAN development board with an integrated RN2483 module. From the looks of it, it is easily one of the best designed boards on the marked, It is also one of the smallest RN2483-based LoRaWAN boards I have seen (the smallest being the one from Thomas van Bellegem from The Netherlands) and with a list price of €51,- including shipping, it is by far the cheapest fully LoRaWAN certified development board in existence at the moment.

With all that good news, there is a flipside: the included Arduino sketches are a mess. It looks like the software was created as a by-product for the hardware, and none of the example programs make any sense. Sending values in JSON? Sending a float? No API to read on-board sensors? No automatic storage of App-EU? If an experienced Arduino programmer had spend a couple of days, these sketches would actually be helpful in understanding the workings of the board.

That said, this board connects to the LoRaWAN network (I've used The Things Network for this test) rock solid, checks it's own inner workings and reboots if things fail, has a battery saving scheduler and is Arduino compatible. Things could be improved enormously, but as it stands, this is working territory.

Getting it connected

I've rewritten the included example programs to make some sense if you've worked with and programmed a TTN node before. Reach out to me if you need the TL;DR.

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

// Badgerboard demonstration sketch that connects to The Things Network
// every five minutes and sends a temperature value from the onboard temp sensor
 
#include 
badger_scheduler temp_sched(5 * 60 * 1000UL, 30 * 1000UL, PRINT_ENABLE); // Send every 5 minutes
uint32_t s_badger_sleep_period_ms = 32 * 1000UL; // Wake every 32 seconds
 
// devEUI comes from the Badgerboard, appKey and appEUI are provided by The Things Network
// The values below are fictional and need to be replaced with your own secret values
const uint8_t devEUI[8] = {0x70, 0xB3, 0xA3, 0xB0, 0x20, 0xF3, 0x5C, 0xE9};
const uint8_t appKey[16] = {0x1F, 0x9D, 0x75, 0xF8, 0x55, 0x6E, 0x9E, 0x80, 0xFF, 0xDA, 0x05, 0xD3, 0xD6, 0x7E, 0xC7, 0xBB};
const uint8_t appEUI[8] = {0x70, 0xB3, 0xA5, 0xB0, 0xF0, 0x00, 0x4D, 0xB5};
 
void setup() 
{
  Serial.begin(9600); // Set the terminal to 9600 bits per second, the default
  badger_init(); // Inits some variables and wakes up the temperature sensor
  Serial.println("Badgerboard firmware started."); // Send a message to the terminal, if connected
  badger_print_EUI(devEUI); // No idea what this does. Leave it here
  LoRa_init(devEUI, appEUI, appKey);  // Init the RN2483 module and provide the secrets for Over-The-Air activation
}
 
void loop()
{
  // This loop runs every s_badger_sleep_period_ms, 30 secs 
  if (temp_sched.run_now())
  {
     Serial.print("Sending temperature");
     badger_pulse_led(1); // Pulse Bager board once
     badger_blink_error(badger_temp_send()); // 4 bytes float, blink led on error  
  } else {
    Serial.print("Nothing to do. ");
  }
  if (Lora_requires_reset()) // Check if everything is connected to LoRaWAN
  {
    Serial.println("Restarting due to disconnected LoRa module");
    badger_restart();        
  }
  Serial.println("Sending Badgerboard to sleep.");
  badger_sleep_now(s_badger_sleep_period_ms);
  Serial.print("Woke up. ");
}

This sketch sends the temperature as float, which uses four bytes. Those four bytes aren't that easily translated back to floats, so you need to decode them as soon as they are sent to The Things Network, which is done in the 'Decoder' section of the application:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

function Decoder(bytes, port) {
  // Decode an uplink message from a buffer
  // (array) of bytes to an object of fields.
 
  var decoded = {};
 
  function bytesToFloat(bytes) {
    var bits = bytes[3]<<24 | bytes[2]<<16 | bytes[1]<<8 | bytes[3]; var sign = (bits>>>31 == 0) ? 1.0 : -1.0;
    var e = bits>>>23 & 0xff;
    var m = (e == 0) ? (bits & 0x7fffff)<<1 : (bits & 0x7fffff) | 0x800000;
    var f = sign * m * Math.pow(2, e - 150);
    return f;
  }
 
  if (port == 1) {
     // Decode bytes to float and fix number of decimals to 3
    decoded.temperature = bytesToFloat(bytes.slice(0, 4).toFixed(3)); 
  }
  return decoded;  
}

Test results

I've used this board for a number of days, connected to my Mac, to a seperate USB charger and to a USB power bank with the same results: flawless connections. The board has an integrated LiPo-charger and JST connector for a LiPo battery, but those I have not used yet. The included antenna works just fine (I'll do a boards and antenna comparison in the near future).

Conclusion

I didn't know what to expect from this board, with the software in the state it is. However, after spending some time with the software, the board works just great. The Badgerboard connect flawlessly, sleep mode works as a dream and sensor values are transmitted reliably. This might just as well be the best node on the market at the moment, if you're willing to take the time to get the software to work. Your milage may vary, though, depending on your LoRaWAN and Arduino experience. @nasys_no, you really should spend a couple of days finishing the software and documentation.

De LoRa communicatietechnologie is voor een goede werking afhankelijk van antennes. "De beste versterker is een goede antenne," zei een collega vroeger wel eens tegen me. LoRa werkt in Nederland in twee frequentiebanden, respectievelijk '433 MHz' en '868 MHz' genoemd. De tweede, 868 MHz, wordt het meest gebruikt.

Een antenne is een geleider in de vorm van een staaf of spriet die met een leiding met een communicatiemodule is verbonden. De diameter van de geleider is nauwelijks van belang. Handig is wel als het materiaal waarvan de antenne is gemaakt in staaf- of sprietvorm blijft, dus een enigszins stugge geleider heeft hier de voorkeur. De antenne is het meest effectief als hij precies zo lang is als de gemiddelde frequentie waarvoor hij moet worden gebruikt. Indien dat niet praktisch is dan kan voor de lengte van de antenne ook, met iets mindere resultaten, worden volstaan met een helft of een kwart van de golflengte. Dat laatste wordt het meest toegepast.

De golflengte is gelijk aan v / f, waarbij v de voortplantingssnelheid van de radiogolf is en f de frequentie. In lucht is v gelijk aan de lichtsnelheid c, 299.792.458 m/s. De golflengte voor de 868 MHz band is dan 299.792.458 / 868.000.000 = 34,54 cm. De helft hiervan is 17,27 cm en een kwart is 8,63 cm.

Voor de 433 MHz band is de golflengte 299.792.458 / 433.000.000 = 69,24 cm. De helft hiervan is 34,62 cm en een kwart is 17,31 cm.

Een draadantenne van 8,6 cm volstaat dus voor een LoRa toepassing op de 868 MHz band. Een stukje montagedraad van 8,6 cm is genoeg. De lengte van de antenne is gemeten vanaf de aansluiting. Als een antenne met een leiding wordt verbonden dan moet deze leiding in de vorm van een 50 ohm kabel worden uitgevoerd.

Een Microchip RN2483 is een degelijke, door de LoRa Alliance gecertificeerde manier om verbinding te maken met een LoRaWAN gateway van KPN of The Things Network. En als het de bedoeling is om af en toe sensorwaarden naar het internet te sturen dan heb je niet veel extra's nodig. De RN2483 is een SoC dat bestaat uit een Semtech SX1276 LoRa zendontvanger en een Microchip PIC18LF46K22 microcontroller. Deze laatste heeft mogelijkheden genoeg om een sensorwaarde in te lezen, maar om de certificering in stand te houden heeft Microchip ervoor gekozen het lastig te maken om de PIC18LF46K22 te laten herprogrammeren of aan te vullen met extra programmatuur. Maar geen paniek: met een Atmel ATtiny85 kan het ook. Totale kosten van zo'n setje: 20 euro.

In het schema hierboven is een RN2483 met enkele lijnen (GND, RX, TX, RESET) verbonden met de ATtiny85 microcontroller. Beide worden gevoed door een CR2016 knoopcel. Voor de gelegenheid is de RN2483 voorzien van een draadantenne van 8,2 cm, wat voldoende is voor een reikwijdte van een kilometer. De ATtiny85 maakt gebruik van pennen 1 en 3 om de RN2483 serieel aan te sturen en pen 7 om de RN2483 module te herstarten. In de sketch hieronder is het principe weergegeven:

#include 

#define rxPin 4
#define txPin 5
#define rn2483Reset 2

SoftwareSerial rn2483(rxPin, txPin);

byte crlf[2] = {0x0D,0x0A};         // Used to terminate RN2486 commands

void sendCommand(String cmd) {
  rn2483.print(cmd);
  rn2483.write(crlf, 2);
  delay(1000);
}

String getResponse() {
  String response = "";

  while (!rn2483.available()) { // Linger here while no response
  } // Might be better to create a timeout after a few seconds

  while (rn2483.available()) {
    response = response + char(rn2483.read());
  } 
  response = response + "";
  response.trim();
  return response;
}

int initLoRa() {
  String response;
  int code = -1;
  
  sendCommand("mac join otaa"); 
  response = getResponse();
  
  if (response == "ok") {
    code = 0;
    delay(6000);
    response = getResponse();
    if (response == "accepted") {
      // There. A valid LoRa connection
      code = 1;
    } else {
      // Denied. Either no free channels or something else
      code = 2;
    }
  } else {  // not ok
    // Not a wanted response. Something with the hardware
    // We might want to throw a panic here
    code = 3;
  }  
  return code;
}

void setup() {
  pinMode(rn2483Reset, OUTPUT);
  digitalWrite(rn2483Reset, false); // Reset
  delay(100);
  digitalWrite(rn2483Reset, true); // Not reset
  delay(2500);
  rn2483.begin(57600);
  while (!rn2483) {
    delay(100);
  }
  initLoRa();
}

void loop() {
  // put your main code here, to run repeatedly:

}

Het solderen van montagedraden aan een RN2483 is nog niet zo eenvoudig, maar met een soldeerbout met een fijne punt moet het lukken. Het aansturen van de kick-ass PIC18LF46K22 door een ATtiny85 is zoiets als een Tesla model S laten starten met een accu van een lelijke eend, maar LoRaWAN is dan ook niet bedoeld voor iets omvangrijkers dan waar een ATtiny85 toe in staat is.

Ik heb vandaag geprobeerd een RN2483 LoRaWAN module met een Arduino aan de praat te krijgen. Het parsen van de communicatie van en naar de mdule ging niet gemakkelijk: de RN2483 module heeft soms een precieze timing, variaties in de antwoorden en de TheThingsNetwork.h bibliotheek is op de meeste combinaties van Arduino's en uitbreidingen niet te gebruiken (Arduino Diecimila bijvoorbeeld, of Arduino Leonardo met Xbee Shield). En als je moeite hebt om het werkend te krijgen dan heb je met TheThingsNetwork.h als abstractielaag vervolgens ook geen idee wat er verkeerd gaat. Met een terminal daarentegen is het vrij gemakkelijk om een RN2486 met The Things Network aan de gang te krijgen:

> sys reset
RN2486...
> mac join otaa
ok
accepted
> mac tx cnf 1 1234
ok
mac_tx_ok

Bovenstaande instructies is genoeg om data te versturen. Ik heb vandaag daarom een paar uur besteed om de abstractielaag weg te poetsen en de module direct via de seriële Arduino poort aan te sturen.

// Routine that uses the SoftwareSerial library to communicatie
// with an RN2483 LoRaWAN module
// Apart from SoftwareSerial there is no abstraction layer, thus
// all steps and code are visible.
// Note: although this code does work, it is not complete. Take this
// code as an example how to communicate with the RN2483 module

// SoftwareSerial can hook up to any two digital pins. More than
// one serial port can exist, but only one can be open at any time
#include <SoftwareSerial.h>

// Connect the RN2486 module to the following pins
#define LoraRX 8 // Yellow
#define LoraTX 9 // White

// Some variables to set right
byte crlf[2] = {0x0D,0x0A};
String r;
SoftwareSerial lora (LoraRX, LoraTX);

// This is the main send routine
void sendCommand(String cmd) {
  lora.print(cmd);
  lora.write(crlf, 2);
}

// This is the main receive routine
String getResponse() {
  r = "";
  while (!lora.available()) { // Linger here while no response
  } // Might be better to create a timeout

  // There is data to get, get it while it lasts
  while (lora.available()) {
    r = r + char(lora.read());
  } 
  r = r + "";
  r.trim();
  return r;
}

void setup() {
  lora.begin(57600);  // RN2486 default baud rate
  delay(100);  // Short delay to make sure the comms are up

  // Reset the module 
  sendCommand("sys reset");  // Reset the module
  r = getResponse();  // We expect a long string here
  // Containing module version information

  // Connect with the network 
  sendCommand("mac join otaa");  // Join OTAA
  r = getResponse();
  if (r == "ok") {  // That is the response we would like to have
    r = getResponse();  // There is going to be a follow-up
    if (r == "accepted") {
      // We're joined with the network
    } else {
      // 'denied'. No free channel, or max usage exceeded
      // Safe to try again later
    }
  } else { // not ok
    // Something went wrong, might be hardware
    // This should be thrown higher up
  }
  lora.end();
}

void transmitData(int payload) {
  lora.begin(57600);
  delay(100); // Short delay to make sure the comms are up

  // Send the payload confirmed, group 1
  sendCommand("mac tx cnf 1 " + String(payload));
  r = getResponse();
  if (r == "ok") {
    r = getResponse();
    if (r != "mac_tx_ok") {
      // We got data back! Parse the values from r
    } else {
      // 'mac_tx_ok'. No data back, just a succesful send
  } else {
    // 'invalid params'. Invalid parameters, programming error
  }
  lora.end();
}
void loop() {
  // This would be the place to send data, if the
  // connection with The Things Network succeeded

  // transmitData(measureSomeSensor());
}

The Things Network timmert hard aan de weg om wereldwijde LoRaWAN dekking te realiseren. Ze zijn hiervoor volledig afhankelijk van avonturiers en bedrijven die LoRaWAN gateways doneren. Dat hoeven er nog niet eens zo veel te zijn ook: met een stuk of tien gateways heb je Groningen op de kaart.

Onze waddeneilanden hebben nog weinig tot geen LoRaWAN dekking: op drie geplande (maar nog niet aanwezige) gateways op Terschelling na is het on-ontgonnen gebied. Met één zorgvuldig geplaatste gateway heb je op een eiland op de meeste plaatsen wel bereik, dus dat leek ons een mooi doel: Texel op de TTN-kaart zetten. Stap 1: een LoRaWAN gateway construeren. Stap 2: Texel verbinden met The Things Network. Stap 3: Verschillende eiland-toepassingen realiseren.

De TTN-wiki heeft een goed bouwverhaal over het maken van een gateway. Het verhaal eindigt echter wat abrupt na de bouw en installatie van de software: hoe je de gateway aan de praat krijgt blijft onbesproken. Mooie gelegenheid om het verhaal aan te vullen en van wat ervaringen te voorzien.

Bouw

• Sourcen van onderdelen: een IMST ic880A-concentrator board, een Raspberry Pi B+, een wifi-dongle, een antenne en verbindingskabeltje ('SMA pigtail'), een waterdichte doos en wat verbindingsdraadjes
• Bodemplaat voor in de waterdichte doos passend gemaakt en voorzien van gaten voor de ic880A en de Raspberry Pi
• Printplaten, antenne en bodemplaat monteren
• Bedrading leggen
• Alle aansluiting controleren (en nog een keer controleren)
• Raspberry Pi verbinden met een USB-voeding. Ook de ic880A wordt hiermee van stroom voorzien. Beide bordjes hebben verschillende leds die nu gaan branden
• Raspberry Pi voorzien van de meest recente software (apt-get install en apt-get upgrade)
• Raspberry Pi voorzien van de ic880A software met git clone -b spi https://github.com/ttn-zh/ic880a-gateway.git ~/ic880a-gateway
• De software installeren met het install.sh shellscript dat in de /home/pi/ic880a-gateway directory is neergezet (sudo ./install.sh)
• Het installatiescript toont nu het MAC adres van het ic880A concentrator board. Noteer dit, deze moet later in de console van TTN worden ingevoerd
• Antwoord n op de vraag 'Do you want to use remote settings file?' en accepteer de default waardes voor 'Host name' en 'Descriptive name'. Vul een bestaand email adres in bij 'Contact email'. Zoek de coordinaten van de locatie waar de gateway wordt geplaatst op en vul deze bij 'Latitude' en 'Longitude' in. Geef de antennehoogte aan bij 'Altitude'. De installatie wordt nu verder automatisch uitgevoerd

Inregelen en configureren

• Tijdens de installatie van de software is er in de home directory een directory aangemaakt die /home/pi/ic880-gateway heet. Hiernaast is er een directory /opt/packet-forwarder aangemaakt. Beide softwaremodules hebben hun functie: de gateway regelt het verkeer aan de LoRa (radio) kant, de packet-forwarder zorgt voor het ontvangen en versturen van internetverkeer aan de backhaul (wifi) kant
• Bij de installatie is de EUI van de gateway getoond. Deze moet aan de TTN kant bij het aanmaken van een nieuwe gateway worden ingevoerd

Testen

• Een werkende gateway meldt zich binnen enkele seconden met zijn EUI op de staging pagina van The Things Network. Staat de gateway hier niet? Dat verbindt hij niet met TTN
• Een werkende gateway waarvan de EUI bekend is op TTN wordt op de gateway pagina getoond en de doorvoer wordt gemonitord

Mogelijk problemen en oplossingen hiervoor

• De gateway wordt bij het booten van de Raspberry Pi opgestart met /lib/systemd/system/ttn-gateway.service. Als alternatief is er een opstartscript genaamd /opt/ttn-gateway/bin/start.sh. Raspbian lijkt systemd niet geheel te ondersteunen. Neem dan start.sh op in /etc/rc.local
• Voor alle vormen van foutzoeken is het handmatig opstarten van de gateway met start.sh verruit het handigst, omdat deze alle verbindingsinformatie over de terminal laat lopen

Een LoRaWAN node kan op twee manieren voor het eerst met The Things Network verbinden: Over The Air (OTAA) en Activation By Personalisation (ABP). Deze instructie gaat uit van OTAA, een RN2483 node en een bestaand account op TTN:

• Maak verbinding met de RN2483. Het gemakkelijkst gaat dat met een seriële verbinding: de RN2483 heeft een terminal waar commando's uitgewisseld kunnen worden. Voer een algehele factory restore uit: sys factoryRESET
• Vraag het hardware adres op: mac get deveui
• Voer het Device EUI in TTN in bij de node administratie
• Kopieer de gegenereerde App Key uit TTN en voer deze in de node in met mac set appkey <appkey>
• Kopieer de gegenereerde App EUI uit TTN en voer deze in de node in met mac set appeui <appeui>
• Bewaar alle sleutels in de RN2483 met mac save
• Maak verbinding met The Things Network met mac join otaa
• De RN2483 komt direct terug met ok en na enkele seconden met accepted
• Verstuur data met mac tx cnf 1 <databyte>

Als er geen gateway met een vrij kaneel in de buurt is zal er geen verbinding gemaakt kunnen worden. De RN2483 komt dan terug met de melding no_free_ch. Afgelopen week midden in Zwolle vastgesteld dat daar geen bruikbare LoRa dekking was, maar in Groningen is overal wel een kanaal vrij.

Slimme lampen (lampen die je overal ter wereld kunt besturen met een computer en die meestal verschillende kleuren kunnen tonen) zijn er al een poosje. Philips Hue is een bekend product. Het nadeel van Philips Hue is de hub: de lampen van Philips zijn zelf niet verbonden met het internet, maar met een doosje van Philips. Dat maakt de lampen zelf iets goedkoper, maar als je eenmaal in Philips Hue hebt geïnvesteerd, zit je daar redelijk aan vast. Misschien slim van Philips, maar geen 'slimme oplossing'.

LIFX (in Nederland verkocht onder de naam Sylvania) maakt échte wifi lampen: de lampen zelf verbinden met je wifi router thuis en je kunt er eentje voor proef nemen, of je hele huis er mee inrichten. De lamp geeft licht in alle kleuren van de regenboog, plus in alle tinten wit die je kunt verzinnen: van kaarslicht-bijna-rood-wit tot blauwig-wit en alles daartussenin.

LIFX komt met toegang via de website van LIFX en een handige app waarmee je de lampen kunt aansturen. Ook is er een IF This Than That koppeling, zodat je de lampen kunt laten reageren op gebeurtenissen die andere slimme apparaten hebben opgepikt: de lamp op de slaapkamer 's ochtends op wektijd langzaam laten aangaan, de verlichting in huis uitschakelen als de zon buiten schijnt, of inschakelen gaan als je smartphone binnen een straal van 100 meter van je huis komt. Alles kan.

Het nadeel is nog de prijs: in Nederland betaal je per lamp een kleine 90 euro. Als je direct bij de LIFX winkel in Amerika bestelt zijn ze 60 dollar, plus 20 dollar verzendkosten. Als je er meer tegelijk afneemt krijg je 25% korting.

De LIFX geeft zoveel licht als een 75 watt gloeilamp, een goede 1000 lumen. Da's een grote hoeveelheid licht, die je eerder verwacht van een bouwlamp dan van een gloeilamp. Gelukkig is deze hoeveelheid traploos te regelen tussen 3% en 100%. En in alle kleuren: vooral de mogelijkheid om verschillende wittinten toe te passen is handig.

De koppeling van LIFX met IFTTT maakt deze RGB-LED alleskunner ondanks de hoge aanschafprijs toch een goede investering. Naast een heldere lamp (die met maximaal 13 watt ook nog eens het energieverbruik tot weinig weet te reduceren) heb je met de LIFX een handige signalering voor ongeveer iedere gebeurtenis in de wereld.