Rian van Rijbroek’s optreden in Nieuwsuur getoetst

Het bezoek van Rian van Rijbroek, ‘expert cyberveiligheid’ en ‘schrijver van het boek De wereld van Cybersecurity en Cybercrime’ aan het televisieprogramma Nieuwsuur op 29 januari 2018 heeft veel losgemaakt. In het programma werd aandacht besteed aan de DDOS aanvallen op internetdiensten van verschillende bedrijven, zoals de Belastingdienst, ING, ABN AMRO, Rabobank en KPN. Van Rijbroek’s uitlatingen over naderend cyberonheil deden tal van autoriteiten op dit gebied over elkaar heen buitelen om het tegenovergestelde te beweren van wat zij vertelde. Hiernaast bleek een paar dagen later dat het boek dat zij samen met Willem Vermeend had geschreven op diverse plaatsen plagiaat pleegde. Moeilijk te volgen verhaal en een boek met geplagieerde teksten. Nieuwsuur distantieert zich dan ook van het interview met Van Rijbroek, zoveel is duidelijk. Zowel haar uitspraken als haar boek moeten het ontgelden:

De vraag is natuurlijk of het verhaal van Van Rijbroek helemaal is verzonnen, of dat Nieuwsuur om andere redenen gemeend heeft het verhaal te moeten ontkrachten.

Wat is er bijzonder aan deze DDOS aanvallen?

De eerste vraag is natuurlijk, wie het kan zijn die deze DDOS aanvallen uitvoert. Van Rijbroek:

De aanvallen zijn .. je ziet vanaf eh .. eind 2013 zie je bepaalde trend de aanvallen zijn groter, geavanceerder en het lijkt erop alsof iemand de beveiliging van de banken in dit geval, van de Belastingdienst in dit geval, aan het testen is. Dat eh .. daar eh .. ja je kunt nooit eh .. met zekerheid zeggen wie daar achter zit maar je zag dat er codes bij banken binnenzaten, Russische en Iraanse codes, en Noord-Korea. Er wordt gedacht aan hackersgroepen uit die drie landen.

Van Rijbroek suggereert zelf betrokken te zijn bij de analyse van de DDOS aanvallen. Dat zou dan bij de ING Bank, ABN AMRO, Rabobank of Belastingdienst geweest moeten zijn. De ‘codes’ waarover ze spreekt zouden dan al IP-adressen moeten zijn, of regionale informatie in een HTTP request.

Geldautomaten spuwen geld uit

Op de vraag, wat het doel geweest kan zijn van de hackers die de DDOS aanval hebben uitgevoerd antwoordde Van Rijbroek het volgende.

Ik eh gaf al aan dat hackers de beveiligingssystemen aan het testen zijn, dit is een vooraanval van iets groots dat gaat komen. En wat gaat dan komen, we hebben nu recent de afgelopen dagen en dat is eh informatie die ik eh vandaag heb doorgekregen van een veiligheidsdienst, hebben [we? ze? er?] mee te maken gehad en daar hebben [ze? we?] hetzelfde patroon gezien in de VS dus ook deze testaanvallen hebben uitgevoerd en nu zijn [ ] hebben diverse geldautomaten geld uitgespuugd op bepaalde tijdstippen en die zijn door geldezels zijn dat is dat geld opgehaald.

Kan dat kloppen? Geldautomaten die geld uitspugen? Bij nazoek blijkt het van wel en zelfs heel recent, met geldautomaten die zo te zien ook in Nederland worden gebruikt. Al sinds 2013 wordt over gehackte geldautomaten gesproken en fabrikanten Nixdorf en NCR waarschuwen hiertegen volgens Reuters. Geografisch zijn Taiwan, de VS en Duitsland aan de beurt geweest en worden veel Nederlandse geldautomaten in Duitsland door Nixdorf gemaakt. De laatste waarschuwing stamt van 29 januari 2018, de dag van het interview met Van Rijbroek. De waarschuwing van Van Rijbroek lijkt dan ook relevant en terecht.

Mobiele telefoons zijn heel gemakkelijk te hacken

Op de vraag hoe je jezelf kunt beschermen als je gebruik maakt van mobiel bankieren zodat er niet iets gebeurt met je gegevens of je geld geeft Van Rijbroek het volgende antwoord:

