Rudi

In 2007 probeerden Microsoft en Intel iets nieuws dat ze Ultra-Mobile PC’s zouden gaan noemen: kleine laptops met een moderne vormgeving en een laag stroomverbruik en dus weinig rekenkracht maar op papier een volledige computer-voor-onderweg. Het concept sloeg niet aan, ondanks verwoede pogingen van grote merken als HP en Sony en Microsoft en Intel zelf om UMPC’s te promoten. “Tergend traag” en “onwerkbaar” waren de oordelen van reviewers. Tien jaar later echter vond GamePad Digital (GPD) het tijd voor een comeback en meer dan 8.000 investeerders waren het er toen mee eens.

Indiegogo en Kickstarter zijn crowfunding websites waar iedereen met een goed idee geld kan ophalen van een brede groep investeerders. Het lukte GPD in 2017 om op die manier 3,3 miljoen euro op te halen voor de realisatie van de GPD Pocket: een kleine laptop met een 7 inch scherm en een Intel Atom x7-Z8750 op 1.6 GHz. Reviewers konden het ontwerp van de behuizing en de stevige bouw waarderen en spraken lovende woorden over de hoeveelheid werkgeheugen en het heldere hoge-resolutiescherm. Minder tevreden waren ze over het layout van het toetsenbord, de hakkelende warmtehuishouding en het ontbreken van een SD-kaart slot. De GPD Pocket meet 180×106×18.5mm in gesloten toestand. Het enthusiasme van de verschillende reviewers voerde echter de boventoon. Verschillende gebruiksscenario’s passeerden de revue, waarbij verrassend genoeg verschillende games uit de Xbox Games Store succesvol werden uitgeprobeerd. De accu behaalde niet de geadverteerde 12 uur of meer, maar met “it’s more like 7 to 8 hours with normal use” maakte het desalniettemin indruk.

Technische specificaties GPD Pocket 7″

In de jaren die volgden op de introductie van de Pocket wist GPD met opvolgende modellen indruk te maken en raakte de Pocket wat in de vergetelijkheid. In meer recente jaren ontdekten vooral Linux fans de Pocket opnieuw. Het hackers-delight Kali Linux heeft een eigen distributie dat nagenoeg alle eigenschappen van de GPD Pocket ondersteunt. Gecombineerd met de vele uitbreidingspoorten en de ingebouwde wifi en Bluetooth 4.1 vormt de Pocket een onweerstaanbare combinatie voor een ultradraagbare pen test uitrusting.

Ik heb een gebruikte GPD Pocket “used with possible scratches en signs of wear” gekocht van eBay, voor een schappelijke prijs, inclusief verzending, uit Japan. Ik verwachte er niet veel van, hoewel de foto’s een keurig apparaat lieten zien. Bij de verzendopties stond dat er binnen 10 dagen verzonden zou worden en dat de verzending zelf tot anderhalve maand in beslag kon nemen. En hoedt u voor invoerrechten! Hoe groot was mijn verbazing toen ik drie dagen later een FedEx doosje aangeboden kreeg, met een hierin zo goed als nieuwe GPD Pocket, verpakt in de originele doos. Met een Windows besturingssysteem in het Japans, dat dan weer wel. Om een indruk te krijgen van de gebruiksmogelijkheden heb ik Ubuntu Linux geïnstalleerd, ben weer teruggegaan naar de voorgeïnstalleerde Windows 10 en vervolgens Kali Linux uitgeprobeerd.

Pocket met Ubuntu Mate Linux

Voor Ubuntu heb ik gebruik gemaakt van Ubuntu Mate, die een speciaal voor de GPD Pocket ontwikkelde distributie heeft, aanbevolen door GPD zelf. De door mij gedownloade versie was ubuntu-mate-20.04.1-desktop-amd64-gpd-pocket.iso, die met een programma zoals balenaEtcher of Raspberry Pi Imager op een 4 GB USB geheugenstick geschreven kan worden. De GPD Pocket kan van USB opstarten, door in het Bios (Del ingedrukt houden bij het opstarten) de opstartvolgorde te veranderen. Ubuntu Mate start eerst volledig werkend vanaf de USB stick op, en er is een optie om de 128 GB ingebouwde schijf ofwel op te splitsen in een Windowsdeel en een Linux deel, of alle bestaande partities te wissen en er één gehele Lunux schijf van te maken. De installer kan de Windows partitie verkleinen en op het vrijkomende deel een nieuwe partitie maken. Ik heb beide opties geprobeerd en beide werken prima (hoewel het booten van Windows of Linux dan wel het snelst gaat door de bootvolgorde in het bios aan te passen). De installatie van Ubuntu Mate neemt een uurtje in beslag en is dan weer helemaal bijgewerkt en functioneert dan als een zonnetje. Op het kleine scherm waren me de letters standaard net wat te klein, maar door de fontgroottes zo her en der op te krikken werd het geheel comfortabel leesbaar. 

Pocket met Windows 10

