Componenten · 11 min leestijd

NeoPixel-matrix met Arduino: gids voor 8x8- en 16x16-WS2812B-ledpanelen

NeoPixel-matrix met Arduino: serpentine-indeling op 8x8- en 16x16-WS2812B-panelen, de XY-functie, scrollende tekst, animaties, stroomlimieten, ESP32- en Pico-code.

Een NeoPixel-matrix is een van de meest opvallende displays die je met Arduino kunt bouwen. Hij bestaat uit 8x8 (64 leds) of 16x16 (256 leds) adresseerbare WS2812B-RGB-leds op een paneel, en je stelt de kleur van elke pixel afzonderlijk in via één datadraad. Ideaal voor scrollende tekst, pictogrammen, kleine spelletjes, audiospectrumweergaven en decoratieve animaties. In deze gids leer je stap voor stap de serpentine-indeling in het paneel, de functie die een x-y-coördinaat omzet naar een lednummer, scrollende tekst en animaties.

Werken met een matrix vraagt iets meer zorg dan een enkele NeoPixel-strip. 256 leds kunnen bij volle helderheid meer dan 15 ampère trekken, de 2 KB RAM van de Arduino Uno raakt bij grote panelen snel vol, en de 3,3 V-uitgang van de ESP32 en Pico kan bij sommige panelen problemen geven. Daarom behandelen we naast de code ook stroomberekening, helderheidsbeperking en geheugenplanning. Ken je de basis van de WS2812B nog niet? Lees dan eerst het bericht over de WS2812B-NeoPixel-led.

8x8 NeoPixel-WS2812B-ledmatrixpaneel
8x8-NeoPixel-ledmatrix: 64 WS2812B-leds, één datalijn (DIN) en 5 V-voeding.

Wat is een NeoPixel-ledmatrix en hoe werkt hij?

In elke WS2812B-led zit naast de rode, groene en blauwe chips een kleine driver-IC. De microcontroller stuurt per led 24 bits kleurdata over de datalijn met 800 kHz; de bitvolgorde is groen, rood, blauw (GRB). De eerste led houdt de eerste 24 bits voor zichzelf en geeft de rest via zijn DOUT-pin door aan de volgende, en zo gaat de keten verder. Een matrixpaneel werkt hetzelfde: 64 of 256 leds zijn eigenlijk één lange strip die tot een vierkant is gevouwen. Data naar één led sturen kost ongeveer 30 microseconden, dus één keer een paneel van 256 leds bijwerken duurt ongeveer 7,7 ms, wat vloeiende animatie met meer dan 100 beelden per seconde betekent.

Eigenschap8x8-matrix16x16-matrix
Aantal leds64256
Gangbaar formaatOngeveer 65–80 mmOngeveer 160 mm (flexibel paneel)
Voeding5 V5 V
Piekstroom bij volledig witOngeveer 3,8 AOngeveer 15,4 A
Met alle leds uitOngeveer 40–65 mAOngeveer 150–260 mA
Benodigd RAM (3 bytes/led)192 bytes768 bytes
Tijd om het hele paneel bij te werkenOngeveer 2 msOngeveer 7,7 ms
DatalijnEnkele pin (DIN), 800 kHzEnkele pin (DIN), 800 kHz

Serpentine-pixelindeling en de XY-coördinaatfunctie

In code wil je een pixel zien als een (x, y)-coördinaat, maar leds worden aangesproken met één index die bij 0 begint. Op bijna alle flexibele panelen en op 16x16-modellen liggen de leds in een zigzag-volgorde (serpentine): de eerste rij loopt van links naar rechts, de tweede rij van rechts naar links en de derde weer van links naar rechts. Deze indeling maakt de productie eenvoudiger, omdat het einde van elke rij via de kortste weg aansluit op het begin van de volgende. In de tabel hieronder zie je de lednummers in de eerste vier rijen van een 8x8-serpentinepaneel:

