Bouw je eigen display met rgb-leds
We kunnen ons moeilijk voorstellen dat iemand die weleens met elektronica heeft gespeeld, nooit een ledje op een batterij heeft aangesloten. Wil je dat een beetje netjes doen, dan zet je er een weerstandje tussen om de stroom te beperken en je ledje niet te laten doorbranden. Voor velen zal dat de eerste stap zijn geweest in hobby'en met elektronica en niet voor niets is het standaard project voor Arduino, de hello world van de microcontrollerwereld zo je wilt, het Blink-programma. Met dit supersimpele programma laat je de led die op de meeste Arduino-compatibele bordjes standaard aanwezig is, je raadt het al, knipperen.
Zoals dat vaak gaat, zal een enkel knipperend ledje voor veel mensen niet genoeg zijn. Een enkel ledje aansturen via i/o-pinnen is een gateway drug naar meer; voor je het weet, stuur je een hele streng leds aan, of een compleet beeldscherm. Dan hebben we het natuurlijk over een ledscherm, zoals de grote reclameschermen buiten of scoreborden. De pixels daarvan zijn namelijk in de regel afzonderlijke leds. Nu bestaan beeldschermen natuurlijk uit bizar veel leds. Een beetje display heeft honderdduizenden tot miljoenen pixels, en dat is lastig met huis-tuin-en-keukenhardware aan te sturen en van prik te voorzien.
Wat we wel kunnen doen, is een bescheiden matrix, of display zo je wil, aansturen met een Arduino of Raspberry Pi, en plaatjes, animaties of zelfs een spelletje tonen op een pixeldisplay van een dikke duizend pixels. Vooral voor retrobeeldmateriaal leent zo'n matrix zich uitstekend, want 8bit-plaatjes passen al snel op een beperkt aantal pixels. We kijken naar de opties om zo'n matrix te maken en aan te sturen.
/i/2002362189.jpeg?f=imagearticlefull)
Leds, strips en matrices
Voordat we gaan bouwen aan een eigen ledmatrix, kijken we naar verschillende manieren waarop die opgebouwd kunnen worden. We beginnen even met de saaiste methode, die vooral het gemak dient: een matrix kopen. Als je geen zin hebt om zelf iets in elkaar te solderen of dat lastig vindt, kun je ervoor kiezen een kant-en-klare ledmatrix te kopen. Die zijn er in allerlei vormen en maten, van supereenvoudige monochrome 8x8-matrices van nog geen euro die je met een paar regels code aanstuurt, tot schakelbare modules waarmee je een complete tv-wand kunt opbouwen.
Het voordeel van zo'n kant-en-klare matrix is uiteraard het gemak. Je hoeft alleen een paar draadjes aan te sluiten en voor voldoende voeding te zorgen. Je mist alleen de optie om de afmetingen en aansturing zelf te bepalen; een voorgebouwde matrix heeft in de regel al de controller-logica aan boord en is minder flexibel. Voor matrices als de Adafruit Matrix Panels, die ook in Nederlandse webshops verkrijgbaar zijn, heeft Adafruit uitgebreide tutorials online gezet, zodat je met een minimale hoeveelheid uitzoekwerk tot mooie resultaten kunt komen.
We gaan voor deze .Build echter zelf aan de slag om een matrix te bouwen, zodat we flexibeler zijn wat aantal pixels en afmetingen betreft. We kiezen voor rgb-leds, maar je kunt natuurlijk ook een matrix bouwen met witte leds of van een willekeurige andere kleur. Nu kun je uit diverse soorten leds kiezen en er zijn veel manieren om die aan te sturen. Omdat we een matrix bouwen van rgb-leds, zou je verwachten dat je een complex bedradingsschema nodig hebt om de leds individueel aan te kunnen sturen. Zo zou je een matrix kunnen bouwen, de rijen en kolommen kunnen bedraden, en zo de leds waar je signaal kruist, laten oplichten.
/i/2002362215.jpeg?f=imagenormal)
Er is gelukkig een makkelijkere manier om rgb-leds aan te sturen, namelijk door gebruik te maken van leds waar al slimme logica in zit. Die zijn er weer in verschillende soorten, maar een veelgebruikte chip in ledstrips en individuele rgb-leds is de WS2812b. Dat is een superklein chipje dat in de led zelf zit en het decoderen van je signaal en het aansturen van de drie individuele rode, groene en blauwe leds voor zijn rekening neemt. Het grote voordeel van die chip is dat je maar één aanstuurkabel nodig hebt voor je complete matrix. De chip geeft het signaal namelijk steeds door aan de volgende rgb-led, of pixel zo je wil, en zo kun je leds, of strips met leds, aan elkaar knopen en eenvoudig aansturen.
Het signaal voor de WS2812b-chip bestaat uit een simpel blok data. Dat bevat een header en daarna drie bytes aan data voor elke led die is aangesloten. Die drie bytes bevatten voor elke kleur acht bits, zodat je de rode, groene en blauwe kanalen met 256 niveaus kunt aansturen. De eerste led in de streng, of matrix, pakt de eerste 3 bytes van het datapakketje en stuurt de rest door naar de volgende led. Zo snoept elk ledje zijn data van het pakketje af en geeft de rest door aan de volgende led. Elke rgb-led hoeft dus maar vier aansluitingen te hebben, met voeding, aarde, ingangssignaal en uitgangssignaal. Dat maakt het bouwen van een matrix, of een ledstrip, een stuk makkelijker.
/i/2002362219.jpeg?f=imagenormal)
We sluiten voor onze matrix geen individuele WS2812b-leds op elkaar aan, maar maken gebruik van een shortcut in de vorm van een ledstrip. Ook dat maakt het ons makkelijker, want we hoeven niet elke led te solderen, alleen de uiteinden van de strips. De strips die wij gebruiken, hebben 74 leds per meter, maar er zijn ook strips met 30, 60, 96 en zelfs 144 leds per meter. Je kunt de strips eenvoudig op maat knippen om het gewenste aantal pixels te krijgen. Voor onze .Build maken we strips van 32 leds, met een lengte van iets meer dan 43 centimeter. Dat past mooi in de Ikea Lack-tafel waarin we de matrix bouwen.
Leds/meter
|
interled-afstand
|
intraled-afstand
|
16×16 matrix
|
32×32 matrix
|
30
|
33,3mm
|
28mm
|
53,3cm
|
106,6cm
|
60
|
16,6mm
|
12mm
|
26,6cm
|
53,2cm
|
74
|
13,5mm
|
8,78mm
|
21,6cm
|
43,2cm
|
96
|
10,4mm
|
5,44mm
|
16,6cm
|
33,2cm
|
144
|
6,9mm
|
1,92mm
|
11cm
|
22cm
|
Om onze doelstelling te halen, een ledmatrix van 32 bij 32 pixels maken, hebben we 1024 ledjes nodig, wat op drie rollen van vijf meter ledstrips neerkomt. Als je een kleinere matrix wil maken, kun je voor meer ledjes per meter kiezen, of je kunt variëren wat het aantal pixels betreft. De goedkoopste optie is het gebruik van ledstrip van 30 pixels per meter; de door ons gebruikte 74 leds per meter is een van de duurste opties, omdat die minder gangbaar is dan andere variaties. Voor de Lack-tafel is het echter de mooiste strip, omdat we nog mooie randen overhouden, waarover straks meer.
Tafel en voeding
We hebben het al over de Lack-tafel gehad. We gebruiken deze ultieme tweakerstafel om de matrix in te bouwen. Dat doen we om diverse redenen. Je kunt ten eerste kiezen uit diverse kleuren en ten tweede is de tafel zo bizar goedkoop, dat je je een eventueel foutje kunt veroorloven. Bovendien is hij gemaakt van veredeld karton, zodat je er makkelijk gaten in kunt maken en je matrix in kunt bouwen.
Boodschappenlijst
We gaan uit van een ledmatrix van 32×32 leds, in totaal 1024 leds. Variabele kosten voor bijvoorbeeld het raster en verbruiksartikelen als bekabeling hebben we niet meegenomen in deze lijst. De prijzen zijn bij benadering.
-
Drie rollen WS2812b-ledstrip, 74 leds/meter: 3×35 euro
-
Drie voedingen à 20A, 5V: 3×15 euro
-
Arduino Mega 2560: 10 euro
-
Ikea Lack-bijzettafel: 7 euro
-
Witte acrylaatplaat: 10 euro
-
Plastic hoekprofiel: 5 euro
Totaal: ongeveer 162 euro
Let wel, je kunt de kosten flink drukken door ledstrips van 60 leds/meter te gebruiken. Een rol daarvan kost 15 tot 20 euro, waarmee je de kosten bijna halveert. Je kunt dan in de Lack-tafel een matrix maken van ongeveer 25×25 pixels.
Om ruimte te maken voor de leds maken we een gat in de bovenkant. We maken het gat iets groter dan de 432mm die we nodig hebben, want we dekken het af met een plaat mat acrylaat en werken de randen af met plastic profiel om de randen te verbergen. Het gat kun je simpelweg langs een liefst metalen lineaal snijden met een scherp stanleymes. We hebben eerst geëxperimenteerd met een Dremel met kleine cirkelzaagbladen en slijpschijven, maar snijden leverde het schoonste resultaat. Door eerst een centraal gat te maken en extra diagonale snedes vanuit de hoeken naar dat gat toe te maken, konden we makkelijk de bovenkant in vier driehoeken wegsnijden.
De binnenkant van de Lack-tafel bestaat letterlijk uit karton. Grote golfprofielen zorgen voor de stevigheid en die kun je met gemak weghalen. Het enige dat op hout lijkt, zijn vier klossen in de hoeken, waarin de schroeven voor de poten zitten. Als de tafel is geprepareerd, kunnen we naar het volgende onderdeel kijken: de voeding.
Voeding
De WD2812b-strips hebben een voedingsspanning van 5V nodig. Als je een paar ledjes wil aansturen, kun je dat nog makkelijk met de uitgangsvoeding van je controller, bijvoorbeeld een Arduino of Raspberry Pi doen, en met een handjevol leds heb je aan een usb-lader van bijvoorbeeld je telefoon ook nog wel genoeg. Als je echter een flink aantal ledjes gaat schakelen, kan de stroomsterkte aardig oplopen. Elk ledje verstookt maximaal 20mA bij maximale helderheid, dus per rgb-ledje is dat al 60mA. Als we dat doorrekenen voor onze matrix van 32 bij 32 leds, met ruim duizend ledjes dus, zitten we aan 60A als we alle ledjes op fel wit zetten. Nu zullen we dat in de praktijk niet snel doen, maar we moeten er wel rekening mee houden om de voeding niet per ongeluk op te blazen.
/i/2002362223.jpeg?f=imagenormal)
Uiteraard zijn er volop voedingen te vinden die de benodigde 300W kunnen leveren, maar met een spanning van slechts 5V is het lastiger. We kiezen daarom niet voor een voeding van 5V/60A, maar voor drie stuks van 5V/20A. Zo kunnen we de voedingen ook nog passief houden namelijk, aangezien een 60A-voeding actief, dus met het nodige geluid, moet worden gekoeld. We sluiten de voedingen straks ieder op een derde van de matrix aan, zodat de last netjes wordt verdeeld.
Pixels en overige onderdelen
Voordat we naar de aansturing kijken, moeten we nog afzonderlijke pixels van de ledjes maken. Als alle pixels gewoon naast elkaar liggen, lopen de kleuren in elkaar over. Een afscheiding, of raster, tussen de individuele pixels is dus gewenst. We hebben wat zitten puzzelen om dat voor elkaar te krijgen. Eerst met stroken stevig schuim van twee centimeter hoog en half ingesneden om in ze elkaar te kunnen steken, vervolgens met stroken ondervloer, dat iets steviger is, maar nog steeds niet het gewenste resultaat had. Het probleem is dat die materialen wat flexibel zijn, en als een vakje, of pixel zo je wilt, niet helemaal vierkant en even groot is als de rest, valt dat erg op.
Daarna zijn we overgestapt op houtstroken, ook weer van twee centimeter hoog. Dat werkt aardig, als je dun hout van 3mm gebruikt, zoals hardboard. Met een zaagtafel zaagden we de smalle stroken en door ze samen te binden, konden we met een afkortzaag de inkepingen tot de gewenste diepte van 1cm maken. Het nadeel van deze methode is dat je een grof raster krijgt, met dikke randen. We zouden aanraden om het van dik karton in plaats van hardboard te maken om de randen dunner te houden. Uiteindelijk hebben we echter gekozen voor een raster dat we met een 3d-printer hebben gemaakt. Dat levert precies de gewenste afmetingen op zonder stroken in elkaar te hoeven steken en de randen zijn lekker dun. Dankzij een soort messing-en-groefsysteem passen de losse rasterdelen goed in elkaar en bovendien sluiten we het geheel op met houden latjes. We hebben nog getest of zwart in plaats van wit plastic mooiere resultaten oplevert, maar we besloten het bij wit plastic te houden. Het kost wel een aardig tijdje printen om het complete raster in kleine stukjes te maken.
/i/2002362243.jpeg?f=imagenormal)
Om het licht te verstrooien, zodat je geen felle lichtpuntjes ziet, hebben we de tafel afgedekt met diffuus wit acrylaat. Dat kun je in 50x50cm-afmetingen kopen en moet je dus op maat maken. Inkerven en met een lat eronder breken, zoals je met glas zou doen, bleek hiervoor prima te werken. Ten slotte hebben we een plastic hoekprofiel in verstek gezaagd om de snijranden van de tafel en het acrylaat te verbergen.
Aansturing
Voor de aansturing zijn er legio mogelijkheden, die afhankelijk zijn van je wensen en je handigheid. Wie weleens een ledstrip heeft gekocht, heeft er naar alle waarschijnlijkheid een infraroodafstandsbediening bij gekregen en een klein controllertje met infraroodoog dat tussen de voeding en de strip moet worden geplaatst. Met zo'n controller kun je een aantal eenvoudige effecten realiseren, zoals diverse kleuren instellen of kleuren laten verlopen. Dat is al leuk en je hebt een heel aparte tafel als je je leds zo aanstuurt.
/i/2002362247.jpeg?f=imagenormal)
Wil je meer opties, dan moet je zelf aan de slag met software en een controller. Met een kleine matrix kun je toe met een Arduino Nano of Uno. Je kunt namelijk alle benodigde informatie in het werkgeheugen van die Arduino's kwijt en je hoeft niet moeilijk te doen met trucjes. Om alle leds aan te sturen heb je namelijk het aantal leds in je matrix maal 3 bytes nodig, dus in het geval van een 32 bij 32-matrix 1024 maal 3 bytes, oftewel 3kB data. Nu zijn Arduino's, zeker de Nano's en Uno's, niet direct ruim bedeeld wat geheugen betreft, dus die 3kB gaat niet passen in de 2kB van die uitvoeringen. Alleen de Mega heeft 8kB ram, dus daar past de data voor je matrix wel in.
Maak je een kleinere matrix, dan is de Uno of Nano wel prima, en je kunt ook om de geheugenbeperkingen heenwerken door bijvoorbeeld afbeeldingen die je wilt tonen, niet in ram, maar in flash op te slaan.