Bij de tweede keer installeren van Linux koos ik voor het geheel wissen van het ingebouwde 128 GB opslaggeheugen. Ik kneep ‘m een beetje, maar terug naar de oorspronkelijke Windows (Home) versie op de GPD Pocket bleek ook eenvoudig, hoewel het installeren van Windows tot het moment dat je door de laatste updates heen bent meer tijd kost dan bij Linux het geval is. Ik heb de GPD aanbevolen versie GPD Pocket--firmware of Windows OS（20170526）.rar gedownload via de link op hun website. Die link verwees naar een bestand op het Mega fileshareplatform, me dunkt niemands favoriet. Na een kleine 8 uur was de download gereed en kon ik een USB geheugenstick klaarmaken. De instructies zijn, om een USB stick van 32 GB als NTFS onder Windows te formatteren (dat had ik dan gelijk even moeten doen toen er nog geen Linux op de Pocket stond) en deze WINPE te noemen. Vervolgens de .raruitpakken met The Unarchiver (macOS) of 7zip (macOS, Windows). Er ontstaat een directory GPD Pocket OS 升级文件及说明（20170526） met een subdirectory genaamd WINPE. De bestanden in de subdirectory verplaatsen naar de root van de USB stick. Je kunt nu opstarten vanaf de USB stick, die geheel automatisch je 128 GB opslag partitioneert, leegmaakt en er vervolgens Windows 10 op installeert. Bye Ubuntu. Uiteraard vraagt Windows na een keer of wat opnieuw opstarten om een Activatiecode en uiteraard had de verkoper van de Pocket foto’s van de doos op eBay gezet met de activatiecode voor iedereen zichtbaar zodat deze activatiecode – uiteraard – niet meer door Microsoft werd geaccepteerd. De in de haast op Marktplaats aangekochte Windows licentie bleek een Windows 10 Pro in plaats van Home, zodat de Pocket nog wat extra Windows bestanden moest downloaden. Hierna was de Pocket echter weer volledig functioneel en viel er heel aardig mee te werken. Alles reageert vlot en voorspelbaar, iets minder vlot dan je van bijvoorbeeld een 2023 MacBook Pro M2 gewend zou kunnen zijn, maar alleszins werkbaar en ik zou er denk ik geen moeite mee hebben om er (met een aangesloten draadloze toetsenbord en muis) een dag mee te moeten werken, of er bijvoorbeeld in de trein wat artikelen mee te schrijven. YouTube video’s doen het opperbest.

Pocket met Kali Linux

Kali Linux is een Linux distributie specifiek bedoeld als pen test tool suite. Het wordt uitgegeven en onderhouden door Offensive Security (‘OffSec’), een Amerikaans internationaal bedrijf dat zich bezighoudt met informatiebeveiliging, pen testen en digitaal forensisch onderzoek. Het bedrijf, actief vanaf ongeveer 2007, creëerde open source-projecten, geavanceerde beveiligingscursussen, de ExploitDB-kwetsbaarheidsdatabase en de Kali Linux-distributie. Specifiek voor de GPD Pocket ontwikkelde Re4son een Kali installatie. Kali Linux is niet een handig besturingssysteem als je verder ook nog iets met je computer wilt doen. Veel van de ‘normale’ dingen die je met je besturingssysteem wilt doen, zijn bij Kali Linux uitgeschakeld of op een alternatieve manier ingericht. Zo heb je standaard geen verbinding met het internet; niet handig als je even wat wilt doen. Wat Kali Linux wél heeft, zijn diverse tools om pen testen mee uit te voeren, en daar een heleboel van. Het leek me daarom handig om Kali Linux vanaf een USB stick op te starten. Wordt het allemaal niet sneller van natuurlijk. Ik heb de Gnome desktop versie kali-linux-pocket-20180513.iso van Re4son gedownload en met balenaEtcher op een USB stick geschreven. Van de USB stick opstarten door in het Bios (Del ingedrukt houden bij het opstarten) de opstartvolgorde te veranderen. Kali Linux start volledig werkend in de modus Live Forensic, maar bewaren op schijf kan alleen door het resterende deel van de USB stick geschikt te maken voor schrijfdoeleinden,

Het updaten van de wat gedateerde kernel voor de GPD Pocket levert in eerste instantie problemen op, die te fixen zijn met het volgende commando:

$ wget -q -O - http://archive.kali.org/archive-key.asc | apt-key add
$ sudo apt update 
$ sudo apt upgrade

Veel van de Kali tools zijn overigens ook prima onder andere Linux distributies te gebruiken. Onder Ubuntu bijvoorbeeld. Omdat er zo veel tools beschikbaar zijn onder Kali Linux is iets van een hulpje hier wel nodig. Een handig tool voor de selectie van Kali Linux tools is Katoolin, hoewel daar het één en ander op valt af te dingen.

Kali Linux installeren ván een USB drive óp een USB drive

De Kali Linux distributie van Re4son heeft als nadeel dat er sindsdien fors wat wijzigingen zijn geweest in de kernel en dat deze niet meekomen met de oudere distributie. Recentelijk heeft Gabe van Bit Driftingeen poging gepubliceerd om een standaard versie van Kali Linux te installeren op de GPD Pocket en dat lijkt te werken. Abraham van Foss Linux kwam al eens met een ‘van USB naar USB’ installatieprocedure, waarbij je Kali Linux opstart van de ene USB drive en installeert op een andere. Klinkt als een moeite-waard-experimentje:

• Installeer Kali Linux op een USB stick
• Start op van de USB stick
• Start het Kali Linux installatieprogramma
• Installeer Kali Linux op een tweede USB stick
• Start nu op vanaf de tweede USB stick en rond de configuratie af

YouTube reviews

• GPD Pocket 7″ Windows Laptop Review (MobileTechReview)
• The GPD Pocket Review (Handheld Computing)
• They Don’t Come Smaller Than This! (TechTablets)
• Can you game on this? (iBertz)

Externe links