Rijx=0x=1x=2x=3x=4x=5x=6x=7
y=001234567
y=115141312111098
y=21617181920212223
y=33130292827262524

De formule volgt direct: op even rijen is index = y × W + x en op oneven rijen index = y × W + (W − 1 − x), waarbij W de breedte van het paneel is. Op een 8x8-paneel is het punt (2, 1) bijvoorbeeld led nummer 1 × 8 + (7 − 2) = 13. Let op: op sommige 8x8-boards met stijve printplaat lopen alle rijen in dezelfde richting (een rechte of progressieve indeling); dan is de formule gewoon y × W + x. Op sommige panelen slingeren de leds langs kolommen in plaats van rijen, waardoor x en y moeten worden verwisseld. De zekerste manier om te achterhalen welk type je hebt, is een testsketch draaien die de leds één voor één laat oplichten, en kijken hoe het licht zich verplaatst.

Bedrading van de NeoPixel-matrix: Arduino Uno, ESP32 en Pico

Pin van de matrixArduino UnoESP32Raspberry Pi Pico
5V (VCC)+ van de externe 5 V-voeding (5V-pin voor een kleine test)+ van de externe 5 V-voedingExterne 5 V-voeding of VBUS (alleen 8x8, lage helderheid)
GNDGND + – van de voeding (gemeenschappelijk)GND + – van de voeding (gemeenschappelijk)GND + – van de voeding (gemeenschappelijk)
DIND6 (via een weerstand van 330 Ω)GPIO 16 (via een weerstand van 330 Ω)GP2 (via een weerstand van 330 Ω)
DOUTDIN van het volgende paneel (daisy chain)DIN van het volgende paneelDIN van het volgende paneel
Voed een 16x16-paneel nooit op volle helderheid via de 5V-pin van de Arduino of via USB: een USB-poort van een computer levert ongeveer 500 mA, en de beveiligingszekering van de Uno springt rond dat niveau. Verwar ook de DIN- en DOUT-kant van het paneel niet; de pijl op de print toont de richting waarin de data stroomt, en als je data in DOUT stuurt, licht geen enkele led op. Gebruik je een externe voeding, verbind dan altijd de GND ervan met de GND van de microcontroller.

Voor een robuuste schakeling voeg je drie kleine onderdelen toe: een weerstand van 300–500 Ω in serie met de datalijn (die beschermt de ingang van de eerste led tegen spanningspieken), een elco van 1000 µF over 5V en GND van het paneel (die vlakt de stroompiek af wanneer de voeding voor het eerst wordt ingeschakeld) en zo nodig een niveauconverter op 3,3 V-boards. Bij een voeding van 5 V wil de WS2812B op zijn dataingang minstens ongeveer 3,5 V zien (70% van de voedingsspanning); de 3,3 V-uitgang van de ESP32 en Pico werkt op de meeste panelen, maar zit onder die grens. Zie je flikkering of willekeurige kleuren, gebruik dan een buffer-IC zoals de 74AHCT125; de details staan in het bericht over de logische niveauconverter.

Stap voor stap je eerste matrixprogramma (Arduino Uno)

  1. Open de Library Manager in de Arduino IDE en installeer de bibliotheek Adafruit NeoPixel.
  2. Sluit het paneel aan zoals in de tabel: DIN via een weerstand van 330 Ω op D6, GND op de GND van de Arduino, 5V op de voeding.
  3. Stel W en H in de code in op het formaat van je paneel; maak ze bij een 16x16-paneel allebei 16.
  4. Houd de helderheid bij de eerste poging laag; met setBrightness(30) daalt de stroom van een 8x8-paneel tot een niveau dat USB aankan.
  5. Upload de code; je zou een diagonaal scrollende regenboog moeten zien. Als de kleuren rij voor rij kapot lijken, heeft je paneel een andere indeling; pas dan de functie xyIndex daarop aan.
