Arduino-ledkaars met flikkereffect: realistische vlam en adventskrans
Laat een Arduino-ledkaars flikkeren als een echte vlam met PWM en gladgestreken willekeur: een adventskrans met 4 kaarsen, flikkerinstellingen, batterijduur met de Nano en Pico.
In dit Arduino-ledkaarsproject laat je een gewone led flikkeren als een echte kaarsvlam met PWM en gecontroleerde willekeur. Het resultaat is een kaars die veilig brandt op tafel, op de vensterbank of in een kinderkamer, zonder vuur, roet of kans op omvallen. De meeste kant-en-klare ledkaarsen herhalen steeds één flikkerpatroon; als je zelf de code schrijft, bepaal je precies hoe rustig of levendig de vlam is, tussen welke waarden hij op- en afbouwt en hoe vaak hij in een "tochtvlaag" buigt.
In deze gids vind je eerst de logica achter het flikkereffect en een korte sketch voor één kaars, daarna een tabel die laat zien hoe elke parameter de vlam verandert. Vervolgens bouw je een adventskrans met vier kaarsen: bij elke druk op de knop gaat er één kaars extra aan, de keuze wordt opgeslagen in EEPROM en de schakeling gaat na 6 uur zelf slapen. Tot slot pas je alles in een klein doosje met een Arduino Nano, reken je de batterijduur uit en vind je een MicroPython-versie voor de Raspberry Pi Pico.