• Indiegogo campagne van de GPD Pocket (indiegogo.com)
• GPD Pocket (GPD.hk)
• Service & Support (downloadpagina GPD Pocket op GPD.hk)
• Linux on the GPD Pocket: The Return of the Hacker Netbook (Medium.com)
• Kali Linux on your Pocket with the GPD 7 mini-laptop (Medium.com)
• Kali Linux on the GPD Pocket (Re4son)
• Running Kali 2020.3 on an original GPD Pocket (Bit Drifting)
• How to install complete Kali Linux on USB drive (Foss Linux)
• Adding persistence to Kali Linux Live USB drive (Kali Linux)
• Invalid signature when trying to apt-get update on Kali
• GPD Pocket (Gentoo Linux)
• Ubuntu MATE for Ultra Mobile PCs (Ubunto MATE)
• GPD Pocket (Arch Linux)
• Installing Debian On GPD Pocket (Debian Linux)
• GPD Pocket 7: Impressions, Gnu/Linux Installation And Offensive Setup (EvilSocket)

Zo af en toe gebruik ik een digitale projector (‘beamer’) om thuis een film, game of een fotoserie te tonen. Ik heb er eentje (Optoma ML500) die het prima doet en ik vraag me af wat de opvolgers (Optoma ML750e en Optoma ML1050ST) nog voor extra’s te bieden hebben.

De Optoma ML500 is een kleine projector die wat afmetingen betreft op een A4’tje past. Het heeft een ingebouwde voeding en komt in een handig tasje. De lichtopbrengst is voldoende voor een niet te lichte ruimte en de beschikbare ingangen bestrijken zowel de oudere analoge ingangen, als HDMI. Met een resolutie van 1280 x 800 in combinatie met de led-DLP technologie worden mooie beelden getoond. De ingebouwde luidspreker levert een mager, blikkerig geluid. Handig is, dat de led op ECO-stand kan branden, waardoor de ventilator op een acceptabel volume kan draaien.

Als je dacht dat een ML500 klein was, heb je de ML750e nog niet gezien. Deze projector past in de palm van je hand en is minder dan de helft zo groot als de toch al kleine ML500. De lichtopbrengst is anderhalf keer zo veel. Er is geen ECO-stand, maar de ventilator is iets stiller dan de ML500. Het geluid van de ingebouwde luidspreker is bijkans nog slechter dan bij de ML500. De analoge ingangen zijn komen te vervallen, maar er is een ingewikkelde universeelpoort. De ingebouwde voeding van de ML500 heeft plaatsgemaakt voor een externe DC-voeding. Het handige tasje is gebleven.

Ten opzichte van de ML750e is de ML1050ST op veel fronten vergelijkbaar: zelfde grootte, losse netvoeding, zelfde resolutie, zelfde gewicht. Toch zijn er verschillen: de ML1050ST heeft een andere lens die maakt dat de projectieafstand voor dezelfde beelddiagonaal als de ML750e zowat de helft is geworden: handig in kleinere ruimtes. De ‘ST’ in het typenummer staat dan ook voor ‘Short Throw’. Het zorgt ook voor meer licht, want kleinere afstand tot het projectieoppervlakte. En ander opvallend verschil is de ingebouwde ventilator, die bij de ML1050ST merkbaar stiller is. De ML1050ST heeft ook autofocus. Het handige tasje is er nog steeds.

1. Chicony A11-065N1A. Input 100-240V AC 4.4A 50/60Hz. Output 19V DC 3.42A. Connecterformaat 5.5mm x 1.7mm, positief centrum. ↩︎

Led-matrix displays zijn handig in het gebruik van apparaten waar je op prominente wijze wat informatie op wilt tonen. Ik gebruik bijvoorbeeld vier 8×8 led matrix displays met een Max7219 die tot 32×8 zijn gecombineerd voor een klein display voor tijdweergave en stroomverbruik gedurende de dag. De displays verbinden onderling en aan de microcontroller via drie draden en vereisen een enkelvoudige 5V voedingsspanning. Bij het researchen naar een handig lettertype voor het 32×8 display kwam ik een fascinerende led-zandloper van David Projectos op Instagram tegen. De animatie van de ‘zandkorrels’ deden me haast magisch aan en mijn vingers jeukten om dat zelf te programmeren.

David liet in zijn Instagram zien, dat hij de zandlopers had gemaakt met 8×8 led matrix displays en ‘een Arduino’. Nog wat zoektijd later kwam ik de website van AdaFruit tegen, bekend van hun open source elektronicaprojecten, die met dezelfde Max7219-gebaseerde 8×8 displays een eigen variant van de led matrix zandloper hadden gemaakt. AdaFruit had hun hele project als open source hardware en software gepubliceerd, maar de Arduino code, met vele bibliotheken en onnavolgbare afslagen, maakten me niet direct enthousiast. Het viel alleen te compileren als je alle Adafruit bibliotheken gebruikte en de code zelf was grotendeels weggeborgen. En laten we wel wezen: ik was naar dit project gekomen om zélf software te schrijven, niet om die van Adafruit gebruiken.

Om aan het programmeren te raken heb ik eerst een kunststof zandloperbehuizing gemaakt, afgedrukt met mijn Dremel 3D45 en ‘goudkleurige’ PLA aan de hand van de .STL bestanden van AdaFruit op Thingiverse. Het voorpaneel had nog geen uur nodig om te printen zodat ik gelijk daarna mijn eigen matrixdisplays kon uitproberen: ze pasten! De zandloper heeft veel verschillende onderdelen, die allemaal op een ingenieuze wijze in elkaar klikken, daarom op een lik superlijm voor de basisbehuizing op de voet en het vastzetten van beide 8×8 displays na geen extra gereedschap of montage nodig.