C++ (Arduino IDE)
1#include <Adafruit_NeoPixel.h>
2
3#define PIN_DATA 6                 // DIN pini (330 ohm ile) / DIN pin (via 330 ohm)
4#define W 8                        // panel genişliği / panel width
5#define H 8                        // panel yüksekliği / panel height
6#define NUM_LEDS (W * H)
7
8Adafruit_NeoPixel strip(NUM_LEDS, PIN_DATA, NEO_GRB + NEO_KHZ800);
9
10// (x, y) koordinatını LED numarasına çevirir (zikzak) / converts (x, y) to LED index (serpentine)
11uint16_t xyIndex(uint8_t x, uint8_t y) {
12  if (y & 1) {
13    return y * W + (W - 1 - x);    // tek satırlar sağdan sola / odd rows run right to left
14  }
15  return y * W + x;                // çift satırlar soldan sağa / even rows run left to right
16}
17
18void setup() {
19  strip.begin();
20  strip.setBrightness(30);         // 0-255, düşük tut / keep it low
21  strip.clear();
22  strip.show();
23}
24
25void loop() {
26  static uint16_t hueBase = 0;
27  for (uint8_t y = 0; y < H; y++) {
28    for (uint8_t x = 0; x < W; x++) {
29      uint16_t hue = hueBase + (x + y) * 4096U;   // çapraz gökkuşağı / diagonal rainbow
30      strip.setPixelColor(xyIndex(x, y), strip.gamma32(strip.ColorHSV(hue)));
31    }
32  }
33  strip.show();                    // tamponu panele gönder / push the buffer to the panel
34  hueBase += 256;                  // renkleri kaydır / shift the colors
35  delay(20);
36}

Het hart van de code is de functie xyIndex(): door x op oneven rijen om te draaien verbergt ze de serpentine-indeling, zodat je in de rest van de code alleen in coördinaten denkt. ColorHSV() zet een tintwaarde tussen 0 en 65535 op het kleurenwiel om naar RGB; omdat de tint verschuift naarmate de som x + y groter wordt, krijg je diagonale kleurbanden. gamma32() corrigeert voor de manier waarop het oog helderheid waarneemt en laat kleurovergangen natuurlijker ogen. Tot slot bereikt geen enkele wijziging het paneel totdat je show() aanroept; eerst alle pixels in het geheugen schrijven en ze in één keer versturen is het geheim van een vloeiend beeld.

Scrollende tekst: met Adafruit NeoMatrix

Je hoeft niet pixel voor pixel te knutselen om letters en pictogrammen te tekenen. De bibliotheek Adafruit NeoMatrix maakt van je NeoPixel-paneel een display dat compatibel is met Adafruit GFX, zodat de functies die je op OLED-displays gebruikt, zoals print(), drawLine(), fillRect() en drawBitmap(), ook op de matrix werken. Als je Adafruit NeoMatrix via de Library Manager installeert, installeer dan ook de afhankelijkheden Adafruit GFX en Adafruit NeoPixel. De vlaggen in de constructor beschrijven de fysieke indeling van het paneel: NEO_MATRIX_TOP + NEO_MATRIX_LEFT zegt dat de eerste led in de linkerbovenhoek zit, NEO_MATRIX_ROWS zegt dat de leds langs rijen lopen en NEO_MATRIX_ZIGZAG zegt dat de rijen zigzaggen; schrijf op een board met rechte indeling gewoon NEO_MATRIX_PROGRESSIVE in plaats van ZIGZAG. Het standaardlettertype van 5×7 past perfect op een paneel met 8 rijen, en elk teken is 6 pixels breed, inclusief de tussenruimte. Een tekst van negen letters is 54 pixels lang; de constante textWidth berekent dit automatisch, en wanneer x onder die waarde komt, verschijnt de tekst opnieuw van rechts en verandert van kleur.