Hoe werkt een ledkaarseffect?
Arduino-pins kunnen alleen 0 V of 5 V leveren; om een led op halve helderheid te laten branden, wordt de pin honderden keren per seconde aan- en uitgezet. Dit heet PWM (pulsbreedtemodulatie). De waarde 0–255 in analogWrite(pin, value) bepaalt hoeveel van elke periode de pin aan blijft: 64 betekent ongeveer 25 procent en 191 ongeveer 75 procent helderheid. Op de Uno en Nano is de PWM-frequentie ongeveer 980 Hz op pin 5 en 6 en ongeveer 490 Hz op pin 3, 9, 10 en 11; het oog ziet deze snelheid niet en neemt de led waar als constant maar gedimd. De details staan in de gids wat is PWM.
Het geheim van een realistische vlam is de willekeur te egaliseren. Als je elke 20 milliseconden analogWrite(pin, random(0, 256)) schrijft, trilt de led als een kapotte tl-buis, want een echte vlam springt nooit in een oogwenk van nul naar volle helderheid. Een betere methode is een willekeurige doelhelderheid kiezen en de huidige helderheid bij elke stap een stukje dichter bij dat doel brengen: level = level + (target − level) / 4. Het doel verandert af en toe en het niveau stroomt er soepel naartoe. Voeg af en toe een diepe dip toe, de vlam die buigt in de tocht, en het oog accepteert het als een echte kaars.
Onderdelen en de keuze van de leds
| Kleur van de led | Doorlaatspanning (ca.) | Weerstand (Uno, 5 V) | Weerstand (Pico, 3,3 V) | Kaarslook |
|---|---|---|---|---|
| Geel | 2,0–2,1 V | 220 Ω (~13 mA) | 220 Ω (~6 mA) | Zeer goed, klassieke kaarskleur |
| Oranje / amber | 2,0–2,1 V | 220 Ω (~13 mA) | 220 Ω (~6 mA) | De warmste, meest realistische tint |
| Warmwit | 3,0–3,2 V | 150 Ω (~12 mA) | Niet aanbevolen (te zwak) | Helder, zoals een moderne ledkaars |
| Rood | 1,8–2,0 V | 220 Ω (~14 mA) | 220 Ω (~6 mA) | Op zichzelf te donker; goed in combinatie met geel |
- Arduino Uno of Nano: De Uno om op het bureau te testen, de Nano om in een doosje in te bouwen. Beide boards hebben dezelfde pins en dezelfde code.
- 4 gele of oranje leds en de weerstand uit de tabel voor elk ervan. Weerstanden voor andere leds vind je met de ledweerstandcalculator.
- 1 drukknop: Om het aantal kaarsen te veranderen en uit te schakelen. De interne pull-up wordt gebruikt, dus een extra weerstand is niet nodig.
- Breadboard en jumperdraden, plus gaatjesprint en soldeer voor een vaste krans.
- Voeding: Een USB-adapter, een powerbank of een batterijhouder. De batterij kiezen we met de berekening hieronder.
- Kaarslichaam: Een stuk witte pvc-buis, een uitgeholde oude kaars of een matglas; alles wat het licht van de led verspreidt, werkt.
Eén kaars: een eerste flikkersketch
1const byte LED_PIN = 9; // PWM pini, 220 ohm ile LED / PWM pin, LED through 220 ohm
2
3int level = 180; // şu anki parlaklık / current brightness
4int target = 180; // hedef parlaklık / target brightness
5
6void setup() {
7 pinMode(LED_PIN, OUTPUT);
8 randomSeed(analogRead(A0)); // her açılışta farklı titreme / different flicker on every start
9}
10
11void loop() {
12 if (random(100) < 8) { // %8 ihtimalle yeni hedef / 8% chance of a new target
13 target = random(90, 256);
14 if (random(100) < 5) target = 40; // nadir esinti: alev eğilir / rare gust: the flame dips
15 }
16 level += (target - level) / 4; // hedefe yumuşak yaklaş / ease toward the target
17 analogWrite(LED_PIN, level);
18 delay(random(15, 40)); // düzensiz adım / irregular step
19}Sluit de led via een weerstand van 220 Ω aan op pin 9, zijn korte pootje op GND, en upload de sketch. Bij elke lusdoorgang is er 8 procent kans op een nieuw doel tussen 90 en 255; met 5 procent kans wordt het doel naar 40 getrokken voor een diepe dip. De regel level += (target − level) / 4 telt een kwart van het verschil erbij op voor een soepele overgang, en de willekeurige pauze van 15–40 ms maakt het patroon nog onregelmatiger. De regel randomSeed(analogRead(A0)) gebruikt de ruis op de zwevende pin A0 om bij elke start een andere willekeurige reeks te beginnen; zonder dit flikkert de kaars elke keer hetzelfde.
Tabel met flikkerparameters
| Parameter | Standaard | Als je hem verlaagt | Als je hem verhoogt |
|---|---|---|---|
| FLAME_MIN | 90 | De vlam flikkert dieper en lijkt bijna uit te gaan | De vlam komt tot rust en brandt bijna constant |
| FLAME_MAX | 255 | De kaars wordt zwakker, als een nachtlampje | 255 is de bovengrens; voor meer helderheid heb je meer ledstroom nodig |
| CHANGE_CHANCE | 8 (%) | Een stille vlam in een ruimte zonder tocht | Snelle, nerveuze flikkering die na een tijdje vermoeiend wordt |
| GUST_CHANCE | 3 (%) | Bijna geen tocht | Een vlam die vaak buigt, als bij een open raam |
| SMOOTH | 4 | 1–2: plotselinge sprongen, als bij een defecte lamp | 8 en hoger: langzame, golvende helderheidsschommelingen |
| STEP_MS | 25 ms | Een snellere, levendigere vlam | Vanaf 50 ms lijkt het slow motion |
Adventskrans met vier kaarsen: bedrading
Een adventskrans is een traditie, vooral geliefd in Duitsland, Oostenrijk en Zwitserland, waarbij op elk van de vier zondagen voor Kerstmis één kaars extra wordt aangestoken. In 2026 zijn de adventszondagen 29 november, 6 december, 13 december en 20 december. In onze krans staan vier leds voor de vier kaarsen; een korte druk op de knop voegt een brandende kaars toe (0, 1, 2, 3, 4 en weer 0) en een lange druk schakelt de schakeling uit. Elke kaars heeft een eigen flikkertoestand, zodat de vier vlammen onafhankelijk en natuurlijk ogen.
| Aansluiting | Arduino Uno / Nano | Raspberry Pi Pico |
|---|---|---|
| Kaars 1 (weerstand naar het lange pootje van de led) | D3 | GP14 |
| Kaars 2 | D5 | GP15 |
| Kaars 3 | D6 | GP16 |
| Kaars 4 | D9 | GP17 |
| Korte pootjes van de leds | GND | GND |
| Knop (andere pootje naar GND) | D2 | GP2 |

