Componenten · 6 min leestijd

WS2812B NeoPixel-ledstrip met Arduino: gids voor adresseerbare RGB-leds

Wat is een WS2812B NeoPixel en hoe sluit je hem aan? Adresseerbare RGB-ledstrips, -ringen en -matrices, vermogensberekening, code met Adafruit NeoPixel en FastLED, regenboogeffecten, voorbeelden voor ESP32 en Pico.

De WS2812B is een RGB-led met een eigen driverchip erin. Een gewone RGB-led heeft voor elke kleur een aparte pin nodig, maar met de WS2812B stuur je honderden leds aan via één datadraad en geef je elke led een eigen kleur en helderheid. NeoPixel is de naam die Adafruit gebruikt voor deze familie van adresseerbare leds. Ze worden verkocht als strips, ringen, sticks en matrices en worden in talloze projecten gebruikt, van sfeerverlichting en ledklokken tot spelletjes en meldingslampen.

Segment van een adresseerbare WS2812B RGB-ledstrip
Een los segment van een WS2812B-strip: de data komt links binnen via de DI-ingang en gaat via de DO-uitgang rechts door naar de volgende led. De pijl toont de richting van de data.

Hoe werkt de WS2812B?

In de behuizing van 5x5 mm van elke WS2812B zitten drie piepkleine leds, rood, groen en blauw, plus een miniatuurchip die ze aanstuurt. De Arduino stuurt achter elkaar 24-bits kleurpakketten over de datalijn: 8 bits groen, 8 bits rood en 8 bits blauw (GRB-volgorde). De eerste led houdt de eerste 24 bits voor zichzelf en geeft de rest via zijn DO-pin door aan de volgende led; elke led doet hetzelfde. Als de datalijn minstens 50 microseconden LOW blijft (280 bij nieuwere versies), tonen alle leds op hetzelfde moment hun kleur. Met 256 niveaus per kleur kan één led 16,7 miljoen verschillende kleuren weergeven.

EigenschapWaarde
Voedingsspanning5 V (3,5–5,3 V)
Stroom per ledTot ~60 mA (volledig wit), ~1 mA als hij uit is
Datasnelheid800 kHz, één draad
KleurvolgordeGRB (groen, rood, blauw)
Kleurdiepte24 bit, 16,7 miljoen kleuren
Uitvoering5050 SMD (5x5 mm)

Strips, ringen en matrices

TypeAantal ledsTypisch gebruik
Strip30, 60 of 144 per meterSfeerverlichting, tv-achtergrondverlichting, plankverlichting
Ring8, 12, 16, 24Ledklok, meter, bureaulamp
Matrix8x8 = 64, 16x16 = 256Scrollende tekst, animaties, pixelspelletjes
Stick8Niveau-indicator, statuslampje
WS2812B NeoPixel-ring met 24 leds
Een NeoPixel-ring met 24 leds: ideaal voor ledklokken en ronde meters; op een wijzerplaat van 12 uur staat elke led voor een half uur.

De WS2812B aansluiten

De WS2812B heeft drie aansluitingen: 5V, GND en DIN (data in). De pijlen op de strip geven de richting aan waarin de data stroomt; sluit de Arduino altijd aan op het uiteinde waar de pijlen beginnen, de DIN-kant. Een weerstand van 330–470 Ω in serie met de datalijn en een condensator van 1000 µF tussen 5V en GND bij de voedingsingang van de strip beschermen de eerste led tegen plotselinge spanningspieken.

WS2812B-pinAansluiting
5V5V van de Arduino voor een paar leds, een externe 5 V-adapter voor meer
GNDGND (bij een externe adapter moet de massa gedeeld worden met de Arduino)
DIND6 (via een weerstand van 330 Ω)
DOUTDIN van de volgende led of strip
Voed niet veel leds vanaf de 5V-pin van de Arduino: USB levert maximaal 500 mA en één led kan bij volledig wit 60 mA trekken. Voed de strip vanaf een externe 5 V-adapter, verbind de GND van de adapter altijd met de GND van de Arduino en steek de datadraad nooit eerder in dan GND terwijl de schakeling onder spanning staat, anders kan de eerste led beschadigd raken.

Vermogensberekening: hoeveel ampère heb je nodig?