C++ (Arduino IDE)
1#include <Adafruit_GFX.h>
2#include <Adafruit_NeoMatrix.h>
3#include <Adafruit_NeoPixel.h>
4
5#define PIN_DATA 6
6
7// 8x8 panel, ilk LED sol üstte, zikzak satırlar / 8x8 panel, first LED top-left, zigzag rows
8Adafruit_NeoMatrix matrix(8, 8, PIN_DATA,
9  NEO_MATRIX_TOP + NEO_MATRIX_LEFT + NEO_MATRIX_ROWS + NEO_MATRIX_ZIGZAG,
10  NEO_GRB + NEO_KHZ800);
11
12const char text[] = "BlueGrays";
13const int textWidth = (sizeof(text) - 1) * 6;   // karakter başına 6 piksel / 6 pixels per character
14int x = 8;                                      // yazı sağ kenardan başlar / text starts at the right edge
15uint8_t colorStep = 0;
16
17void setup() {
18  matrix.begin();
19  matrix.setTextWrap(false);       // satır kaydırma kapalı / no line wrap
20  matrix.setBrightness(40);
21  matrix.setTextColor(matrix.Color(255, 0, 0));
22}
23
24void loop() {
25  matrix.fillScreen(0);
26  matrix.setCursor(x, 0);
27  matrix.print(text);
28  if (--x < -textWidth) {          // yazı panelden tamamen çıktı / text fully left the panel
29    x = matrix.width();
30    colorStep = (colorStep + 1) % 3;
31    if (colorStep == 0) matrix.setTextColor(matrix.Color(255, 0, 0));
32    if (colorStep == 1) matrix.setTextColor(matrix.Color(0, 255, 0));
33    if (colorStep == 2) matrix.setTextColor(matrix.Color(0, 0, 255));
34  }
35  matrix.show();
36  delay(80);                       // kayma hızı / scroll speed
37}

Geheugenlimieten op de Arduino Uno

De ATmega328P van de Arduino Uno heeft slechts 2048 bytes RAM, en elke led heeft een kleurbuffer van 3 bytes nodig. Een 8x8-paneel past met 192 bytes makkelijk, terwijl een 16x16-paneel 768 bytes inneemt, alleen al meer dan een derde van het RAM. Het verraderlijke is dit: Adafruit NeoPixel reserveert deze buffer terwijl het programma draait, dus hij staat niet in het gebruik van globale variabelen dat na het compileren wordt getoond. Ook als de build 70% gebruik meldt, kan het geheugen opraken zodra de paneelbuffer erbij komt; het board loopt dan vast of je ziet betekenisloze kleuren. Daarnaast zijn op AVR-boards interrupts uitgeschakeld terwijl show() draait; met 256 leds duurt dit ongeveer 7,7 ms, waarin millis() achter kan gaan lopen en data die via Serial binnenkomt verloren kan gaan. Voor grote panelen is een Arduino Mega met 8 KB RAM of een ESP32 met honderden kilobytes een veel comfortabelere keuze.

PanelAantal ledsKleurbufferAandeel van het RAM van de UnoGeschikt voor Uno?
8x864192 bytes9%Ruim voldoende
8x32256768 bytes37,5%Met zorgvuldig gebruik
16x16256768 bytes37,5%Met zorgvuldig gebruik
2 × 16x165121536 bytes75%Lastig in de praktijk
32x3210243072 bytes150%Niet mogelijk (gebruik een ESP32)

Stroomverbruik en helderheidsbeperking

Elk kleurkanaal van een WS2812B trekt bij volle helderheid ongeveer 20 mA; als alle drie branden, dus wit, komt dat op 60 mA per led. Voor een ruwe berekening kun je de formule I ≈ aantal leds × 60 mA × (helderheid / 255) gebruiken. Een 16x16-paneel op volledig wit trekt 256 × 60 = 15.360 mA, meer dan 15 A; dat belast zowel voedingen als de dunne koperen sporen van het paneel. Het goede nieuws is dat een matrix erg helder is: binnenshuis ziet een helderheid van 20–50 van 255 er al duidelijk genoeg uit om op te vallen. In echte animaties zijn niet alle leds tegelijk wit, dus de gemiddelde stroom ligt veel lager dan het berekende getal, maar je moet de voeding nog steeds op het slechtste geval kiezen of de stroom in software beperken.

