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.

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).

Amiga demo Probe

Een paar dagen terug kwam ik toevallig een artikel op The Verge tegen, over de opkomst en teloorgang van de Commodore Amiga. Het zal ergens in 1988 of daaromtrent geweest zijn dat ik mijn Sinclair ZX Spectrum inruilde voor een Amiga 500 en het artikel van The Verge deed me herinneren aan de onvoorstelbare mogelijkheden die de Amiga in die tijd bood. De Amiga was zijn tijd ver vooruit en zelfs nu, anno 2014, zijn de mogelijkheden nog steeds indrukwekkend. De Amiga had een 68000 processor en speciale chips voor geluid en beeld. Deze architectuur houdt ook nu nog stand, maar in de jaren ’80 was dat heel ongebruikelijk: zelfs de Macintosh, voor die tijd de bekendste geavanceerde computer, deed beeld en geluid (weliswaar heel slim) in software op de CPU.

In mijn herinneringen heb ik veel tijd doorgebracht met een MS-DOS kaart, Guild of Thieves en vele demo’s. Denkende aan die demo’s herinnerde ik me een hele fraaie, met een simulatie van een bezoek aan een vreemde planeet. En laat ik die nu op YouTube hebben gevonden!

Zork

manuals-Zork1In de jaren 80 van de vorige eeuw was ik geabonneerd op het maandblad Kijk. De illustraties en bijbehorende vaak fantastische verhalen hielden mijn fantasie goed bezig en ik herinner me één specifiek artikel over verborgen spannende werelden aan de binnenkant van computers: de adventure. Tegen de tijd dat ik er over las was er al een heel genre van tekstgebaseerde computerspellen ontstaan die op de computers van die tijd werden gespeeld: Adventure, Zork, The Pawn en tientallen anderen.

De tekstadventures in die tijd waren vaak geïnspireerd door verhalen als The Hobbit en The Lord of the Rings, met meestal een eigen invulling voor de plaats waar het verhaal zich afspeelde en de personages die in het verhaal voorkwamen. De interactie met het spel ging via het invoeren van commando’s, gericht aan een denkbeeldige persona in het computerspel, en in de vorm van de beschrijvingen die in tekstvorm over het scherm rolden. Een bekende adventure uit die tijd was Zork.

Welcome to Zork.

You are in an open field west of a big white house with a boarded
front door.
There is a small mailbox here.

> open mailbox

Opening the mailbox reveals:
A leaflet.

 

Zork was belangrijk voor het genre, ondermeer omdat het op haast ieder platform beschikbaar was, van Apple II, Amiga en TRS-80 tot Commodore 64. In vergelijking met het grafische geweld dat we tegenwoordig verwachten is een tekstadventure hopeloos saai. Het spelelement zit echter niet in het beeld, maar in het woord. De tekstadventures werden ook ‘interactieve fictie’ genoemd: een avonturenverhaal waar jij het verloop bepaalde. Meestal moest er van de ene locatie naar de andere verplaatst worden, voorwerpen gezocht, puzzles opgelost en slechterikken verslagen. Hulp bestond er in de vorm van maps, hints en structured walkthroughs: stap-voor-stap beschrijvingen om het einde van de tekstadventure te bereiken. Een beetje als naar het laatste hoofdstuk gaan om te zien hoe het afloopt, dat wel.

 

’t Is bijna zo ver

Omslag Leidraad grafischIn het licht van het nieuwe EPD/ZIS van Siemens dat er staat aan te komen heb ik met co-auteur Ton Kunen in opdracht van het UMCG een boek geschreven over de ervaringen die het UMCG de afgelopen jaren met testen heeft opgedaan. Het boek, dat Leidraad Test en Acceptatie heet, is op 23 september naar de drukker gegaan.

Boeken over testen maken voor het grote publiek over het algemeen niet zulk beste lectuur en ik heb niet de illusie dat dat met dit boek structureel anders zal zijn. Echter, we hebben een aantal unieke onderwerpen samengesteld waar ik erg trots op ben: opstellen en gebruik van acceptatiecriteria, testautomatisering voor eindgebruikers en een betere balans tussen testprofessie en materiedeskundigheid bij acceptatietesten. Hiernaast hebben we hebben veel zorg besteed aan een grote hoeveelheid kleurrijke illustraties, die hopelijk niet alleen de drukkosten hebben opgejaagd maar ook de leesbaarheid zullen bevorderen.

Naast een ‘stand van zaken’ rapport hopen we goede sier te maken richting het aanstaande EPD/ZIS testtraject van het UMCG. En natuurlijk collega’s, leveranciers en de medewerkers van tientallen ziekenhuizen die de eerstvolgende jaren een soortgelijke migratie gaan doorleven, te inspireren met de testaanpak die we beschrijven.

Update: de eerste recensie is er al.

Sinterklaasmachines

Tegenwoordig zijn zo goed als alle gedrukte publicaties ontsproten aan ‘desktop publishing’: een krant of tijdschrift wordt met behulp van een computer geheel digitaal ontworpen en met een kleuren laserprinter afgedrukt. Het fenomeen desktop publishing is geboren in 1985 met het programma Aldus Pagemaker, de Apple Macintosh en de toen nog onbetaalbare laserprinters. In ongeveer 25 jaar is de publicatiewereld volledig veranderd en is het technisch mogelijk geworden om op een zolderkamer in een namiddag een professioneel uitziende publicatie vorm te geven.

Anno 2013 is er een nieuw fenomeen genaamd ‘desktop manufacturing’, dat in vogelvlucht lijkt te geraken door een mechanisme dat ‘3D printen’ heet. Bij desktop manufacturing is ook op het scherm zichtbaar, hoe een voorwerp er bij de uiteindelijke productie uit gaat zien. Het 3D printen maakt, via een additief proces, mogelijk om een voorwerp laagje voor laagje in kunststof op te bouwen. Er zijn weinig beperkingen aan het type voorwerp dat op deze manier wordt geprint en ik vind dat 3D printers de bijnaam ‘Sinterklaasmachines’ moeten krijgen, omdat ze elke gadget die je je kunt voorstellen in korte tijd voor je kunnen maken.


Zebra’s in Mountain Lion

OS X 10.8, Mountain Lion, komt met een aantal nieuwe bureaubladachtergronden. Sommige ervan zijn achter de computer tot stand gekomen, andere ervan zijn echte foto’s. Eén ervan, die bekend staat als Zebras, is gemaakt door Steve Bloom. Op zijn website doet hij het verhaal achter de foto:

We took off as soon as Air Traffic Control allowed us to and headed for the Delta. The clouds momentarily parted to let the morning light in and we found the zebras moving in the swamp. The encounter was brief. The diaphanous light faded quickly; the weather closed in behind us. The picture shows how the strong herd instinct protects each individual against predators.  After we landed, I managed to catch my flight home in the nick of time.

Moet Apple een leuk bedrag gekost hebben, maar wat een fraaie foto is het geworden.