Een RGB-led gebruiken: kleuren mengen met Arduino, common anode vs. common cathode
Hoe werkt een RGB-led en hoe herken je common cathode en common anode? Arduino-bedrading, weerstandswaarden per kleur, kleuren mengen met analogWrite, een regenboogfade, code voor ESP32 en Pico.
Een RGB-led bestaat uit drie afzonderlijke leds in één behuizing: rood, groen en blauw. Door de helderheid van elke led apart in te stellen, maak je bijna elke gewenste kleur, van geel tot cyaan en van paars tot oranje. Elke pixel op een computerscherm werkt volgens hetzelfde principe. Het is een van de leukste Arduino-onderdelen voor statuslampjes, sfeerlampen en kleurrijke meldingsindicatoren.

Hoe werkt een RGB-led?
Lichtkleuren mengen additief: rood en groen samen zien er geel uit, groen en blauw geven cyaan, rood en blauw geven paars (magenta) en alle drie samen maken wit. De Arduino stelt de helderheid van elk kanaal in van 0 tot 255 met PWM. Dat geeft in theorie 256 × 256 × 256 ≈ 16,7 miljoen combinaties. PWM schakelt de led honderden keren per seconde aan en uit; je oog ziet het geflikker niet en neemt alleen de gemiddelde helderheid waar.
| Kleur | Rood | Groen | Blauw |
|---|---|---|---|
| Rood | 255 | 0 | 0 |
| Groen | 0 | 255 | 0 |
| Blauw | 0 | 0 | 255 |
| Geel | 255 | 255 | 0 |
| Cyaan | 0 | 255 | 255 |
| Magenta | 255 | 0 | 255 |
| Oranje | 255 | 80 | 0 |
| Wit | 255 | 255 | 255 |
Common cathode of common anode?
Het langste van de vier pootjes van de RGB-led is de gemeenschappelijke pin die de drie leds delen. Verbindt die pin de kathodes van de leds, dan is de led common cathode; verbindt hij de anodes, dan is het common anode. Van buiten zien ze er hetzelfde uit, maar bedrading en code zijn tegengesteld:
| Eigenschap | Common cathode (CC) | Common anode (CA) |
|---|---|---|
| Lang pootje gaat naar | GND | 5V |
| Om een kleur te laten branden | Zet de pin HIGH (255) | Zet de pin LOW (0) |
| Waarde in code | analogWrite(pin, waarde) | analogWrite(pin, 255 - waarde) |
| Helemaal uit | 0 | 255 |
Pinvolgorde en Arduino-bedrading
Bij gangbare 5 mm RGB-leds is de pinvolgorde rood, gemeenschappelijk (langste), groen, blauw, maar omdat die per fabrikant kan verschillen, is het veiligst om elk pootje te testen. Elke kleur wordt via een eigen weerstand aangesloten op een PWM-pin. Op de Arduino Uno zijn de PWM-pins die met ~ gemarkeerd zijn: 3, 5, 6, 9, 10 en 11.
| Pootje | Aansluiting | Arduino Uno-pin |
|---|---|---|
| Rood (R) | Via een weerstand | D9 |
| Gemeenschappelijk (langste) | GND voor common cathode, 5V voor common anode | — |
| Groen (G) | Via een weerstand | D10 |
| Blauw (B) | Via een weerstand | D11 |
Weerstandswaarden: een aparte weerstand voor elke kleur
Elke kleur heeft een andere spanning nodig om te branden (de doorlaatspanning): ongeveer 2,0 V voor rood en 3,0–3,2 V voor groen en blauw. Als je op 20 mA mikt bij 5 V, heeft rood (5 − 2,0) / 0,020 = 150 Ω nodig en groen en blauw (5 − 3,2) / 0,020 ≈ 100 Ω. In de praktijk is 220 Ω op alle drie veilig en nog helder genoeg; de kleuren kun je in de code in balans brengen. Gebruik voor je eigen waarden de rekenmodule ledweerstand en voor de doorlaatspanning van elke kleur de tabel ledspanningen.
Kleuren mengen met Arduino
De code hieronder verpakt de drie kanalen in één functie setColor() en laat om de beurt zeven kleuren zien. Heb je een common-anode-led, zet dan gewoon COMMON_ANODE op true; de functie keert de waarden voor je om.
1const int R_PIN = 9;
2const int G_PIN = 10;
3const int B_PIN = 11;
4const bool COMMON_ANODE = false; // ortak anotsa true yap / set true for common anode
5
6void setColor(int r, int g, int b) {
7 if (COMMON_ANODE) { r = 255 - r; g = 255 - g; b = 255 - b; }
8 analogWrite(R_PIN, r);
9 analogWrite(G_PIN, g);
10 analogWrite(B_PIN, b);
11}
12
13void setup() {
14 pinMode(R_PIN, OUTPUT);
15 pinMode(G_PIN, OUTPUT);
16 pinMode(B_PIN, OUTPUT);
17}
18
19void loop() {
20 setColor(255, 0, 0); delay(1000); // kırmızı / red
21 setColor(0, 255, 0); delay(1000); // yeşil / green
22 setColor(0, 0, 255); delay(1000); // mavi / blue
23 setColor(255, 255, 0); delay(1000); // sarı / yellow
24 setColor(0, 255, 255); delay(1000); // turkuaz / cyan
25 setColor(255, 0, 255); delay(1000); // mor / magenta
26 setColor(255, 255, 255); delay(1000); // beyaz / white
27}Soepele kleurovergangen: een regenboogeffect
In plaats van tussen kleuren te springen, laat je het licht soepel van rood naar groen, van groen naar blauw en weer terug naar rood vloeien als je één kanaal verlaagt terwijl je een ander verhoogt. De lus hieronder gebruikt dezelfde functie setColor(); verander de waarde van delay om de snelheid aan te passen.
1// setColor() ve pin tanımları yukarıdaki gibi / setColor() and pins as above
2void loop() {
3 for (int i = 0; i < 256; i++) { setColor(255 - i, i, 0); delay(8); } // kırmızı → yeşil / red → green
4 for (int i = 0; i < 256; i++) { setColor(0, 255 - i, i); delay(8); } // yeşil → mavi / green → blue
5 for (int i = 0; i < 256; i++) { setColor(i, 0, 255 - i); delay(8); } // mavi → kırmızı / blue → red
6}Een kleur kiezen met potentiometers
Als je drie potentiometers aansluit op A0, A1 en A2, kun je elk ervan gebruiken als draaiknop voor één kleurkanaal. analogRead() geeft een waarde van 0 tot 1023; door die door 4 te delen krijg je het bereik 0–255 dat PWM verwacht. Hoe je een potentiometer aansluit, lees je in Wat is een potentiometer?
1// A0, A1, A2'de üç potansiyometre; setColor() yukarıdaki gibi
2// three pots on A0, A1, A2; setColor() as above
3void loop() {
4 int r = analogRead(A0) / 4; // 0–1023 → 0–255
5 int g = analogRead(A1) / 4;
6 int b = analogRead(A2) / 4;
7 setColor(r, g, b);
8}RGB-leds met de ESP32 en Raspberry Pi Pico
Op de ESP32 met de huidige Arduino-core (3.x) werkt analogWrite() op elke uitgangspin, dus de code hierboven draait ongewijzigd zodra je de pinnummers aanpast. Let wel op de spanning: de pins geven 3,3 V, dus de groene en blauwe kanalen, waarvan de doorlaatspanning dicht bij 3 V ligt, zijn zwakker. Gebruik bij 3,3 V kleine weerstanden zoals 47–100 Ω, of stuur de led aan met 5 V via een transistor als je hem echt helder wilt. Op de Pico accepteert de PWM-klasse van MicroPython waarden van 0 tot 65535:
1from machine import Pin, PWM
2import time
3
4pins = [PWM(Pin(n)) for n in (11, 12, 13)] # GP11 R, GP12 G, GP13 B
5for p in pins:
6 p.freq(1000)
7
8def set_color(r, g, b): # 0–255
9 for p, v in zip(pins, (r, g, b)):
10 p.duty_u16(v * 257) # 0–65535 (ortak anotta 65535 - v * 257)
11
12while True:
13 set_color(255, 0, 0); time.sleep(1) # kırmızı / red
14 set_color(0, 255, 0); time.sleep(1) # yeşil / green
15 set_color(0, 0, 255); time.sleep(1) # mavi / blueGewone RGB-led of adresseerbare led (WS2812B)?
| Eigenschap | Gewone RGB-led | WS2812B (NeoPixel) |
|---|---|---|
| Benodigde pins | 3 PWM-pins per led | 1 datapin voor de hele strip |
| Kleurbesturing | Met de PWM-uitgangen van de Arduino | Met een piepkleine chip in elke led |
| Bibliotheek | Niet nodig | Adafruit NeoPixel of FastLED |
| Het best voor | 1–2 leds, statusindicatoren | Strips, ringen, matrices, sfeerverlichting |
Voor een of twee gekleurde lampjes is een gewone RGB-led de eenvoudigste en goedkoopste oplossing. Wil je tientallen leds afzonderlijk kleuren, dan zijn de 6 PWM-pins van de Uno niet genoeg; dan stap je over op WS2812B-strips, die honderden leds via één draad aansturen.
Projectideeën met een RGB-led
- Sfeerlamp: zet de regenboogfade in een melkglazen pot voor een zacht nachtlampje.
- Temperatuurindicator: combineer hem met een DHT11 voor een lamp die blauw gloeit als het koud is, groen als het mild is en rood als het warm is.
- Kleurenmixer: maak met drie potentiometers met de hand elke kleur.
- Een kleur kiezen met je telefoon: verander de kleur van de lamp met een kleurkiezer op een webpagina die door een ESP32 wordt aangeboden.
- Meldingslampje: laat de led in een bepaalde kleur knipperen als er een nieuwe e-mail of een nieuw bericht binnenkomt.
- Keypad-kleuren: toon een andere kleur afhankelijk van het getal dat op een keypad wordt ingetikt.
Veelgemaakte fouten en hoe je ze oplost
- De kleuren werken omgekeerd: je stuurt een common-anode-led aan alsof het een common cathode is; zet COMMON_ANODE op true.
- Eén kleur brandt nooit: de pinvolgorde kan afwijken van wat je verwachtte; test elk pootje een voor een met een weerstand.
- Fades gaan in stapjes, zonder tussentinten: de led zit op een pin zonder PWM; op de Uno kunnen die pins alleen volledig aan of uit.
- Kleuren haperen terwijl een buzzer speelt: op de Uno gebruikt tone() Timer2 en verstoort dat PWM op pin 3 en 11; verplaats de RGB-led naar pins zoals 5, 6, 9 en 10.
- De weerstanden weglaten: te veel stroom beschadigt uiteindelijk zowel de led als de Arduino-pin.
- Erg zwak op de ESP32: bij 3,3 V zitten groen en blauw op hun limiet; gebruik kleinere weerstanden of een transistor.
Wil je de basis van leds begrijpen en weten waarom ze weerstanden nodig hebben, lees dan Wat is een led? en Wat is een weerstand? In de BlueGrays-app vind je projecten met RGB-led-kleurfades, een lamp die je met een keypad bestuurt en een kleurenmixer, met schakelschema's en code.
Veelgestelde vragen
Hoe weet ik of mijn RGB-led common anode of common cathode is?
Sluit het lange pootje aan op GND en raak met een ander pootje 5V aan via een weerstand van 220 Ω; als hij oplicht, is hij common cathode. Zo niet, sluit dan het lange pootje aan op 5V en het andere pootje via de weerstand op GND; als hij nu oplicht, is hij common anode. De diodeteststand van een multimeter doet hetzelfde werk.
Welke weerstand moet ik gebruiken bij een RGB-led?
Bij 5 V is ongeveer 150 Ω voor rood en ongeveer 100 Ω voor groen en blauw ideaal. Voor het gemak is 220 Ω op alle drie veilig en geeft het nog steeds helder genoeg licht. Een aparte weerstand voor elke kleur is een must.
Hoeveel kleuren kan een RGB-led maken?
Elk kanaal kent 256 helderheidsniveaus van 0 tot 255, dus in theorie zijn er 16,7 miljoen combinaties. In de praktijk kan je oog minder kleuren onderscheiden en brengen de helderheidsverschillen tussen de leds sommige tinten dichter bij elkaar.
Waarom ziet mijn RGB-led er blauwachtig uit in plaats van wit?
De drie leds verschillen in helderheid en je oog is gevoeliger voor sommige kleuren dan voor andere; blauw en groen domineren meestal. Verlaag die twee kanalen een beetje in de code, of gebruik er grotere weerstanden bij, voor een neutraler wit.
Wat gebeurt er als ik een RGB-led op een pin zonder PWM aansluit?
Dat kanaal werkt dan alleen volledig aan of volledig uit; analogWrite beschouwt 128 en hoger als aan en alles lager als uit. Als alle drie de kanalen zo werken, krijg je maar 8 basiskleuren en geen soepele overgangen.
Hoeveel RGB-leds kan een Arduino Uno aansturen?
De Uno heeft 6 PWM-pins, dus je kunt maximaal 2 RGB-leds met onafhankelijke kleuren aansturen. Gebruik voor meer een PWM-driver met 16 kanalen zoals de PCA9685, of WS2812B-strips die honderden leds vanaf één pin aansturen.
Projecten om hierna te bouwen
Alle projecten bekijken
Een RGB-led gebruiken
In één enkele led zitten drie kleuren verstopt: de RGB-led licht eerst rood op, dan groen, dan blauw, elke kleur een halve seconde aan en een halve seconde uit, waarna de cyclus opnieuw begint.

