Ratgeber · 8 Min. Lesezeit

LED-Kerze flackern mit Arduino: echte Flamme und Adventskranz

LED-Kerze mit Arduino flackern lassen: echte Flamme per PWM und geglättetem Zufall, Adventskranz mit 4 Kerzen, Flacker-Tabelle, Nano mit Akkulaufzeit und Pico.

In diesem Projekt bringst du eine gewöhnliche LED mit PWM und kontrolliertem Zufall dazu, wie eine echte Kerzenflamme zu flackern. Das Ergebnis ist eine Kerze, die sicher auf dem Tisch, auf der Fensterbank oder im Kinderzimmer brennt, ohne Feuer, Ruß und Kipprisiko. Die meisten fertigen LED-Kerzen wiederholen ein einziges Flackermuster; schreibst du den Code selbst, bestimmst du genau, wie ruhig oder lebhaft die Flamme ist, in welchem Bereich sie hell und dunkel wird und wie oft sie sich in einem "Luftzug" neigt.

In dieser Anleitung findest du zuerst die Logik hinter dem Flackereffekt und einen kurzen Sketch für eine Kerze, dann eine Tabelle, die zeigt, wie jeder Parameter die Flamme verändert. Danach baust du einen Adventskranz mit vier Kerzen: Jeder Tastendruck zündet eine Kerze mehr an, die Auswahl wird im EEPROM gespeichert, und die Schaltung legt sich nach 6 Stunden schlafen. Zum Schluss geht es um den Einbau mit einem Arduino Nano in eine kleine Box, die Akkulaufzeit und eine MicroPython-Version für den Raspberry Pi Pico.

5-mm-LEDs
5-mm-LED: Für den Kerzeneffekt nimmst du Gelb, Orange oder Warmweiß; blaue und kaltweiße LEDs sehen nicht wie eine Flamme aus.

Wie funktioniert der LED-Kerzeneffekt?

Die Pins des Arduino können nur 0 V oder 5 V ausgeben; um eine LED mit halber Helligkeit leuchten zu lassen, wird der Pin hunderte Male pro Sekunde ein- und ausgeschaltet. Das nennt man PWM (Pulsweitenmodulation). Der Wert 0–255 in analogWrite(pin, wert) legt fest, wie lange der Pin pro Periode eingeschaltet bleibt: 64 bedeutet etwa 25 Prozent, 191 etwa 75 Prozent Helligkeit. Beim Uno und Nano liegt die PWM-Frequenz an den Pins 5 und 6 bei etwa 980 Hz, an 3, 9, 10 und 11 bei etwa 490 Hz; das Auge sieht diese Geschwindigkeit nicht und nimmt die LED als gleichmäßig gedimmt wahr. Mehr dazu im Beitrag Was ist PWM.

Das Geheimnis einer echten Flamme ist, den Zufall zu glätten. Schreibst du alle 20 Millisekunden analogWrite(pin, random(0, 256)), zuckt die LED wie eine kaputte Leuchtstoffröhre, denn eine echte Flamme springt nie schlagartig von null auf volle Helligkeit. Besser ist es, eine zufällige Zielhelligkeit zu wählen und die aktuelle Helligkeit bei jedem Schritt ein Stück darauf zuzubewegen: level = level + (target − level) / 4. Das Ziel ändert sich ab und zu, die Helligkeit fließt sanft hinterher. Kommen noch seltene tiefe Einbrüche dazu, also eine Flamme, die sich im Luftzug neigt, hält das Auge sie für eine echte Kerze.

Material und LED-Auswahl

