16 November 2026 –
Agelopen jaar geleden kocht ik voor de ontwikkeling van een prototype een 7,8-inch e-inkdisplay van Waveshare. Een bijzonder mooi e-ink paneel met een resolutie van 1872 × 1404 pixels en 16 grijswaarden. Alleen bleek de aansturing destijds behoorlijk lastig. Het display maakt gebruik van een IT8951-controller en de beschikbare voorbeeldsoftware en documentatie hielpen me niet voldoende om er een goed werkende, betrouwbare toepassing mee te maken.
Inmiddels zijn we een jaar verder en vooral de ondersteuning door LLM-tools is flink verbeterd. Ik ben benieuwd of ik met Claude en ChatGPT de aansturing nu wel goed werkend kan krijgen. En als dat lukt, wil ik er meteen iets leuks mee maken: een digitale klok met een combinatie van embedded elektronica, Super Mario en GTA Vice City.
Ik geef mezelf maximaal vijf uur om een werkend model te realiseren. Niet omdat de klok binnen die tijd helemaal af moet zijn, maar omdat ik wil ontdekken hoe ver ik kom en welke eigenaardigheden van e-ink ik onderweg tegenkom.

Waarom ik dit soort projecten leuk vind
Wat ik leuk vind aan dit soort projecten, is dat ik vooraf niet precies weet waar ik uitkom. Ik heb een stuk hardware, een globaal idee en een beperkte hoeveelheid tijd. Vervolgens ga ik experimenteren en kijken wat er mogelijk is. Daarbij komen elektronica, embedded software, Linux, grafische vormgeving en het gebruik van nieuwe technologie samen.
Het hoeft voor mij ook niet direct een volledig uitgewerkt product te worden. Ik vind het vooral interessant om te ontdekken hoe iets werkt, waar de beperkingen zitten en hoe ik die kan omzeilen. Het moment waarop een stuk hardware voor het eerst doet wat ik voor ogen heb, blijft leuk. En met een tijdslimiet van vijf uur moet ik bovendien keuzes maken en voorkomen dat ik te lang blijf hangen in details.
De hardware en de eerste uitdaging
Het display is een Waveshare 7,8-inch e-paperpaneel, type ED078KC2. De aansturing verloopt via een IT8951 Driver HAT (B) en een aparte adapterprint. Als host gebruik ik een Raspberry Pi 400 met Raspberry Pi OS Lite (64-bit). De communicatie tussen de Raspberry Pi en de displaycontroller verloopt via SPI.
De belangrijkste specificaties:
– Waveshare ED078KC2, 7,8 inch
– Resolutie van 1872 × 1404 pixels
– Ondersteuning voor 16 grijswaarden
– IT8951-displaycontroller met SPI-interface
– Raspberry Pi 400 met Raspberry Pi OS Lite
– Software in C en Python


Ik begin met het downloaden en compileren van de IT8951-voorbeeldsoftware van Waveshare. Daar loop ik al snel tegen een probleem aan. De oorspronkelijke code gebruikt op enkele plaatsen 32-bit geheugenadressen, terwijl mijn Raspberry Pi een 64-bit besturingssysteem draait. Met behulp van ChatGPT analyseer ik de code en vervang ik de betreffende pointerconversies door het datatype uintptr_t.
Ook de VCOM-instelling vraagt aandacht. Deze spanning speelt een belangrijke rol bij het aansturen van het e-paperpaneel. Dit is één van de gebieden waar ik eerder tegen aan liep bij het ontwikkelen van een betrouwbaar prototype. De voorbeeldsoftware kan de instelling automatisch wijzigen, maar dat wil ik niet zomaar laten gebeuren. Ik pas de code daarom aan zodat de bestaande waarde wordt uitgelezen zonder deze te overschrijven.
Na het compileren krijg ik de volgende informatie terug:
Panel(W,H) = (1872,1404)
FW Version = .v.0
LUT Version = M841
Huidige VCOM = -2.500 V
IT8951 initialisatie geslaagd
Dat is een goed begin. De controller wordt herkend en de communicatie werkt. Nu wil ik natuurlijk ook beeld zien.
Van een klein plaatje naar een werkende klok
De eerste afbeelding verschijnt slechts als een klein vlakje in de hoek van het display. Niet helemaal de bedoeling, maar het bewijst wel dat de hardware daadwerkelijk reageert. Na wat aanpassingen lukt het om een schermvullende testafbeelding weer te geven.