Ik besloot gebruik te maken van een Wemos D1mini met ESP8266, te programmeren met een nieuw tooltje genaamd ESPHome dat Arduino/Processing ondersteunt. ESPHome heeft als bijzondere eigenschap het via WiFi programmeren van de ESP8266, hetgeen een uitkomst is als je met een prototype bezig bent. De ESP8266 maakt via drie draden verbinding met het matrixdisplay en de kleine print van de D1mini die ik hiervoor gebruikte was gemakkelijk weg te bergen in de behuizing van de zandloper.

Het aansluiten van de led matrix displays ging eenvoudig, en ik had er net veel ervaring mee opgedaan bij het maken van het bovengenoemde 32×8 tijdweergavedisplay, dus na een paar minuten solderen en 24 uur 3D-printen later kon ik aan de slag met de animatie van de zandloper. Na het bepalen van een coordinatenstelsel ging de eerste pixels aan- en uitzetten eenvoudig genoeg, maar ik realiseerde me al snel dat het animeren een ding zou gaan worden. Ik wendde me tot mijn beste animatiegereedschap om een ontwerp te maken van realistisch ‘bewegende’ zandkorrels: Microsoft PowerPoint.

Ik had besloten dat ik iedere zandkorrel zou uitprogrammeren. Er passen 64 pixels op ieder display en ik had bedacht, dat het bovenste display 59 pixels aan had staan die één voor één via een overtuigende valbeweging naar het onderste display zouden vallen, iedere seconde één. Het kostte me wat tijd, voor ik een algoritme had ontdekt die een redelijk natuurlijke animatie van de vallende zandkorrels zou realiseren, zonder dat ik hiervoor formules van zwaartekracht of golfbewegingen zou moeten implementeren. Ik heb de eerste frames uitgetekend in PowerPoint en de x en y posities van de meest recente zandkorrel in een tabel gezet om te zien, of ik hier een patroon in kon ontdekken.

Met een patroon in de hand heb ik vervolgens gekeken of ik een vallende zandkorrel (de blauwe pixel) op de al aanwezige zandkorrels (de rode) zou kunnen laten vallen en de vallende zandkorrel (oranje) dan naar de plek zou kunnen animeren. Hier leek een elegant algoritme voor mogelijk.

In het kort zijn er drie situaties te onderkennen: de vallende zandkorrel, de bewegende zandkorrel en de positie waar de zandkorrel op moet landen. De positie van een zandkorrel wordt gerepresenteerd door zijn coordinaten (x,y). Het coordinatenstelsel valt in het bereik (0,0)-(15,7). Afgeleiden van de coordinaten zijn de val_pos (y-coordinaat), de laag en de korrels_op_laag.

De functionaliteit is de volgende geworden:

• Iedere seconde ‘valt’, in de seconde voorafgaande aan de seconde, een zandkorrel (led) van de voorraad op het bovenste display op de hoop zandkorrels in het onderste display. Een zandkorrel verdwijnt van de voorraad en animeert:
  • Eerst als een vallende zandkorrel totdat de stapel is bereikt
  • Dan links of rechts van de stapel afhankelijk van een even of oneven seconde
  • De zandkorrel blijft oplichten op de plek waar deze hoort
• De laatste seconde (59) worden de verstreken seconden weer omhoog gezogen
• Het is ook mogelijk om een tijd in decimalen te tonen

Ik moet zeggen dat ik blij verrast was met de relatief natuurlijke manier waarop de zandkorrels lijken te vallen en over de stapel lijken te rollen naar hun plek. Ik kan de lusjes en condities dromen en herken hoe de zandkorrels links of rechts vallen. Maar toch, mooi eindresultaat.

Het volledige programma in ESPHome configuratie met Arduino programmcode erin verwerkt ziet er als volgt uit:

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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

# Goudkleurige full-scale zandloper met twee 8x8 matrix displays
 
esphome:
  name: esphome-web-9fc5fd
 
esp8266:
  board: d1_mini
 
logger:
  level: info
 
api:
 
ota:
 
wifi:
  ssid: !secret wifi_ssid
  password: !secret wifi_password
 
  ap:
    ssid: "Esphome-Web-9Fc5Fd"
    password: !secret wifi_ap_password
 
captive_portal:
 
spi:
  clk_pin: D0
  mosi_pin: D1
 
font:
    # Nette 3x6 font voor kleine teksten en getallen
  - file: "fonts/uncle_lee3x6.ttf"
    id: uncle_lee_font
    size: 11
    glyphs: '0123456789'
 
time:
  - platform: sntp
    id: rtctime
 
switch:
  - platform: template
    name: "Zandloper Toon Tijd"
    id: toon_tijd
    optimistic: true
 