LED-FarbeDurchlassspannung (ca.)Widerstand (Uno, 5 V)Widerstand (Pico, 3,3 V)Wirkung als Kerze
Gelb2,0–2,1 V220 Ω (~13 mA)220 Ω (~6 mA)Sehr gut, klassische Kerzenfarbe
Orange / Bernstein2,0–2,1 V220 Ω (~13 mA)220 Ω (~6 mA)Der wärmste, echteste Farbton
Warmweiß3,0–3,2 V150 Ω (~12 mA)Nicht empfohlen (zu dunkel)Hell, wie eine moderne LED-Kerze
Rot1,8–2,0 V220 Ω (~14 mA)220 Ω (~6 mA)Allein zu dunkel; gut zusammen mit Gelb
  • Arduino Uno oder Nano: Den Uno zum Testen am Schreibtisch, den Nano für den Einbau in eine Box. Pins und Code sind bei beiden gleich.
  • 4 gelbe oder orange LEDs und für jede den Widerstand aus der Tabelle. Widerstände für andere LEDs findest du mit dem LED-Vorwiderstandsrechner.
  • 1 Taster: Zum Ändern der Kerzenzahl und zum Ausschalten. Der interne Pull-up wird genutzt, ein zusätzlicher Widerstand ist nicht nötig.
  • Steckbrett und Jumperkabel, für einen dauerhaften Kranz Lochrasterplatine und Lötzinn.
  • Stromversorgung: USB-Netzteil, Powerbank oder Batteriehalter. Die Batterie wählen wir mit der Rechnung weiter unten.
  • Kerzenkörper: Ein Stück weißes PVC-Rohr, eine ausgehöhlte alte Kerze oder ein Milchglas; alles, was das Licht der LED streut, ist geeignet.

Eine Kerze: der erste Flacker-Sketch

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}

Schließ die LED über einen 220-Ω-Widerstand an Pin 9 an, das kurze Bein an GND, und lade den Sketch hoch. In jedem Durchlauf wird mit 8 Prozent Wahrscheinlichkeit ein neues Ziel zwischen 90 und 255 gewählt; mit 5 Prozent Wahrscheinlichkeit wird das Ziel für einen tiefen Einbruch auf 40 gesetzt. Die Zeile level += (target − level) / 4 addiert ein Viertel der Differenz und sorgt für einen weichen Übergang, und die zufällige Pause von 15–40 ms macht das Muster noch unregelmäßiger. Die Zeile randomSeed(analogRead(A0)) nutzt das Rauschen am offenen Pin A0, damit bei jedem Einschalten eine andere Zufallsfolge startet; ohne sie flackert die Kerze jedes Mal gleich.

Tabelle der Flackerparameter

ParameterStandardWenn du ihn verkleinerstWenn du ihn vergrößerst
FLAME_MIN90Die Flamme flackert tiefer und wirkt, als würde sie gleich ausgehenDie Flamme beruhigt sich und brennt fast gleichmäßig
FLAME_MAX255Die Kerze wird dunkler, wie ein Nachtlicht255 ist die Obergrenze; für mehr Helligkeit braucht die LED mehr Strom
CHANGE_CHANCE8 (%)Eine ruhige Flamme in einem zugfreien RaumSchnelles, nervöses Flackern, das nach einer Weile anstrengt
GUST_CHANCE3 (%)Fast nie ein LuftzugEine Flamme, die sich oft neigt, wie bei offenem Fenster
SMOOTH41–2: plötzliche Sprünge, wie eine defekte GlühbirneAb 8: langsame, wellenartige Helligkeitsschwankungen
STEP_MS25 msEine schnellere, lebendigere FlammeAb 50 ms wirkt es wie Zeitlupe
Ändere beim Einstellen immer nur einen Parameter und betrachte die LED nicht direkt, sondern durch Papier oder Milchglas; an einer nackten LED wirkt das Flackern immer härter, als es ist. Für die meisten wirkt es am natürlichsten mit FLAME_MIN bei 80–110, SMOOTH bei 3–5 und CHANGE_CHANCE bei 6–10.

Adventskranz mit vier Kerzen: Anschluss

Der Adventskranz ist eine besonders in Deutschland, Österreich und der Schweiz beliebte Tradition: An jedem der vier Sonntage vor Weihnachten wird eine Kerze mehr angezündet. 2026 sind die Adventssonntage der 29. November, 6. Dezember, 13. Dezember und 20. Dezember. In unserem Kranz stehen vier LEDs für die vier Kerzen; ein kurzer Tastendruck erhöht die Zahl der brennenden Kerzen um eins (0, 1, 2, 3, 4 und wieder 0), ein langer schaltet die Schaltung aus. Jede Kerze hat ihren eigenen Flackerzustand, sodass die vier Flammen unabhängig und natürlich wirken.

