Weihnachtsbaum Beleuchtung Arduino: WS2812B mit Schnee & Regenbogen

Für eine Weihnachtsbaum-Beleuchtung mit Arduino und einem WS2812B-LED-Streifen bist du nicht auf die wenigen festen Modi fertiger Lichterketten angewiesen. Weil du Farbe und Helligkeit jeder einzelnen LED steuern kannst, lässt du Schneeflocken von der Spitze nach unten rieseln, einen Regenbogen um die Zweige kreisen oder rote, grüne und goldene Sterne zufällig aufblitzen. Dafür brauchst du nur eine einzige Datenleitung, einen Taster und ein richtig gewähltes 5-V-Netzteil.

In dieser Anleitung gehen wir von der Materialliste über die Netzteilberechnung nach Streifenlänge und die richtige Verbindung von Netzteil, Board und Streifen bis zu einem vollständigen Arduino-Uno-Programm (FastLED) mit Effektwechsel per Taster durch. Danach folgen dieselben Projekte für ESP32 (Adafruit NeoPixel) und Raspberry Pi Pico (MicroPython). Am Ende weißt du, wie du den Streifen um den Baum wickelst, worauf du bei der Sicherheit achten musst und wie du die häufigsten Probleme löst.

Warum ein WS2812B-LED-Streifen für den Weihnachtsbaum?

Bei klassischen Lichterketten leuchten alle Lämpchen gleichzeitig oder in wenigen Gruppen nacheinander. Beim WS2812B sitzt in jeder LED ein kleiner Treiberchip. Der Arduino sendet die Farbdaten hintereinander über die Datenleitung; die erste LED nimmt ihre 24 Bit und gibt den Rest an die nächste weiter. So steuerst du einen Streifen mit 100 oder 300 LEDs über nur einen Pin und kannst jeder LED eine eigene Farbe geben. Dadurch bekommen bewegte Effekte wie Schneefall eine Lebendigkeit, die mit festen Lichtern unmöglich ist. Wie adressierbare LEDs genau funktionieren, erfährst du im Beitrag WS2812B NeoPixel LED.

Materialliste

• WS2812B-LED-Streifen: Für einen Baum von 1,5–1,8 m Höhe sind 2,5 m mit 60 LEDs/m oder 5 m mit 30 LEDs/m ein guter Start. Silikonummantelte IP65-Modelle halten Zweigen und Staub besser stand.
• Steuerboard: Arduino Uno, Nano, ESP32 oder Raspberry Pi Pico.
• 5-V-Netzteil: Wähle die Stromstärke nach der Tabelle unten; für 100 LEDs sind 5 V 4 A eine komfortable Wahl.
• Hohlstecker-Buchse (mit Schraubklemmen): Um den Stecker des Netzteils ohne Löten an Kabel anzuschließen.
• Elko 1000 µF / 10 V: Glättet plötzliche Stromspitzen am Streifeneingang.
• 330-Ω-Widerstand: Wird in Reihe in die Datenleitung gelegt; er dämpft Reflexionen im Signal und begrenzt den Eingangsstrom der ersten LED.
• Taster: Zum Umschalten zwischen den Effekten.
• Dickes Kabel: Für 5V und GND mindestens 0,75–1,5 mm² Querschnitt.
• Optional 74AHCT125 oder 74HCT245: Um das 3,3-V-Datensignal von ESP32 und Pico auf 5 V anzuheben.

Netzteilberechnung: Wie viel Ampere brauchst du?

Die roten, grünen und blauen Chips im WS2812B ziehen bei voller Helligkeit je etwa 20 mA; eine LED nimmt bei Vollweiß also etwa 60 mA auf. Den Worst-Case-Strom ermittelst du mit der Formel I = Anzahl LEDs × 60 mA. Ein Streifen mit 100 LEDs zieht, wenn alle LEDs voll hell und rein weiß leuchten, 6 A; das sind P = 5 V × 6 A = 30 W. Bei Regenbogen-, Schnee- und Sterneffekten leuchten die meisten LEDs nur in einer Farbe oder gedimmt, deshalb liegt der Strom in der Praxis bei etwa einem Drittel des schlimmsten Falls. Für eine sichere Wahl multiplizierst du diesen typischen Strom mit 2 und rundest auf den nächsten Netzteilwert auf; das Strom-Limit in der Software stellst du auf etwa 80 % des Netzteils ein. Den Zusammenhang zwischen Strom, Spannung und Leistung prüfst du bequem mit dem Ohmschen-Gesetz-Rechner.