display:
  - platform: max7219digit
    id: zandloperdisplay
    cs_pin: D2
    num_chips: 2
    intensity: 1
    update_interval: 30ms
    lambda: >
      int MAX_X = 15;
      int MAX_Y = 7;
 
      static int vorige_seconde = 0;
      static int val_pos = 0;
      static int vul_aantal = 0;
      int korrel, korrels, laag, korrels_op_laag, volgende_korrels;
      int resterende_korrels_op_laag, resterend_volume;
      int huidige_seconde = id(rtctime).now().second;
 
      if (!id(toon_tijd).state) {
        korrels = vorige_seconde;
        laag = sqrt(korrels);
        korrels_op_laag = korrels - (laag * laag);
 
        volgende_korrels = huidige_seconde;
        resterend_volume = sqrt(volgende_korrels + 4);
        resterende_korrels_op_laag = volgende_korrels + 4 - (resterend_volume * resterend_volume);
 
        it.filled_rectangle(0, 0, 8, 8, COLOR_ON);
        it.filled_rectangle(0, 0, resterend_volume, resterend_volume, COLOR_OFF);
        it.line(resterend_volume, 0, resterend_volume, resterende_korrels_op_laag / 2, COLOR_OFF);
        if (resterende_korrels_op_laag % 2 != 0) {
          it.line(0, resterend_volume, resterende_korrels_op_laag / 2, resterend_volume, COLOR_OFF);
        } else {
          if (resterende_korrels_op_laag / 2 > 0) {
            it.line(0, resterend_volume, resterende_korrels_op_laag / 2 - 1, resterend_volume, COLOR_OFF);
          }
        }
 
        if (huidige_seconde != vorige_seconde) {
          if (huidige_seconde == 0) {
            if (vul_aantal < 60) {
              vul_aantal += 6;
              int aantal_korrels = 60 - vul_aantal;
              resterend_volume = sqrt(aantal_korrels + 4);
              resterende_korrels_op_laag = aantal_korrels + 4 - (resterend_volume * resterend_volume);
              it.filled_rectangle(0, 0, 8, 8, COLOR_ON);
              it.filled_rectangle(0, 0, resterend_volume, resterend_volume, COLOR_OFF);
              it.line(resterend_volume, 0, resterend_volume, resterende_korrels_op_laag / 2, COLOR_OFF);
              if (resterende_korrels_op_laag % 2 != 0) {
                it.line(0, resterend_volume, resterende_korrels_op_laag / 2, resterend_volume, COLOR_OFF);
              } else {
                if (resterende_korrels_op_laag / 2 > 0) {
                  it.line(0, resterend_volume, resterende_korrels_op_laag / 2 - 1, resterend_volume, COLOR_OFF);
                }
              }
              resterend_volume = sqrt(aantal_korrels);
              it.filled_rectangle(MAX_X - resterend_volume + 1,MAX_Y - resterend_volume + 1, resterend_volume, resterend_volume);
 
            } else {
              vul_aantal = 0;
              vorige_seconde = huidige_seconde;
            }
 
          } else {
            if (val_pos < (8 - laag)) {
              it.draw_pixel_at(8 + val_pos, val_pos);
            } else {
              if (korrels_op_laag % 2 == 0) {
                it.draw_pixel_at(8 + val_pos, MAX_Y - laag);
              } else {
                it.draw_pixel_at(MAX_X - laag,  val_pos);
              }
            }
            val_pos += 1;
            if (val_pos >= (7 - (korrels_op_laag / 2))) {
              vorige_seconde = huidige_seconde;
              val_pos = 0;
            }
          }
        }
 
        if (huidige_seconde != 0) {
          it.filled_rectangle(MAX_X - laag + 1,MAX_Y - laag + 1, laag, laag);
          for (korrel = 0; korrel < korrels_op_laag; korrel++) {
            if (korrel % 2 == 0) {
              it.draw_pixel_at(MAX_X - (korrel / 2), MAX_Y - laag);
            } else {
              it.draw_pixel_at(MAX_X - laag, MAX_Y - (korrel / 2));
            }
          }
        }
      } else {
        it.printf(0, 4, id(uncle_lee_font), COLOR_ON, TextAlign::CENTER_LEFT, "%02u", id(rtctime).now().hour);
        it.printf(8, 4, id(uncle_lee_font), COLOR_ON, TextAlign::CENTER_LEFT, "%02u", id(rtctime).now().minute);
      }

Het is niet overdreven om te stellen dat je in 2022 prima elektronische prototypes van fancy gadgets in een paar uur kunt realiseren en zo is ook dit leuke apparaatje ontstaan. Uitgerust met vier 8×8 led matrix modules die in serie verbonden zijn met een Wemos D1mini, een leuke 3D geprinte behuizing en wat handige ESPhome-gebaseerde software is dit 32×8 led matrix display een toonbeeld van neo-traditionele functionaliteit.

Het is geen geheim dat ik sinds het uitkomen van de eerste rode 5mm led in 1975 gefascineerd ben door de vele toepassingsmogelijkheden ervan. Rode dot-matrix displays zijn daarom al tientallen jaren geen nieuws meer voor me, maar daar zelf even iets mee knutselen heeft nog nooit iets aan aantrekkingskracht ingeboet. Ik heb een speciale projectdoos met allerlei in de loop der jaren verzamelde leds, led displays en op leds gebaseerde halfproducten, waaronder een voorraadje MAX7219 8*8 Dot Matrix LED Display Modules. Dit zijn kleine (3,2 x 3,2cm) modules met 8×8 leds, die worden aangestuurd door een speciaal IC genaamd MAX7219. Dit IC wordt zelf weer aangestuurd door een microprocessor of microcontroller.

Het project bestaat uit de volgende onderdelen:

• Vier 8×8 led matrix modules met MAX7219 driver
• Een Wemos D1mini met ESP32 microcontroller
• Een 3D geprinte behuizing
• Een USB chassisdeel voor de stroomverzorging van D1mini en led displays
• Software in ESPhome