Paneel (volledig wit)Helderheid 32 (12,5%)Helderheid 64 (25%)Helderheid 255 (100%)Aanbevolen voeding
8x8 (64 leds)Ongeveer 0,48 AOngeveer 0,96 AOngeveer 3,8 A5 V 2–4 A
16x16 (256 leds)Ongeveer 1,9 AOngeveer 3,9 AOngeveer 15,4 A5 V 4–10 A + beperking in software

Als je op een 16x16-paneel de stroom maar van één kant toevoert, zien de leds in de verste hoek een spanningsval en ziet wit er geelachtig of roodachtig uit. Voorkom dit door 5V en GND zowel aan de ingang als aan de uitgang van het paneel toe te voeren, met draad van minstens 0,75 mm² doorsnede; dit heet power injection. In software berekent de functie setMaxPowerInVoltsAndMilliamps(5, 2000) van de bibliotheek FastLED bij elk beeld de geschatte stroom en verlaagt automatisch de helderheid als de limiet zou worden overschreden. Werk je op batterijen, dan kun je met de batterijduurcalculator controleren hoe lang de schakeling het volhoudt, en voor details over het kiezen van een voeding zie je het bericht over de voeding van de Arduino.

16x16-matrixanimatie met de ESP32 (FastLED)

Met zijn grote RAM en 240 MHz-processor is de ESP32 een veel comfortabelere keuze voor grote panelen; omdat hij het NeoPixel-signaal opwekt met zijn RMT-hardware-eenheid, houdt hij de processor ook niet te veel bezig. De onderstaande code gebruikt FastLED om twee gekleurde punten met een staart over een 16x16-paneel te laten glijden. beatsin8() levert een coördinaat die sinusvormig in de tijd heen en weer beweegt, terwijl fadeToBlackBy() bij elk beeld alle pixels een beetje dimt voor het staarteffect. Installeer gewoon de nieuwste versie van FastLED via de Library Manager; actuele versies ondersteunen zowel de 2.x- als de 3.x-releases van de ESP32-Arduino-core.

C++ (Arduino IDE)
1#include <FastLED.h>
2
3#define DATA_PIN 16                // DIN -> GPIO 16 (330 ohm ile) / DIN -> GPIO 16 (via 330 ohm)
4#define W 16
5#define H 16
6#define NUM_LEDS (W * H)
7
8CRGB leds[NUM_LEDS];
9
10// Zikzak dizilim için koordinat dönüşümü / coordinate mapping for serpentine layout
11uint16_t xyIndex(uint8_t x, uint8_t y) {
12  return (y & 1) ? (y * W + (W - 1 - x)) : (y * W + x);
13}
14
15void setup() {
16  FastLED.addLeds<WS2812B, DATA_PIN, GRB>(leds, NUM_LEDS);
17  FastLED.setBrightness(60);                       // genel parlaklık / global brightness
18  FastLED.setMaxPowerInVoltsAndMilliamps(5, 2000); // 5 V, en fazla 2 A / 5 V, max 2 A
19  FastLED.clear(true);
20}
21
22void loop() {
23  static uint8_t hue = 0;
24  fadeToBlackBy(leds, NUM_LEDS, 30);               // iz efekti / trail effect
25
26  uint8_t px1 = beatsin8(13, 0, W - 1);            // sinüs salınımlı koordinatlar / sine-wave coordinates
27  uint8_t py1 = beatsin8(17, 0, H - 1);
28  uint8_t px2 = beatsin8(11, 0, W - 1, 0, 64);
29  uint8_t py2 = beatsin8(7, 0, H - 1, 0, 128);
30
31  leds[xyIndex(px1, py1)] = CHSV(hue, 255, 255);
32  leds[xyIndex(px2, py2)] = CHSV(hue + 128, 255, 255);
33
34  FastLED.show();
35  hue++;
36  delay(16);                                       // yaklaşık 60 kare/sn / about 60 fps
37}