Bei langen Streifen ist der Spannungsabfall das zweite Problem. Weil die dünnen Kupferbahnen auf dem Streifen Widerstand haben, kann die Spannung am Ende eines 5-m-Streifens unter 4 V fallen; dann werden Blau und Grün schwach und Weiß wirkt gelblich und blass. Die Lösung: Speise 5V und GND nicht nur am Anfang ein, sondern alle 1–1,5 Meter (bzw. alle 100–150 LEDs) mit eigenen Kabeln vom Netzteil erneut ein. Das nennt man Power Injection. Nimm für diese Kabel bei 5 Ampere mindestens 0,75 mm² und bei 10 Ampere 1,5 mm² Querschnitt; die Datenleitung schließt du nur am Anfang des Streifens an.

Schaltplan: 5-V-Netzteil, Streifen und Board

1. Suche die Pfeile auf dem Streifen und löte ein Kabel an das Ende, an dem der Pfeil beginnt (DIN). Wenn du Daten gegen die Pfeilrichtung, also am DOUT-Ende, einspeist, leuchtet keine LED.
2. Verbinde den +5-V-Ausgang des Netzteils mit dem 5V-Anschluss des Streifens (bei manchen Streifen steht dort +5V oder VCC) und das GND des Netzteils mit dem GND-Anschluss des Streifens.
3. Schalte den 1000-µF-Kondensator am Streifeneingang zwischen 5V und GND; das lange Bein (Plus) kommt an 5V, das Bein mit der Streifenmarkierung am Gehäuse (Minus) an GND.
4. Verbinde den GND-Pin des Boards mit dem GND des Netzteils. Ohne gemeinsame Masse hat das Datensignal keine Referenz.
5. Verbinde den Datenpin des Boards (beim Uno D6) über den 330-Ω-Widerstand mit dem DIN-Anschluss des Streifens; der Widerstand funktioniert am besten nah am Streifen.
6. Verbinde ein Bein des Tasters mit D2 und das andere mit GND; der interne Pull-up-Widerstand wird im Code aktiviert.
7. Wenn du mehr als 150 LEDs verwendest, ziehe auch in der Mitte und am Ende des Streifens separate 5V- und GND-Kabel vom Netzteil.
8. Versorge das Board während der Entwicklung per USB und den Streifen über das Netzteil. Wenn das Projekt fertig ist, kannst du die 5 V des Netzteils an den 5V-Pin des Uno legen; stecke dann aber nicht gleichzeitig das USB-Kabel ein.

Arduino-Uno-Code (FastLED): drei Effekte und Moduswechsel per Taster

Öffne in der Arduino IDE den Bibliotheksverwalter und installiere die Bibliothek, indem du nach FastLED suchst; eine ausführliche Anleitung findest du im Beitrag Bibliothek in Arduino hinzufügen. Das folgende Programm enthält Regenbogen-, Schneefall- und sternartige Funkeleffekte; mit jedem Tastendruck wechselt es zum nächsten Effekt. Weil der Code millis() statt delay() verwendet, wird der Taster jederzeit erkannt, während ein Effekt läuft. Die Logik dahinter findest du im Beitrag Unterschied zwischen millis und delay.