De software is als volgt geworden:

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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168

# MAX7219 matrix clock 4 x 64 pixels
# ORANJE / GRIJS
 
esphome:
  name: esphome-web-180e68
 
esp8266:
  board: d1_mini
  restore_from_flash: true
 
# 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: "Esphome-Web-180E68"
    password: !secret wifi_ap_password
 
captive_portal:
 
globals:
  - id: shpm_internal
    type: float
    restore_value: yes
    initial_value: "0.0000"
 
sensor:
  - platform: homeassistant
    name: "Passanten"
    id: passanten
    entity_id: counter.passanten_voorzijde
    accuracy_decimals: 0
    internal: true
  - platform: homeassistant
    name: "Gas verbruikt totaal"
    id: gas_totaal
    entity_id: sensor.totaal_gasconsumptie
    internal: true
    accuracy_decimals: 3
    unit_of_measurement: "m³"
  - platform: homeassistant
    name: "Gas verbruikt vandaag"
    id: gas_vandaag
    entity_id: sensor.daily_gas_usage
    internal: true
    accuracy_decimals: 3
    unit_of_measurement: "m³"
  - platform: homeassistant
    name: "Zonnecellen energieproductie"
    id: zonnecellen_productie
    entity_id: sensor.huidige_elektriciteitsproductie
    internal: true
    accuracy_decimals: 3
  - platform: homeassistant
    name: "Net energieconsumptie"
    id: afname_energienet
    entity_id: sensor.huidige_elektriciteitsconsumptie
    internal: true
    accuracy_decimals: 3
  - platform: template
    name: "Netto productie"
    id: netto_productie
    internal: true
    accuracy_decimals: 3
    lambda: |-
      if (id(zonnecellen_productie).state > 0) {
        return id(zonnecellen_productie).state;
      } else {
        return 0 - id(afname_energienet).state;
      }
  - platform: homeassistant
    name: "SolarEdge productie"
    id: solaredge_productie
    entity_id: sensor.solaredge_current_power
    internal: true
    accuracy_decimals: 4
  - platform: homeassistant
    name: "SolarEdge productie vandaag"
    id: solaredge_productie_vandaag
    entity_id: sensor.solaredge_energy_today
    internal: true
    accuracy_decimals: 2
  - platform: homeassistant
    name: "Dremel 3D45 Print Voortgang"
    id: dremel_3d45_progress
    entity_id: sensor.dremel_3d45_progress
    internal: true
    accuracy_decimals: 1
    unit_of_measurement: "%"
  - platform: template
    name: "SolarEdge Historical Maximum Power Output"
    id: solaredge_historical_power_max
    unit_of_measurement: "W"
    accuracy_decimals: 4
    lambda: |-
      if (id(solaredge_productie).state > id(shpm_internal)) {
        id(shpm_internal) = id(solaredge_productie).state;
      }
      return id(shpm_internal);
  - platform: homeassistant
    name: "Gaskosten vandaag"
    id: kosten_gas_vandaag
    entity_id: sensor.gasverbruikskosten_vandaag
    unit_of_measurement: "€"
    accuracy_decimals: 2
    internal: true
  - platform: homeassistant
    name: "Dremel 3D45 Resterend"
    id: dremel_3d45_resterend
    entity_id: sensor.dremel_3d45_remaining_print_time_human_readable
    internal: true
 
# https://www.energievergelijk.nl/energieprijzen
 
spi:
  clk_pin: D0
  mosi_pin: D1
 
# pixelmix.ttf toont prima in 6 punten, maar enkele cijfers vertonen 'gaten', 8 punten is 'native'
# monobit.ttf werkt niet bij 6 punten
# slkscr.ttf toont okee bij 8 punten maar heeft een rare horizontale spatiëring
 
font:
    # Mooie volle letters voor klokweergave
  - file: "fonts/eight-bit-dragon.ttf"
    id: dragon_font
    size: 8
    glyphs: '.,:0123456789abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ'
    # Nette 3x6 font voor kleine teksten en getallen
  - file: "fonts/uncle_lee3x6.ttf"
    id: uncle_lee_font
    size: 11
    glyphs: '€-.,:%0123456789abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ'
    # Nette 3x6 font voor kleine teksten en getallen
  - file: "fonts/Toy.ttf"
    id: toy_font
    size: 16
    glyphs: '€-.,:0123456789abcdefghijklmnopqrstuvwxyz'
 
time:
  - platform: sntp
    id: ntptime
 
display:
  - platform: max7219digit
    id: multidisplay
    cs_pin: D2
    num_chips: 4
    intensity: 5
    update_interval: 500ms
    lambda: |-
      //it.strftime(16, 4, id(dragon_font), TextAlign::CENTER, "%H:%M", id(ntptime).now());
      //it.printf(33, 4, id(uncle_lee_font), TextAlign::CENTER_RIGHT, "%.1f W", id(solaredge_productie).state);
      it.printf(33, 4, id(uncle_lee_font), TextAlign::CENTER_RIGHT, "%.1f kWh", id(solaredge_productie_vandaag).state);
      // it.printf(33, 2, id(toy_font), TextAlign::CENTER_RIGHT, "€%.2f", id(kosten_gas_vandaag).state);
      //it.printf(33, 4, id(uncle_lee_font), TextAlign::CENTER_RIGHT, "3D %.1f%%",  id(dremel_3d45_progress).state);
      //it.printf(it.get_width(), 4, id(uncle_lee_font), TextAlign::CENTER_RIGHT, "%s", id(dremel_3d45_resterend).state);

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.

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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

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.