VerbindungArduino Uno / NanoRaspberry Pi Pico
1. Kerze (Widerstand zum langen Bein der LED)D3GP14
2. KerzeD5GP15
3. KerzeD6GP16
4. KerzeD9GP17
Kurze Beine der LEDsGNDGND
Taster (anderes Bein an GND)D2GP2
Schließ die Kerzen nur an PWM-fähige Pins an: Beim Uno und Nano sind das 3, 5, 6, 9, 10 und 11 (auf der Platine mit ~ markiert). An einem anderen Pin flackert die LED mit analogWrite() nicht; unter 128 bleibt sie aus, darüber leuchtet sie voll. Den Taster schließt du an Pin 2 an, weil der Sketch über den Interrupt dieses Pins (INT0) aus dem Schlaf aufwacht. Die Pinbelegung des Nano findest du im Beitrag Arduino-Nano-Pinbelegung.
Arduino Nano
Arduino Nano: derselbe ATmega328P und dieselben PWM-Pins wie beim Uno, aber klein genug für den Sockel eines Adventskranzes.

Code für den Adventskranz: jeden Sonntag eine Kerze mehr

Der Sketch arbeitet mit millis() statt delay(), damit das Flackern nie stoppt, während er den Taster abfragt und den Timer zählt. Dieses Vorgehen erklärt der Beitrag millis und delay im Vergleich. Alle 25 ms wird der Zustand der vier Kerzen aktualisiert, nicht angezündete Kerzen bleiben auf PWM-Wert null. Die gewählte Kerzenzahl landet an Adresse 0 im EEPROM; selbst wenn du den Stecker ziehst und wieder einsteckst, startet der Kranz mit derselben Zahl an Kerzen.

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}
CodeteilAufgabe
level[i], target[i]Eigene Helligkeit und eigenes Ziel jeder Kerze; die vier Flammen flackern unabhängig
i >= litCountLöscht Kerzen, die noch nicht an der Reihe sind; am 2. Advent ist litCount = 2
EEPROM.update(0, litCount)Schreibt nicht, wenn sich der Wert nicht geändert hat, und schont so die EEPROM-Zelle
litCount > CANDLES, dann 1Nie beschriebenes EEPROM liefert 255; beim allerersten Start beginnt der Kranz mit einer Kerze
ON_TIMELöscht nach 6 Stunden die Kerzen und geht schlafen; ein über Nacht vergessener Kranz leert den Akku nicht
goToSleep()Hält den Prozessor mit SLEEP_MODE_PWR_DOWN an; ein Tastendruck weckt das Board über den INT0-Interrupt

Im Schlafmodus bleibt der Takt des ATmega328P stehen und der Prozessor sinkt auf Mikroampere. Zum Aufwecken wird an Pin 2 ein LOW-Pegel-Interrupt gehängt; im Power-down-Modus kann nur ein Pegel-Interrupt den Prozessor wecken, CHANGE oder FALLING funktionieren hier also nicht. Nach dem Aufwachen wartet der Code, bis der Taster losgelassen wird, damit der weckende Druck nicht zusätzlich als neue Kerze zählt. Auch millis() steht im Schlaf still, deshalb wird der Timer beim Aufwachen zurückgesetzt.

Klein mit dem Nano und Berechnung der Akkulaufzeit

Wie lange eine Batterie hält, berechnest du mit Laufzeit (h) = nutzbare Kapazität (mAh) / mittlerer Strom (mA). Rechnen wir den Strom des Kranzes aus: Eine flackernde LED zieht im Mittel etwa 70 Prozent ihres Spitzenstroms, bei einer 12-mA-LED also etwa 8–9 mA. Vier Kerzen ergeben rund 35 mA; dazu kommen 15–20 mA, die ein Nano-Klon selbst braucht, zusammen etwa 50 mA. Ein 6-Stunden-Abend verbraucht also 300 mAh. Im Schlaf zieht der Prozessor fast nichts, doch wegen Power-LED, USB-Chip und Spannungsregler auf der Platine brauchen die meisten Nano-Klone weiterhin einige mA (meist um 5 mA); 18 Stunden Schlaf kosten etwa 90 mAh. Andere Szenarien probierst du mit dem Akkulaufzeit-Rechner aus.