Een andere, veelzijdige mogelijkheid is het gebruik van een computer in combinatie met een Duits programma dat Glediator heet. Je kunt op je laptop of pc de ledanimaties bedienen en als een dj effecten in elkaar laten overlopen. We hadden succes met deze software in combinatie met een ledmatrix van 16 bij 16 pixels, maar de 32 bij 32-matrix kregen we niet aan de praat. Je hebt namelijk een Arduino als tussenstation nodig, en we liepen met een Uno tegen bovengenoemde geheugenbeperking aan voor de grote matrix. Een poging om de sketch succesvol op een Mega met meer geheugen te draaien, mislukte.
Naast Arduino's kun je ook andere kleine computers inzetten om je matrix te bedienen. Zo kun je bijvoorbeeld een Teensy-microcontroller of een esp8266 gebruiken, of andere microcontrollers waarop de code in real time draait. Volgens velen is dat namelijk een voorwaarde om de leds aan te sturen: een rtos, of realtimebesturingssysteem. De timing van de aansturing let namelijk nogal nauw en een verstoring in de aansturing kan de patronen danig in de war sturen. Een besturingssysteem als Windows of Linux (uitzonderingen daargelaten) werkt niet in real time en kan voorrang geven aan andere zaken dan de aansturing van je leds. Dat is de reden om voor Glediator tussen de laptop en de leds een Arduino te plaatsen; die zorgt voor de juiste timing.