De YAML code voor dit dashboard is als volgt:

1
2
3
4
5
6
7
8
9
10
11

type: vertical-stack
cards:
  - type: glance
    entities:
      - entity: sensor.radiation_level
      - entity: binary_sensor.radiation_warning
      - entity: sensor.geiger_counter
  - type: history-graph
    entities:
      - entity: sensor.radiation_level
    hours_to_show: 48

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:

1
2
3
4
5
6
7
8
9

- type: gauge
  entity: sensor.radiation_level
  needle: true
  name: Straling
  max: 1.6
  severity:
    green: 0
    yellow: 0.32
    red: 0.8

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.

Toevoeging aan de ESPhome sensor:

sensor:
  - platform: pulse_counter
    pin: ..
    ...
    total:
      name: 'Total Counts'

Home Assistant configuratiebestand:

1
2
3
4

# 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:

• 8×32 pixel WS2812 led matrix (256 kleurenleds)
• Wemos D1 mini ESP8266 microcontroller
• 5 volt netvoeding die tenminste anderhalf ampère kan leveren
• Paar stukjes montagedraad, soldeerbout
• (optie) diffuserframe 3D printen of met stripjes visitekaartjespapier maken
• (optie) restjes MDF of foamboard voor de behuizing
• (optie) houtlijm of plakband
• (optie) stukje wit acrylglas, plexiglas of laagjes restanten verpakkingsmateriaal voor het voorpaneel

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:

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

light:
  - platform: neopixelbus
    variant: WS2812
    pin: GPIO4
    num_leds: 256
    type: GRB
    name: led_matrix
    id: led_light_32x8
 
display:
  - platform: addressable_light
    id: led_matrix_display
    addressable_light_id: led_light_32x8
    width: 32
    height: 8
    update_interval: 45ms
    pixel_mapper: |-
        if (y % 2 == 0) {
          return (y * 32) + x;
        }
        return (y * 32) + (31 - x);

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’:

1
2
3
4
5
6
7
8
9
10
11
12
13

font:
  - id: pixel_font
    file: "fonts/pixelmix.ttf"
    size: 8
 
time:
  - platform: sntp
    id: rtctime
 
display:
    ...
    lambda: |-
        it.strftime(16, 4, id(pixel_font), Color(0xFFFFFF), TextAlign::CENTER, "%H:%M", id(rtctime).now());

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.

We zijn helemaal gewend om soms even te moeten wachten voor we gebruik kunnen maken van voorzieningen als verlichting, verwarming, inkjetprinters en kooktoestellen. Fabrikanten van dit soort apparaten proberen ons leven gemakkelijker te maken door automatische aan- en uitschakeling, of het toevoegen van een sluimerstand. Het nadeel hiervan is dat sommige apparaten continue stroom en/of gas verbruiken, soms voor een minimale toename aan comfort. Een mooi voorbeeld hiervan is de comfortstand van een centrale verwarmingsinstallatie. Bijna ieder huis in Nederland heeft er eentje en de meeste ervan hebben een ‘gratis’ comfortstand (die soms altijd aan staat en dan de ecostand heet). Deze stand zorgt voor sneller warm tapwater, ten koste van een hoop gas, elektriciteit en levensduur van de CV-installatie.

CV-installaties zonder boiler leveren, naast de verwarming van de radiatoren, warm tapwater. Op het moment dat er warm water wordt gevraagd dan springt de installatie aan, stopt de productie van warmte voor de radiatoren en wordt er, na enige tijd, warm water op het tappunt geleverd. Dat kan een paar seconden duren, of, als de afstand tussen de CV en het tappunt erg groot is, soms wel een minuut. In de zomer, als de installatie niet voor de verwarming van radiatoren wordt gebruikt, komt daar nog de opwarmtijd van het apparaat bij: de koude aluminium onderdelen moeten eerst opgewarmd worden en dat duurt ook enkele seconden. Hiervoor is de comfortstand bedacht, die ervoor zorgt dat de verwarmende onderdelen altijd op een bepaalde temperatuur (vaak 50 graden of hoger) blijven. Je merkt dat de comfortstand van je CV-installatie is ingeschakeld omdat het toestel dan een paar keer per uur even ontsteekt, zonder dat er warm water wordt gevraagd. Ook ’s nachts en als je op vakantie bent.

Is dat handig, zo’n comfortstand? Ik heb zelf een warmwater tappunt naast de CV-installatie, ideaal voor een experiment. In mijn situatie scheelt het in de zomer, als de installatie zelf ongeveer 20 graden is, net geen 2 seconden tussen het leveren van handwarm water zonder en met de comfortstand: ongeveer 5 in plaats van ongeveer 3 seconden voor het warm water bij de kraan op temperatuur is. Een nauwelijk merkbaar verschil die de extra kosten wat mij betreft niet rechtvaardigt. Voor de verschillende merken CV-installaties gaat het uitzetten van de comfortstand natuurlijk allemaal op een andere manier. Soms heet het de Comfort modus, en soms heet het de Eco stand (die je dan ‘aan’ zet om de comfort modus te verlaten). Hieronder verzamelde instructies voor wat bekende merken (de naam van het toestel bevat een link naar de handleiding ervan):