Ik zou in ieder geval als ik in zou loggen bij een bank zal ik .. zou ik het al doen via .. je kunt tegenwoordig inloggen of via VPN of via de beveiligde modus zoals bijvoorbeeld eh .. bij Apple, dan zou ik niet eh .. via de mobiele telefoon doen want mobiele telefoons .. ja die zijn gewoon heel gemakkelijk te hacken, locatiehacken, ook niet op een openbare .. ik zou [zelf geen app van bank op mijn telefoon zetten]. Ik zou .. als ik eh .. ik zou, als ik dus zeg maar zou bankieren met mijn gegevens zou ik zorgen dat ik dat op een computer doe die op een kabel is aangesloten dus ook niet op een wifi netwerk want die zijn ook gemakkelijk over te nemen en te hacken dus ik zou daar toch eh wel voor opletten.

Het antwoord van Van Rijbroek is (alweer) wat moeilijk te volgen, mogelijk omdat ze verschillende onderwerpen in haar antwoord wil verwerken en halverwege haar verhaal wordt geïnterrumpeerd, maar de stellingen “mobiele telefoons zijn heel gemakkelijk te hacken” en “wifi netwerken zijn gemakkelijk over te nemen” steken er wel bovenuit. Kan dat eenvoudig, smartphones hacken en op die manier de gebruiker geld of informatie ontfutselen?

De uitspraak over mobiele telefoons lijkt niet te passen bij moderne Apple- en Android telefoons. Zoveel geeft Van Rijbroek ook zelf al aan (“beveiligde modus [..] van Apple”). Ze zal het dus over andere telefoons hebben gehad. Wikipedia laat zien dat meer dan de helft van de Android gebruikers een verouderd besturingssysteem gebruiken. En Android vormt 74% van de telefoonmarkt. Dat maakt dat alleen al in Nederland meer dan 6 miljoen mensen met een hackbare Android telefoon rondlopen. En voor Android zijn veel, heel veel ‘exploits’ en ‘hacks’. Lijkt erop alsof Van RIjbroek hier niet per se verkeerd zit, maar misschien een ongenuanceerd beeld probeert over te brengen.

Wifi netwerken zijn gemakkelijk over te nemen

Op de vraag hoe je veilig kunt bankieren adviseert Van Rijbroek om geen gebruik te maken van wifi netwerken “omdat die gemakkelijk zijn over te nemen”. Heeft ze daar gelijk in? Daar hoeven we denk ik niet al te lang over nadenken: bankieren via een wifi access point is vragen om problemen:

Conclusie

Van Rijbroek’s optreden in het NOS programma Nieuwsuur kwam weinig vertrouwenswekkend over met een hakkelend en wat gerepeteerd klinkend verhaal waarbij Van Rijbroek met enig regelmaat de draad leek kwijt te zijn. Toch lijkt er na enig Googelen inhoudelijk niets mis met de gegeven informatie: geldautomaten worden inderdaad in de landen om ons heen gehackt en de geldautomaten in Nederland lijken van hetzelfde fabrikaat als die in Duitsland worden gebruikt. Meer dan 6 miljoen Nederlanders lijken met een hackbare Android telefoon rond te lopen en veel wifi toegangspunten zijn eenvoudig over te nemen. Blijft over de vraag of Van Rijbroek de kennis uit eerste hand heeft, of het nieuws heel goed volgt. Op basis van haar uitspraken in Nieuwsuur wijst niets erop dat ze kennis uit eerste hand heeft opgedaan, maar juist alle informatie van horen zeggen heeft. Ze lijkt handig in het combineren van stukjes informatie tot iets wat op een antwoord lijkt.