Voor de klok stap ik over op Python en Pillow. Daarmee kan ik een achtergrondafbeelding laden, de actuele tijd en datum toevoegen en het resultaat omzetten naar een BMP-bestand dat vervolgens via de IT8951-software naar het display wordt gestuurd.
De eerste versies werken, maar de positionering van de cijfers, datum en batterij-indicator is nog niet helemaal goed. Bovendien blijkt dat ik in de achtergrondafbeelding al een datum heb opgenomen, terwijl Python er opnieuw een datum overheen tekent. Ik besluit daarom de achtergronden volledig vrij te houden van dynamische informatie. Tijd, datum en batterij-indicator worden voortaan uitsluitend door Python toegevoegd.

De grenzen van AI
Bij het maken van de achtergronden loop ik nog tegen een andere beperking aan. ChatGPT geeft regelmatig een melding dat de gegenereerde afbeelding mogelijk in strijd is met richtlijnen rondom intellectueel eigendom. Vooral bij ontwerpen die verwijzen naar Super Mario blijkt dat lastig, ook wanneer ik alleen de sfeer van deze games wil gebruiken en niet de originele afbeeldingen wil kopiëren. Na verschillende pogingen besluit ik daarom Claude te gebruiken voor het genereren en aanpassen van de achtergronden. Daarmee lukt het wel om de gewenste combinatie van retro game-elementen en elektronische schakelingen vorm te geven. Een mooi voorbeeld van hoe verschillende AI-tools elkaar bij dit soort projecten kunnen aanvullen.
Super Mario ontmoet embedded elektronica
Voor de eerste achtergrond combineer ik een Super Mario-landschap met een elektronisch schema. Mario, een paddenstoel en de bekende stenen vormen de onderkant van het ontwerp. Daarboven staan verschillende elektronische componenten, waaronder een ESP32 en een Raspberry Pi. In het midden komt een groot digitaal klokdisplay.
Ik experimenteer met verschillende lettertypen en kies uiteindelijk voor een blokkerige variant die goed aansluit bij de pixelachtige Super Mario-stijl. De afbeelding wordt uitgevoerd in grijstinten, passend bij de mogelijkheden van het e-paperpaneel. Dat blijkt verrassend goed te werken. De beperkte kleurweergave versterkt juist de retro-uitstraling.

GTA Vice City met een NE555
Als de Super Mario-versie werkt, wil ik ook een tweede achtergrond maken. Met de introductie van GTA 6 in het achterhoofd, kies ik voor een GTA Vice City-achtige sfeer, met palmbomen, een skyline, een sportwagen en een zonsondergang. Om de combinatie met embedded elektronica te behouden, verwerk ik ook hier een schakeling in het ontwerp.
Het decoratieve schema bevat onder andere een NE555-timer, NAND-poort, potentiometer, LDR, relais en een analoge voltmeter. Ook de voedingsspanning van 3,3 V krijgt een plaatsje. Het is geen schakeling die ik daadwerkelijk wil bouwen, maar een grafisch onderdeel van het ontwerp.
De combinatie van elektronica en de Miami-achtige achtergrond levert een heel andere uitstraling op. Ondanks het ontbreken van kleur blijft de GTA-sfeer goed herkenbaar.