• Remeha Calenta Ace: stel parameter DP200 in op ‘0’ of volg de gebruikershandleiding voor meer verfijning in de instellingen
• Remeha Calenta: stel parameter P4 in op ‘0’
• Vaillant EcoTEC: Kies het ‘kraan’ menu, kies Comfortstand, kies Uit
• Remeha Avanta (dank aan familie Kleinman): Druk de Enter toets in, kies P4, kies “1”, druk op Enter, druk op R
• Nefit Trendline: Kies het menu Warmwaterbedrijf en verander de instelling in Eco

Als je de Eco stand hebt aangezet, of de Comfort stand op uit, vraag je je af waarom:

• Als ik vaak warm water gebruik in de zomer, en ik wil niet langer wachten, kan ik dan niet beter de comfortstand aan laten staan?
  Als je vaak warm water gebruikt dan zal de CV niet volledig afkoelen tot je weer warm water gebruikt. Een comfortstand heeft dan geen meerwaarde en je kunt deze dan beter uitzetten voor de momenten dat je helemaal geen warm water gebruikt, zoals ’s nachts.
• Wat levert het me op dan, de comfortstand uitzetten? Niet zo veel denk ik?
  Als je wat aannames doet over de lengte van de zomer en het gebruik van je CV-installatie voor warm-water dan kom je ongeveer op 20.000 ontstekingen en korte opwarmingen in de zomermaanden. Natuurlijk is dat veel minder als je veel en vaak warm water tapt.
• Maakt het in de winter verschil of ik de comfortstand gebruik of niet?
  In de winter slaat de CV-installatie toch al vaker aan en blijft het apparaat al op temperatuur. Een comfortstand heeft hier dan weinig invloed en kan dan beter uitgeschakeld worden zodat de installatie ook ’s nachts uit blijft.
• Maar kost dat niet veel meer energie dan, als het toestel eerst helemaal opgewarmd moet worden?
  Ja, dat wel. De opwarming vanaf 20 graden kost meer energie dan de opwarming vanaf (circa) 50 graden, waar de comfortstand het toestel op houdt. Maar niet heel veel meer energie, gezien de snelle opwarming van het toestel.
• Zou de fabrikant de comfortstand hebben toegevoegd om de levensduur van het apparaat expres te verminderen? Of meer onderdelen te kunnen verkopen? Net als bij de inkjetprinters, die veel dure inkt gebruiken om de inktspuiters schoon te maken?
  Ik denk het niet, de comfortstand heeft echt wel toegevoegde waarde in situaties dat er af en toe warm water wordt gevraagd( zeg eens per uur) en waar de opwarmtijd van belang is (zeg de professionele dienstverlening). Maar voor een gemiddeld huishouden is de comfortstand (of eco-stand) iets waar je even over na wilt denken hoe je dit wilt gebruiken.
• Ga het apparaat niet eerder stuk als het afkoelt naar omgevingstemperatuur, in plaats van dat het op een gezellige 50 graden blijft?
  In zeldzame omstandigheden kan een apparaat beter verwarmd blijven, zoals in een onverwarmde, vochtige omgeving als een kelder, waar de omgevingstemperatuur altijd zo’n beetje rond het dauwpunt hangt. Dan kan een onverwarmd technisch apparaat wellicht last krijgen van condens, hetgeen zich zal uiten in verstoringen en roest. Hangt je CV-installatie in een vochtige kelder waar de vloeren en wanden altijd wat vochtig aanvoelen? Check dan even of het apparaat wel zo vaak gebruik wordt dat het zelf altijd een beetje warm aanvoelt.

Toen ik in maart een Dremel 3D20 3D printer op de kop tikte wist ik nog niet hoe handig het is om een betrouwbare, internetgekoppelde 3D printer altijd als gereedschap in je elektronica-lab te hebben klaarstaan. Na een paar maanden leek het me een goed idee om de 3D20 een permanente opstelling in de kelder te geven, met het filament in een kast eronder. Na eens wat rondgeneusd te hebben om te zien hoe anderen dit oplossen kwam ik toevallig de opvolger van de 3D20, de Dremel DigiLab 3D45 tegen. Deze printer is iets groter en zwaarder, heeft een verwarmde printer-bouwplaat en kan ook flexibele filamenten zoals nylon en rubber aan.

Niet dat het nodig was om een grotere, veel zwaardere printer te hebben om hier een handige opstelling mee te maken en toen ik de 3D45 op de plek van de 3D20 had neergezet wist ik het zeker: hiermoest een speciale verrijdbare kast voor komen.

Ik had nog voldoende restmateriaal liggen van eerdere projecten en het leuke van hout is, dat het in allerlei varianten met elkaar verbonden kan worden. Met wat plaatmateriaal kon ik een kast maken, waarna ik de binnenkant versterkte met diverse vuren planken die ik nog had liggen. Het geheel was een lappendeken van verschillende materialen, maar het eindresultaat was prima. De bovenkant heb ik van verschillende plaatmateriaaldiktes gemaakt, onderling verlijmd.

Ik had bedacht dat de kast er professioneel uit moest komen te zien, iets wat niet zou misstaan in een onderzoekslab waar Dremel de inrichting had verzorgd. De kleuren blauw, grijs en oranje zijn direct afkomstig van de productkleuren van Dremel. Het Idea logo vond ik op het internet, waarna ik er een stencil van maakte. Met een deurtje in de kast en een plank aan de binnenkant was het eindresultaat heel aardig wat me voor ogen stond.