De formule voor het slechtste geval is simpel: aantal leds × 60 mA. In animaties zijn zelden alle leds tegelijk volledig wit; in de praktijk zie je gemiddeld zo'n 20 mA per led. Toch kies je de adapter het best voor het slechtste geval of beperk je de helderheid in software. Gebruik de tool Wet van Ohm om het vermogen in watt uit te rekenen en de tool batterijduur om de looptijd van projecten op batterijen te schatten.

Aantal ledsSlechtste geval (volledig wit)Aanbevolen voeding
80.48 AUSB is genoeg (beperkte helderheid)
301.8 A5 V 3 A-adapter
603.6 A5 V 4 A-adapter
1448.6 A5 V 10 A-adapter
Bij lange strips verliezen de dunne koperbanen spanning en ziet het einde van de strip er geelachtig of roodachtig uit. Voorkom dit door elke 1–2 meter opnieuw 5V en GND van de adapter naar de strip te voeren (power injection). De helderheid terugzetten naar 20–30% verlaagt de stroom ook sterk, zonder dat je met het oog veel verschil ziet.

Je eerste code met de bibliotheek Adafruit NeoPixel

Zoek in de Library Manager naar Adafruit NeoPixel en installeer hem. De code hieronder "veegt" de strip vol met een kleur door de leds een voor een rood, groen en blauw te laten branden:

C++ (Arduino IDE)
1#include <Adafruit_NeoPixel.h>
2
3#define PIN 6          // DIN pini / data pin
4#define NUM_LEDS 8     // LED sayısı / number of LEDs
5
6Adafruit_NeoPixel strip(NUM_LEDS, PIN, NEO_GRB + NEO_KHZ800);
7
8void setup() {
9  strip.begin();
10  strip.setBrightness(50);   // 0–255, yalnız bir kez / only once
11  strip.show();              // hepsini söndür / all off
12}
13
14void colorWipe(uint32_t color, int wait) {
15  for (int i = 0; i < NUM_LEDS; i++) {
16    strip.setPixelColor(i, color);
17    strip.show();            // değişikliği gönder / send the change
18    delay(wait);
19  }
20}
21
22void loop() {
23  colorWipe(strip.Color(255, 0, 0), 80);   // kırmızı / red
24  colorWipe(strip.Color(0, 255, 0), 80);   // yeşil / green
25  colorWipe(strip.Color(0, 0, 255), 80);   // mavi / blue
26}

setPixelColor() verandert de kleur alleen in het geheugen; om de leds echt te laten branden moet je show() aanroepen. Zo kun je de kleur van elke led instellen en ze allemaal in één keer weergeven. Omdat setBrightness() de kleurdata blijvend schaalt, roep je die het best één keer aan in setup() in plaats van hem steeds te wijzigen in loop(). Elke led neemt 3 bytes van het RAM van de Arduino in beslag; de 2 KB van de Uno raakt met honderden leds snel vol.

Regenboogeffect: HSV-kleuren

Met HSV (hue, saturation, value) in plaats van rood-, groen- en blauwwaarden worden effecten veel eenvoudiger: je doorloopt het hele kleurenwiel door alleen de hue te veranderen. In de Adafruit-bibliotheek loopt de hue van 0 tot 65535. gamma32() corrigeert de kleuren naar hoe het oog ze waarneemt, zodat overgangen natuurlijker ogen:

C++ (Arduino IDE)
1#include <Adafruit_NeoPixel.h>
2
3#define PIN 6
4#define NUM_LEDS 24
5
6Adafruit_NeoPixel strip(NUM_LEDS, PIN, NEO_GRB + NEO_KHZ800);
7
8void setup() {
9  strip.begin();
10  strip.setBrightness(40);
11}
12
13void loop() {
14  for (long first = 0; first < 65536; first += 256) {
15    for (int i = 0; i < NUM_LEDS; i++) {
16      uint16_t hue = first + i * 65536L / NUM_LEDS;   // her LED'e farklı ton / a different hue per LED
17      strip.setPixelColor(i, strip.gamma32(strip.ColorHSV(hue)));
18    }
19    strip.show();
20    delay(10);
21  }
22}

De bibliotheek FastLED