NeoPixel-matrix met de Raspberry Pi Pico en MicroPython

MicroPython op de Pico wordt geleverd met de module neopixel ingebouwd, dus je hoeft geen extra bestanden te kopiëren. De module regelt zelf de timing van het signaal; jij wijst alleen kleuren toe met np[i] = (r, g, b) en stuurt ze met write() naar het paneel. Omdat MicroPython geen setBrightness-functie heeft zoals de Adafruit-bibliotheek, beperk je de helderheid zelf door de kleurwaarden met een factor te vermenigvuldigen. Het voorbeeld hieronder laat langzaam een hartpictogram in- en uitfaden op een 8x8-paneel; het pictogram wordt getekend uit een bitmaparray waarin elke rij één byte is en de meest linkse bit overeenkomt met kolom x = 0.

MicroPython
1from machine import Pin
2from neopixel import NeoPixel
3import time
4
5W, H = 8, 8
6np = NeoPixel(Pin(2), W * H)       # DIN -> GP2 (330 ohm ile) / DIN -> GP2 (via 330 ohm)
7BRIGHTNESS = 0.1                   # %10 parlaklık / 10% brightness
8
9HEART = [
10    0b01100110,
11    0b11111111,
12    0b11111111,
13    0b11111111,
14    0b01111110,
15    0b00111100,
16    0b00011000,
17    0b00000000,
18]
19
20def xy_index(x, y):
21    # zikzak dizilim / serpentine layout
22    if y % 2:
23        return y * W + (W - 1 - x)
24    return y * W + x
25
26def draw_bitmap(rows, color):
27    r, g, b = color
28    c = (int(r * BRIGHTNESS), int(g * BRIGHTNESS), int(b * BRIGHTNESS))
29    for y in range(H):
30        for x in range(W):
31            on = rows[y] & (0x80 >> x)     # soldaki bit x=0 / leftmost bit is x=0
32            np[xy_index(x, y)] = c if on else (0, 0, 0)
33    np.write()                     # panele gönder / push to the panel
34
35while True:
36    for level in range(0, 256, 8):         # kalp yavaşça yanar / heart fades in
37        draw_bitmap(HEART, (level, 0, 0))
38        time.sleep_ms(20)
39    for level in range(255, -1, -8):       # ve söner / and fades out
40        draw_bitmap(HEART, (level, 0, 0))
41        time.sleep_ms(20)

Projectideeën voor een NeoPixel-matrix

  • Scrollend tekstbord: laat berichten van internet of de tijd scrollen met een ESP32; voor de klok kun je de methode uit het bericht over de ESP32-NTP-klok gebruiken.
  • Snake- en blokkenspellen: bouw een kleurrijke minigameconsole met een 16x16-paneel en een joystick.
  • Muziekgevoelig spectrum: toon het geluidsniveau dat een microfoon meet als gekleurde kolommen; details staan in het bericht over de muziekgevoelige led.
  • Pictogrambadge: schakel met een knop op een 8x8-paneel tussen pictogrammen zoals een smiley, een hart en een pijl.
  • Kleurrijke thermometer: teken een balk die van blauw naar rood vult op basis van de temperatuur die een DHT11 meet.
  • Bediening met je telefoon: installeer WLED op een ESP32 en bestuur het paneel via Wi-Fi met kant-en-klare 2D-effecten.
  • Kerstdecoratie: voeg een visueel paneel met sneeuwval- en sterrenanimaties toe aan je project kerstboom-led.

Veelgemaakte fouten en hoe je ze oplost