1#include <FastLED.h>
2
3#define LED_PIN     6      // şeridin DIN girişi (330 ohm üzerinden) / strip DIN input (via 330 ohm)
4#define BUTTON_PIN  2      // buton, diğer bacak GND / button, other leg to GND
5#define NUM_LEDS    100    // şeritteki LED sayısı / number of LEDs on the strip
6#define BRIGHTNESS  120    // genel parlaklık 0-255 / global brightness 0-255
7#define MAX_MA      3200   // 4 A adaptörün %80'i / 80% of a 4 A supply
8
9CRGB leds[NUM_LEDS];
10
11const uint8_t MODE_COUNT = 3;                          // 0 gökkuşağı, 1 kar, 2 yıldız / 0 rainbow, 1 snow, 2 twinkle
12const uint16_t FRAME_MS[MODE_COUNT] = {20, 60, 30};    // kare süreleri (ms) / frame times (ms)
13const CRGB XMAS[4] = {CRGB::Red, CRGB::Green, CRGB::Gold, CRGB::White};
14
15uint8_t mode = 0;
16uint8_t hue = 0;
17
18void setup() {
19  pinMode(BUTTON_PIN, INPUT_PULLUP);
20  FastLED.addLeds<WS2812B, LED_PIN, GRB>(leds, NUM_LEDS);
21  FastLED.setMaxPowerInVoltsAndMilliamps(5, MAX_MA);  // akım sınırı / current limit
22  FastLED.setBrightness(BRIGHTNESS);
23  FastLED.clear(true);                                // açılışta hepsini söndür / all off at start
24}
25
26void checkButton() {
27  static bool lastState = HIGH;
28  static unsigned long lastChange = 0;
29  bool state = digitalRead(BUTTON_PIN);
30  if (state != lastState && millis() - lastChange > 50) {  // 50 ms zıplama filtresi / 50 ms debounce
31    lastChange = millis();
32    lastState = state;
33    if (state == LOW) {                                     // basıldı / pressed
34      mode = (mode + 1) % MODE_COUNT;
35      FastLED.clear();
36    }
37  }
38}
39
40void rainbow() {
41  fill_rainbow(leds, NUM_LEDS, hue, 3);   // her LED'de ton 3 artar / hue +3 per LED
42  hue += 2;                               // renkler döner / colours rotate
43}
44
45void snowfall() {
46  for (int i = 0; i < NUM_LEDS - 1; i++) {
47    leds[i] = leds[i + 1];                // bir LED aşağı kaydır / shift one LED down
48  }
49  if (random8() < 38) {
50    leds[NUM_LEDS - 1] = CRGB::White;     // tepede yeni kar tanesi / new flake at the top
51  } else {
52    leds[NUM_LEDS - 1] = CRGB(0, 0, 24);  // koyu mavi gece / dark blue night
53  }
54}
55
56void twinkle() {
57  fadeToBlackBy(leds, NUM_LEDS, 20);      // hepsini biraz kıs / dim everything a little
58  if (random8() < 80) {
59    leds[random16(NUM_LEDS)] = XMAS[random8(4)];  // rastgele yıldız / random star
60  }
61}
62
63void loop() {
64  checkButton();
65  static unsigned long lastFrame = 0;
66  if (millis() - lastFrame >= FRAME_MS[mode]) {
67    lastFrame = millis();
68    if (mode == 0) rainbow();
69    else if (mode == 1) snowfall();
70    else twinkle();
71    FastLED.show();                       // renkleri şeride gönder / push colours to the strip
72  }
73}

Wie funktionieren die Effekte?

Regenbogen: Die Funktion fill_rainbow beginnt beim Farbton (Hue) der ersten LED und erhöht ihn bei jeder LED um 3 Schritte. In FastLED liegt der Farbton zwischen 0 und 255; bei 100 LEDs wächst er insgesamt um 300 Schritte, sodass auf dem Streifen etwas mehr als ein voller Farbkreis zu sehen ist. Weil wir die Variable hue in jedem Frame um 2 erhöhen, drehen sich die Farben langsam um den Baum. Für breitere Farbbänder nimmst du 1 oder 2 statt 3.

Schneefall: Wenn du den Streifen von unten nach oben um den Baum wickelst, ist die erste LED ganz unten und die letzte an der Spitze. In jedem Frame schieben wir alle Farben um eine LED nach unten und fügen oben entweder eine weiße Schneeflocke oder einen dunkelblauen Nachtpixel ein. Weil random8() eine Zahl zwischen 0 und 255 liefert, beträgt die Wahrscheinlichkeit für einen Wert unter 38 etwa 15 %; erhöhst du diese Zahl, schneit es dichter. Bei 60 ms Framezeit braucht eine Schneeflocke 6 Sekunden für 100 LEDs. Funkeln (Sterne): fadeToBlackBy dimmt in jedem Frame alle LEDs um etwa 8 %; gleichzeitig leuchtet eine zufällig gewählte LED in Rot, Grün, Goldgelb oder Weiß mit voller Helligkeit auf. Das Ergebnis erinnert an alte Weihnachtslichter, wirkt aber viel lebendiger.

Weihnachtsbaum mit ESP32 (Adafruit NeoPixel)