Voor geavanceerdere effecten is de bibliotheek FastLED ook erg populair. Die bewaart de leds in een CRGB-array, biedt leesbare commando's zoals leds[3] = CRGB::Red; en gebruikt een hue-bereik van 0–255. Kant-en-klare functies als fill_rainbow() en fadeToBlackBy() laten je in een paar regels vuur-, vallende-ster- of ademhalingseffecten schrijven. Een van de handigste functies is FastLED.setMaxPowerInVoltsAndMilliamps(5, 2000);: de bibliotheek verlaagt automatisch de helderheid om de stroom onder 2 A te houden.

Een NeoPixel-matrix van 8x8 gebruiken

Een matrix is eigenlijk gewoon een lange strip: 64 leds achter elkaar geschakeld op één datalijn. Bij de meeste matrices lopen de rijen in zigzag (serpentine): even rijen van links naar rechts, oneven rijen van rechts naar links. Om een x,y-coördinaat om te zetten in een lednummer gebruik je dus y × 8 + x voor even rijen en y × 8 + (7 − x) voor oneven rijen. Omdat 64 leds bij volledig wit 3,8 A kunnen trekken, is een lage helderheid vooral bij matrices belangrijk.

8x8 WS2812B NeoPixel-ledmatrix
Een NeoPixel-matrix van 8x8: 64 adresseerbare leds, aangestuurd via één datalijn; ideaal voor scrollende tekst en pixelspelletjes.

WS2812B met de ESP32 en de Raspberry Pi Pico

De bibliotheken Adafruit NeoPixel en FastLED werken ook op de ESP32; dankzij Wi-Fi bestuur je de leds eenvoudig met je telefoon of bouw je een lamp die van kleur verandert met het weer. Let op het spanningsniveau: een WS2812B die op 5 V draait, verwacht minstens 3,5 V op zijn datapin, terwijl de ESP32 en de Pico 3,3 V uitsturen. De meeste strips werken toch, maar als de eerste led flikkert of er willekeurige kleuren verschijnen, voeg dan een niveauconverter zoals een 74AHCT125 toe aan de datalijn. Op de Raspberry Pi Pico heeft MicroPython een ingebouwde module neopixel:

MicroPython
1from machine import Pin
2import neopixel
3import time
4
5NUM = 8
6np = neopixel.NeoPixel(Pin(0), NUM)      # GP0 → DIN
7
8def wheel(pos):                          # 0–255 → renk çemberi / colour wheel
9    if pos < 85:
10        return (255 - pos * 3, pos * 3, 0)
11    if pos < 170:
12        pos -= 85
13        return (0, 255 - pos * 3, pos * 3)
14    pos -= 170
15    return (pos * 3, 0, 255 - pos * 3)
16
17j = 0
18while True:
19    for i in range(NUM):
20        r, g, b = wheel((i * 256 // NUM + j) & 255)
21        np[i] = (r // 5, g // 5, b // 5)  # parlaklığı düşür / dim it
22    np.write()
23    j = (j + 2) & 255
24    time.sleep_ms(20)

Projectideeën met de WS2812B

  • Tv-sfeerlicht: plak een strip achter je tv om de kamer een zachte gloed te geven.
  • NeoPixel-klok: toon uren, minuten en seconden in verschillende kleuren op een ring met 60 leds.
  • Geluidsniveaumeter: bouw met een microfoonmodule een ledbalk die stijgt met het volume van de muziek.
  • Meldingslamp: laat de ESP32 van kleur veranderen op basis van het weer of nieuwe e-mail van internet.
  • Politielichten en Knight Rider: programmeer rood-blauw knipperende of heen-en-weer scannende lichteffecten.
  • Pixel-slangenspel: maak het klassieke slangenspel na met een 8x8-matrix en een joystick.

Veelgemaakte fouten en hoe je ze oplost

  • Geen enkele led brandt: de Arduino is aangesloten op het verkeerde uiteinde van de strip, de DOUT-kant; controleer de pijlen en gebruik het DIN-uiteinde.
  • Kleuren zijn door elkaar (groen in plaats van rood): de kleurvolgorde klopt niet; gebruik NEO_GRB in de code, al hebben sommige strips NEO_RGB nodig.
  • De eerste led flikkert of toont willekeurige kleuren: er is geen serieweerstand, de GND wordt niet gedeeld of het datasignaal van 3,3 V is niet genoeg.
  • Het einde van de strip ziet er geelachtig uit: er is spanningsverlies; voed de strip op meerdere punten of verlaag de helderheid.
  • De Arduino reset als de leds aangaan: er wordt te veel stroom via USB getrokken; gebruik een externe adapter en een condensator van 1000 µF.
  • Alleen de eerste paar leds branden: NUM_LEDS in de code is kleiner dan het echte aantal leds, of er zit ergens in de strip een onderbreking.

De WS2812B is een prima startpunt om te begrijpen hoe kleuren mengen; de kleurlogica vind je in Een RGB-led gebruiken en helderheidsregeling in Wat is PWM? In de BlueGrays-app vind je de basis van de WS2812B, politielichten, looplichten, een Knight Rider-scanner, animatie-effecten en NeoPixel-stripbesturing met de ESP32, met schakelschema's en code.

Veelgestelde vragen

Wat is het verschil tussen de WS2812B en NeoPixel?

NeoPixel is de merknaam van Adafruit voor adresseerbare leds zoals de WS2812, WS2812B en SK6812. Ze gebruiken allemaal hetzelfde dataprotocol, dus je bestuurt ze op dezelfde manier met dezelfde bibliotheken.

Hoeveel WS2812B's kan ik op één Arduino aansluiten?

Aan de datakant is er geen harde limiet, maar drie dingen beperken je: RAM (3 bytes per led, dus in de praktijk een paar honderd leds op een Uno), verversingstijd (30 microseconden per led; 1000 leds duren ongeveer 30 ms, ofwel ~33 beelden per seconde) en de voeding.

Kan ik een WS2812B voeden vanaf de 5V-pin van de Arduino?

Alleen een paar leds op lage helderheid; een stick met 8 leds werkt bijvoorbeeld via USB bij een helderheid van ongeveer 50. Gebruik voor meer leds een externe 5 V-adapter en verbind de massa's met elkaar.

Zijn de weerstand en de condensator echt nodig?

Strikt verplicht zijn ze niet, maar ze worden sterk aanbevolen. De weerstand van 330–470 Ω op de datalijn dempt pieken in het signaal en beschermt de eerste led, en de condensator van 1000 µF op de voedingsingang vangt de inschakelstroom op het moment dat er spanning op komt.

Werkt de WS2812B met de ESP32 en boards van 3,3 V?

Meestal wel, maar het is niet gegarandeerd: een WS2812B die op 5 V draait, verwacht minstens 3,5 V op zijn datapin. Zie je flikkeren of verkeerde kleuren, breng het datasignaal dan omhoog naar 5 V met een niveauconverter zoals een 74AHCT125.

Wat zijn de verschillen tussen de WS2812B, WS2811, WS2813 en SK6812?

De WS2811 is een aparte driverchip die meestal drie leds samen aanstuurt op strips van 12 V. De WS2813 heeft een reservedatalijn, zodat de keten blijft werken als één led uitvalt. De SK6812 is een compatibel alternatief dat ook als RGBW-versie met een witte led bestaat; daarvoor gebruik je NEO_GRBW in de code.

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-looplicht
AR-71Gemiddeld
Premium

WS2812B-looplicht

Op een strip van tien leds loopt een groen lichtpuntje led voor led van begin naar eind en springt dan terug naar het begin; het blijft een derde seconde op elke led.

4.8(58)
75
WS2812B-looplicht (opbouweffect)
AR-72Gemiddeld
Premium

WS2812B-looplicht (opbouweffect)

Een lichtstrip die zich vult en leegt als een glas water. De Arduino laat tien kleurenleds een voor een oranje branden en houdt ze aan; als de strip vol is, schakelt hij ze in dezelfde volgorde een…

4.7(50)
65
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 Knight Rider-effect (3 leds)
AR-74Gemiddeld
Premium

WS2812B Knight Rider-effect (3 leds)

Alle kleuren van de regenboog glijden langzaam langs een strip van 56 leds. Elke led brandt in een iets andere kleur dan zijn buur en de kleuren blijven in dezelfde richting stromen, waardoor de…

4.8(61)
79
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
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