StromquelleNutzbare KapazitätAbende à 6 Stunden (≈50 mA)Hinweis
3 × AA Alkaline (≈4,5 V, an den 5V-Pin)~2.000 mAh~5 Abende (inkl. Schlafverlust)Mit schwächer werdenden Batterien werden auch die LEDs dunkler
4 × AA NiMH-Akku (≈4,8 V, an den 5V-Pin)~1.900 mAh~5 AbendeIm Advent 4–5-mal nachladen
18650 + TP4056 + 5-V-Aufwärtswandler~1.600 mAh (bei 5 V)~4 AbendeLädt über USB, passt in eine Box
USB-Powerbank mit 10.000 mAh~6.300 mAh (bei 5 V)~16 AbendeKann sich im Schlaf wegen des geringen Stroms abschalten
USB-Netzteil 5 V 1 AUnbegrenztUnbegrenztDie bequemste Lösung für den Kranz auf dem Tisch
Schließ vier Alkaline-AA-Batterien nicht direkt an den 5V-Pin an: Frische Alkalinezellen kommen zusammen auf bis zu 6,4 V, und am 5V-Pin, der den Regler umgeht, überschreitet das die 5,5-V-Grenze des Prozessors. Auch ein 9-V-Block ist keine gute Wahl; er hat nur etwa 500 mAh, und der Regler an VIN verheizt die überschüssige Spannung. Soll eine Kerze lange mit Batterien laufen, senkt ein Arduino Pro Mini mit ausgelöteter Power-LED den Schlafstrom auf Mikroampere.

Version für Raspberry Pi Pico in MicroPython

Beim Pico kann jeder GPIO-Pin PWM ausgeben, die Kerzen kommen also an GP14–GP17 und der Taster an GP2. In MicroPython wird die Helligkeit mit duty_u16() von 0 bis 65535 gesetzt; der Code behält die Werte 0–255 der Arduino-Version bei und multipliziert sie mit 257, um auf dieselbe Skala zu kommen (255 × 257 = 65535). Statt im EEPROM wird die Kerzenzahl in der Datei mum.txt im Dateisystem des Pico gespeichert. Speicherst du den Code als main.py, leuchtet der Kranz, sobald der Pico Strom bekommt.

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)

Da der Pico mit 3,3 V arbeitet, leuchten warmweiße LEDs (etwa 3 V Durchlassspannung) kaum; nimm gelbe oder orange LEDs mit 220-Ω-Widerständen. Diese Version hat keinen Timer und keinen Schlafmodus; wenn du möchtest, zählst du mit time.ticks_ms() 6 Stunden ab und setzt dann alle Duty-Werte auf null. Die PWM-Frequenz des Pico haben wir auf 1 kHz gesetzt; bei niedrigeren Frequenzen können in Handyvideos Streifen sichtbar werden.

So wirkt die Kerze echt

  • Licht streuen: Mattiere die Spitze der LED mit feinem Schleifpapier oder steck etwas Watte in den Kerzenkörper; dann leuchtet der ganze Körper statt eines einzelnen Punkts.
  • Flamme aus zwei LEDs: Setz eine gelbe und eine orange LED an getrennte PWM-Pins in eine Kerze und lass sie unterschiedlich schnell flackern, dann bewegt sich auch die Farbe der Flamme; die sechs PWM-Pins des Uno reichen für drei solcher Kerzen.
  • Kerzenkörper: Nimm weißes PVC-Rohr mit 2–3 cm Durchmesser, eine ausgehöhlte echte Kerze oder ein Milchglas. Ein echter Kerzenkörper streut das Licht am natürlichsten.
  • Kranzsockel: Schmück die vier Kerzen mit künstlichen Tannenzweigen und Zapfen, versteck Nano und Batterie unter dem Sockel und setz den Taster an eine gut erreichbare Ecke.
  • Farbtemperatur: Wenn du warmweiße LEDs nutzt, bringt eine orange transparente Folie davor das Licht näher an die Farbe einer echten Flamme.

Häufige Fehler und Lösungen