Updates

  1. In de podcast van De Technoloog | BNR van 17 januari noemt Van Rijbroek in bijna iedere zin voorbeelden uit bronnen die ze soms bij name noemt. Dat verklaart mogelijk waarom de bronvermeldingen in haar boek zo haperen: het redactieteam heeft het waarschijnlijk gewoon opgegeven om alle bronnen erbij te zoeken. Haar ‘boekenwijsheid’ is echter opvallend.
  2. Ik lees net via Twitter een artikel van Joost Schellevis die stelt dat “informatie uit de echte wereld [door Van Rijbroek] aan elkaar [wordt] geknoopt en door de blender gehaald”.
  3. Marcel van den Berg heeft een CV-onderzoek gedaan naar Rian van Rijbroek. Het resultaat is ontluisterend. De titel van zijn blog-entry “Nieuwsuur liet nep cybersecurityspecialist uitleg geven over DDoS-aanvallen Nederlandse banken” is veelzeggend en Vermeend lijkt er tot zijn nek in verwikkeld.
  4. Alexander Klöpping verwoord zijn gedachten in zijn blog in vijf punten.
  5. Politie arresteert 18-jarige Oosterhouter op verdenking van de DDOS aanvallen.
  6. Volkskrant gaat in gesprek met de 18-jarige MBO scholier Jelle S. die achter de massale DDOS aanvallen blijkt te zitten. Hij zegt botnets te ‘huren’ en demonstreert dit aan de redactie van de Volkskrant door de internetaansluiting van de Volkskrant tijdelijk over te belasten.

Geen toegang tot mysql database bij nieuwe Raspbian installatie op Raspberry Pi

Nieuwe installaties van mysql (suo apt-get install mysql-server) regelen de authenticatie op een andere manier dan voorheen: er wordt niet meer tijdens de installatie gevraagd naar een ‘database administrator user’. In plaats daarvan wordt gebruik gemaakt van ‘local unix authorization’. Het effect is, dat je oeverloos op zoek kunt naar de oorzaak van de foutmelding mysql - ERROR 1698 (28000): Access denied for user 'root'@'localhost', en via omwegen zonder enig effect het wachtwoord van de root user kunt wijzigen, of de installatie helemaal opnieuw doen en tot de conclusie komen dat er nog stééds niet om een wachtwoord wordt gevraagd. De oplossing is simpel, echter: wijzig het account van de root gebruiker zodat deze van een los wachtwoord gebruikt maakt, en voeg de normale pi user toe aan de mysql installatie:

$ sudo mysql -u root

mysql> USE mysql;
mysql> UPDATE user SET plugin='mysql_native_password' WHERE User='root';
mysql> FLUSH PRIVILEGES;
mysql> exit;

$ service mysql restart

en toevoegen pi user aan toegangsrechten:

$ sudo mysql -u root

mysql> USE mysql;
mysql> CREATE USER 'pi'@'localhost' IDENTIFIED BY '';
mysql> GRANT ALL PRIVILEGES ON * . * TO 'pi'@'localhost';
mysql> UPDATE user SET plugin='auth_socket' WHERE User='pi';
mysql> FLUSH PRIVILEGES;
mysql> exit;

$ service mysql restart

Testing a Badgerboard with @thethingsntwrk The Things Network and @nasys_no Badgerboard

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.

// 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 send to The Things Network, which is done in the ‘Decoder’ section of the application:

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.

Apple event op dinsdag 12 september 19.00 (NL tijd)

Aan de uitnodiging vallen een aantal zaken op:

  • Gebruik van heldere tinten, in de kleuren blauw, rood en wit. Amerikaanse vlag? Productie van Apple producten of diensten vanuit de VS in plaats van China? Of viering van het 10-jarige bestaan van de iPhone?
  • Heldere kleuren, nieuwe beeldtechnologie? OLED?
  • Rechthoekige, afgeronden vormen met verhoudingen die lijken op een iPhone. Nieuw model iPhone? Ik zie er overigens drie (het rode vlak heeft rechtsonder een onverwachte afbuiging, hetgeen suggereert dat er twee iPhones op elkaar liggen, de bovenste kleiner dan de onderste).
  • In het nieuwe Steve Jobs Theater. Da’s mooi, een ruimte vernoemd naar de overleden baas van Apple. Zeker als bij introductie van de oorspronkelijke iPhone in 2007 wordt stilgestaan. Ik weet dat me dat in 2007 wel maanden heeft beziggehouden.

Het evenement is om 19.00 en normaliter is het live te volgen vanaf een Apple TV, iPad, iPhone of Mac. Apple heeft hiervoor deze placeholder gereserveerd. Uiteraard hebben de blogs ook de nodige berichtgeving:

Het gevalletje bedrijfsspionage waar Apple afgelopen week mee te maken heeft gekregen is toch een beetje alsof je stukken van het script van Jochem Meyjers nieuwe theatershow te zien krijgt. Gelukkig is de media overwegend terughoudend om al te veel ‘clues’ te lekken, zodat ik nog steeds uitkijk naar het live event. Ik ben ook erg benieuwd welk verhaal er achter de bedrijfsspionage vandaan komt. Niemand wordt er beter van, zeker de betreffende medewerker van Apple niet.

WS2812 displays als samengesteld display gebruiken met NodeMCU

Met de komst van de WS2812 individueel-adresseerbare RGB leds ontstaat de mogelijkheid om displays te maken in elk gewenst formaat. Op dit moment zijn displaymodules te koop met afmetingen 2×2, 4×4 en 8×8 WS2812 leds met afmetingen van 15x15mm, 30x30mm en 71x71mm die onderling kunnen worden doorgelust om een groter geheel te maken. De leds hebben een individueel volgnummer, genummerd 1 tot aantal modules x aantal leds per module.

In de afbeelding hierboven zijn 8 WS2812-ledmodules van 8×8 leds aaneengeschakeld tot een groter display. De led linksboven in de eerste module heeft nummer 1, de led linksboven in de tweede module heeft 65, enzovoorts. Het omrekenen van een  coördinatenpaar (x, y) naar een led-volgnummer gaat als volgt:

function toLineair(x, y)
  boardNumber = math.floor((y - 1) / boardHeight) * boardsWide + math.floor((x - 1) /   boardWidth)
  boardX = x - math.floor((x - 1) / boardWidth) * boardWidth
  boardY = y - math.floor((y - 1) / boardHeight) * boardHeight
  linPos = boardNumber * ledsPerBoard + (boardY - 1) * boardHeight + boardX
  return linPos
end

De programma’s en documentatie zijn te vinden op GitHub: https://github.com/rudiniemeijer/NodeMCU-Lua-WS2812-matrix-displays

Selenium webdriver development stack

GUI testen op websites kun je handig automatiseren met Selenium webdriver, een Open Source testautomatiseringstool. Maar het initiële gebruik hiervan is nog niet eens zo eenvoudig: kijk je op de installatiepagina van Selenium dan krijg je het Spaans benauwd van alle modules en opties die je nodig hebt. Dat komt omdat Selenium webdriver geschikt is voor verschillende webbrowsers en diverse programmeertalen ondersteunt. Daar zijn drivers en stubs voor nodig om dat mogelijk te maken.

Keuze voor de programmeertaal en IDE

Als tester zou je wellicht het liefst voor JavaScript of Python willen kiezen, maar het feit is dat de programmeertaal het liefst wordt afgestemd met de ontwikkelaars. Immers, de kans is groot dat zij Selenium willen inzetten voor hun unittesten en daarvoor een voor hen bekende taal willen gebruiken. En natuurlijk helpt het om ervaring met zo’n taal in het team te hebben. De keus voor een editor (‘integrated development environment’) is ook zo’n dingetje: Mac gebruikers hebben daar een prima Xcode omgeving voor, maar ontwikkelaars kiezen liever voor de Visual Studio IDE of Eclipse.

Keuze voor de browser

In beginsel willen ontwikkelaars hun webapplicatie geschikt maken voor alle browsers, maar als er problemen optreden worden al snel niet meer alle browsers ondersteund. Daarom is het van belang om vroegtijdig een referentiebrowser af te spreken. Gelukkig is de keus beperkt: Internet Explorer (versie..), Opera, Chrome, Firefox of Safari. Meestal is Chrome een veilige keus (hoewel Mac bezitters ook prima voor Safari kiezen: de gebruikte WebKit engine wordt ook in Chrome en Opera gebruikt).

LoRa antennelengte voor 868MHz

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.

LoRa, KPN en The Things Network met ATtiny85 en RN2483

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.

Arduino communicatie met een RN2483 LoRaWAN module aan The Things Network

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());
}

LoRaWAN gateway construeren en verbinden met The Things Network

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