Auf dem ESP32 läuft auch FastLED, aber hier schreiben wir dasselbe Projekt mit der Bibliothek Adafruit NeoPixel, damit du beide beliebten Bibliotheken kennenlernst. Die aktuelle Version der Bibliothek lässt sich mit demselben Code für den ESP32-Arduino-Core 2.x und 3.x kompilieren und erzeugt das Signal mit der Hardware-RMT-Einheit. Weil bei Adafruit NeoPixel mit setBrightness gedimmte Farben beim Zurücklesen verfälscht werden können, berechnen wir die Effekte in einem eigenen Helligkeits-Array (level) und schreiben sie in jedem Frame neu auf den Streifen. Der Datenpin ist GPIO 13, der Taster GPIO 4. Wenn du den Baum später per Smartphone steuern willst, bietet dir der Beitrag WLED einrichten eine fertige Oberfläche.

1#include <Adafruit_NeoPixel.h>
2
3#define LED_PIN     13     // şeridin DIN girişi (330 ohm üzerinden) / strip DIN input (via 330 ohm)
4#define BUTTON_PIN  4      // buton, diğer bacak GND / button, other leg to GND
5#define NUM_LEDS    100    // şeritteki LED sayısı / number of LEDs on the strip
6
7Adafruit_NeoPixel strip(NUM_LEDS, LED_PIN, NEO_GRB + NEO_KHZ800);
8
9const uint8_t MODE_COUNT = 3;                          // 0 gökkuşağı, 1 kar, 2 yıldız / 0 rainbow, 1 snow, 2 twinkle
10const uint16_t FRAME_MS[MODE_COUNT] = {20, 60, 30};    // kare süreleri (ms) / frame times (ms)
11const uint8_t PALETTE[4][3] = {{255, 0, 0}, {0, 255, 0}, {255, 160, 0}, {255, 255, 255}};
12
13uint8_t level[NUM_LEDS];      // LED başına parlaklık / per-LED level
14uint8_t colorIdx[NUM_LEDS];   // yıldız rengi / star colour index
15uint8_t mode = 0;
16uint16_t hue = 0;
17
18void setup() {
19  pinMode(BUTTON_PIN, INPUT_PULLUP);
20  strip.begin();
21  strip.setBrightness(110);   // genel parlaklık / global brightness
22  strip.clear();
23  strip.show();
24}
25
26void checkButton() {
27  static bool lastState = HIGH;
28  static unsigned long lastChange = 0;
29  bool state = digitalRead(BUTTON_PIN);
30  if (state != lastState && millis() - lastChange > 50) {  // 50 ms zıplama filtresi / 50 ms debounce
31    lastChange = millis();
32    lastState = state;
33    if (state == LOW) {                                     // basıldı / pressed
34      mode = (mode + 1) % MODE_COUNT;
35      memset(level, 0, sizeof(level));                      // efekt belleğini sıfırla / reset effect buffer
36      strip.clear();
37    }
38  }
39}
40
41void rainbow() {
42  for (int i = 0; i < NUM_LEDS; i++) {
43    uint16_t h = hue + (uint32_t)i * 65536UL / NUM_LEDS;   // LED'e göre ton / hue per LED
44    strip.setPixelColor(i, strip.gamma32(strip.ColorHSV(h)));
45  }
46  hue += 256;                                              // renkler döner / colours rotate
47}
48
49void snowfall() {
50  for (int i = 0; i < NUM_LEDS - 1; i++) level[i] = level[i + 1];   // bir LED aşağı kaydır / shift one LED down
51  level[NUM_LEDS - 1] = (random(100) < 15) ? 255 : 0;               // tepede yeni kar / new flake on top
52  for (int i = 0; i < NUM_LEDS; i++) {
53    if (level[i]) strip.setPixelColor(i, 255, 255, 255);            // kar tanesi / snowflake
54    else strip.setPixelColor(i, 0, 0, 24);                          // koyu mavi gece / dark blue night
55  }
56}
57
58void twinkle() {
59  for (int i = 0; i < NUM_LEDS; i++) {
60    level[i] = (level[i] > 12) ? level[i] - 12 : 0;                 // yavaşça sön / fade out
61  }
62  if (random(100) < 30) {
63    int p = random(NUM_LEDS);
64    level[p] = 255;                                                 // yeni yıldız / new star
65    colorIdx[p] = random(4);
66  }
67  for (int i = 0; i < NUM_LEDS; i++) {
68    const uint8_t *c = PALETTE[colorIdx[i]];
69    strip.setPixelColor(i, c[0] * level[i] / 255, c[1] * level[i] / 255, c[2] * level[i] / 255);
70  }
71}
72
73void loop() {
74  checkButton();
75  static unsigned long lastFrame = 0;
76  if (millis() - lastFrame >= FRAME_MS[mode]) {
77    lastFrame = millis();
78    if (mode == 0) rainbow();
79    else if (mode == 1) snowfall();
80    else twinkle();
81    strip.show();                                                   // renkleri şeride gönder / push colours to the strip
82  }
83}