SymptoomWaarschijnlijke oorzaakOplossing
Geen enkele led licht opData zit op DOUT, GND is niet gemeenschappelijk of het pinnummer klopt nietControleer de pijl en voer data in DIN in, verbind de GND's en controleer de pin in de code
Beeld kapot rij voor rij, tekst gespiegeldDe indeling is niet serpentine of de beginhoek is andersZoek de eerste led met een testsketch, pas xyIndex of de NeoMatrix-vlaggen aan
Verkeerde kleuren (groen in plaats van rood)Kleurvolgorde verkeerd ingesteldGebruik NEO_GRB bij Adafruit, GRB bij FastLED
Willekeurig flikkerende pixelsDatasignaal van 3,3 V te zwak, geen serieweerstand of een lange datadraadVoeg een niveauconverter en een weerstand van 330 Ω toe, maak de datadraad korter
Board reset bij heldere beeldenVoeding te zwak, spanning zakt inVerlaag de helderheid, gebruik een sterke externe voeding en een condensator van 1000 µF
Wit ziet er in de verste hoek geelachtig uitSpanningsval langs de sporen van het paneelVoer stroom toe vanaf beide kanten van het paneel
Uno loopt vast of toont betekenisloze kleurenRAM is opVerminder het aantal leds, schrijf tekst met F(), stap over op een ESP32 of Mega
Als het beeld betekenisloos uitkomt, test dan de indeling voordat je de code de schuld geeft: laat in loop() de leds één voor één oplichten, beginnend bij 0 en op lage helderheid, en let op het pad dat het licht volgt. Zien in welke hoek led nummer 0 zit en welke kant de tweede rij op loopt is genoeg om de juiste xyIndex-formule of NeoMatrix-vlaggen te kiezen.

Een NeoPixel-matrix is de leukste manier om je projecten met een betaalbaar paneel een kleurrijk, bewegend display te geven. Begin klein: laat eerst een 8x8-paneel op lage helderheid draaien, krijg de functie xyIndex aan de praat en ga dan verder met scrollende tekst en 16x16-animaties. Hoef je alleen eenkleurige tekst en cijfers te tonen, dan is een MAX7219-ledmatrix een alternatief dat minder stroom trekt. In de BlueGrays-app kun je projecten met WS2812B-politielichten, Knight Rider en animaties, en snakespellen op 8x8- en 16x16-matrices stap voor stap verkennen, met schakelschema's en code.

Veelgestelde vragen

Kan ik een NeoPixel-matrix voeden via de 5V-pin van de Arduino?

Een 8x8-paneel kun je voor korte tests op lage helderheid (zoiets als 20–30 van 255) voeden via USB en de 5V-pin; de stroom blijft dan op een paar honderd milliampère. Gebruik bij een 16x16-paneel of hoge helderheid altijd een externe 5 V-adapter en deel de GND met de Arduino. Anders reset het board of kan de USB-poort beschadigd raken.

Hoeveel ampère trekt een 16x16-WS2812B-matrix?

Omdat elke led bij volledig wit ongeveer 60 mA trekt, komt een paneel met 256 leds in het slechtste geval boven 15 A. In echte animaties ligt het getal veel lager; als je de helderheid verlaagt naar 32, is het zelfs bij volledig wit ongeveer 1,9 A. Kies een voeding van minstens 4 A en stel met FastLED een stroomlimiet in software in.

Waarom lijkt de tekst op mijn ledmatrix omgekeerd of kapot?

De code gaat uit van de verkeerde paneelindeling. Je paneel kan recht zijn in plaats van serpentine, de eerste led kan in een andere hoek zitten, of de leds kunnen langs kolommen in plaats van rijen lopen. Achterhaal de indeling met een test die de leds achter elkaar laat oplichten en pas daarna de functie xyIndex of de NeoMatrix-vlaggen aan.

Hoeveel NeoPixel-leds kan een Arduino Uno aansturen?

Omdat elke led 3 bytes RAM gebruikt, ligt de praktische limiet op een Uno met 2 KB RAM bij ongeveer 300–500 leds; de rest van het geheugen is nodig voor de eigen variabelen van de code. Eén 16x16-paneel (256 leds) werkt zonder problemen. Voor twee panelen of meer is een Arduino Mega of ESP32 geschikter.

