Arduino RGB-ledstrip aansturen: 12 V kleuren mengen met MOSFETs
Arduino RGB-ledstrip aansturen: bestuur een 12 V 5050-strip met IRLZ44N-MOSFETs, driekanaals PWM, kleurfades en een kleurkiezer met potmeter, plus code voor ESP32 en Pico.
Een RGB-ledstrip aansturen met Arduino betekent dat je het rode, groene en blauwe kanaal van een 12 V niet-adresseerbare 5050 RGB-strip aanstuurt met drie aparte PWM-signalen, zodat je elke gewenste kleur krijgt. Arduino-pins kunnen de ampères en de 12 V van een strip niet aan, dus krijgt elk kanaal een MOSFET: de Arduino stuurt alleen een 5V-signaal naar de gate van de MOSFET en de MOSFET voert de echte stroom. Zo kan een kleine microcontroller veilig meters strip aansturen.
In deze gids leer je hoe een 5050-strip van binnen werkt, hoe je de juiste MOSFET kiest, hoe je de bedrading maakt en hoe je de voeding berekent. Daarna meng je kleuren met een Arduino Uno, bouw je een soepele kleurfade op basis van millis() en kies je tint en helderheid met potmeters. Dezelfde schakeling draai je ook met de LEDC-eenheid van de ESP32 en met MicroPython-PWM op de Raspberry Pi Pico. Je leest ook hoe de strip verschilt van WS2812B, en aan het eind vind je oplossingen voor de meest gemaakte fouten.
Wat is een RGB-ledstrip en hoe werkt hij?
In een niet-adresseerbare RGB-strip bevat elke 5050 SMD-behuizing drie aparte ledchips: rood, groen en blauw. De strip bestaat uit 12V-segmenten die parallel zijn geschakeld, elk met drie led's en één stroombegrenzende weerstand per kleur; de totale doorlaatspanning van de drie led's in serie is ongeveer 6–9 V, afhankelijk van de kleur, en de weerstand neemt de rest voor zijn rekening. De strip heeft vier aansluitingen: een gemeenschappelijke plus (+12V) en R, G en B. De strip is dus gemeenschappelijke anode: om een kleur te laten branden trek je de lijn van die kleur naar GND. De hele strip toont steeds één kleur; je kunt led's niet afzonderlijk in verschillende kleuren laten branden. Je stelt de kleur in met de PWM-duty cycle van elk kanaal: rood en groen volledig aan geeft geel, alle drie volledig aan geeft bijna wit licht.
| Eigenschap | Strip met 30 led's/m | Strip met 60 led's/m |
|---|---|---|
| Soort led | 5050 SMD (5,0 × 5,0 mm, 3 chips) | 5050 SMD (5,0 × 5,0 mm, 3 chips) |
| Werkspanning | 12 V DC | 12 V DC |
| Vermogen (volledig wit) | Ongeveer 7,2 W/m | Ongeveer 14,4 W/m |
| Stroom (volledig wit) | Ongeveer 0,6 A/m | Ongeveer 1,2 A/m |
| Stroom per kanaal | Ongeveer 0,2 A/m | Ongeveer 0,4 A/m |
| Knipinterval | Elke 3 led's (10 cm) | Elke 3 led's (5 cm) |
| Aansluitingen | +12V, R, G, B | +12V, R, G, B |
RGB-strip vs WS2812B: wat is het verschil?
Beide strips geven RGB-licht, maar je bestuurt ze op een totaal andere manier. Een niet-adresseerbare strip werkt als een lamp: je stelt de kleur van de hele strip in door de helderheid van drie kanalen te veranderen. In een WS2812B NeoPixel-strip zit in elke led een kleine driverchip en kun je via één datalijn aan elke led een andere kleur sturen. De tabel hieronder helpt je kiezen:
| Eigenschap | 12V RGB-strip (5050) | WS2812B-strip |
|---|---|---|
| Aansturing | Hele strip, één kleur | Elke led een eigen kleur |
| Voeding | 12 V (er zijn ook 24V-versies) | 5 V |
| Bedrading | 4 draden: +12V, R, G, B | 3 draden: 5V, DIN, GND |
| Driverschakeling | Eén MOSFET per kanaal | Niet nodig, één datapin is genoeg |
| Code | analogWrite / PWM | FastLED- of Adafruit NeoPixel-bibliotheek |
| Stroom (60 led's/m, volledig wit) | Ongeveer 1,2 A/m (12 V) | Ongeveer 3,6 A/m (5 V) |
| Spanningsverlies | Meestal prima tot 5 m | Lange strips hebben op meerdere punten extra voeding nodig |
| Effecten | Vaste kleur, fades, ademend licht | Looplicht, regenboog, animaties |
| Prijs | Goedkoop | Duurder |
Waarom heb je een MOSFET nodig en welke kies je?
Een pin van een Arduino Uno is ontworpen voor ongeveer 20 mA (absolute limiet 40 mA), terwijl één kanaal van een strip van 5 m met 60 led's/m 2 A kan trekken. Bovendien werkt de strip op 12 V. Een N-kanaal-MOSFET lost dit op als low-side-schakelaar: de Drain gaat naar de kleurlijn van de strip, de Source gaat naar GND en de spanning op de Gate schakelt de MOSFET aan en uit. Het belangrijkste is dat je een logic-level-MOSFET kiest; standaard-MOSFETs zoals de IRF520 of IRF540N hebben ongeveer 10 V nodig om volledig aan te gaan, en bij 5 V blijven ze half open en worden ze heet. Het vermogen dat in een MOSFET wordt omgezet in warmte is P = I² × Rds(on): bij 2 A en 0,025 Ω is dat 2 × 2 × 0,025 = 0,1 W, dus je hebt geen koelplaat nodig. Voor de basis lees je Een MOSFET gebruiken met Arduino.
| MOSFET | Gatespanning | Rds(on) | Geschiktheid |
|---|---|---|---|
| IRLZ44N | Logic level, volledig aan bij 4–5 V | 0,025 Ω (bij 5 V) | Ideaal voor Uno en Nano; bij 3,3 V alleen voor korte strips |
| IRLB8721 | Gaat ook bij 3,3 V goed aan | Ongeveer 0,009 Ω (bij 4,5 V) | Een van de beste keuzes voor ESP32 en Pico |
| AO3400 (SMD) | Gaat aan bij 2,5 V | Ongeveer 0,03 Ω (bij 4,5 V) | Kleine boards, 2–3 A per kanaal |
| IRF520 / IRF540N | Heeft ongeveer 10 V nodig | Hoog bij 5 V | Niet aanbevolen, wordt heet |
Schakelschema en bedradingstabel
Je bouwt dezelfde kleine schakeling drie keer, één per kleurkanaal. Houd de IRLZ44N met de bedrukte kant naar je toe; de pins zijn dan van links naar rechts Gate, Drain, Source. De volgorde van de pins kun je ook controleren met de transistortool. Zet een weerstand van 220 Ω tussen de Gate en de pin van het board; die beperkt de stroompiek uit de pin terwijl de gatecapaciteit wordt opgeladen. Voeg ook een 10 kΩ pull-downweerstand toe tussen de Gate en GND; die voorkomt dat de MOSFET uit zichzelf aangaat en de strip willekeurig laat branden als de pins zweven tijdens het opstarten of het uploaden van code. De belangrijkste regel: de min van de 12V-adapter moet verbonden zijn met de GND van het board, anders heeft het gatesignaal geen referentie. Dit leggen we uitgebreid uit in het artikel over gemeenschappelijke GND.
| Aansluiting | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| Gate van rode MOSFET (via 220 Ω) | D9 | GPIO 25 | GP11 |
| Gate van groene MOSFET (via 220 Ω) | D10 | GPIO 26 | GP12 |
| Gate van blauwe MOSFET (via 220 Ω) | D11 | GPIO 27 | GP13 |
| Drain-pins van de MOSFETs | R-, G- en B-draden van de strip | R-, G- en B-draden van de strip | R-, G- en B-draden van de strip |
| Source-pins van de MOSFETs | GND | GND | GND |
| Tintpotmeter (middelste pin) | A0 | GPIO 34 | GP26 (ADC0) |
| Helderheidspotmeter (middelste pin) | A1 | Niet gebruikt | Niet gebruikt |
| Buitenste pins van de potmeters | 5V en GND | 3V3 en GND | 3V3 en GND |
| Min van de 12V-adapter | GND | GND | GND |
| +12V-draad van de strip | Plus van de adapter | Plus van de adapter | Plus van de adapter |
Vermogen berekenen: welke adapter koop je?
Om de adapter te kiezen bereken je eerst de stroom van de strip bij volledig wit: I = meters × A/m. Een strip van 5 m met 60 led's/m trekt 5 × 1,2 = 6 A; het vermogen is P = V × I = 12 × 6 = 72 W. Kies altijd een adapter met ongeveer 20% extra ruimte: in dit voorbeeld is een 12V-voeding van 8 A (96 W) de juiste keuze. Een strip van 2 m met 30 led's/m trekt 1,2 A, dus een 12V-adapter van 2 A is genoeg. Kies ook de draad passend bij de stroom; boven 5 A gebruik je draad van minstens 0,75 mm² in plaats van jumperdraden. Als je het board vanuit dezelfde adapter wilt voeden: de voedingsjack of Vin-pin van de Arduino Uno accepteert 12 V en werkt bij lichte belasting prima. Sluit op ESP32-devboards en de Pico geen 12 V rechtstreeks aan; de VSYS-ingang van de Pico accepteert maximaal 5,5 V. Voor deze boards is het netste om 12 V terug te brengen naar 5 V met een LM2596 step-downconverter en die aan te sluiten op de 5V-pin van de ESP32 en op VSYS van de Pico. Je kunt de berekeningen controleren met de rekenmachine voor de wet van Ohm en voor details lees je elektrisch vermogen berekenen.
Stap voor stap opbouwen
- Bouw de hele schakeling voordat je de adapter in het stopcontact steekt; verander geen aansluitingen terwijl de schakeling onder spanning staat.
- Soldeer vier draden aan de soldeerpads van de strip of gebruik een kant-en-klare connector; sluit de +12V-draad aan op de plus van de adapter.
- Plaats de drie MOSFETs en verbind hun Source-pins met de gemeenschappelijke GND-rail. De rails van een breadboard zijn geschikt voor ongeveer 1 A; bij strips die meerdere ampères trekken maak je het stroompad met gesoldeerde verbindingen of een schroefklem.
- Verbind de Drain van elke MOSFET met de bijpassende kleurdraad van de strip (R, G, B).
- Verbind de Gate-pins via weerstanden van 220 Ω met D9, D10 en D11; zet een weerstand van 10 kΩ tussen elke Gate en GND.
- Verbind de min van de 12V-adapter met de GND-pin van de Arduino om de gemeenschappelijke massa te maken.
- Sluit de Arduino met USB aan op je computer, upload de eerste code en steek dan de adapter in.
- Controleer of elke kleur afzonderlijk brandt; brandt de verkeerde kleur, verwissel dan de pinnummers in de code.
Eerste code: kleuren mengen met Arduino
Nadat je de schakeling hebt gebouwd, is het veiligst om elk kanaal één voor één te testen. De code hieronder gebruikt de PWM-pins 9, 10 en 11 van de Uno en toont met de functie setColor() om de beurt zes verschillende kleuren. Wil je weten hoe PWM werkt, lees dan Wat is PWM.
1const int PIN_R = 9; // kırmızı MOSFET kapısı / red MOSFET gate
2const int PIN_G = 10; // yeşil MOSFET kapısı / green MOSFET gate
3const int PIN_B = 11; // mavi MOSFET kapısı / blue MOSFET gate
4
5void setColor(uint8_t r, uint8_t g, uint8_t b) {
6 analogWrite(PIN_R, r); // 255 = tam parlak, 0 = sönük / 255 = full, 0 = off
7 analogWrite(PIN_G, g);
8 analogWrite(PIN_B, b);
9}
10
11void setup() {
12 pinMode(PIN_R, OUTPUT);
13 pinMode(PIN_G, OUTPUT);
14 pinMode(PIN_B, OUTPUT);
15 setColor(0, 0, 0); // başlangıçta kapalı / off at start
16}
17
18void loop() {
19 setColor(255, 0, 0); delay(1000); // kırmızı / red
20 setColor(0, 255, 0); delay(1000); // yeşil / green
21 setColor(0, 0, 255); delay(1000); // mavi / blue
22 setColor(255, 120, 0); delay(1000); // turuncu / orange
23 setColor(160, 0, 255); delay(1000); // mor / purple
24 setColor(255, 255, 255); delay(1000); // beyaz / white
25}Hier zit een belangrijk verschil: als je één RGB-led met gemeenschappelijke anode rechtstreeks op een pin aansluit, is de logica omgekeerd (255 zet hem uit), maar in een MOSFET-schakeling zet analogWrite(pin, 255) de MOSFET volledig aan en brandt de kleur op volle helderheid; 0 zet hem uit. Op de Uno hangen pin 9 en 10 aan Timer1 en pin 11 aan Timer2, en alle drie draaien ze op ongeveer 490 Hz; bij deze frequentie zie je geen flikkering. tone() gebruikt echter Timer2 en verstoort dus PWM op pin 11, en de Servo-bibliotheek schakelt PWM op pin 9 en 10 uit. Heeft je project een buzzer of servo, plan je pins dan daarop. De helderheid van de kleuren van de strip is ook niet gelijk; als wit blauwachtig oogt, kun je dat compenseren door het blauwe kanaal te verlagen naar ongeveer 200.
Langzame kleurfade: een kleurenwiel met millis()
Om de strip soepel door alle kleuren te laten gaan, gebruiken we een kleurenwiel: een tintwaarde van 0–767 wordt verdeeld in drie gebieden. In de eerste 256 stappen daalt rood en stijgt groen, in de volgende 256 gaat het van groen naar blauw en in het laatste deel van blauw naar rood. Omdat twee kanalen samen steeds 255 zijn, lopen de kleuren zonder sprongen in elkaar over. Doordat we millis() gebruiken in plaats van delay(), kan loop() ook ander werk doen, zoals knoppen uitlezen of sensoren meten. Ons oog neemt helderheid niet lineair waar: kleine veranderingen bij lage waarden vallen sterk op, terwijl ze bij hoge waarden nauwelijks te zien zijn. Daarom schaalt de functie gamma8() in de code de waarde met het kwadraat (v × v / 255), waardoor overgangen in zwak licht natuurlijker lijken. Als je STEP_MS verhoogt, duurt de volledige cyclus langer; bij 15 ms duurt één cyclus ongeveer 11,5 seconden.
1const int PIN_R = 9; // kırmızı / red
2const int PIN_G = 10; // yeşil / green
3const int PIN_B = 11; // mavi / blue
4
5const unsigned long STEP_MS = 15; // 768 x 15 ms = yaklaşık 11,5 s / about 11.5 s per cycle
6unsigned long lastStep = 0;
7int hue = 0; // renk tonu 0-767 / hue 0-767
8
9uint8_t gamma8(uint8_t v) {
10 return (uint16_t)v * v / 255; // basit gama düzeltmesi / simple gamma correction
11}
12
13void setColor(uint8_t r, uint8_t g, uint8_t b) {
14 analogWrite(PIN_R, gamma8(r));
15 analogWrite(PIN_G, gamma8(g));
16 analogWrite(PIN_B, gamma8(b));
17}
18
19void wheel(int h) {
20 uint8_t p = h % 256;
21 if (h < 256) setColor(255 - p, p, 0); // kırmızı -> yeşil / red -> green
22 else if (h < 512) setColor(0, 255 - p, p); // yeşil -> mavi / green -> blue
23 else setColor(p, 0, 255 - p); // mavi -> kırmızı / blue -> red
24}
25
26void setup() {
27 pinMode(PIN_R, OUTPUT);
28 pinMode(PIN_G, OUTPUT);
29 pinMode(PIN_B, OUTPUT);
30}
31
32void loop() {
33 if (millis() - lastStep >= STEP_MS) {
34 lastStep = millis();
35 wheel(hue);
36 hue = (hue + 1) % 768;
37 }
38 // burada buton ya da sensör okuyabilirsin / you can read buttons or sensors here
39}Kleur en helderheid kiezen met potmeters
Twee potmeters zijn genoeg om de kleur met de hand te kiezen: die op A0 stelt de tint in (0–767) en die op A1 de totale helderheid (0–255). Omdat analogRead() 0–1023 teruggeeft, schalen we de waarde met map() naar het gewenste bereik. De helderheid pas je toe door de waarde van elk kanaal te vermenigvuldigen met bri / 255, zodat het licht dimt terwijl de tint behouden blijft. Je kunt R, G en B ook rechtstreeks instellen met drie aparte potmeters, maar een kleurenwiel met één knop is veel intuïtiever en geeft toegang tot elke verzadigde kleur behalve wit.
1const int PIN_R = 9;
2const int PIN_G = 10;
3const int PIN_B = 11;
4const int POT_HUE = A0; // renk tonu / hue
5const int POT_BRI = A1; // parlaklık / brightness
6
7void setup() {
8 pinMode(PIN_R, OUTPUT);
9 pinMode(PIN_G, OUTPUT);
10 pinMode(PIN_B, OUTPUT);
11}
12
13void loop() {
14 int hue = map(analogRead(POT_HUE), 0, 1023, 0, 767);
15 int bri = map(analogRead(POT_BRI), 0, 1023, 0, 255);
16
17 uint8_t r, g, b;
18 uint8_t p = hue % 256;
19 if (hue < 256) { r = 255 - p; g = p; b = 0; } // kırmızı -> yeşil / red -> green
20 else if (hue < 512) { r = 0; g = 255 - p; b = p; } // yeşil -> mavi / green -> blue
21 else { r = p; g = 0; b = 255 - p; } // mavi -> kırmızı / blue -> red
22
23 analogWrite(PIN_R, (uint16_t)r * bri / 255); // parlaklığı uygula / apply brightness
24 analogWrite(PIN_G, (uint16_t)g * bri / 255);
25 analogWrite(PIN_B, (uint16_t)b * bri / 255);
26 delay(20);
27}Een RGB-strip aansturen met de ESP32 (LEDC)
De ESP32 gebruikt zijn hardware-LEDC-eenheid voor PWM; je kiest zelf de frequentie en resolutie. 5 kHz en 8 bits geven zowel een flikkervrij licht als het vertrouwde bereik van 0–255. In Arduino core 3.x gebruik je ledcAttach(pin, frequentie, resolutie) en ledcWrite(pin, waarde), terwijl je in 2.x eerst een kanaal instelt met ledcSetup(), dat met ledcAttachPin() aan een pin koppelt en ledcWrite() naar het kanaal schrijft; de code hieronder ondersteunt beide versies met #if. Omdat de pins van de ESP32 3,3 V leveren, is het belangrijk een MOSFET met een lage gatespanning te kiezen, zoals de IRLB8721 uit de tabel. We hebben de potmeter aangesloten op GPIO 34, een ADC1-pin die ook met Wi-Fi aan prima werkt; de ADC is 12-bit, dus de waarden lopen van 0–4095, en acht metingen worden gemiddeld om ruis te verminderen. Voor de basis van het board lees je Wat is de ESP32.
1const int PIN_R = 25; // kırmızı MOSFET kapısı / red MOSFET gate
2const int PIN_G = 26; // yeşil / green
3const int PIN_B = 27; // mavi / blue
4const int POT_HUE = 34; // ADC1, yalnız giriş / ADC1, input only
5const int PWM_FREQ = 5000; // 5 kHz, titreşimsiz / flicker-free
6const int PWM_RES = 8; // 8 bit: 0-255
7
8void setColor(uint8_t r, uint8_t g, uint8_t b) {
9#if ESP_ARDUINO_VERSION_MAJOR >= 3
10 ledcWrite(PIN_R, r); // core 3.x: pine yaz / write to pin
11 ledcWrite(PIN_G, g);
12 ledcWrite(PIN_B, b);
13#else
14 ledcWrite(0, r); // core 2.x: kanala yaz / write to channel
15 ledcWrite(1, g);
16 ledcWrite(2, b);
17#endif
18}
19
20void setup() {
21#if ESP_ARDUINO_VERSION_MAJOR >= 3
22 ledcAttach(PIN_R, PWM_FREQ, PWM_RES);
23 ledcAttach(PIN_G, PWM_FREQ, PWM_RES);
24 ledcAttach(PIN_B, PWM_FREQ, PWM_RES);
25#else
26 ledcSetup(0, PWM_FREQ, PWM_RES);
27 ledcSetup(1, PWM_FREQ, PWM_RES);
28 ledcSetup(2, PWM_FREQ, PWM_RES);
29 ledcAttachPin(PIN_R, 0);
30 ledcAttachPin(PIN_G, 1);
31 ledcAttachPin(PIN_B, 2);
32#endif
33 analogReadResolution(12); // 0-4095
34 setColor(0, 0, 0);
35}
36
37void loop() {
38 long sum = 0;
39 for (int i = 0; i < 8; i++) {
40 sum += analogRead(POT_HUE); // 8 okumayı topla / sum 8 readings
41 }
42 int hue = map(sum / 8, 0, 4095, 0, 767);
43 uint8_t p = hue % 256;
44 if (hue < 256) setColor(255 - p, p, 0); // kırmızı -> yeşil / red -> green
45 else if (hue < 512) setColor(0, 255 - p, p); // yeşil -> mavi / green -> blue
46 else setColor(p, 0, 255 - p); // mavi -> kırmızı / blue -> red
47 delay(20);
48}MicroPython-code met de Raspberry Pi Pico
Op de Pico kan elke GPIO-pin PWM leveren en duty_u16() neemt een waarde van 0–65535. In de code schalen we kleurwaarden van 0–255 naar dat bereik door te vermenigvuldigen met 257 (255 × 257 = 65535). De potmeter zit op GP26 (ADC0); read_u16() geeft ook 0–65535 terug, dus die zet je gemakkelijk om naar een tintwaarde. GP12 en GP13 delen dezelfde PWM-slice (slice 6); omdat we beide dezelfde frequentie geven is dat geen probleem, maar als je verschillende frequenties probeert in te stellen, geldt de laatste instelling voor beide. Omdat de Pico op 3,3 V werkt, geldt het MOSFET-advies dat we voor de ESP32 gaven ook hier. Voor de installatie lees je Wat is de Raspberry Pi Pico.
1from machine import Pin, PWM, ADC
2import time
3
4pins = (11, 12, 13) # R, G, B MOSFET kapıları / gates
5leds = []
6for p in pins:
7 pwm = PWM(Pin(p))
8 pwm.freq(1000) # 1 kHz PWM
9 pwm.duty_u16(0) # başlangıçta kapalı / off at start
10 leds.append(pwm)
11
12pot = ADC(26) # GP26 = ADC0
13
14def set_color(r, g, b):
15 # 0-255 değerini 0-65535'e çevir / convert 0-255 to 0-65535
16 leds[0].duty_u16(r * 257)
17 leds[1].duty_u16(g * 257)
18 leds[2].duty_u16(b * 257)
19
20def wheel(hue):
21 p = hue % 256
22 if hue < 256:
23 return 255 - p, p, 0 # kırmızı -> yeşil / red -> green
24 elif hue < 512:
25 return 0, 255 - p, p # yeşil -> mavi / green -> blue
26 return p, 0, 255 - p # mavi -> kırmızı / blue -> red
27
28while True:
29 hue = pot.read_u16() * 767 // 65535 # 0-767 ton / hue
30 set_color(*wheel(hue))
31 time.sleep_ms(20)Projectideeën met een RGB-ledstrip
- Muziekgevoelig sfeerlicht: laat met een geluidssensor de kleur en helderheid van de strip meebewegen met het ritme van muziek; details staan in het artikel over muziekgevoelige led.
- Tv-achtergrondverlichting met afstandsbediening: verander kleur en helderheid vanaf de bank met een IR-ontvanger en afstandsbediening.
- Trapverlichting met bewegingsdetectie: als een PIR-sensor iemand detecteert, laat je de strip langzaam aanfaden en schakel je hem na een tijdje uit.
- Automatisch nachtlampje: als een LDR merkt dat het donker wordt, laat je een warm oranje licht branden met lage helderheid.
- Bediening met je telefoon: zet een webserver op de ESP32 en gebruik een kleurkiezer in je browser.
- Wekker met zonsopgang: laat de strip vanaf 20 minuten voor je wektijd langzaam van donkerrood naar wit faden.
Veelgemaakte fouten en hoe je ze oplost
| Symptoom | Waarschijnlijke oorzaak | Oplossing |
|---|---|---|
| De strip brandt helemaal niet | Geen gemeenschappelijke GND of de +12V-draad is niet aangesloten | Verbind de min van de adapter met de GND van het board en controleer de +12V-draad van de strip |
| Eén kleur brandt altijd, wat de code ook zegt | Drain en Source van de MOSFET zijn verwisseld of de MOSFET is doorgebrand | Controleer de pinvolgorde (G-D-S) en vervang zo nodig de MOSFET |
| De strip flitst uit zichzelf bij het opstarten | Geen pull-downweerstand op de Gate | Voeg 10 kΩ toe tussen elke Gate en GND |
| De MOSFET wordt erg heet | Geen logic-level-MOSFET of te lage gatespanning bij 3,3 V | Gebruik een logic-level-MOSFET zoals de IRLZ44N of IRLB8721 |
| Kleuren zijn door elkaar gehaald (groen brandt in plaats van rood) | De labels van de strip of de draadvolgorde zijn anders | Verwissel de waarden van PIN_R, PIN_G, PIN_B in de code |
| Het einde van de strip ziet er geelachtig en dof uit | Spanningsverlies op een lange strip | Voed strips langer dan 5 m aan beide uiteinden en gebruik dikkere draad |
| Het board reset of start opnieuw op | Adapter te zwak, spanning zakt in | Gebruik een krachtigere adapter en voed het board met een aparte spanningsregelaar |
| Flikkering of lijnen op camera | Lage PWM-frequentie | Verhoog de frequentie naar 1–5 kHz op de ESP32 en Pico |
Een niet-adresseerbare RGB-strip met drie MOSFETs en drie PWM-pins is de praktischste manier om een krachtige, goedkope laag licht toe te voegen aan je kamer, bureau of project. Wil je elke led afzonderlijk aansturen, dan kan WS2812B je volgende stap zijn. In de BlueGrays-app kun je stap voor stap, met schakelschema's en code, RGB-led-kleurmenging, soepele kleurfades, een ESP32-kleurmengerlamp en een Pico RGB-kleurencyclusproject ontdekken.
Veelgestelde vragen
Kan een RGB-ledstrip rechtstreeks op een Arduino worden aangesloten?
Nee. Een 12V-strip kan meer dan een ampère per meter trekken, terwijl een Arduino-pin maar ongeveer 20 mA kan leveren en op 5 V werkt. Je moet de strip per kleurkanaal aansturen via een logic-level-MOSFET; de Arduino stuurt alleen een PWM-signaal naar de gate van de MOSFET.
Welke MOSFET moet ik gebruiken voor een 12V-ledstrip?
Voor de 5V-boards Arduino Uno en Nano is de IRLZ44N een gangbare en geschikte keuze. Op 3,3V-boards zoals de ESP32 en Raspberry Pi Pico werken MOSFETs die bij een lage gatespanning volledig aangaan, zoals de IRLB8721 of AO3400, beter. De IRF520 en IRF540N gaan bij 5 V niet volledig aan en worden daardoor heet.
Hoeveel ampère trekt een RGB-ledstrip van 5 meter?
Een 5050-strip met 60 led's/m trekt bij volledig wit ongeveer 1,2 A per meter; 5 meter is ongeveer 6 A en 72 W. Bij een strip met 30 led's/m zijn deze waarden de helft. Kies de adapter met 20% extra ruimte; voor 6 A is een 12V-adapter van 8 A de juiste keuze.
Wat is het verschil tussen een RGB-ledstrip en WS2812B?
Op een niet-adresseerbare RGB-strip tonen alle led's tegelijk dezelfde kleur en stuur je hem aan met drie MOSFETs. Bij een WS2812B heeft elke led een eigen driverchip en stuur je vanaf één datapin aan elke led een andere kleur. WS2812B is ideaal voor looplichteffecten, terwijl de RGB-strip ideaal is voor goedkope, krachtige eenvoudige verlichting.
Waar kun je een RGB-ledstrip doorknippen?
12V-strips werken in segmenten van drie led's en kunnen alleen worden doorgeknipt bij de knipmarkeringen op de koperen pads; die afstand is 5 cm bij 60 led's/m en 10 cm bij 30 led's/m. Knip je ergens anders, dan brandt dat segment niet. Het stuk dat je hebt afgeknipt kun je weer aansluiten door draden aan de pads te solderen of een klikconnector te gebruiken.
Kan ik de Arduino voeden vanuit de 12V-adapter van de strip?
Je kunt de Arduino Uno met 12 V voeden via de voedingsjack of de Vin-pin; de ingebouwde regelaar kan dat bij lichte belasting aan. Op ESP32-devboards en de Raspberry Pi Pico moet je 12 V met een step-downconverter zoals de LM2596 terugbrengen naar 5 V. In elk geval moet de min van de adapter met de GND van het board zijn verbonden.
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-led dimmen met PWM
De helderheid van de led soepel veranderen van 0 naar max en van max naar 0. We sturen PWM aan met analogWrite() zoals bij Arduino; dezelfde syntaxis werkt zonder problemen met ESP32 Arduino Core 3.0+. Een pindefinitie, pinMode en analogWrite zijn genoeg.

ESP32 ledhelderheid regelen met een potmeter (analoog → PWM)
In dit project regel je de helderheid van een led analoog met een potmeter. De ADC-pin van de ESP32 leest de spanning van 0–3,3 V van de potmeter; die waarde wordt omgezet in een PWM-signaal (pulsbreedtemodulatie) en naar de led gestuurd. Als je aan de potmeter draait, wordt de led dus geleidelijk helderder en zwakker. Met Arduino Core 3.0+ kun je analogWrite() direct gebruiken; op de ESP32-S2/S3 ligt de ADC-resolutie vast op 12 bit.

Raspberry Pi Pico PWM-led-fade (ademeffect)
De led knippert niet meer alleen, hij ademt! Met de PWM (Pulse Width Modulation) van de Raspberry Pi Pico wordt de helderheid van de led langzaam hoger en dan langzaam weer lager: een rustig "ademeffect" zoals het lampje van een slapende laptop. Je leert de klasse machine.PWM, de 16-bits helderheidswaarde van 0–65535 met duty_u16() en de PWM-frequentie.
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