Toch hebben we met een Raspberry Pi en Raspbian succes gehad. Je kunt een van de gpio-pinnen gebruiken om je leds aan te sturen, bijvoorbeeld met een python-library als rpi_WS281x. Wel wordt aangeraden om een logic level converter te gebruiken om het 3,3V-signaal van de Pi-gpio-pinnen naar 5V te converteren. De WS2812b-leds verwachten namelijk 0,7x de voedingsspanning op de signaalpin, maar toen we het eerst zonder een dergelijke converter probeerden, werkte het ook.
Er zijn nog legio andere opties om je leds aan te sturen, maar bovenstaande zijn de meestgebruikte. Vooral Adafruit heeft uitgebreide libraries voor WS2812-leds ontwikkeld voor de Arduino-ide, die veelzijdig en redelijk eenvoudig in gebruik zijn.Ook de Fastled-library is goed te gebruiken voor rgb-ledstrips en de NeoMatrix-library, opnieuw van Adafruit, is ook een aanrader.
De bouw
Met alle onderdelen in huis kunnen we met de bouw te beginnen. We beginnen met het opknippen van de ledstrips in strengen van 32 leds. Je kunt van dit type ledstrips elke led individueel losknippen, zolang je dat maar op de kniplijn doet. Je kunt dan de voeding- en signaalkabels op de koperen soldeerpads vastsolderen.
/i/2002362259.jpeg?f=imagenormal)
Als ondergrond nemen we een stuk hardboard zo groot als de matrix, dus van 432 millimeter in het vierkant. Om het solderen wat makkelijker te maken en vooral de draadjes uit de weg van het geprinte raster te houden, hebben we de twee zijkanten van de plaat waar we solderen een beetje afgeschuind. Vervolgens tekenen we een raster op de plaat waar we de ledstrips moeten plakken en dan begint de matrix vorm te krijgen.
De volgende stap is het solderen van alle draadjes, waar we een netwerkkabel voor opofferen. Omdat de stroomsterkte vrij groot kan worden en de netwerkadertjes dun zijn, solderen we voedingskabeltjes aan elke strip van 32 leds en knopen we elf strips aan elkaar met een dikkere kabel. De positieve voeding solderen we aan de ene kant en de negatieve aan de andere kant van de strips. Zo stuurt elk van de drie voedingen elf strips van 32 leds aan en blijven de stroomsterktes binnen de perken. De signaaldraad moeten we uiteraard ook doorlussen van strip naar strip en ook daarvoor gebruiken we korte netwerkadertjes. Let erop dat je de kabels van 'out' naar 'in' soldeert. Als het soldeerwerk klaar is, kunnen we de matrix even testen met bijvoorbeeld een strandtest-sketch of matrixtest-sketch van de Neopixel-library, die we naar de Arduino Mega uploaden.
De uitgeholde Lack-tafel dient als behuizing en we maken een paar gaten in de bodemplaat om daar de voedingskabels en de signaaldraad doorheen te voeren. Met wat vulhout kun je de plaat met ledstrips op de juiste hoogte krijgen. Dat vergt wat experimenteren met de acrylaatplaat en het raster op hun plek, zodat je de bovenkant netjes vlak kunt krijgen. Je kunt de ledstripplaat vastlijmen, schroeven of plakken, maar de kans is groot dat met een beetje klemmen alles al goed op zijn plek blijft zitten.
De voedingen hebben we onder de tafel gemonteerd op een plaat hardboard. Omdat het hout van het tafeltje niet bijzonder stevig is, hebben we dat hardboard met een tweede stuk hardboard aan de binnenkant van de tafel bevestigd. De onderkant van de Lack-tafel is zo gesandwicht tussen de twee platen hout om krachten zoveel mogelijk te verdelen. Nu is het nog een kwestie van de kabels door een gat in de onderkant routeren en we zijn bijna klaar. We hebben met tiewraps door de sandwich heen voor kabelontlasting gezorgd, zodat we niet per ongeluk een voedingskabel lostrekken. Een netschakelaar op de voedingskabel naar de drie voedingen toe stelt je in staat de tafel makkelijk aan en uit te zetten, zonder de stekker in het stopcontact te hoeven steken. We hebben om te voorkomen dat iemand per ongeluk de voedingen of bekabeling kan raken, nog een ombouw onder de tafel gemaakt die de voedingen afschermt. Zo zijn alleen de usb-kabel van de Arduino, de netvoedingsstekker en de schakelaar toegankelijk.
Tot slot
Je tafel is klaar en functioneel. Je kunt met de Adafruit-libraries en een Arduino Mega allerlei effecten op je tafel toveren, maar het wordt nog leuker als je er een beetje pixelart op kunt tonen. We hadden het er eerder al even over, maar je kunt niet simpelweg een afbeelding in een sketch gooien. Je zult die eerst moeten vertalen in een formaat waar de Arduino iets mee kan. We gebruiken de UTFT ImageConverter om een willekeurige afbeelding te converteren naar een utf-bestand. Die laden we met een sketch in progmem, oftewel het flashgeheugen, en roepen die afbeeldingsdata op in een sketch.
Zo kunnen we kleine plaatjes, liefst vierkante en herkenbare afbeeldingen, converteren en op de ledtafel tonen. We gebruiken daarvoor de MatrixGFXDemo-sketch uit de NeoMatrix-library van Adafruit. Om jouw afbeeldingen te tonen, moet je de c-file met afbeeldingsdata samen met de sketch naar je Arduino uploaden en uiteraard de juiste pin definiëren waarop je je matrix hebt aangesloten.
Als we het toch over de aansluitingen van de Arduino hebben, moeten we overigens nog even de voeding en aarde melden. We sluiten de Arduino gewoon aan op dezelfde 5V-voeding als de ledstrips. In principe delen ze dan de aarde of massa met de ledstrips, maar we onderstrepen nog even dat je de aarde of massa van de ledstrips en de Arduino met elkaar moet verbinden. Dat voorkomt storingen. Zo kun je ook een weerstandje van een paar honderd ohm tussen je ledstrip en je Arduino, of andere controller, zetten om eventuele beschadiging te voorkomen en het kan evenmin kwaad een flinke condensator op de voeding van je ledmatrix te zetten.
We hebben met bovenstaande sketch allerlei afbeeldingen op de tafel getoond. Daarbij zetten we de helderheid van de leds vrij conservatief. Je kunt die namelijk instellen op 0-255, maar om je ogen een beetje te beschermen en de Chinese voedingen niet te laten klappen, hebben we die op 40 ingesteld. Alles boven de 100 vonden we bizar fel worden en zal bovendien je ledjes flink opwarmen.
/i/2002362285.jpeg?f=imagenormal)
We hebben nog wat geëxperimenteerd met een Raspberry Pi en gestoeid met de rpi_WS281x-library. Daarmee kun je met behulp van python je ledmatrix aansturen en in principe elke afbeelding op je Pi op je tafel tonen. Als we dat een tijdje lieten lopen, zagen we echter veel glitches, dus helemaal perfect werkte dat voor ons niet. Nu kun je natuurlijk altijd zelf rondstruinen op internet en inspiratie opdoen van een van de vele ledmatrixprojecten die anderen hebben gebouwd. Zo kun je zelfs games spelen op je tafel, of animated gifs of video op je matrix tonen. Je budget, handigheid en creativiteit zijn je enige beperkingen.