-
RSNL Clubkampioenschappen 2024
Na meer dan veertien jaar heb ik eindelijk weer eens een wedstrijd gereden. Het was afwachten wat de overhand zou hebben; de verbetering van de techniek of de veroudering van het gestel 😜. Het bleek het laatste te zijn, want de PRs van toen zijn nu ver buiten bereik gebleken. Ik moest me tevredenstellen met een 01:03.220 op de 500 meter en 02:09.900 op de 1000 meter. Ter vergelijking, dit waren de PRs die ik bij Isis heb gereden:
Afstand Datum PR 300 m 2009-01-14 (Eindhoven) 00:37.920 500 m 2009-02-18 (Eindhoven) 00:57.720 1000 m 2009-02-18 (Eindhoven) 01:58.710 1500 m 2009-02-19 (Eindhoven) 02:57.660 3000 m 2008-03-11 (Thialf) 06:16.750
2023-12-16: Noud aan de start bij de NRW PokalInmiddels heb ik wel opvolging gekregen, want Noud rijdt sinds dit jaar ook fanatiek op de schaats en heeft al een aantal wedstrijden verreden. Met de sprongen die hij dit jaar heeft gemaakt duurt het niet lang voordat hij mijn tijden verpulvert. Ik kijk er nu al naar uit, hij heeft er in ieder geval heel veel plezier in; op naar de laatste wedstrijd van het seizoen!
Datum Wedstrijd 100 meter 300 meter 500 meter 1000 meter 2023-12-09 Förderkreispokal 01:06.870 01:46.330 2023-12-16 NRW pokal (2) 00:22.370 01:44.070 2024-01-07 Super Sprint 00:20.470 00:57.090 2024-02-17 RSNL Clubkampioenschappen 01:31.660 02:56.190 2024-02-24 NRW pokal (3) 00:18.140 00:51.760 Update 25 februari: Tijden NRW pokal (3) toegevoegd.
-
Hoe werkt een mechanisch horloge?
In navolging van mijn vorige post, waarin ik zei dat we onze rol van ontdekkingsreizigers op het wereldwijde web weer moesten herpakken, vond ik een prachtig voorbeeld van zo’n website die er gewoon is om te zijn. De site van Bartosz Ciechanowski bevat niet heel veel artikelen, maar het zijn stuk voor stuk juweeltjes. Met werkende 3D modellen legt hij in jouw eigen webbrowser uiteenlopende principes stap voor stap uit.
Een kleine greep uit het aanbod: Een gedetailleerde omschrijving van de verschillende bewegingen in een mechanisch horloge, van de grote veer tot aan de datumaanwijzer, de kroon en het automatisch opwindmechanisme. Een uiteenzetting van de principes achter het Global Positioning System (GPS), waaruit ook meteen af te leiden is dat zowat elke televisieserie die GPS-signalen beweert te hacken volledige onzin is. Een hogerdimensionale reis in de wereld van de tesseract die je doet duizelen. Een technische uitleg hoe een digitale computer toch met floating point getallen kan rekenen.
Elke pagina is weer een ijzersterk didactisch verhaal gecombineerd met een vernuftig stukje techniek.
-
Waar zijn alle websites heen?
Ik zag laatst een artikel op Slashdot langskomen, waar de schrijver zich afvroeg waar alle websites gebleven waren.
Het verhaal begint in 2009, toen het internet nog een digitale speeltuin was vol verrassingen. Facebook en Instagram waren als de coole kids op het schoolplein die de laatste roddels verspreidden, en surfen op het web betekende het intikken van webadressen met de hoop op een avontuurlijke ontdekkingsreis bij elke klik.
Fast forward naar 2024 en het internet lijkt een totale make-over te hebben ondergaan. De “Voor Jou Pagina” levert nu op maat gemaakte content van je favoriete “creators”, speciaal afgestemd op verschillende platforms. De ooit gevarieerde wereld van websites lijkt echter te zijn verdwenen, alles is in hetzelfde format gedwongen, en dat roept vragen op over de huidige toestand van het web en waarom we er helemaal niet zo blij meer mee zijn.
De echte verandering zit hem echter in onszelf. De vreugde van ontdekking en “curatie”, ooit essentieel voor de internetervaring, lijkt te zijn uitbesteed aan bedrijfsalgoritmen. We scrollen nu eindeloos passief door content, vertrouwend op algoritmes voor onze digitale avonturen. Algoritmes die echter hele andere belangen dienen…
De oplossing? Laten we teruggaan naar onze rol als ontdekkingsreizigers! Iedereen kan een curator worden door open webportals te creëren. Gebruik platforms zoals Linktree.com om je favoriete blogposts, artiesten of coole websites te delen. Heb je meer te melden, open je eigen website op WordPress.com en link ernaar vanuit je socials in plaats van jouw ideeën op te sluiten in de platforms van anderen. Laten we de interconnectiviteit nieuw leven inblazen en het web weer leuk maken om te ontdekken, zonder dat je een computernerd hoeft te zijn.
En als je nog een stapje verder wilt gaan hoeft het helemaal niet ingewikkeld te zijn. Het boek hiernaast heb ik bij ons in de bibliotheek gevonden voor Jasper die op school als verrijkingsproject “Een eigen website” heeft gekozen. Bouw je eigen website, stap voor stap, van de grond op. Je eigen virtuele volkstuintje op het internet.
-
Arduino ✕ PlatformIO
De electronica en code voor de Rheinturm zijn al een hele tijd af, maar ik moet nog steeds een “behuizing” voor het geheel bedenken. Ik twijfel nog tussen een eenvoudige houten plaat of een uitgesneden vorm, maar een 3D geprint model zou ook heel tof zijn. Blijkbaar zijn 3D-printers tegenwoordig ook niet meer super duur als je van
prutsentinkeren houdt… Anyway, dat is weer een heel andere hobby!Voorlopig ligt de boel dus veilig in een doos opgeborgen te wachten op de afwerking. Tot die tijd wil ik de code wel een beetje netjes achterlaten, zodat het later makkelijk weer op te pakken is. Daarbij heb ik al gemerkt dat de Arduino IDE niet het beste stuk software is om dat mee te doen. Arduino-Rheinturm gebruikt een aantal software-bibliotheken die ingeladen moeten worden en de vraag is of die over twee of drie jaar nog werken in de Arduino IDE.
Daarnaast is het prototype wat ik nu heb gebouwd weliswaar gebaseerd op een Arduino UNO, maar heb ik tegen de tijd dat ik de definitieve versie maak, misschien een ander type controller waar de Arduino IDE helemaal niet mee samenwerkt. Wat ik nodig heb, is een manier om te zeggen welke bibliotheken ik nodig heb en hoe de broncode moet worden gebouwd voor de controller die ik op dat moment heb. Als je ooit een Java-project hebt gemaakt, zul je denken aan Maven of Gradle. Voor Ruby heb je Gemspecs en Bundler, voor Python is er
setup.py
(of tegenwoordigproject.toml
) enpip
en in de JavaScript-wereld gebruik jepackage.json
ennpm
.PlatformIO
Het van oorsprong Oekraïense project PlatformIO is zo’n tool voor embedded software development. Een enkele
platformio.ini
in je project en de sources op een aangewezen plek (Convention over Configuration), meer heb je niet nodig om snel weer op weg te zijn als je een tijd weg bent geweest van je project.[env:uno] platform = atmelavr board = uno framework = arduino lib_deps = bxparks/AceTime @ ^2.0.1 adafruit/Adafruit NeoPixel @ ^1.11.0 northernwidget/DS3231 @ ^1.1.2 rlogiacco/CircularBuffer @ ^1.3.3
Doordat spullen op voor PlatformIO bekende plaatsen staan, kan die ook de benodigde projectbestanden genereren om het te openen in je IDE, zonder dat die bestanden in Git hoeven te worden gezet. Vandaag de dag werk ik met JetBrains CLion, maar misschien is dat morgen Visual Studio Code. Die snappen elkaars projectstructuur niet, dus dan is het fijn dat je niet helemaal opnieuw hoeft te beginnen met de inrichting, maar gewoon
platformio -c clion init
ofplatformio -c vscode init
kan doen en alles staat weer recht.Daar houdt het echter niet op, want als ik een andere microcontroller gebruik, dan kan ik eenvoudig een nieuwe minimale configuratie aanmaken en ben ik ook weer op weg. Met de juiste hardware zou het zelfs mogelijk moeten zijn om unit testen te schrijven die de code kan verifiëren.
CLion
De overstap van Arduino IDE via PlatformIO naar CLion was wel fundamenteel, want plotseling had ik een hele krachtige omgeving tot mijn beschikking waarmee het programmeren in C++ daadwerkelijk ondersteund wordt. Het nodigde uit tot opschonen en opsplitsen van de code, waardoor ik nu een heel nette structuur heb die ik over een jaar of twee ook nog begrijp. En ja, dan kan je de code ook maar beter publiek maken, want misschien heeft iemand er ooit nog iets aan.
Links
-
VR panorama browser
Zoals ik afgelopen week al schreef, wilde ik de panorama-viewer verder uitbreiden om meer foto’s toe te voegen. Interacties in de derde dimensie werken echter nét anders dan op het platte scherm. Daarnaast zijn allerlei conventies nog helemaal niet uitgewerkt, dus iedereen doet maar wat en dat is heel verfrissend.
In de 20e eeuw werden de nieuwe grafische interfaces aangeleerd door het gebruik van bedieningselementen die waren ontworpen naar het voorbeeld van een fysieke tegenhanger, een skeuomorfisme zoals dat heet. Mappen, schuifknoppen en zandlopers; allemaal elementen uit de echte wereld om ons te laten begrijpen hoe de interface werkt in de platte digitale wereld.
Meta Quest: Zwevende 2D windows met een 3D sausjeDigitale 3D werelden kunnen werken op een heel andere manier, maar de interface-ontwerpers maken het zich er makkelijk vanaf en plakken gewoon een 2D interface in de lucht, want die kennen we al. Ze willen het ons nu nog niet te lastig maken, maar de échte revolutie moet nog komen, denk ik.
Apple visionOS: Nog niet veel beterSimpel
Hoe dan ook, ik wilde iets simpels maken om mee te beginnen. Met A-Frame doe je dat met Custom Elements in HTML. Hieronder zie je het specifieke deel om de scene te definiëren.
<a-scene> <a-assets> <img id="image-0" src="image-0.jpg"> <img id="city" src="https://cdn.aframe.io/a-painter/images/sky.jpg"> <img id="floor" src="https://cdn.aframe.io/a-painter/images/floor.jpg"> </a-assets> <a-sky src="#city"></a-sky> <a-curvedimage id="panorama" src="#image-0" position="0 2 0" height="2.5" radius="2" theta-start="60" theta-length="240"></a-curvedimage> <a-cylinder id="ground" src="#floor" radius="32" height="0.1"></a-cylinder> </a-scene>
Eerst definieer je een aantal assets, in dit geval afbeeldingen, waar je vanaf andere plekken naar kan verwijzen. Om te voorkomen dat je in het luchtledige lijkt te zweven is het verstandig een
a-sky
toe te voegen met een 360º afbeelding. Daarnaast heb ik eena-cylinder
toegevoegd die als een soort vloer dient.De
a-curvedimage
bevat het echte panorama-plaatje en is eigenlijk een boogsegment van de wand van een cilinder. Het is een beetje zoeken naar de juiste waardes, maar de meeste van mijn panorama’s zijn ongeveer 240º. Als het niet helemaal klopt, is dat nog niet zo’n ramp, want dat zie je amper, behalve als je met veel rechte lijnen werkt en het allemaal precies zou moet passen.Nu voeg ik nog twee
a-image
toe onder de panorama om zometeen vooruit en achteruit te kunnen en voila, de scène is zo’n beetje klaar:
Overzicht van de sceneMet A-Frame hoef je je om de rendering verder geen zorgen meer te maken. Je headset schakelt om naar VR-modus en je wordt omringd door de scène die je hebt gebouwd. De interactie daarentegen zul je wel zelf moeten opbouwen, want anders dan op het platte web kan je hier niet gewoon ergens een
<a href=...>
wegzetten om een link te maken.Interactie
In 2D interfaces zijn we gewend dat we één aanwijzer hebben die we eventueel met meerdere apparaten kunnen bedienen ( muis, touchpad, tekenpen, …). In de 3D wereld zijn al die apparaten opeens onafhankelijke bedieningen geworden, vergelijkbaar met hoe een smartphone elke vinger apart detecteert en “multitouch gestures” herkent. A-Frame ondersteunt hoofd- en controller-tracking, dus je kijkrichting en wat je met je controllers doet kan als invoer dienen. Omdat je hoofd (waarschijnlijk) geen knoppen heeft, werkt een interactie daarmee anders dan met een hand-controller.
Een controller declareer je door een
a-entity
te maken met een aantal attributen, bijvoorbeeld zo:<a-entity oculus-touch-controls="hand: right" laser-controls b-button-listener></a-entity>
Met
oculus-touch-controls="hand: right"
zeg je dat je de Meta Quest controller voor de rechter hand wil configureren. Delaser-controls
zorgt ervoor dat de controller een laserstraal afschiet in de wijsrichting, en dat een aantal events worden afgevuurd als die laserstraal een object raakt, waarover later meer.Uit de VR-modus gaan
Ten slotte koppel ik met
b-button-listener
mijn eigen code aan de controller hardware:AFRAME.registerComponent('b-button-listener', { init: function () { this.el.addEventListener('bbuttondown', function (e) { const sceneEl = document.querySelector('a-scene'); if (sceneEl.is('vr-mode')) { sceneEl.exitVR(); } }); } });
Dit zorgt ervoor dat als je op de B knop op de controller drukt wanneer je in VR-mode bent, dat je uit VR-mode gaat.
Een foto vooruit of achteruit gaan
De twee kleine fotootjes onderaan op het screenshot had ik nog niet aan de scène toegevoegd, dus dat doen we nog even:
<a-image id="prev-image" src="#image-2" position="-1 0.5 -1.5" rotation="-45 30 0" width="1" height="0.33" cursor-listener="direction: prev"></a-image> <a-image id="next-image" src="#image-1" position="1 0.5 -1.5" rotation="-45 -30 0" width="1" height="0.33" cursor-listener="direction: next"></a-image>
Hier zie je de
cursor-listener
component. Deze code is straks verantwoordelijk voor het naar hetclick
signaal luisteren dat delaser-controls
component produceert wanneer je op een van dea-image
s “klikt”. Je ziet dat je extra informatie kan meegeven, net als bij deoculus-touch-controls
, om de component te configureren.AFRAME.registerComponent('cursor-listener', { schema: { direction: {type: 'string', default: 'next'} }, init: function () { this.el.addEventListener('click', (e) => { switch (this.data.direction) { case 'prev': nextImage(-1); break; default: nextImage(1); break; } }); } });
In de code hierboven wordt aan
this.el
, dat is dea-image
waar het op staat, een event listener toegevoegd voor hetclick
signaal. Afhankelijk van de waarde vandirection
zal hij nu de volgende of de vorige afbeelding inladen.De logica voor het wisselen van de afbeelding is niet A-Frame of WebXR specifiek en kan je vinden in de source van de panorama pagina (net als de rest van deze blog trouwens).
En dat is het! Het resultaat is een wereld waarin je kan schakelen tussen zes panorama’s met behulp van je controllers! Voor degenen zonder headset, een filmpje:
Nuttige links
- Een lijst van voorbeelden met A-Frame (in onwijze 90s homepage vibe) van Lee Stemkoski
- A-Frame documentatie
-
Aan de slag in Virtual Reality met WebXR
We hebben onszelf laatst een VR-headset cadeau gedaan. Om Beat Saber te spelen natuurlijk, maar ook om lekker mee te knutselen. Er zijn native ontwikkelomgevingen voor zo’n beetje elke headset die op de markt te krijgen is, maar er is ook een W3C specificatie voor VR- en AR-applicaties, gezamenlijk vaak XR genoemd. Die specificatie heet WebXR en breidt het 2D web uit met de derde dimensie.
Nu is de W3C specificatie vrij low-level dus is het lastig daar een toepassing mee te maken, maar er zijn al frameworks ontwikkeld die het veel makkelijker maken. Een van die frameworks is A-Frame en daarmee heb ik al een simpele viewer geknutseld voor de panoramafoto’s die ik in de loop van de tijd heb gemaakt.
Met een desktop browser kan je die pagina gewoon openen en in XR-emulatie bekijken, met een headset krijg je een “immersieve ervaring” zoals dat zo mooi heet.
Kijk maar eens naar het panorama van de Pont du Gard in VR wat ik afgelopen vakantie heb gemaakt.
Ik wil de viewer nog verder uitbreiden zodat het een echte applicatie is waarin je meerdere panorama’s kan bekijken, want ze komen in VR echt veel beter tot hun recht dan op een plat beeldscherm.
-
Djöflaterta
Lang geleden leefde ik een paar maanden in IJsland, waar ik kennismaakte met de perfecte IJslandse variant van de Devil’s Pie: Djöflaterta. Nu was ik niet helemaal kapot van het recept wat ik destijds had en ben ik op zoek gegaan naar een nieuwe samenstelling.
Ik heb denk ik de perfecte receptuur nu gevonden: Djöflaterta sem bráðnar í munninum oftewel “Duivelse taart die smelt in je mond”.
Voor het beslag
Voeg de ingrediënten een voor een toe en blijf mixen op hoge snelheid.
150 gr margarine
1 1/2 cup suiker (355 ml)
3 eieren
2 cups bloem (473 ml)
1 tl bakpoeder
1/2 tl zout
1 tl baking soda
2 tl vanilledruppels
1 cup melk (237 ml)
2 el cacaoMeng alles door elkaar en doe in 2 springvormen en bak 20-30 min op 180°. Houd het in de gaten, zodat het bovenop niet te donker wordt.
Met een enkele springvorm lukt het ook, dan duurt het ongeveer 40-50 minuten en moet je het uiteindelijk horizontaal snijden. Dit recept gebruikt zowel bakpoeder als baking soda; het deeg is dan ook heel erg “fluffy” als het is gebakken.
Voor de crème
50 gr boter
300 gr poedersuiker
1 ei
1 tl vanilledruppels
2-6 el melk
2 el cacao
of 2 eieren en sla de melk overLaat de cake volledig afkoelen voordat je de creme erop smeert, want anders loopt het er zo weer uit.
Voor de ganache
Hiervoor heb ik een ander “recept” gevonden wat goed werkt. Gebruik pure chocolade en slagroom in 1:1 verhouding. Smelt de chocolade au bain-marie en laat het een beetje afkoelen. Breng de slagroom aan de kook en voeg het bij de chocolade. Goed roeren en laten afkoelen tot het een stevige pasta is, dat kan prima in de koelkast. Wel regelmatig doorroeren zodat je niet een grote dikke klont krijgt.
Nu kan je de pasta eenvoudigweg eroverheen smeren en ziet het er zalig uit, en zo smaakt het ook…
-
Stabiel de tijd bijhouden tussen herstarten
Met baby steps, zo komen we er wel. Eerder had ik het erover dat de Arduino geen eigen RTC (Real Time Clock) heeft en daardoor ten eerste een vrij grote afwijking van enkele seconden per dag heeft en ten tweede de tijd-instelling steeds kwijtraakt bij herstarten.
Er zijn twee goed ondersteunde RTCs voor Arduino verkrijgbaar; de DS1307 en de DS3231. Qua prijs ontlopen ze elkaar niet veel, maar qua precisie is de DS3231 absoluut superieur met een afwijking van maar ±2 minuten per jaar. Aansluiten op de Arduino, het wordt langzaam een beetje voorspelbaar, is weer een fluitje van een cent.
VCC
enGND
naar de plus en min,SDA
direct op analoge poortA4
enSCL
direct naar analoge poortA5
.
DS3231 met batterijhouder en pinsVervolgens kan je met de DS3231 library de boel besturen:
#include <DS3231.h> #include <AceTime.h> BasicZoneProcessor zoneProcessor; TimeZone tz = TimeZone::forZoneInfo(&zonedb::kZoneEurope_Amsterdam, &zoneProcessor); void setup() { // Initialiseer de verbinding Wire.begin(); Serial.begin(9600); } void loop() { // Haal de huidige tijd op uit de RTC DateTime rtcNow = RTClib::now(); ZonedDateTime now = ZonedDateTime::forUnixSeconds64(rtcNow.unixtime(), tz); now.printTo(Serial); delay(100); }
De tijd instellen
De kans dat de RTC de juiste tijd geeft als je hem voor het eerst gebruikt is op zich vrij klein, dus moet je hem eerst instellen. Via de seriële poort van de Arduino kunnen we de module instellen:
void loop() { // Als er iets op de seriële poort klaar staat... if (Serial.available()) { // ... dan lees het als een integer long readLong = Serial.parseInt(); // ... en lees de rest van de buffer leeg, zoals een <enter> of spaties while (Serial.available()) { Serial.read(); } // stel de RTC in op de integer die van de seriële poort is ingelezen rtc.setEpoch(readLong); } ZonedDateTime now = ZonedDateTime::forUnixSeconds64(RTClib::now().unixtime(), tz); now.printTo(Serial); delay(100); }
Vervolgens kunnen we de tijd instellen door de Unix epoch timestamp over de seriële poort naar de Arduino te sturen. De huidige Unix epoch krijg je met het commando
date +%s
. Je kan de uitvoer daarvan in de Arduino IDE naar de seriële poort sturen (Tools | Serial monitor), maar het kan ook vanaf de command line met hetcu
commando. Eerst moet je weten welk device je seriële poort heeft; in de Arduino IDE zie je dat onderin het scherm als je Arduino verbonden is. Bij mij is dat/dev/cu.usbmodem101
, vervolgens start jecu
met het commando:$ sudo cu -l /dev/cu.usbmodem101
Nu zie je alles wat over de seriële poort binnenkomt, dus in dit geval elke 100 milliseconden de huidige tijd. Het
cu
commando kan echter ook berichten terugsturen (zieman cu
), en heeft zelfs nog functionaliteit om de invoer uit een ander programma te halen door middel van~$<command>
. We krijgen de huidige epoch metdate +%s
(zie ookman date
).Als je door de stroom aan timestamps heen het commando
<enter>~$date +%s
invoert, zul je zien dat de timestamps opeens de huidige tijd weergeven. Aangezien je dit maar af en toe hoeft te doen zou je kunnen overwegen dit in een apart programma te doen, want dat scheelt weer in het geheugengebruik. Je sluitcu
netjes af met het commando<enter>~.
.Andere tijdsignaal-bronnen
Een RTC is zeker niet de enige bron van tijdsignalen. Als je een WiFi module toevoegt aan de Arduino, kan de tijd opgehaald worden vanaf een NTP-server. Met een GPS-ontvanger kan je de tijd ophalen van satellieten. Een nog andere optie is om een tijdsignaal van de DCF77-zender in Mainflingen bij Frankfurt op te vangen. Ook de originele klok in de Rheinturm doet dit!
Ik wil daar in de toekomst nog wel eens naar kijken, maar op dit moment is de klok volledig zelfstandig operationeel! De volgende stap is eerst iets compleet anders: de lichtstrip moet worden ingebouwd in een meer permanente opstelling.
-
Vrolijke steentjes uit Tsjechië gevonden, en dan?
Met Pasen was ik samen met Jasper op vader-zoon weekend naar Parijs, waarover later misschien nog wat meer. Op onze zoektocht naar de Vrijheidsbeelden van Parijs kwamen we in de
Jardin du Luxembourg
een exemplaar tegen. Er staan twee bordjes bij die wat achtergrondinformatie over dit beeld geven en vóór een van die bordjes vonden we een beschilderde kiezelsteen.Nu kom je die overal wel tegen, elk dorp en elke stad heeft wel een stel creatievelingen die het leuk vindt om een glimlach op het gezicht van een ander te toveren. Rond het begin van de coronapandemie zag je ze overal opduiken, “Happy Stones” werd het genoemd in goed Nederlands, in Engelstalige landen heette het “Kindness Rocks” (mét woordspeling!). Vaak gingen ze anoniem de wereld in, maker en vinder bleven onbekend. Soms stond er nog een hashtag op die je naar een Instagram- of Facebook-pagina stuurt, maar het was allemaal kleinschalig en individueel. Ook wij hebben nog eens wat geknutseld voor op school, met eigen hashtag en Insta-account. Het grootste initiatief lijkt Happy Stones Limburg te zijn, maar dat heeft ook maar een paar duizend deelnemers.
Deze steen was anders; deze had de Tsjechische vlag 🇨🇿 en het Facebook-logo erop staan, een nummer van vijf cijfers (67555) en iets wat op een datum (01/23 - januari 2023?) lijkt. Iemand in Tsjechië heeft deze steen bovendien gesigneerd met LH. Ik besluit uit te gaan zoeken hoe ze Happy Stones in Tsjechië doen.
Veselé Kameny
De vertaling van
Happy Stones
volgens Google Translate isVeselé Kameny
. Op Facebook is dat een nogal lege pagina met 30 volgers en vrijwel geen leven. De zoekfunctie geeft me wel veel resultaten uit een andere groep genaamd Kamínky. Google Translate vertaalt dit ook metstenen
, maar Tsjechisch is familie van het Pools, waarvan ik weet dat de uitgang ‘-nki’ en ‘-nka’ verkleinwoorden maken:Steentjes
dus. De groep heeft bijna 400.000 leden, ik denk dat ik hier wel goed zit. Happy Stones is huge in Tsjechië!Een klein nadeel, want net als dat de kleine Nederlandse groepen in het Nederlands zijn, is deze groep volledig in het Tsjechisch. Uit de uitleg maak ik op dat het nummer de postcode van deze kunstenaar is. De postcode 675 55 is Hrotovice of Slavětice, zo’n 50 kilometer ten westen van Brno. Ik besluit een post in de groep te zetten en nadat deze is goedgekeurd krijgt die al vrij snel een reactie met daarin een naam die voldoet aan de initialen LH die inderdaad in Slavětice woont. De posts van het profiel in de groep onthullen vele honderden stenen die ze al de wijde wereld in heeft gestuurd!
Alomtegenwoordig Facebook…
Er zijn heel wat redenen om niet op Facebook te zitten, maar het enorme bereik van het netwerk zorgt wel voor een laagdrempelige manier om dit soort toevallige ontmoetingen mogelijk te maken. De kamínky hadden nooit zo populair geworden als men ze stuk voor stuk als Geocaching Travel Bugs hadden geregistreerd, omdat het bereik van Geocaching nou eenmaal beperkt is. In een boek kan je nog een uitleg meegeven hoe BookCrossing werkt, maar ook de ruimte op een kiezel is beperkt. Het Facebook-logo is herkenbaar en met minimale context en uitleg kan iedereen meedoen.
-
Automatisch dimmen als het donker wordt
Het project ligt even een beetje stil, maar ik heb in de tussentijd wel een kleine uitbreiding gemaakt zodat je ‘s nachts niet wordt verblind door een zee aan licht, maar dat je tegelijk overdag de klok ook nog kan aflezen.
Met een fotodiode meet ik het omgevingslicht en dankzij de in de Arduino ingebouwde analoog-digitaalomzetter is het weer een poepsimpel circuitje geworden:
De analoge poort
A0
lees je eenvoudig uit met de functieanalogRead(A0)
. De waarde uit de analoge poort wordt omgezet naar een 10-bit integer, dus tussen 0 en 1024. OmdatsetBrightness
een waarde tussen 0 en 255 wil, delen we die door 4 en om te voorkomen dat het licht helemaal uitgaat in het donker zetten we er een minimum op.void updateBrightness() { int brightnessReading = analogRead(A0) / 4; pixels.setBrightness(max(brightnessReading, 1)); }
Dit kan echter — zoals bij veel regelsystemen — leiden tot hysterese, waarbij het licht feller gaat branden omdat het licht wegvalt, maar doordat het licht feller gaat branden het weer lichter wordt en de helderheid bij de volgende keer dat de sensor wordt uitgelezen weer naar beneden wordt bijgesteld, waarna het hele circus opnieuw begint. Dit kunnen we voorkomen door de helderheid afhankelijk te maken van een langere periode.
Hieronder slaan we de ingelezen waarde tijdelijk op in een circulaire buffer van lengte 10, om vervolgens het gemiddelde aan
setBrightness
te voeren. Het voordeel in het gebruik van zo’n type buffer is dat je waardes erin kan blijven duwen (push()
) en als hij vol is valt de oudste waarde eruit. Omdat ik een lopend gemiddelde wil bepalen, haal ik die oudste waarde er zelf uit (shift()
) en trek die van het gemiddelde af.#include <CircularBuffer.h> CircularBuffer<int, 10> brightnessReadings; int brightnessAverage = 0; void updateBrightness() { int brightnessReading = analogRead(A0) / 4; brightnessAverage += brightnessReading; if (brightnessReadings.isFull()) { brightnessAverage -= brightnessReadings.shift(); } brightnessReadings.push(brightnessReading); pixels.setBrightness(max(brightnessAverage / brightnessReadings.size(), 1)); }
De waarde die uiteindelijk naar
setBrightness
gaat is het gemiddelde van de 10 laatste waarden. Een plotse verandering in helderheid wordt daardoor uitgesmeerd over 100 milliseconden (deloop()
functie heeft eendelay(10)
die ervoor zorgt dat die aan het eind van elk rondje 10 milliseconden wacht) en hysterese wordt voorkomen. -
De tijd weergeven op 60 LEDs
In de vorige post zagen we de hardwarekant van mijn model van de Lichtzeitpegel. In deze post gaan we de softwarekant verkennen, om er vervolgens achter te komen dat we nog lang niet klaar zijn met de hardware…
NeoPixel
Vorige keer hadden we de
strandtest
al gedaan om te bevestigen dat de schakeling werkt. Nu gaan we een simpel looplicht maken om de NeoPixel library te leren kennen.Onderstaande code is alles om mee te beginnen:
#include <Adafruit_NeoPixel.h> #define LED_PIN 6 // Which pin on the Arduino is connected to the strip? #define LED_COUNT 60 // How many LEDs are on the strip? #define HUE_STEP 65536 / 90 // Full rainbow cycle in 90 frames // Declare the strip object: Adafruit_NeoPixel strip(LED_COUNT, LED_PIN, NEO_GRB + NEO_KHZ800); int hue = 0; void setup() { strip.begin(); // Initialize library strip.show(); // Initialize LEDs strip.setBrightness(50); // Set default brightness at about 1/5 } void loop() { for (int i = 0; i < LED_COUNT; i++) { strip.clear(); // Clear LED color in controller RAM for (int j = 0; j <= 9; j++) { strip.setPixelColor( (i - j + LED_COUNT) % LED_COUNT, // Makes for a fluid run-off at the end strip.ColorHSV(hue, 255, 255 - j * (255 / 9)) ); } strip.show(); // Update LEDs according to controller RAM delay(10); hue += HUE_STEP; } }
En dat levert dan iets dergelijks op als dit:
Regenboog looplichtLogische klok
LED index – 0-based Kleur Omschrijving 56 – 59 Geel Geen functie 54 – 55 Wit Tien uren 53 Geel Scheidingslamp 44 – 52 Wit Uren 43 Geel Scheidingslamp 42 Rood Luchtbaken 37 – 41 Wit Tien minuten 36 Geel Scheidingslamp 27 – 35 Wit Minuten 26 Rood Luchtbaken 25 Geel Scheidingslamp 20 – 24 Wit Tien seconden 19 Geel Scheidingslamp 10 – 18 Wit Seconden 0 – 9 Geel Geen functie Er zijn online niet heel veel details te vinden van de werking van de klok. Op de Duitstalige Wikipedia-pagina van de Lichtzeitpegel staat wel een tabel met de verdeling van de lampen. Het origineel heeft er 62, maar omdat ik maar 60 LEDs in de strip heb, heb ik de eerste en laatste lamp zonder functie laten vervallen. Ik hoop dat iemand me kan vergeven.
De gele lampen zijn niet geheel zonder functie. Aan het eind van elke minuut gaan alle scheidingslampen een seconde lang aan. Aan het eind van elk uur gaan alle scheidingslampen bovendien een hele minuut lang aan. Het effect bij de volle minuut is ook te zien in een video op YouTube. De precieze werking van het hele uur is daar echter niet zichtbaar. Ik gok dat ik daarvoor echt zelf naar Düsseldorf zal moeten.
Code
Opvallend genoeg is het algoritme eenvoudiger te lezen dan de tijd aflezen van een klok op een zendmast.
void updateTime(const ZonedDateTime& dt) { for (int i = 0; i < NUMPIXELS; i++) theLEDs[i] = 0; // Reset for (int i = 0; i < dt.second() % 10; i++) theLEDs[10 + i] = 1; // Single seconds for (int i = 0; i < dt.second() / 10; i++) theLEDs[20 + i] = 1; // Ten seconds for (int i = 0; i < dt.minute() % 10; i++) theLEDs[27 + i] = 1; // Single minutes for (int i = 0; i < dt.minute() / 10; i++) theLEDs[37 + i] = 1; // Ten minutes for (int i = 0; i < dt.hour() % 10; i++) theLEDs[44 + i] = 1; // Single hours for (int i = 0; i < dt.hour() / 10; i++) theLEDs[54 + i] = 1; // Ten hours /* Whole Minute and Whole Hour effect */ if (dt.second() == 59 || dt.minute() == 59) { for (int i = 0; i < 10; i++) theLEDs[i] = 2; theLEDs[19] = 2; theLEDs[25] = 2; theLEDs[36] = 2; theLEDs[43] = 2; theLEDs[53] = 2; for (int i = 56; i < 60; i++) theLEDs[i] = 2; } }
Nu de tijd getoond kan worden op de strip, hebben we natuurlijk de tijd zelf nog nodig.
Een Arduino komt niet met een eigen klok en een losse RTC (Real Time Clock) module heb ik (nog) niet. Voorlopig zet ik de tijd handmatig tijdens compilatie en kan de tijd bijgesteld worden via de seriële interface. En dat moet regelmatig gebeuren, want de
millis()
functie die Arduino biedt om het aantal milliseconden sinds het starten te bepalen is niet erg precies. Na een nacht heb je al een afwijking van zo’n 7 seconden te pakken.Daarnaast is onmogelijk om de helderheid van de LEDs te bepalen voor zowel een zonnige dag als een donkere nacht. Er moet dus een dimmer in komen die afhangt van het omgevingslicht.
Twee onderwerpen voor een volgende post; wordt vervolgd!
-
Lichtzeitpegel in je woonkamer
Naast programmeren was ik altijd al geïnteresseerd in de hardware-kant, wat zelfs in een vlaag van verstandsverbijstering leidde tot een studiejaar elektrotechniek. Wat me altijd een beetje er vanaf hield om er meer mee te doen was de enorme verscheidenheid aan componenten en het grillige gedrag van analoge schakelingen wat ik niet altijd goed begreep. Er was eigenlijk gewoon teveel wat ik niet wist om goed te beginnen.
Sinds een paar maanden rommel ik soms in de avonduren wat met de Arduino Starter Kit die ik een tijd geleden heb aangeschaft. Eigenlijk zijn hiermee beide problemen opgelost, want ik hoefde nu niet zelf te bepalen welke componenten ik nodig zou gaan hebben en de voorbeelden zijn van een niveau dat analoog gedoe geen roet in het eten gooit. Hierdoor begon ik beter te begrijpen wat de verschillende componenten doen; in ieder geval beter dan tijdens het college Netwerken.
Rheinturm in Düsseldorf
Van het een kwam het ander en zo kwam ik uiteindelijk terecht op een ander verloren project uit de jaren 90; het nabouwen van de decimale klok in de Rheinturm in Düsseldorf. Dit vereist wellicht wat meer uitleg, want de Lichtzeitpegel zoals de installatie heet is nét iets minder bekend dan pakweg de verlichting van de Eiffeltoren of de melodie van Big Ben.
Langs de toren zijn 62 lampen aangebracht die van boven naar onder de decimalen van een 24-uurs klok voorstellen. De eerste twee lampen geven de tientallen uren aan, de volgende tien lampen de enkele uren, daaronder zes lampen die tientallen minuten aangeven en tien lampen de enkele minuten. Ten slotte zijn er nog zes lampen voor de tientallen seconden en tien lampen voor de enkele seconden.
De klok hiernaast geeft 16:56:39 aan, omdat van boven naar onder 1, 6, 5, 6, 3 en 9 lampen branden. Er zijn nog wat extra’s, zoals scheidingslampen tussen de groepen die op elk volle uur een minuut lang branden, maar dit zijn de pure regels voor de klok.
Het Elektor project
De toren met klok staat al sinds 1981, maar eind jaren 90 werd in het blad Elektor 05-1998 een elektrisch schakelschema gepubliceerd waarmee de klok na te bouwen was. Omdat het een erg populair artikel was, werd het in Elektor 01-2000 nog eens dunnetjes overgedaan.
In onderstaande video laat Roger Leifert zijn versie zien die nog steeds voldoende aandacht krijgt op tentoonstellingen. Vanaf 6:20 zie je de ingewikkelde schakeling en lijmblob die alle leds bij elkaar houdt.
… en toen kwam de WS2812B
De WS28xx serie RGB LED modules veroorzaakten een revolutie in aanstuurbare verlichting. Voeding en aansturing werd gescheiden, waardoor je schakeling een stuk eenvoudiger kan worden. Daarnaast biedt de WS28xx ook een uitgangssignaal, wat alle inkomende berichten doorstuurt minus het bericht wat voor de huidige LED is bedoeld! Dat betekent dat je er ketens van kan bouwen die je met een enkele data-lijn kan aansturen!
Drie maal WS2812B in serieJe kan zelf de losse WS2812Bs aan elkaar koppelen, maar er zijn ook kant-en-klare LED-strips die zelf op lengte te maken zijn. Ze zijn er met 30, 60 en zelfs 144 LEDs per meter. Ze zijn er trouwens ook in de vorm van ringen, arrays (meerdere strips naast elkaar), ze zijn waterdicht en stofdicht verkrijgbaar. Voor mijn toepassing is 60 / meter optimaal; het model van de Lichtzeitpegel wordt dan ongeveer een meter hoog.
Belachelijk simpele schakelingHet resultaat is in de basis een belachelijk simpele schakeling met alleen twee draadjes voor de power en een weerstandje tussen de I/O poort van de Arduino en de data-lijn van de WS2812B strip. De Arduino in combinatie met de NeoPixel library doet de rest. In de Arduino IDE kan je voorbeeld-code voor de NeoPixel library inladen. Deze laat onder andere onderstaande bewegende regenboog zien. Mooi! De schakeling werkt!
NeoPixel ‘strandtest’ demonstratieDe enige uitdaging die er nu nog overblijft, is de code voor de klok schrijven. Dát is voor een volgende post!
Pagina 1 van 28
Volgende keyboard_arrow_right