SymptomMögliche UrsacheLösung
Die LED flackert nicht, sie ist entweder an oder ausDie LED hängt an einem Pin ohne PWMLED an Pin 3, 5, 6, 9, 10 oder 11 umstecken
Die Flamme zuckt wie eine kaputte LeuchtstoffröhreSMOOTH ist zu klein oder das Ziel ändert sich bei jedem SchrittSMOOTH auf 4–6 setzen, CHANGE_CHANCE unter 10 senken
Alle Kerzen flackern gleichzeitig gleichEine einzige level-Variable wird an alle Pins geschriebenFür jede Kerze eigene level- und target-Arrays verwenden
Das Board wacht nicht aus dem Schlaf aufTaster nicht an D2 oder der Interrupt reagiert nicht auf LOW-PegelTaster an D2 anschließen und attachInterrupt(..., LOW) verwenden
Bei jedem Start dasselbe FlackermusterrandomSeed wurde nicht aufgerufen oder an A0 hängt etwasrandomSeed(analogRead(A0)) mit einem offenen Analogpin aufrufen
Die Batterie ist nach wenigen Tagen leerPower-LED und USB-Chip des Nano ziehen auch im Schlaf StromNetzteil nutzen oder auf einen Pro Mini ohne Power-LED wechseln
Beobachte eine echte Kerze ein paar Minuten in einem dunklen Raum und zähle, wie oft sich die Helligkeit ändert; stell dann STEP_MS und CHANGE_CHANCE nach dieser Beobachtung ein. Die meisten Flammen schwanken zwei- bis dreimal pro Sekunde sichtbar und neigen sich nur alle paar Minuten wirklich.

Diese LED-Kerze aus ein paar LEDs, Widerständen und einem Taster verbindet PWM, Timing mit millis(), EEPROM, Schlafmodus und Akkurechnung in einem gemütlichen Projekt. In der BlueGrays-App findest du Schritt-für-Schritt-Schaltpläne und Code für einfache Lichtprojekte wie eine LED einschalten, eine LED per Taster schalten, einen weichen Farbübergang mit einer RGB-LED und PWM-Dimmen mit ESP32 oder Pico, mit denen du den Kerzeneffekt in eigene Projekte übernehmen kannst.

Häufige Fragen

Wie baue ich mit Arduino eine flackernde LED-Kerze?

Schließ die LED über einen 220-Ω-Widerstand an einen PWM-Pin des Arduino an und ändere ihre Helligkeit mit analogWrite() zufällig, aber weich. Am besten wirkt es, wenn du eine zufällige Zielhelligkeit wählst und die aktuelle Helligkeit bei jedem Schritt langsam darauf zubewegst. Gelegentliche tiefe Einbrüche ahmen eine Flamme im Luftzug nach.

Welche LED-Farbe eignet sich für eine LED-Kerze?

Gelbe oder orange (bernsteinfarbene) LEDs kommen der Farbe einer echten Flamme am nächsten. Warmweiße LEDs sind heller und erinnern an moderne LED-Kerzen, bleiben aber an 3,3-V-Boards dunkel. Blaue und kaltweiße LEDs wirken nicht wie eine Flamme.

Welchen Vorwiderstand brauche ich für eine LED am Arduino?

Bei 5 V liefern 220 Ω für eine gelbe oder rote LED und 150 Ω für eine warmweiße LED etwa 12–14 mA, das ist sicher. Der Wert ergibt sich aus (Versorgungsspannung − LED-Spannung) / gewünschter Strom. Ohne Widerstand können LED und Arduino-Pin Schaden nehmen.

Welche Arduino-Pins können PWM?

Beim Arduino Uno und Nano sind die PWM-Pins 3, 5, 6, 9, 10 und 11, auf der Platine mit ~ markiert. Die Pins 5 und 6 arbeiten mit etwa 980 Hz, die übrigen mit etwa 490 Hz. Beim Raspberry Pi Pico kann jeder GPIO-Pin PWM ausgeben.

Wie lange hält eine Arduino-LED-Kerze mit Batterien?