Code voor de adventskrans: elke zondag een kaars meer
De sketch werkt met millis() in plaats van delay(), zodat de flikkering nooit stopt terwijl hij naar de knop luistert en de timer bijhoudt. Deze aanpak wordt uitgelegd in de gids millis vs delay. Elke 25 ms wordt de toestand van de vier kaarsen bijgewerkt, en niet-brandende kaarsen houden een PWM-waarde van nul. Het gekozen aantal kaarsen wordt naar EEPROM-adres 0 geschreven; ook als je de stekker eruit trekt en weer terugsteekt, komt de krans terug met hetzelfde aantal kaarsen.
1#include <EEPROM.h>
2#include <avr/sleep.h>
3
4const byte CANDLES = 4;
5const byte CANDLE_PINS[CANDLES] = {3, 5, 6, 9}; // PWM pinleri / PWM pins
6const byte BUTTON_PIN = 2; // buton -> GND, INT0 / button -> GND, INT0
7
8// Titreme ayarları / flicker settings
9const int FLAME_MIN = 90; // en kısık alev / dimmest flame
10const int FLAME_MAX = 255; // en parlak alev / brightest flame
11const byte CHANGE_CHANCE = 8; // her adımda yeni hedef olasılığı (%) / chance of a new target per step (%)
12const byte GUST_CHANCE = 3; // esinti olasılığı (%) / chance of a gust (%)
13const byte SMOOTH = 4; // büyüdükçe alev yavaşlar / higher = calmer flame
14const unsigned long STEP_MS = 25; // adım süresi / step time
15const unsigned long ON_TIME = 6UL * 60 * 60 * 1000; // 6 saat sonra uyku / sleep after 6 hours
16
17int level[CANDLES];
18int target[CANDLES];
19byte litCount = 1; // yanan mum sayısı (0-4) / number of lit candles (0-4)
20unsigned long onSince = 0;
21unsigned long lastStep = 0;
22
23void wakeUp() {} // yalnız uyandırmak için / only used to wake the chip
24
25void goToSleep() {
26 for (byte i = 0; i < CANDLES; i++) analogWrite(CANDLE_PINS[i], 0);
27 while (digitalRead(BUTTON_PIN) == LOW) {} // butonun bırakılmasını bekle / wait for release
28 delay(50);
29 set_sleep_mode(SLEEP_MODE_PWR_DOWN);
30 sleep_enable();
31 noInterrupts();
32 attachInterrupt(digitalPinToInterrupt(BUTTON_PIN), wakeUp, LOW);
33 interrupts();
34 sleep_cpu(); // burada uyur / sleeps here
35 sleep_disable(); // butona basınca buradan devam / resumes here on press
36 detachInterrupt(digitalPinToInterrupt(BUTTON_PIN));
37 while (digitalRead(BUTTON_PIN) == LOW) {} // uyandıran basış sayılmasın / ignore the wake-up press
38 delay(50);
39 onSince = millis();
40}
41
42void flicker() {
43 for (byte i = 0; i < CANDLES; i++) {
44 if (i >= litCount) { // bu mum henüz yakılmadı / not lit yet
45 analogWrite(CANDLE_PINS[i], 0);
46 continue;
47 }
48 if (random(100) < CHANGE_CHANCE) {
49 target[i] = random(FLAME_MIN, FLAME_MAX + 1);
50 if (random(100) < GUST_CHANCE) target[i] = FLAME_MIN / 2; // alev eğilir / the flame bends
51 }
52 level[i] += (target[i] - level[i]) / SMOOTH;
53 analogWrite(CANDLE_PINS[i], level[i]);
54 }
55}
56
57void setup() {
58 pinMode(BUTTON_PIN, INPUT_PULLUP);
59 for (byte i = 0; i < CANDLES; i++) {
60 pinMode(CANDLE_PINS[i], OUTPUT);
61 level[i] = target[i] = 200;
62 }
63 randomSeed(analogRead(A0));
64 litCount = EEPROM.read(0); // son seçimi hatırla / remember the last choice
65 if (litCount > CANDLES) litCount = 1; // boş EEPROM 255 okur / empty EEPROM reads 255
66 onSince = millis();
67}
68
69void loop() {
70 if (digitalRead(BUTTON_PIN) == LOW) {
71 unsigned long pressStart = millis();
72 while (digitalRead(BUTTON_PIN) == LOW) {
73 if (millis() - pressStart > 1500) { // uzun basış: kapat / long press: switch off
74 goToSleep();
75 return;
76 }
77 }
78 if (millis() - pressStart > 50) { // kısa basış: bir mum daha / short press: one more candle
79 litCount = (litCount + 1) % (CANDLES + 1);
80 EEPROM.update(0, litCount);
81 onSince = millis();
82 }
83 }
84
85 if (millis() - onSince > ON_TIME) goToSleep(); // zamanlayıcı / auto-off timer
86
87 if (millis() - lastStep >= STEP_MS) {
88 lastStep = millis();
89 flicker();
90 }
91}| Code | Wat het doet |
|---|---|
| level[i], target[i] | De eigen helderheid en het eigen doel van elke kaars; de vier vlammen flikkeren onafhankelijk |
| i >= litCount | Zet kaarsen uit die nog niet aan de beurt zijn; voor de 2e zondag litCount = 2 |
| EEPROM.update(0, litCount) | Schrijft niet als de waarde niet is veranderd, zodat de levensduur van de EEPROM-cel wordt beschermd |
| if litCount > CANDLES then 1 | Nooit beschreven EEPROM leest 255; bij de allereerste start begint hij met één kaars |
| ON_TIME | Zet na 6 uur de kaarsen uit en gaat slapen; een krans die een nacht vergeten wordt, leegt de batterij niet |
| goToSleep() | Stopt de processor met SLEEP_MODE_PWR_DOWN; een druk op de knop wekt het board via de INT0-interrupt |
In de slaapstand stopt de klok van de ATmega328P en zakt de processor naar microampères. Om hem te wekken wordt een LOW-level-interrupt aan pin 2 gekoppeld; in power-down-modus kan alleen een level-interrupt de processor wekken, dus CHANGE of FALLING werkt hier niet. Na het ontwaken wacht de code tot de knop wordt losgelaten, zodat de wekkende druk niet ook meetelt als het toevoegen van een kaars. millis() staat tijdens de slaap ook stil, daarom wordt de timer bij het ontwaken gereset.
Klein formaat met een Nano en berekening van de batterijduur
Hoe lang een batterij meegaat, vind je met looptijd (uren) = bruikbare capaciteit (mAh) / gemiddelde stroom (mA). Laten we de stroom van de krans berekenen: een flikkerende led neemt gemiddeld ongeveer 70 procent van zijn piekstroom op, dus ongeveer 8–9 mA voor een led van 12 mA. Vier kaarsen komen op ongeveer 35 mA; tel daar de 15–20 mA bij die een Nano-kloon zelf verbruikt en het totaal is ongeveer 50 mA. Een avond van 6 uur kost 300 mAh. Tijdens de slaap neemt de processor bijna niets op, maar door de voedingsled, de USB-chip en de regelaar op het board verbruiken de meeste Nano-klonen nog een paar mA (meestal ongeveer 5 mA); 18 uur slaap voegt ongeveer 90 mAh toe. Met de batterijduurcalculator kun je verschillende scenario's uitproberen.
| Voedingsbron | Bruikbare capaciteit | Avonden van 6 uur (≈50 mA) | Opmerking |
|---|---|---|---|
| 3 × AA alkaline (≈4,5 V, naar de 5V-pin) | ~2.000 mAh | ~5 avonden (incl. slaapverliezen) | De leds worden zwakker naarmate de batterijen leeglopen |
| 4 × AA NiMH oplaadbaar (≈4,8 V, naar de 5V-pin) | ~1.900 mAh | ~5 avonden | Moet tijdens de advent 4–5 keer worden opgeladen |
| 18650 + TP4056 + 5 V-boostconverter | ~1.600 mAh (bij 5 V) | ~4 avonden | Laadt op via USB, past in een doosje |
| USB-powerbank van 10.000 mAh | ~6.300 mAh (bij 5 V) | ~16 avonden | Kan zichzelf tijdens de slaap uitschakelen door de lage stroom |
| USB-adapter 5 V 1 A | Onbeperkt | Onbeperkt | De eenvoudigste oplossing voor een krans op tafel |
Raspberry Pi Pico-versie in MicroPython
Elke GPIO-pin van de Pico kan PWM leveren, dus de kaarsen gaan naar GP14–GP17 en de knop naar GP2. In MicroPython stel je de helderheid in met duty_u16() van 0 tot 65535; de code behoudt de waarden 0–255 uit de Arduino-versie en vermenigvuldigt ze met 257 om dezelfde schaal te bereiken (255 × 257 = 65535). In plaats van EEPROM wordt het aantal kaarsen opgeslagen in een bestand mum.txt op het bestandssysteem van de Pico. Sla de code op als main.py en de krans gaat aan zodra de Pico stroom krijgt.
1from machine import Pin, PWM
2import time, random
3
4PINS = (14, 15, 16, 17) # 4 mum: GP14-GP17, 220 ohm / 4 candles, 220 ohm each
5button = Pin(2, Pin.IN, Pin.PULL_UP) # buton -> GND / button -> GND
6
7FLAME_MIN = 90 # 0-255 ölçeğinde / on a 0-255 scale
8FLAME_MAX = 255
9CHANGE_CHANCE = 8 # yeni hedef olasılığı (%) / chance of a new target (%)
10GUST_CHANCE = 3 # esinti olasılığı (%) / chance of a gust (%)
11SMOOTH = 4
12STEP_MS = 25
13
14leds = []
15for p in PINS:
16 pwm = PWM(Pin(p))
17 pwm.freq(1000) # 1 kHz, göz titreşimi görmez / 1 kHz, no visible strobing
18 leds.append(pwm)
19
20level = [200] * len(PINS)
21target = [200] * len(PINS)
22
23try:
24 with open("mum.txt") as f: # son seçimi oku / read the last choice
25 lit = int(f.read())
26except (OSError, ValueError):
27 lit = 1
28
29
30def save(n):
31 with open("mum.txt", "w") as f:
32 f.write(str(n))
33
34
35last_button = 1
36while True:
37 b = button.value()
38 if b == 0 and last_button == 1: # basıldığı an / the moment it is pressed
39 lit = (lit + 1) % (len(PINS) + 1)
40 save(lit)
41 time.sleep_ms(30) # basit debounce / simple debounce
42 last_button = b
43
44 for i, led in enumerate(leds):
45 if i >= lit:
46 led.duty_u16(0)
47 continue
48 if random.randint(0, 99) < CHANGE_CHANCE:
49 target[i] = random.randint(FLAME_MIN, FLAME_MAX)
50 if random.randint(0, 99) < GUST_CHANCE:
51 target[i] = FLAME_MIN // 2
52 level[i] += (target[i] - level[i]) // SMOOTH
53 led.duty_u16(level[i] * 257) # 0-255 -> 0-65535
54 time.sleep_ms(STEP_MS)Omdat de Pico op 3,3 V werkt, lichten warmwitte leds (ongeveer 3 V doorlaatspanning) nauwelijks op; gebruik gele of oranje leds met weerstanden van 220 Ω. Deze versie heeft geen timer of slaapstand; tel desgewenst 6 uur met time.ticks_ms() en zet alle duty-waarden op nul. We stellen de PWM-frequentie van de Pico in op 1 kHz; bij lagere frequenties kunnen er strepen zichtbaar zijn in video's die met een telefooncamera zijn opgenomen.
Zorgen dat het realistisch oogt
- Verspreid het licht: Maak de bovenkant van de led mat met fijn schuurpapier of stop wat watten in het kaarslichaam; dan gloeit het hele lichaam in plaats van één punt.
- Vlam met twee leds: Zet een gele en een oranje led in één kaars op aparte PWM-pins en laat ze met verschillende snelheden flikkeren, dan beweegt ook de kleur van de vlam mee; de zes PWM-pins van de Uno zijn genoeg voor drie van zulke kaarsen.
- Kaarslichaam: Gebruik witte pvc-buis van 2–3 cm doorsnede, een uitgeholde echte kaars of een matglas. Een echt kaarslichaam verspreidt het licht het natuurlijkst.
- Voet van de krans: Versier de vier kaarsen met kunstmatige dennentakken en dennenappels, verberg de Nano en de batterij onder de voet en plaats de knop in een goed bereikbare hoek.
- Kleurtemperatuur: Als je warmwitte leds gebruikt, brengt een oranje doorzichtige folie ervoor het licht dichter bij de kleur van een echte vlam.
Veelgemaakte fouten en oplossingen
| Symptoom | Waarschijnlijke oorzaak | Oplossing |
|---|---|---|
| De led flikkert niet, hij is aan of uit | De led zit op een pin zonder PWM | Verplaats de led naar pin 3, 5, 6, 9, 10 of 11 |
| De vlam trilt als een kapotte tl-buis | SMOOTH is te klein of het doel verandert bij elke stap | Zet SMOOTH op 4–6 en verlaag CHANGE_CHANCE tot onder 10 |
| Alle kaarsen flikkeren tegelijk op dezelfde manier | Eén enkele variabele level wordt naar alle pins geschreven | Gebruik aparte arrays voor level en target voor elke kaars |
| Het board wordt niet wakker uit de slaapstand | De knop zit niet op D2 of de interrupt is niet LOW-level | Sluit de knop aan op D2 en gebruik attachInterrupt(..., LOW) |
| Bij elke start hetzelfde flikkerpatroon | randomSeed is niet aangeroepen of A0 is met iets verbonden | Roep randomSeed(analogRead(A0)) aan met een zwevende analoge pin |
| De batterij is in een paar dagen leeg | De voedingsled en de USB-chip van de Nano verbruiken ook tijdens de slaap stroom | Gebruik een adapter of stap over op een Pro Mini met verwijderde voedingsled |
Deze ledkaars, gebouwd met een paar leds, een paar weerstanden en een knop, brengt PWM, timing met millis(), EEPROM, slaapstand en batterijberekeningen samen in één gezellig project. Je kunt het kaarseffect meenemen naar je eigen projecten door in de BlueGrays-app te kijken naar de stap-voor-stap-schakelschema's en code voor basisprojecten met licht, zoals een led laten branden, een led schakelen met een knop, een zachte kleurovergang met een RGB-led en PWM-dimmen met een ESP32 of Pico.
Veelgestelde vragen
Hoe maak ik een flikkerende ledkaars met Arduino?
Sluit de led via een weerstand van 220 Ω aan op een van de PWM-pins van de Arduino en verander de helderheid willekeurig maar soepel met analogWrite(). Het beste resultaat krijg je door een willekeurige doelhelderheid te kiezen en de huidige helderheid bij elke stap langzaam daar naartoe te brengen. Af en toe een diepe dip bootst de vlam na die in de tocht buigt.
Welke ledkleur moet ik voor een ledkaars gebruiken?
Gele of oranje (amberkleurige) leds komen het dichtst bij de kleur van een echte vlam. Warmwitte leds zijn helderder en lijken op moderne ledkaarsen, maar blijven zwak op boards met 3,3 V. Blauwe en koudwitte leds lijken niet op een vlam.
Welke weerstand moet ik gebruiken om een led op Arduino aan te sluiten?
Bij 5 V geven een weerstand van 220 Ω voor een gele of rode led en 150 Ω voor een warmwitte led ongeveer 12–14 mA, wat veilig is. De waarde bereken je met (voedingsspanning − ledspanning) / gewenste stroom. Als je de weerstand weglaat, kun je zowel de led als de Arduino-pin beschadigen.
Welke Arduino-pins ondersteunen PWM?
Op de Arduino Uno en Nano zijn de PWM-pins 3, 5, 6, 9, 10 en 11, op het board gemarkeerd met ~. Pin 5 en 6 werken op ongeveer 980 Hz, de rest op ongeveer 490 Hz. Op de Raspberry Pi Pico kan elke GPIO-pin PWM leveren.
Hoe lang gaat een Arduino-ledkaars mee op batterijen?
Een krans met vier kaarsen op een Nano neemt ongeveer 50 mA op; met drie AA-cellen van 2.000 mAh is dat, inclusief slaapverliezen, ongeveer vijf avonden van 6 uur. Een powerbank van 10.000 mAh gaat ongeveer 16 avonden mee. Gebruik voor een lange batterijduur een Pro Mini met verwijderde voedingsled plus slaapstand.
Op welke dagen worden de kaarsen van de adventskrans aangestoken?
Op een adventskrans wordt op elk van de vier zondagen voor Kerstmis één kaars extra aangestoken. In 2026 zijn dat 29 november, 6 december, 13 december en 20 december. Druk in dit project elke zondag één keer op de knop om het aantal brandende kaarsen te verhogen.
Projecten om hierna te bouwen
Alle projecten bekijken
LED laten knipperen
De allereerste hallo van de elektronica: één LED aan- en uitzetten. De Arduino zet de LED met korte tussenpozen aan en uit, zodat het licht snel knippert.

Twee LED's om en om laten knipperen
Twee LED's knipperen snel om de beurt: als de ene aangaat, gaat de andere uit, alsof ze elkaar een bal toegooien.

LED schakelen met een knop (aan/uit)
Druk één keer op de knop en het licht gaat aan, druk nog een keer en het gaat uit, net als de lichtschakelaar in je kamer. De Arduino merkt elke druk op en zet de led in de tegenovergestelde toestand.

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-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