Heb ik een niveauconverter nodig voor een WS2812B-matrix met een ESP32?

Bij een voeding van 5 V wil de WS2812B ongeveer 3,5 V op zijn dataingang; de 3,3 V-uitgang van de ESP32 zit daar iets onder. De meeste panelen werken toch, maar zie je flikkering of willekeurige kleuren, gebruik dan een niveauconverter zoals de 74AHCT125. Een korte datadraad en een serieweerstand van 330 Ω verbeteren het signaal ook.

Wat is het verschil tussen een NeoPixel-matrix en een MAX7219-matrix?

In een NeoPixel-matrix is elke pixel een RGB-led die afzonderlijk gekleurd kan worden en met één datadraad wordt aangestuurd, maar het stroomverbruik is hoog. MAX7219-matrices zijn eenkleurig, worden met drie datadraden aangesloten en trekken veel minder stroom. MAX7219 past bij eenkleurige scrollende borden, terwijl NeoPixel beter is voor kleurenanimaties en spellen.

Alle projecten bekijken
Een WS2812B-ledstrip gebruiken
AR-69Gemiddeld
Premium

Een WS2812B-ledstrip gebruiken

Maak kennis met een slimme ledstrip waarvan je elk lampje apart kunt kleuren. De Arduino laat eerst de eerste vijf leds rood branden, zet een seconde later de andere vijf blauw, schakelt dan alles…

4.8(54)
70
Politieknipperlicht met WS2812B
AR-70Gemiddeld
Premium

Politieknipperlicht met WS2812B

Je haalt de rode en blauwe lichten van het dak van een politieauto naar je bureau.

4.8(67)
86
WS2812B Knight Rider-effect
AR-73Gemiddeld
Premium

WS2812B Knight Rider-effect

Een rood lichtpuntje glijdt van het ene uiteinde van een slimme ledstrip naar het andere en komt dan terug, heen en weer zonder ooit te stoppen.

4.9(73)
94
WS2812B-animatie 1
AR-75Gemiddeld
Premium

WS2812B-animatie 1

Op een strip van 56 leds staan alle kleuren van de regenboog naast elkaar en stromen ze zonder ophouden door, alsof er een rivier van licht over de strip glijdt.

4.9(69)
89
WS2812B-animatie 2
AR-76Gemiddeld
Premium

WS2812B-animatie 2

Zet in je kamer een lichtshow op die helemaal zelf van kleur verandert. De Arduino laat kleuren over een strip van 30 leds stromen en schakelt om de paar seconden over op een nieuwe kleurenset…

4.8(65)
84
Pixelslang 8x8-matrix
AR-88Gevorderd
Premium

Pixelslang 8x8-matrix

Bouw het klassieke slangenspel zelf en speel het. Op een kleurrijke 8x8-lichtmatrix stuur je met een joystick een groene slang en eet je rode appels.

4.7(39)
57
Matrixslang 16x16
AR-89Gevorderd
Premium

Matrixslang 16x16

Het klassieke slangenspel, nu op een enorm ledscherm van 256 lichtjes. Je stuurt de groene slang met een joystick en verzamelt rode appels.

4.8(52)
67
ESP32 WS2812B NeoPixel-strip aansturen
ES-24Gemiddeld
Premium

ESP32 WS2812B NeoPixel-strip aansturen

WS2812B-leds (NeoPixel) zijn adresseerbare slimme RGB-leds die je kunt doorlussen en via één datapin kunt aansturen. In dit project sturen we een WS2812B-strip met 8 leds aan met de Adafruit_NeoPixel-bibliotheek en maken we een vloeiende regenbooganimatie. De 3,3V-logica van de ESP32 werkt met de meeste WS2812B-batches; wordt het instabiel, dan laten we de oplossing zien met een serieweerstand van 470Ω en een condensator van 1000µF. De animatie schuift de tint op in de HSV-kleurruimte.

4.9(19)
30