Gidsen · 9 min leestijd

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.

5 mm-leds
5 mm-led: kies voor een kaarseffect geel, oranje of warmwit; blauwe en koudwitte leds lijken niet op een vlam.

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 ledDoorlaatspanning (ca.)Weerstand (Uno, 5 V)Weerstand (Pico, 3,3 V)Kaarslook
Geel2,0–2,1 V220 Ω (~13 mA)220 Ω (~6 mA)Zeer goed, klassieke kaarskleur
Oranje / amber2,0–2,1 V220 Ω (~13 mA)220 Ω (~6 mA)De warmste, meest realistische tint
Warmwit3,0–3,2 V150 Ω (~12 mA)Niet aanbevolen (te zwak)Helder, zoals een moderne ledkaars
Rood1,8–2,0 V220 Ω (~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

C++ (Arduino IDE)
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

ParameterStandaardAls je hem verlaagtAls je hem verhoogt
FLAME_MIN90De vlam flikkert dieper en lijkt bijna uit te gaanDe vlam komt tot rust en brandt bijna constant
FLAME_MAX255De kaars wordt zwakker, als een nachtlampje255 is de bovengrens; voor meer helderheid heb je meer ledstroom nodig
CHANGE_CHANCE8 (%)Een stille vlam in een ruimte zonder tochtSnelle, nerveuze flikkering die na een tijdje vermoeiend wordt
GUST_CHANCE3 (%)Bijna geen tochtEen vlam die vaak buigt, als bij een open raam
SMOOTH41–2: plotselinge sprongen, als bij een defecte lamp8 en hoger: langzame, golvende helderheidsschommelingen
STEP_MS25 msEen snellere, levendigere vlamVanaf 50 ms lijkt het slow motion
Verander tijdens het afstellen telkens één parameter en kijk naar de led door papier of matglas in plaats van rechtstreeks; bij een kale led lijkt de flikkering altijd harder dan ze is. Voor de meeste mensen komt het meest natuurlijke resultaat met FLAME_MIN op 80–110, SMOOTH op 3–5 en CHANGE_CHANCE op 6–10.

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.

AansluitingArduino Uno / NanoRaspberry Pi Pico
Kaars 1 (weerstand naar het lange pootje van de led)D3GP14
Kaars 2D5GP15
Kaars 3D6GP16
Kaars 4D9GP17
Korte pootjes van de ledsGNDGND
Knop (andere pootje naar GND)D2GP2
Sluit de kaarsen alleen aan op pins die PWM kunnen: op de Uno en Nano zijn dat 3, 5, 6, 9, 10 en 11 (op het board gemarkeerd met ~). Een led op een andere pin flikkert niet met analogWrite(); hij blijft uit bij waarden onder 128 en brandt er boven volledig. Sluit de knop aan op pin 2, omdat de sketch via de interrupt op deze pin (INT0) uit de slaapstand ontwaakt. Voor de pinindeling van de Nano, zie de gids Arduino Nano pinout.
Arduino Nano
Arduino Nano: dezelfde ATmega328P-processor en dezelfde PWM-pins als de Uno, maar klein genoeg om in de voet van een krans te passen.

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.

C++ (Arduino IDE)
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}
CodeWat het doet
level[i], target[i]De eigen helderheid en het eigen doel van elke kaars; de vier vlammen flikkeren onafhankelijk
i >= litCountZet 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 1Nooit beschreven EEPROM leest 255; bij de allereerste start begint hij met één kaars
ON_TIMEZet 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.

VoedingsbronBruikbare capaciteitAvonden 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 avondenMoet tijdens de advent 4–5 keer worden opgeladen
18650 + TP4056 + 5 V-boostconverter~1.600 mAh (bij 5 V)~4 avondenLaadt op via USB, past in een doosje
USB-powerbank van 10.000 mAh~6.300 mAh (bij 5 V)~16 avondenKan zichzelf tijdens de slaap uitschakelen door de lage stroom
USB-adapter 5 V 1 AOnbeperktOnbeperktDe eenvoudigste oplossing voor een krans op tafel
Sluit geen vier alkaline AA-cellen rechtstreeks aan op de 5V-pin: verse alkalinecellen halen samen tot 6,4 V, en op de 5V-pin, die de regelaar omzeilt, overschrijdt dat de limiet van 5,5 V van de processor. Een 9V-batterij is ook geen goede keuze; de capaciteit is ongeveer 500 mAh en de regelaar op VIN zet de overtollige spanning om in warmte. Wil je een kaars die lang op batterijen werkt, dan brengt een Arduino Pro Mini met verwijderde voedingsled de slaapstroom terug tot microampères.

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.

MicroPython
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

SymptoomWaarschijnlijke oorzaakOplossing
De led flikkert niet, hij is aan of uitDe led zit op een pin zonder PWMVerplaats de led naar pin 3, 5, 6, 9, 10 of 11
De vlam trilt als een kapotte tl-buisSMOOTH is te klein of het doel verandert bij elke stapZet SMOOTH op 4–6 en verlaag CHANGE_CHANCE tot onder 10
Alle kaarsen flikkeren tegelijk op dezelfde manierEén enkele variabele level wordt naar alle pins geschrevenGebruik aparte arrays voor level en target voor elke kaars
Het board wordt niet wakker uit de slaapstandDe knop zit niet op D2 of de interrupt is niet LOW-levelSluit de knop aan op D2 en gebruik attachInterrupt(..., LOW)
Bij elke start hetzelfde flikkerpatroonrandomSeed is niet aangeroepen of A0 is met iets verbondenRoep randomSeed(analogRead(A0)) aan met een zwevende analoge pin
De batterij is in een paar dagen leegDe voedingsled en de USB-chip van de Nano verbruiken ook tijdens de slaap stroomGebruik een adapter of stap over op een Pro Mini met verwijderde voedingsled
Kijk een paar minuten naar een echte kaars in een donkere kamer en tel hoe vaak de helderheid verandert, en stel dan STEP_MS en CHANGE_CHANCE in op basis van wat je zag. De meeste vlammen waaieren zichtbaar twee of drie keer per seconde en buigen pas echt eens in de zoveel minuten.

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.

Alle projecten bekijken
LED laten knipperen
AR-1Beginner

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.

4.6(200)
1246
Twee LED's om en om laten knipperen
AR-2Beginner

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.

4.6(110)
362
LED schakelen met een knop (aan/uit)
AR-10Beginner

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.

4.7(103)
177
Een RGB-led gebruiken
AR-39Beginner
Premium

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.

4.9(73)
100
Vloeiende kleurovergang met een RGB-led
AR-40Beginner
Premium

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.

4.8(58)
78
ESP32-led dimmen met PWM
ES-8Beginner

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.

4.8(36)
55
ESP32 ledhelderheid regelen met een potmeter (analoog → PWM)
ES-13Gemiddeld
Premium

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.

4.5(19)
32
Raspberry Pi Pico PWM-led-fade (ademeffect)
PI-14Beginner

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.

4