Iedere minuut een andere achtergrond
Nu beide ontwerpen beschikbaar zijn, wil ik ze automatisch laten wisselen. De twee PNG-bestanden worden door Python geladen en op basis van de actuele minuut geselecteerd. Iedere tien seconden wordt de tijd bijgewerkt en iedere minuut wisselt de achtergrond tussen Super Mario en GTA.
De belangrijkste functies van de software zijn:
– Tijdweergave met een update iedere tien seconden
– Automatische achtergrondwisseling iedere minuut
– Dynamische datum en grafische batterij-indicator
– Periodieke volledige schermverversing tegen ghosting
– Automatisch opstarten van de klok bij het inschakelen van de Raspberry Pi
De eigenaardigheden van e-ink
Een van de redenen om deze klok te bouwen, is dat ik meer wil ontdekken over het verversingsgedrag van e-ink. Een e-paperdisplay werkt heel anders dan een LCD of OLED. Het beeld blijft zichtbaar zonder dat het voortdurend opnieuw hoeft te worden aangestuurd, maar het aanpassen van de afbeelding kost relatief veel tijd.
Vooral het verschil tussen gedeeltelijke en volledige verversingen vind ik interessant. Bij herhaaldelijk bijwerken kunnen resten van eerdere afbeeldingen zichtbaar blijven, het zogenaamde ghosting. Een volledige verversing kan dat verminderen, maar duurt langer en is duidelijk zichtbaar.
Ook de weergave van grijswaarden vraagt aandacht. Het paneel ondersteunt 16 niveaus, maar subtiele overgangen en fijne details worden niet altijd weergegeven zoals op een computermonitor. Door iedere tien seconden de klok bij te werken en regelmatig tussen twee verschillende achtergronden te wisselen, kan ik goed onderzoeken hoe het display zich op langere termijn gedraagt.

Gedeeltelijke verversing van het e-inkdisplay
Een interessante eigenschap van de IT8951-controller is dat je het display gedeeltelijk kunt verversen. In plaats van het complete scherm opnieuw op te bouwen, worden alleen de gewijzigde delen bijgewerkt. Voor mijn klok is dat ideaal, omdat alleen de cijfers iedere tien seconden veranderen. De IT8951 ondersteunt verschillende update-modi, waaronder DU (Direct Update) en GC16 voor 16 grijswaarden. Gedeeltelijk verversen is sneller en voorkomt dat het hele scherm telkens knippert. Wel kunnen na meerdere updates restanten van eerdere beelden zichtbaar blijven, het zogenaamde ghosting. Daarom experimenteer ik met een combinatie van gedeeltelijke updates en periodieke volledige schermverversingen.
Wat heeft het experiment opgeleverd?
Binnen mijn tijdsbudget van vijf uur heb ik een werkend model gerealiseerd. Het Waveshare-display wordt aangestuurd door een Raspberry Pi 400, de klok draait in Python en beide achtergronden worden automatisch afgewisseld. Ook het automatisch starten van de software is geregeld, zodat het display zonder aangesloten monitor of toetsenbord als zelfstandige klok kan functioneren.

Wat ik misschien nog wel het interessantst vind, is de rol die ChatGPT bij dit experiment heeft gespeeld. De IT8951-controller is niet eenvoudiger geworden en de beschikbare voorbeeldsoftware is nog steeds behoorlijk technisch. Maar met de huidige LLM-tools kan ik veel sneller bestaande code analyseren, foutmeldingen begrijpen en aanpassingen uitproberen.
Daarbij blijft mijn eigen technische kennis belangrijk. Ik moet nog steeds begrijpen wat ik aanpas, de resultaten controleren en bepalen welke oplossingen bruikbaar zijn. Maar de drempel om met complexere elektronica aan de slag te gaan, wordt wel een stuk lager.
En dat is precies wat ik leuk vind aan dit soort experimenten: een combinatie van bestaande hardware, nieuwe hulpmiddelen en een idee dat gaandeweg vorm krijgt. Uiteindelijk staat er gewoon een werkende klok op tafel, met Super Mario, GTA Vice City en een flinke dosis embedded elektronica.
Voorlopig laat ik hem draaien. Ik ben vooral benieuwd hoe het display zich houdt bij langdurig gebruik en welke mogelijkheden de verschillende update-modi nog bieden.