Weihnachtsbaum mit Raspberry Pi Pico und MicroPython

In der MicroPython-Firmware des Raspberry Pi Pico ist das Modul neopixel bereits enthalten; du musst nichts extra installieren. Weil das Modul das präzise Timing des WS2812B selbst übernimmt, kannst du jeden beliebigen GP-Pin verwenden; unten hängen die Daten an GP0 und der Taster an GP15. Da MicroPython keine globale Helligkeitseinstellung hat, dimmen wir die Farben selbst mit dem Faktor BRIGHT. Weil Python langsamer läuft als C++, sind die Effekte bei 100 LEDs flüssig; ab über 300 LEDs können die Framezeiten länger werden. Wenn du neu bei MicroPython bist, beginne mit dem Beitrag MicroPython-Grundlagen.

1from machine import Pin
2import neopixel, time, random
3
4NUM_LEDS = 100
5BRIGHT = 0.4                                   # 0-1 parlaklık / brightness
6np = neopixel.NeoPixel(Pin(0), NUM_LEDS)       # veri GP0 / data on GP0
7button = Pin(15, Pin.IN, Pin.PULL_UP)          # buton GP15-GND / button GP15-GND
8
9mode = 0
10MODE_COUNT = 3                                 # 0 gökkuşağı, 1 kar, 2 yıldız / 0 rainbow, 1 snow, 2 twinkle
11FRAME_MS = (20, 60, 30)                        # kare süreleri / frame times
12level = [0] * NUM_LEDS                         # LED başına parlaklık / per-LED level
13color_idx = [0] * NUM_LEDS                     # yıldız rengi / star colour index
14PALETTE = ((255, 0, 0), (0, 255, 0), (255, 160, 0), (255, 255, 255))
15hue = 0
16
17def scale(r, g, b):
18    return (int(r * BRIGHT), int(g * BRIGHT), int(b * BRIGHT))
19
20def wheel(pos):
21    # 0-255 -> gökkuşağı rengi / rainbow colour
22    pos = pos & 255
23    if pos < 85:
24        return (255 - pos * 3, pos * 3, 0)
25    if pos < 170:
26        pos -= 85
27        return (0, 255 - pos * 3, pos * 3)
28    pos -= 170
29    return (pos * 3, 0, 255 - pos * 3)
30
31def rainbow():
32    global hue
33    for i in range(NUM_LEDS):
34        np[i] = scale(*wheel(hue + i * 256 // NUM_LEDS))
35    hue = (hue + 2) & 255                      # renkler döner / colours rotate
36
37def snowfall():
38    for i in range(NUM_LEDS - 1):
39        level[i] = level[i + 1]                # bir LED aşağı kaydır / shift one LED down
40    level[-1] = 255 if random.randint(0, 99) < 15 else 0
41    for i in range(NUM_LEDS):
42        np[i] = scale(255, 255, 255) if level[i] else scale(0, 0, 24)
43
44def twinkle():
45    for i in range(NUM_LEDS):
46        level[i] = level[i] - 12 if level[i] > 12 else 0   # yavaşça sön / fade out
47    if random.randint(0, 99) < 30:
48        p = random.randint(0, NUM_LEDS - 1)
49        level[p] = 255                         # yeni yıldız / new star
50        color_idx[p] = random.randint(0, 3)
51    for i in range(NUM_LEDS):
52        r, g, b = PALETTE[color_idx[i]]
53        k = level[i] * BRIGHT / 255
54        np[i] = (int(r * k), int(g * k), int(b * k))
55
56effects = (rainbow, snowfall, twinkle)
57last_btn = 1
58last_change = time.ticks_ms()
59last_frame = time.ticks_ms()
60
61while True:
62    now = time.ticks_ms()
63    state = button.value()
64    if state != last_btn and time.ticks_diff(now, last_change) > 50:   # zıplama filtresi / debounce
65        last_change = now
66        last_btn = state
67        if state == 0:                         # basıldı / pressed
68            mode = (mode + 1) % MODE_COUNT
69            for i in range(NUM_LEDS):
70                level[i] = 0
71    if time.ticks_diff(now, last_frame) >= FRAME_MS[mode]:
72        last_frame = now
73        effects[mode]()
74        np.write()                             # şeride gönder / push to the strip

Streifen am Baum anbringen und Sicherheit

• Unten anfangen: Lege das DIN-Ende des Streifens unten an den Fuß des Baums neben die Steuerbox und wickle den Streifen spiralförmig nach oben. So fällt der Schneeeffekt von der Spitze nach unten und das Datenkabel bleibt kurz.
• Spiralabstand: Bei einem 1,8-m-Baum verteilt ein Wickelabstand von 20–25 cm einen 5-m-Streifen gleichmäßig auf die Zweige; weil der Windungsdurchmesser zur Spitze hin kleiner wird, kannst du den Abstand dort etwas verringern.
• Senkrechte Bahnen: Du kannst den Streifen auch im Zickzack von oben nach unten und wieder nach oben verlegen. Bei dieser Anordnung kehrt sich die Richtung des Schneeeffekts bei jeder zweiten Bahn um, deshalb musst du die LED-Reihenfolge mit einer kleinen Anpassung nach der Bahnnummer berechnen.
• Wärme: Der WS2812B-Streifen wird bei hoher Helligkeit warm; drücke ihn nicht fest auf Papierdeko und trockene Zweige. Eine Helligkeit um 100–150 reduziert sowohl Wärme als auch Strom.
• Netzteilsicherheit: Baue auf der 220-V-Seite keine eigene Schaltung; nimm ein fertiges 5-V-Netzteil mit CE-Kennzeichen und geschlossenem Gehäuse. Halte die Steuerbox von Wasser und vom Gießwasser fern und schalte den Baum aus, wenn du das Haus verlässt.
• Sicherung: Bei Systemen über 5 A ist eine passende Flachsicherung am Netzteilausgang eine gute Vorkehrung gegen einen möglichen Kurzschluss.

Projektideen für den Weihnachtsbaum

• Musikreaktiver Baum: Lass die Lichter mit einem Mikrofon im Rhythmus des Songs leuchten; Details im Beitrag musikreaktive LED.
• Silvester-Countdown: Zeige die Zeit bis Mitternacht auf einem Display an und starte um 00:00 Uhr einen Feuerwerkseffekt am Baum; schau dir den Beitrag Silvester-Countdown-Zähler an.
• Baum, der sich selbst einschaltet: Schalte die Lichter mit einem LDR-Lichtsensor automatisch ein, sobald es dunkel wird.
• Baum, der bei Annäherung heller wird: Erhöhe mit einem PIR-Bewegungssensor die Helligkeit, wenn jemand den Raum betritt, und dimme sie, wenn der Raum leer ist.
• Steuerung per Smartphone: Öffne mit dem ESP32 eine Webseite und wähle Effekte und Farben vom Handy aus; der Beitrag ESP32-Webserver ist ein guter Einstieg.
• Display für die Baumspitze: Setze eine kleine WS2812B-LED-Matrix auf die Baumspitze und spiele eine Stern- oder Schneeflockenanimation ab.

Häufige Fehler und ihre Lösungen

Mit ein paar Metern LED-Streifen, einem einzigen Taster und einem richtig dimensionierten 5-V-Netzteil wird dein Weihnachtsbaum zu einer programmierbaren Lichtshow, die du jedes Jahr mit neuen Effekten erneuern kannst. Spiele mit Farbpaletten und Framezeiten, um eigene Effekte zu entwerfen, und wenn du bei Strom und Verdrahtung Fragen hast, schau in die Anleitung Arduino-Stromversorgung. In der BlueGrays-App findest du mit dem WS2812B Lauflicht, Knight-Rider-Effekt, Polizeiblitz und Animationsprojekte sowie die NeoPixel-Streifensteuerung mit dem ESP32, Schritt für Schritt mit Schaltplänen und Code.