Als je met je thuisautomatisering een centrale afzuiginstallatie wilt besturen dan loop je automatisch tegen vragen als 'hoe' en 'waarmee' aan. Als je een centrale afzuiginstallatie met een zogenaamde 'perilex' (4-polige) aansluiting hebt, dan heb je mazzel (of slim ingekocht), want deze is eenvoudig met een relais te besturen. Een relaismodule, standaard voorzien van een ESP8266 microcontroller met Tasmota-firmware vind je op AliExpress.
Een perilex-stekker verbindt een schakelaar met 3 standen met de centrale afzuiginstallatie en schakelt tussen de standen 'laag', 'midden' (of 'auto') en 'hoog'. Een relais heeft slechts 2 standen en als je hiernaast ook zeker wilt weten dat een verkeerde softwareaansturing geen bedradingsfouten kan opleveren, dan kom je op drie relais uit:
Inschakelen van de netspanning
Kiezen tussen 'laag' (stand 1) en 'auto/boost' (standen 2 en 3)
Kiezen tussen 'auto' (stand 2) en 'boost' (stand 3)
Je kunt met deze drie relais geen bedradingsfouten maken bij het inschakelen met de software en je kunt met het eerste relais de hele centale afzuiginstallatie van het stroom halen. Als je dat niet wilt, laat je relais 1 altijd 'aan' staan. Vervolgens kun je met relais 2 kiezen tussen 'laag' en 'niet laag'. Als je kiest voor 'niet laag', dan kun je met relais 3 kiezen tussen 'auto' en 'hoog'. Overigens werkt dit geheel in combinatie met een eventuele draadloze afstandsbediening, waarmee altijd de juiste stand gekozen kan worden. Voorwaarde is natuurlijk dat met het eerste relais de netspanning van de centrale afzuiginstallatie is ingeschakeld.
Met een eenvoudige Chinese Geiger-Muller telbuis en een kleine microcontroller heb je in een half uurtje een permanente weergave van de huidige omgevingsstraling in µSv/uur gemaakt en krijg je een waarschuwing als het stralingsniveau in je omgeving boven een bepaald niveau uitstijgt. Voor iedereen met een Home Assistant installatie een must-have en nog gemakkelijk te maken ook.
Ik ben dit project begonnen met een kant-en-klare Geigerteller-printplaat met daarop een J305 GM-telbuis. Het is een buis die je in meer Chinese stralingsmeters tegenkomt; het is niet een supergevoelige telbuis maar hij is goedkoop en - door volumeproductie en bijbehorende kwaliteitscontroles - betrouwbaar gebleken. Ik heb al eens vaker over stralingsmeting geschreven en in die artikelen aangegeven dat de telbuis werkt doordat het gas in de buis door bombardement van ionen ontlaadt en dan een elektrisch stroompje doorlaat. De telbuis wordt voorzien van een hoge spanning om dit mogelijk te maken en ieder type telbuis heeft een fabrieksspecificatie van de verhouding van ontladingen ('counts per minute') en de eenheid van straling, Sv/h ('Sievert per uur'). In het geval van de J305 is dat verhoudingsgetal 123,14709 (zie overweging aan het einde van dit artikel). De buis zelf heeft een onderdrempel van 0,2 ontladingen per seconde, je hebt dus in elk geval 12 ontladingen per minuut op basis van de 'achtergrondstraling' die je overal op aarde tegenkomt. De levensduur van de buis is gespecificeerd als '> 1 x 10^9 pulse', hetgeen bij 100 pulsen per minuut een levensduur van tenminste 2 jaar zou betekenen.
Je begint het project door een D1mini microcontroller met een kabeltje te voorzien van de basisfirmware en te verbinden met je wifi toegangspunt. Het kabeltje kan dan weer verwijderd worden: alle volgende updates van de firmware gaan 'over the air'. Met drie korte stukjes montagedraad verbind je de D1mini met de aansluitingen 5V, GND en VIN van de Geigerteller. De VIN aansluiting van de Geigerteller is een digitale uitgang (die dus VOUT had moeten heten) die hoog wordt bij iedere telpuls. Ik heb deze pulsuitgang met aansluiting D6 van de D1mini verbonden. Met een stukje verpakkingsschuim en een eindje dubbelzijdig tape heb ik de D1mini op een handige plek op de Chinese stralingsmeter-printplaat vastgezet zodat het net lijkt alsof beide printplaten bij elkaar horen. Nuver.
Aan de softwarekant heb ik de informatie vanaf de D1mini in drie delen opgesplitst: de telinformatie in CPM ('telpulsen per minuut'), een stralingsniveau omgerekend naar µSv/h en een indicatie van of zich een onveilige situatie voordoet: drie handige entiteiten die hun weg zo naar Home Assistant zullen vinden.
substitutions:
friendly_name: Geiger Counter
esphome:
name: esphome-web-9fc591
esp8266:
board: esp01_1m
# Board pinout
# GPIO12 D6 PULSE
# Enable logging
logger:
level: debug
# Enable Home Assistant API
api:
ota:
wifi:
ssid: !secret wifi_ssid
password: !secret wifi_password
# Enable fallback hotspot (captive portal) in case wifi connection fails
ap:
ssid: ${friendly_name}
password: !secret wifi_ap_password
captive_portal:
sensor:
- platform: pulse_counter
pin: 12
name: ${friendly_name}
id: "geiger_counter"
state_class: measurement
unit_of_measurement: 'CPM'
on_raw_value:
- sensor.template.publish:
id: radiation_level
state: !lambda 'return x / 123.14709;'
- platform: template
name: "Radiation Level"
id: "radiation_level"
unit_of_measurement: 'µSv/h'
icon: mdi:radioactive
accuracy_decimals: 5
binary_sensor:
- platform: template
device_class: safety
name: "Radiation Warning"
lambda: |-
if (id(radiation_level).state > 0.32) {
// Value of 2.8 mSv/year is the radiation dose in The Netherlands the average person receives
// which translates to 0.32 µSv/hour. Everything above is suspicious and thus warrants a warning
// See https://www.rivm.nl/straling-en-radioactiviteit/blootstelling-en-gezondheidsrisico/blootstelling-aan-ioniserende-straling-samengevat
return true;
} else {
// Value equal or below the normal level
return false;
}
In Home Assistant heb ik vervolgens de entiteiten zichtbaar gemaakt op een dashboard.
Als je een analoge wijzerplaat wilt tonen, is het handig om gebruik te maken van de normen die RIVM erop na houdt: 2,8 mSv/jaar wordt als normaal gezien. Dat is omgerekend 0,32 µSv/uur. Als je dat als 20%-waarde instelt, en dus 1,6 µSv/uur als schaalmaximum, zou je 0,8 als 50%-waarde kunnen gebruiken. Op die manier krijg je een meter met een groene zone, oranje zone en rode zone:
Ik gebruik een verzameling proefmaterialen om de opstelling te testen: uraniumerts in een loodgevoerd potje en een paar scherven van een aardewerken potje met uraniumhoudende verf.
Met de aardewerk scherven krijg je een prachtige demonstratie van de werking van de opstelling: de weergegeven straling stijgt tot ongekende hoogte en je krijgt een waarschuwing dat er veel straling is. Prima resultaat van een half uurtje knutselen (en wat langer spelen met de opstelling).
Een project is niet af als er niet een beschermende - en bij voorkeur aantrekkelijke - verpakking omheen zit. Speciaal voor dit doel heb ik een doosje met eigen ontworpen deksel ge-3D-print waar de geigerteller-print-met-D1mini prima in verpakt zitten. Ik heb er zwarte Eco-ABS voor gebruikt, met het idee dat ik er nog een keer met een spuitbus gele verf wat mooie accenten op wil aanbrengen. Zie mijn Thingiverse pagina voor het ontwerp van deze behuizing.
Update: de Y305 Geiger-Muller telbuis heeft een eindige levensduur, die wordt bepaald door het aantal gasontladingen dat de buis heeft doorstaan en nog kan doorstaan. De levensduur van de buis is gespecificeerd als 'Life: > 1 x 10^9 pulse', hetgeen bij 100 pulsen per minuut een levensduur van tenminste 2 jaar zou betekenen. Om daar een beetje gevoel voor te krijgen is het handig om het totaal aantal ontladingen total counts bij te houden. Ik laat Home Assistant het totale 'gebruik' bijhouden met een utility_meter. Hieronder de aanpassingen aan de ESPhome firmware en het Home Assistant configuratiebestand.
# Usage counters, are persistent (i.e. keep the value after a reset)
utility_meter:
geiger_tube_j305_usage:
source: sensor.total_counts
Een Geiger-Muller telbuis reageert op ioniserende straling en het aantal impulsen per minuut heeft een relatie met de stralingsdosis. Echter, wat is die relatie? De fabrikant van de buis zou het kunnen weten en er over publiceren, maar in het geval van de J305 is dat wat 'mistig'. We komen echter zelf een heel eind als we de stelling van RIVM dat we in Nederland zo'n 2.8 mSv per jaar ontvangen. Met dat gegeven kunnen we de normale hoeveelheid straling per minuut omrekenen en in verhouding brengen met het aantal telpulsen.
Voor de handige knutselaar is er met een paar onderdelen en wat materialen uit de knipselbak eenvoudig een praktisch display te realiseren dat internettijd en boodschappen kan tonen. Met een beetje moeite een parel voor in de woonkamer of keuken; met iets minder moeite een uitbreiding van de werkplaatsuitrusting of hobbykamer.
Het display dat ik in dit artikel beschrijf bestaat uit twee aan te schaffen onderdelen (drie, als je de 5 volt netvoeding meerekent) en wat restmaterialen zoals een vel A4 papier. Als je een 3D printer tot je beschikking hebt kun je die ook gebruiken. In dit project maak ik gebruik van ESPhome, een raamwerk om ESP8266 en ESP32 microcontrollers te besturen met eenvoudige configuratiebestanden en (zeer) weinig programmeerwerk, bedoeld om apparaten van afstand 'over the air' te besturen en te updaten:
De twee belangrijkste onderdelen zijn de led matrix, die bestaat uit 256 in serie geschakelde RGB leds van het type WS2812 op een flexibel paneeltje verlijmd (ca. € 12,50), en het Wemos D1 mini microcontrollerbordje (ca. € 2,50). De led matrix heeft drie aansluitingen: +5V, GND en een data ingang. GND en de data ingang worden met de microcontroller verbonden aan respectievelijk GND en D2/GPIO4. De +5V wordt verbonden met de 5V netvoeding. De +5V van de D1 mini wordt hier ook mee verbonden. Op deze wijze trekken de led matrix en de microcontroller los van elkaar stroom en kan de microcontroller de led matrix aansturen, zonder dat de microcontroller de volledige stroom van de leds moet 'ophoesten'.
De ESP8266 microcontroller is al sinds jaar en dag het meest praktische onderdeel om sensoren mee aan het internet te knopen: laag stroomverbruik, ingebouwde wifi en meer dan uitstekende ondersteuning van de open source community. Via de Arduino ontwikkelstack te programmeren. ESPhome, een initiatief van ontwikkelaar Otto Winter en tegenwoordig in handen van Nabu Casa, heeft daaroverheen een magische schil gelegd die het mogelijk maakt om kale ESP8266's via de webbrowser en een kabeltje te voorzien van ESPhome firmware en vanaf dan alle nieuwe functies 'over the air' te versturen. En die nieuwe functies maak je met ESPhome vanuit de browser, met YAML en wat C++ instructies en de gehele codeboom wordt voor je gegenereerd en als nieuwe firmware naar je ESP8266 ge-upload.
De led matrix bestaat uit WS2812 leds, die voorzien zijn van een seriele ingang en uitgang. De eerste led wordt aangesloten op de microcontroller en ontvangt de instructie, die bestaat uit een lednummer en een kleur. De leds geven de instructies onderling door totdat de juiste led is bereikt.
Ik gebruik in ESPhome de volgende configuratie om de led matrix aan te sturen. In het eerste deel light wordt een lichtslang gedefinieerd die bestaat uit 256 WS2812 leds die de naam led_matrix krijgt. In het tweede deel display wordt een adresseerbare lichtkrant gedefinieerd die wordt gebaseerd op de lichtslang met de naam led_matrix en die als eigenschappen 8 x 32 pixels heeft. Met de pixel_mapper worden de x en y coordinaten omgerekend naar een serieel lednummer 0-255. Het display updatet iedere 45 ms, voldoende voor vloeiende animaties en lopende teksten. Zowel light als display erven eigenschappen en methoden van ESPhome, zoals lichteffecten en het kunnen tonen van tekst en beeld:
Zelf heb ik eerst gebruik gemaakt van de led matrix, de microcontroller, een vel papier en wat plakband om het geheel wat structurele stevigheid te geven. De code hierboven definieert het display als een basis van adresseerbare leds en zorgt ervoor dat iedere pixel met een x en y coordinaat kan worden aangesproken. Dat is echter niet waar ESPhome ophoudt: het display kan beschreven worden met lijnstukken, tekst, afbeeldingen, animaties en grafieken, uiteraard in alle denkbare kleuren. Met lambda kan C++ (Arduino) worden 'gesproken':
Nadat het geheel zich bewezen heeft wordt het tijd voor een wat steviger behuizing. Ik heb van thingiverse één van de vele 'grids' ge-3D-print en daaromheen met wat MDF restjes een doosje inelkaar gelijmd. Een laagje van (halfdoorzichtig) plastic verpakkingsmateriaal of een stukje wit perspex maakt het geheel af. De diffuser is ervoor om te zorgen dat er mooie kleuren zichtbaar worden; de grid is ervoor zodat er ondanks de diffuser onderscheidbare beeldpunten ontstaan. Note to self: als je gebruik maakt van superlijm, laat het geheel dan uitgebreid luchten voordat je het kastje sluit om het zichtbaar maken van vingerafdrukken op het perspex met de cyano-acrylaat te voorkomen.
Ik heb altijd een paar stukken MDF van 4 en 6 millimeter op voorraad: het materiaal is erg eenvoudig te verwerken met zaag en schuurpapier en verlijmt tot solide voorwerpen met de bekende witte houtlijm van Bison (bouwmarkt) of Pattex (Action). Het schuren van MDF levert wel veel stof op dus draag een stofmasker en stofzuig de werkplek na het schuren grondig. Ik heb de maten proefondervindelijk vastgesteld volgens het volgende procédé:
Diffuser en bodem (achterkant) zelfde maat als het grid
Lange wand 'een paar centimeter' hoog en even lang als diffuser en bodem
Zijkanten even hoog als de lang wand en zo breed als de diffuser en bodem, plus twee keer de plaatdikte
Alles verlijmen met houtlijm, fixeren met plakband en paar uurtjes laten drogen. Met wat blokjes MDF aan de binnenkant het grid en diffuser vlak met de voorkant laten lopen en het geheel grondig schuren met een schuurblokje, korrel 120 of fijner. Met goed schuren, houtplamuur-uit-een-tube, spuitplamuur en spuitverf krijg je een mooie gladde afwerking.
ESPhome heeft prachtige voorzieningen voor het gebruik van sensorinformatie van andere bronnen, zoals Home Assistant, en ondersteunt het gebruik van True Type fonts. Met een timer blader ik om de 30 seconden tussen pagina's die de (internet-)tijd, de buitentemperatuur van het Netatmo weerstation, informatie over de afvalophaaldiensten, het weerbericht (in tekst) van het KNMI en headlines van de NOS tonen.
Toen de Chinese startup Espressif Systems in 2014 met de ESP8266 op de markt kwam was dit de eerste betaalbare microcontroller met een ingebouwd WiFi radiocircuit. De chip werd onder hobbyisten bekend door de ESP-01 module van het eveneens Chinese Ai-Thinker, die de 5x5 mm grote ESP8266 op een kleine printplaat uit had gebracht, voorzien van software om met WiFi netwerken verbinding te maken. De ESP-01 kon met eenvoudige Hayes-commando\'s TCP/IP verbindingen opzetten en had twee digitale aansluitingen om verbindingen met andere microcontrollers te maken. Hoewel er geen enkele vorm van documentatie beschikbaar was, was de uiterst goedkope ESP-01 een *instant hit* bij de makers en het duurde niet lang voor men had uitgevonden hoe er eigen software op de ESP8266 kon worden geïnstalleerd. De ESP8266 werd hierna door veel fabrikanten van de eerste generatie internet of things toepassingen gebruikt. Espressif Systems vaarde er wel bij en in 2016 bracht het de ESP32 uit met meer mogelijkheden, waaronder een betere WiFi implementatie en Bluetooth op de chip. De ESP32 werd eind 2019 in een herziene versie uitgebracht, genaamd de S2.
De ESP32 S2 is niet zonder meer een verbetering van de ESP32. Zo is Bluetooth, geïntroduceerd op de ESP32, komen te vervallen en is de dual-core LX6 vervangen door een (snellere) single core LX7. Ook de hoeveelheid werkgeheugen en intern flashgeheugen is afgenomen.
| | ESP8266 | ESP32 | ESP32 S2 |
|---|---------|-------|----------|
| Instructieset | Xtensa 32-bit RISC architectuur met 82 instructies | Xtensa 32-bit RISC architectuur met 82 instructies | Xtensa 32-bit RISC architectuur met 82 instructies |
| Processor | 1-core L106 | 1/2-core LX6 | 1-core LX7 |
| Klok | 80 MHz | 160/240 MHz | 240 MHz |
| Werkgeheugen (SRAM) | 160 KB | 520 KB | 320 KB |
| Flashgeheugen (ROM) | - | 448 KB | 128 KB |
| WiFi implementatie | 802.11 b/g/n 2.4 GHz HT20 | 802.11 b/g/n 2.4 GHz HT20 | 802.11 b/g/n 2.4 GHz HT20 |
| Bluetooth implementatie | - | Bluetooth 4.2 & BLE | - |
| Ethernet implementatie | - | 10/100 Mbps | - |
| CAN bus | - | CAN 2.0 | - |
| Generiek toepasbare I/O (GPIO) | 16 | 34 | 43 |
| Analoge ingangen (ADC) | 1 (10-bit) | 18 (12-bit) | 20 (12-bit) |
| Analoge uitgangen (DAC) | - | 2 (8-bit) | 2 (8-bit) |
| USB OTG | - | - | 1 |
| Beveiliging | - | Secure boot flash encryptie (1024-bit) | Secure boot flash encryptie (4096-bit) |
| Cryptografie | - | AES, SHA-2, RSA, ECC, RNG | AES-128/192/256, SHA-2, RSA, RNG, HMAC, Digital Signature |
| Stroomopname slaapstand | 20 µA | 10 µA | Automatisch 5µA in *idle* toestand |
| Stroomopname maximaal | 215 mA | 260 mA | 245 mA |
Vergelijking tussen de ESP8266, ESP32 en de nieuwe ESP32 S2De conclusie kan niet anders zijn, dan dat het gebruik van de ESP32 S2 aan te raden is in situaties waarin beveiliging en cryptografie de serieuze aandacht heeft en waarin de beschikbaarheid van Bluetooth en BLE geen rol spelen. De \'S2\' is in veel opzichten een stap terug ten opzichte van de voorganger maar is in alle opzichten een *grote* stap vooruit ten opzichte van de ESP8266.
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:
Het MAC-adres van je weerstation vind je in Mijn Station beheren.
MAC-adres van de binnenmodule 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
Wie zijn (of haar) Mac recentelijk naar macOS 10.15 Catalina heeft geüpgraded komt tot de vervelende conclusie dat het 'branden' van nieuwe firmware op een ESP32 (en meer specifiek een M5StickC) niet meer werkt: het gebruikte esptool.py heeft een timingsprobleem in combinatie met macOS Catalina, waardoor de communicatie bij het uploaden van nieuwe firmware spaak loopt. Er bestaat echter een tijdelijke oplossing.
De M5StickC wordt voorzien van nieuwe firmware middels het M5Burner programma. Dat programma maakt onder de motorkap gebruik van het programma esptool.py, dat door Espressif Systems wordt ondersteund. Het nieuwe macOS Catalina levert in combinatie met esptool.py en de M5StickC problemen op, met meldingen die lijken op onderstaande:
esptool.py v2.5.0
Serial port COM3
Connecting........_____....._____....._____....._____....._____....._____....._____
A fatal error occurred: Failed to connect to ESP32: Timed out waiting for packet header
Het probleem wordt beschreven in het M5Stack forum, met als titel M5StickC usb driver and Catalina. Uit de reacties wordt duidelijk dat er geen directe oplossing is in termen van softwareaanpassingen: het wachten is op een nieuwe versie van esptool.py (versie hoger dan 2.5.0) die wél compatibel is met macOS Catalina.
Een tijdelijke oplossing is echter, om de timing problemen een handje te helpen door de G0 pin met GND te verbinden ten tijde van de firmware upgrade (en alle andere momenten waarop nieuwe software op de M5StickC/ESP32 met esptool.py moet worden geplaatst. Met een paperclip (klein formaat) of verbindingskabeltje is dat eenvoudig gepiept.
Kabeltje tussen G0 en GND doet wonderen bij het flashen en firmware upgrades
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 CO2 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.
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:
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:
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:
Hoewel de programmeertaal Lua en bijbehorende modules voor sensoren, actuatoren en andere systeemfuncties een integraal onderdeel vormen van het NodeMCU concept, valt de meerwaarde van Python op dit platform niet te ontkennen. Sinds een tijdje is er een kleine implementatie beschikbaar voor de NodeMCU genaamd MicroPython. Tijd voor een testje.
Er zijn een aantal testsituaties die ik zeker mee wil nemen:
Ondersteuning van sensoren zoals DS18B20 en actuatoren zoals de WS2812 intelligente leds (iets wat in Lua altijd een module was)
Ondersteuning van systeemfuncties zoals http (get), network time
Manier van flashen
Ondersteuning van zowel NodeMCU boards als de ESP01 modules
Mate van ondersteuning van de Python programmeertaal
MicroPython is gedocumenteerd op micropython.org, een initiatief om Python op embedded systemen te ondersteunen. MicroPython is er voor de ESP8266 maar ook voor de ESP32 modules. Vooral dat laatste is heel interessant, gezien de beschikbaarheid van de ESP32-met-oled-en-lora-chipsets (zoals de Wemos TTGO LORA32). Gecombineerd met MicroPython en The Things Network zou dat absoluut hoog scoren. Het MicroPython forum is daar echter nog niet echt over uit.
Gisteren heb ik klaarblijkelijk twee NodeMCU's "gesloopt". De eerste wilde niet meer reageren door een combinatie van de automatisch ladende init.lua en een programmeerfout die de NodeMCU na een halve seconde deed herstarten. Normaal voldoet dan het opnieuw laden van de firmware, maar na het opwaarderen van de firmware ging de blauwe LED van de ESP12 in hoog tempo knipperen en spuwde met een baudrate van 74880 herhaald het volgende bericht uit:
Da's niet goed. Ik dacht direct aan een elektrisch defect en heb een tweede (nieuwe, goed werkende maar met een verkeerde firmware) NodeMCU voorzien van dezelfde firmware. En ook deze gaf "de blauwe flitsende LED ter bevestiging van een totale ondergang". Zucht. En dat kost je dan een halve dag om dat uit te zoeken. Ik heb, na het halve internet te consulteren, de volgende dingen tevergeefs geprobeerd om de boel weer opnieuw aan de gang te krijgen:
Andere instellingen voor de flasher gebruikt: de gebruikte NodeMCU's hebben 4MB flashgeheugen (32mbit) en werken met de "Dual IO SPI" (DIO) flash methode, maar toch maar met andere instellingen geprobeerd, zoals 4m en "detect"; flashmode veranderd van dio naar qio
Andere USB kabel
Eerst een niet-NodeMCU firmware geladen, zoals de oorspronkelijke boot_v1.1.bin. Deze deed het prima en maakte na het booten een sprong naar het
Andere firmware flasher (ik gebruikte esptool.py onder OS X, maar heb een Windows tool van electrodragon geprobeerd onder Windows 10 op de PC
Uiteindelijk bleek de oplossing erg simpel en bleek het probleem goed gedocumenteerd, echter zonder het noemen van de symptomen. In het 4MB geheugen van de NodeMCU zijn blokken voor zowel de firmware als voor instellingen gereserveerd. Deze instellingen hangen samen met de versie van de ESP12. De firmware en de instellingen hebben een grote samenhang en blijkbaar zat daar iets in verkeerd. Door het uploaden van instellingen die beter bij de master build van de NodeMCU firmware passen, namelijk die uit SDK patch 1.5.4.1, kon ik de NodeMCU weer terug naar het land der levenden brengen. Bij het laden van die instellingen nog even om de juiste parameters van het esptool.py denken, en wel specifiek de geheugenplaats 0x3fc000 waar de instellingen moeten landen:
Een van beide NodeMCU's leek het in eerste instantie niet goed te doen. Toen ik van 74880 bits/seconde overschakelde naar een baudrate van 115200 bits per seconde zag ik de melding "Formatting file system. Please wait..." voorbij komen. Dat duurde een minuutje en vervolgens kwam de melding:
NodeMCU custom build by frightanic.com
branch: master
commit: 7b83bbb2ea134cd85ac9d63108603cc02c4e20f7
SSL: false
modules: adc,bit,cjson,coap,dht,file,gpio,i2c,mqtt,net,node,ow,pwm,rtctime,sntp,spi,tmr,uart,wifi,ws2812
build built on: 2016-11-25 08:30
powered by Lua 5.1.4 on SDK 1.5.4.1(39cb9a32)
lua: cannot open init.lua
>
Blijkbaar was de gebruikte Geekcreit Doit NodeMcu voorzien van een oudere versie van de NodeMCU firmware die niet (meer) compatible was met de SPIFFS versie die voor het bestandsbeheer zorgt. Probleem opgelost!
De twee belangrijkste onderdelen zijn de led matrix, die bestaat uit 256 in serie geschakelde RGB leds van het type WS2812 op een flexibel paneeltje verlijmd (ca. € 12,50), en het Wemos D1 mini microcontrollerbordje (ca. € 2,50). De led matrix heeft drie aansluitingen: 
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 