Vloeiende kleurovergang met een RGB-led
Een enkele RGB-led gaat langzaam van rood naar groen, van groen naar blauw en weer terug naar rood, en doorloopt zo zonder te stoppen de regenboog.

ESP32 RGB-led aansturen
Onbeperkt kleuren maken met één RGB-led in plaats van 3 aparte leds. Net als op Arduino stel je met analogWrite() de R/G/B-waarden in en maak je een regenboogovergang. Kleurtheorie (zoals red+green=yellow) zie je in de praktijk.

ESP32 kleurenmixlamp (3 potmeters + RGB-led + OLED)
Een slimme kleurenmixlamp: draai aan 3 potmeters op de ESP32 en mix elke kleur die je wilt! Terwijl je aan de rode, groene en blauwe potmeter draait, verandert de RGB-led met gemeenschappelijke kathode meteen van kleur. Het SSD1306 OLED-display toont per kanaal de waarde van 0-255, vulbalken en de HEX-webkleurcode (zoals #FF8040) live.

Raspberry Pi Pico RGB-led-kleurcyclus (3-kanaals PWM)
Eén led, miljoenen kleuren! Een RGB-led bevat eigenlijk 3 aparte leds: rood, groen en blauw. Stel de helderheid van elk ervan apart in met de 3 PWM-kanalen van de Pico en de kleuren mengen: rood + groen = geel, groen + blauw = cyaan, alle drie = wit. In dit project doorloopt de led 8 kleuren.

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.

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…
Meer artikelen
BlueGrays-app
Bouw deze schakeling stap voor stap op je telefoon
Schakelschema, code en onderdelenlijst op één scherm. Meer dan 500 Arduino-, ESP32- en Pico-projecten om te bouwen.
Scan met je telefoon
Richt je camera op de code en de appstore van je telefoon opent.
of open de store