Ein Adventskranz mit vier Kerzen zieht mit einem Nano etwa 50 mA; mit drei AA-Batterien à 2.000 mAh sind das samt Schlafverlust etwa fünf Abende à 6 Stunden. Eine Powerbank mit 10.000 mAh hält rund 16 Abende. Für lange Laufzeit nimmst du einen Pro Mini ohne Power-LED und den Schlafmodus.

An welchen Tagen werden die Kerzen am Adventskranz angezündet?

Am Adventskranz wird an jedem der vier Sonntage vor Weihnachten eine Kerze mehr angezündet. 2026 sind das der 29. November, 6. Dezember, 13. Dezember und 20. Dezember. Drück in diesem Projekt jeden Sonntag einmal den Taster, um die Zahl der brennenden Kerzen zu erhöhen.

Alle Projekte ansehen
LED Blinken
AR-1Anfänger

LED Blinken

Das allererste Hallo der Elektronik: eine einzelne LED an- und ausschalten. Der Arduino schaltet die LED in kurzen Abständen ein und aus, das Licht blinkt also schnell.

4.6(200)
1245
Zwei LEDs abwechselnd blinken
AR-2Anfänger

Zwei LEDs abwechselnd blinken

Zwei LEDs blinken schnell im Wechsel: Leuchtet die eine, geht die andere aus, als würden sie sich einen Ball zuwerfen.

4.6(110)
362
LED mit Taster ein- und ausschalten
AR-10Anfänger

LED mit Taster ein- und ausschalten

Einmal drücken und das Licht geht an, noch einmal drücken und es geht aus, genau wie der Lichtschalter in deinem Zimmer.

4.7(103)
177
RGB-LED verwenden
AR-39Anfänger
Premium

RGB-LED verwenden

In einer einzigen LED stecken drei Farben: Die RGB-LED leuchtet erst rot, dann grün, dann blau, jede Farbe eine halbe Sekunde an und eine halbe Sekunde aus, und dann geht es von vorne los.

4.9(73)
100
Sanfte Farbübergänge mit RGB-Led
AR-40Anfänger
Premium

Sanfte Farbübergänge mit RGB-Led

Eine einzige RGB-LED wandert langsam von Rot zu Grün, von Grün zu Blau und wieder zurück zu Rot, eine Regenbogenschleife ohne Ende.

4.8(58)
78
ESP32 LED-Überblendung mit PWM
ES-8Anfänger

ESP32 LED-Überblendung mit PWM

Ändern Sie die Helligkeit der LED stufenlos von 0 bis max, von max bis 0. Wir steuern PWM mit analogWrite() wie in Arduino - die gleiche Syntax mit ESP32 Arduino Core 3.0+ funktioniert reibungslos. Pin-Definition + pinMode + analogWrite ist genug.

4.8(36)
55
ESP32: LED-Helligkeit mit Potentiometer (Analog → PWM)
ES-13Mittel
Premium

ESP32: LED-Helligkeit mit Potentiometer (Analog → PWM)

In diesem Projekt steuern wir die Helligkeit einer LED analog über ein Potentiometer. Der ADC-Pin des ESP32 liest die vom Potentiometer kommende Spannung von 0-3,3 V aus, woraufhin dieser Wert in ein PWM-Signal (Pulsweitenmodulation) umgewandelt und an die LED gesendet wird. So leuchtet die LED beim Drehen des Potentiometers stufenweise auf und erlischt wieder. Mit Arduino Core 3.0+ kann analogWrite() direkt verwendet werden; bei ESP32-S2/S3 ist die ADC-Auflösung auf 12 Bit festgelegt.

4.5(19)
32
Raspberry Pi Pico PWM LED Fade (Atem-Effekt)
PI-14Anfänger

Raspberry Pi Pico PWM LED Fade (Atem-Effekt)

Die LED blinkt nicht mehr nur — sie atmet! Mit der PWM (Pulsweitenmodulation) des Raspberry Pi Pico steigt die Helligkeit langsam an und fällt wieder ab. Lerne die machine.PWM-Klasse, duty_u16() (16-Bit-Helligkeit 0–65535), PWM-Frequenz, range()-Schleifen und analogähnliche Ausgabe. Grundlage für RGB-Farbmischung, Motorsteuerung, Servos und Buzzer.

4