🌈 ESP32 + WLED Kurs – Von der Regenbogen-Zählmaschine zum leuchtenden Netzwerk

Warum Bits sichtbar machen? Weil unsichtbare Dinge schwer zu verstehen sind.

💡 Das WARUM

Die Frage die alles startet:

"Wie kann ich sehen, was das Netzwerk tut?"

Computer sagen: "Daten werden übertragen"
Aber wo? Wie? Warum?

Unsichtbar = Unverständlich
Unsichtbar = Magisch
Unsichtbar = Angsteinflößend

Die Antwort:

Mach es sichtbar. Mit Licht. Mit Farben. Mit Regenbogen.

Bit fließt → LED leuchtet
Paket kommt → Farbe ändert sich
Netzwerk aktiv → Baum atmet

Sichtbar = Verständlich
Sichtbar = Begreifbar
Sichtbar = Lernbar

🌈 Die Progression (von Simulation zu Realität)

Schritt 1: CrumbBlocks Rainbow Counter

Im Browser:

Sensor liest Farbe
  ↓
Counter zählt
  ↓
Display zeigt an
  ↓
Simulation läuft

→ Du verstehst die LOGIK

Was Krümel lernt:
- IF Farbe = Rot THEN Counter++
- Sensoren lesen Daten
- Programm verarbeitet
- Output wird angezeigt

Aber:
- Nichts ist real
- Kein echter Sensor
- Keine echte LED
- Nur Pixel auf Bildschirm

Schritt 2: ESP32 + WLED

In Realität:

ESP32 Board
  ↓
WLED Firmware flashen
  ↓
LED-Streifen anschließen
  ↓
WiFi konfigurieren
  ↓
Browser öffnen
  ↓
REGENBOGEN!

→ Du siehst ECHTES Licht

Was Krümel lernt:
- Microcontroller sind echte Computer
- Code läuft auf Hardware
- Strom fließt durch Kabel
- LEDs leuchten wirklich

Und:
- Kann es anfassen
- Kann Farben ändern
- Kann mitnehmen
- Kann weiterbauen

Schritt 3: Netzwerk sichtbar machen

Am LED-Baum:

traceroute chatgpt.com
  ↓
Jeder Hop = eine Station
  ↓
Python Script liest Hops
  ↓
WLED zeigt Farben pro Hop
  ↓
NETZWERK LEUCHTET!

→ Du SIEHST wo deine Bits fliegen

Was Krümel lernt:
- Bits reisen durch viele Stationen
- Internet ist nicht magisch
- Router sind Wegweiser
- Alles hat einen Pfad

Schritt 4: Saturn Hexagon (Resonanz wird Form)

Im Taubenstock:

6 Rollen × 6 LEDs
  ↓
Hexagon-Form
  ↓
Jede Rolle hat ihre Farbe
  ↓
Beat/Clap/Button → Licht läuft
  ↓
RESONANZ WIRD SICHTBAR

→ Du verstehst: Chaos wird Ordnung

Was Krümel lernt:
- Muster entstehen aus Wiederholung
- Ordnung entsteht aus Resonanz
- Hexagon ist stabile Form
- Natur zeigt uns das (Saturn!)

🔧 Der Kurs (praktisch)

Modul 1: Was ist WLED?

Dauer: 15 Minuten
Ziel: Verstehen was WLED macht

Erklärung für Krümel:

WLED ist wie eine App für LEDs.

Stell dir vor:
- Dein Handy ist der ESP32
- Die App ist WLED
- Die LEDs sind der Bildschirm

WLED sagt den LEDs:
  "Du sollst ROT sein!"
  "Du sollst BLAU sein!"
  "Du sollst BLINKEN!"

Und die LEDs machen es.

Fragen beantworten:

Q: "Warum nicht einfach Arduino?"
A: "Kannst du! Aber WLED ist schon fertig.
    Wie eine App die du nur installierst,
    statt sie selbst zu programmieren."

Q: "Ist das Mogeln?"
A: "Nein. Das ist NUTZEN was andere gebaut haben.
    Später kannst du eigenen Code schreiben.
    Aber erst: Verstehen wie es funktioniert."

Modul 2: ESP32 kennenlernen

Dauer: 20 Minuten
Ziel: ESP32 Board verstehen

Zeigen (nicht erklären!):

Das ist ein ESP32 Board:
  [Board zeigen]

Das ist wie ein Mini-Computer:
  - Hat Prozessor (denkt)
  - Hat Speicher (erinnert sich)
  - Hat WiFi (redet mit anderen)
  - Hat Pins (verbindet sich mit Dingen)

Wichtige Pins markieren:

5V   → Strom rein (wie Steckdose)
GND  → Strom raus (wie Erde)
D4   → Daten raus (zu LEDs)

"Diese 3 sind wichtig.
 Mehr brauchst du nicht zu wissen.
 Jetzt."

Größenvergleich:

ESP32 = Klein wie Daumen
Raspberry Pi = Groß wie Kreditkarte

ESP32:
  - Billiger (3-5€)
  - Weniger Power
  - Perfekt für LEDs

Pi:
  - Teurer (40€)
  - Mehr Power
  - Für Computer-Sachen

Modul 3: WLED flashen

Dauer: 15 Minuten
Ziel: WLED auf ESP32 installieren

Methode A: Web Flasher (einfachste)

1. Gehe zu: install.wled.me
2. Verbinde ESP32 mit USB-Kabel
3. Klick "Install"
4. Warte 2 Minuten
5. Fertig!

Was passiert (erklärt):

Der Flasher:
  1. Löscht alten Code
  2. Lädt WLED runter
  3. Schreibt es auf ESP32
  4. ESP32 startet neu

Wie: Computer neu installieren
Aber: Viel schneller (2 Minuten statt 1 Stunde)

Methode B: ESPHome Flasher (für offline)

1. Lade WLED.bin herunter
2. Öffne ESPHome Flasher
3. Wähle COM-Port
4. Wähle WLED.bin Datei
5. Flash!

Modul 4: LEDs anschließen

Dauer: 20 Minuten
Ziel: LED-Streifen zum Leuchten bringen

Material:

- ESP32 (mit WLED geflasht)
- WS2812B LED-Streifen (30-60 LEDs)
- 5V Netzteil (mindestens 2A)
- 3 Kabel (Dupont oder gelötet)

Verbindung (kritisch!):

LED-Streifen hat 3 Kabel:
  +5V (rot)    → ESP32: 5V
  GND (schwarz/weiß) → ESP32: GND
  DIN (grün/gelb)    → ESP32: D4 (GPIO2)

WICHTIG:
  Erst alle Kabel verbinden
  DANN Strom einschalten
  NIEMALS anders rum!

Safety-Check:

Bevor Strom ein:

☐ 5V zu 5V? (nicht zu 3.3V!)
☐ GND zu GND? (gemeinsame Erde!)
☐ DIN zu D4? (Daten-Pin!)
☐ Keine Kabel berühren sich?
☐ Netzteil stark genug? (2A minimum)

Wenn ALLES ✓ → Strom einschalten

Modul 5: WLED konfigurieren

Dauer: 20 Minuten
Ziel: LEDs steuern können

Schritt 1: Mit WLED verbinden

1. ESP32 startet → macht eigenes WiFi
   Name: "WLED-AP"

2. Mit Handy/Tablet verbinden
   (kein Passwort)

3. Browser öffnet automatisch
   (wenn nicht: http://4.3.2.1)

Schritt 2: WiFi Setup

"WiFi Setup" klicken
  ↓
Dein Heimnetz wählen
  ↓
Passwort eingeben
  ↓
"Save & Connect"
  ↓
ESP32 neustartet
  ↓
Jetzt im gleichen Netz wie dein Tablet!

Schritt 3: LED Setup

"Config" → "LED Preferences"

Wichtig:
  LED count: [Anzahl deiner LEDs, z.B. 30]
  Data GPIO: 2 (wenn D4 Pin genutzt)
  LED type: WS281x

"Save"

Schritt 4: Erste Farben!

Zurück zur Hauptseite
  ↓
Color Wheel erscheint
  ↓
Farbe wählen
  ↓
LEDS LEUCHTEN! 🌈

Modul 6: Effekte erkunden

Dauer: 30 Minuten (freies Spiel)
Ziel: Möglichkeiten entdecken

Vorinstallierte Effekte:

Solid:        Eine Farbe, still
Rainbow:      Regenbogen läuft durch
Twinkle:      Funkeln wie Sterne
Fire:         Wie Feuer
Scanner:      Lauflicht (Kitt)
Colorwipe:    Farbe fließt durch

Krümel-Aufgabe:

"Finde deinen Lieblings-Effekt.

 Aber nicht nach Name.
 Sondern: Probiere ALLE aus.

 Welcher fühlt sich richtig an?"

Fragen die kommen werden:

Q: "Wie funktioniert Rainbow?"
A: "Jede LED bekommt eine andere Farbe.
    Dann rotieren die Farben.
    Wie ein Karussell."

Q: "Kann ich eigene Effekte machen?"
A: "Ja! Aber erst: Verstehe diese.
    Dann: Baue eigene."

Modul 7: Netzwerk-Visualisierung (Verbindung zu CrumbBlocks)

Dauer: 30 Minuten
Ziel: Verstehen warum das wichtig ist

Zurück zu Rainbow Counter:

Erinnerst du dich an CrumbBlocks?

Rainbow Counter:
  Sensor → Farbe erkennen
  Counter → Zählen
  Display → Anzeigen

Das war SIMULATION.
Das hier ist REAL.

Aber umgekehrt:

Statt: Sensor liest Farbe
Jetzt: WIR machen Farbe

Statt: Counter zählt
Jetzt: Netzwerk sendet Bits

Statt: Display zeigt
Jetzt: LEDs leuchten

Das Netzwerk zählen:

Wenn du "ping google.com" machst:
  1 Paket gesendet = 1 LED blinkt

Wenn du Website lädst:
  100 Pakete = 100 Blinker

Wenn du Video streamst:
  1000 Pakete/Sekunde = Regenbogen!

Demo vorbereiten:

Python Script (vereinfacht):

import subprocess
import requests

# Ping senden
result = subprocess.run(['ping', '-c', '1', 'google.com'])

if result.returncode == 0:
    # Erfolgreich → LED grün
    requests.get('http://[ESP32-IP]/win&FX=0&CL=00FF00')
else:
    # Fehler → LED rot
    requests.get('http://[ESP32-IP]/win&FX=0&CL=FF0000')

Krümel-Erklärung:

"Dieser Code:
 1. Sendet Ping zu Google
 2. Wartet auf Antwort
 3. Wenn Antwort → LED grün
 4. Wenn keine Antwort → LED rot

 Das ist wie:
 Rainbow Counter liest Farbe
 Aber:
 WIR machen die Farbe!"

Modul 8: traceroute visualisieren

Dauer: 30 Minuten
Ziel: Verstehen wie Bits reisen

Konzept erklären:

Wenn du "chatgpt.com" besuchst:

Dein Computer → Router → Telekom → Internet → Cloudflare → ChatGPT

Das sind viele Stationen!
Jede Station = ein "Hop"

traceroute zeigen:

Terminal: traceroute chatgpt.com

Ergebnis:
 1  router.lan (192.168.88.1)         1ms
 2  telekom.de (217.0.116.1)          5ms
 3  de-fra.core.telekom.de (...)     10ms
 ...
11  104.18.32.47 (ChatGPT)           30ms

→ 11 Stationen!
→ 30 Millisekunden!

Auf LEDs mappen:

30 LEDs = 30 Stationen (maximal)

Jeder Hop bekommt eine LED:
  Hop 1 (Router)    → LED 1  → Blau
  Hop 2 (Telekom)   → LED 2  → Grün
  Hop 3 (Core)      → LED 3  → Gelb
  ...
  Hop 11 (ChatGPT)  → LED 11 → Violett

Licht läuft von LED 1 bis LED 11
→ Du SIEHST den Weg!

Python Script (erweitert):

import subprocess
import re
import requests
import time

ESP32_IP = "192.168.1.100"  # Deine ESP32 IP

def traceroute_to_leds(target):
    # traceroute ausführen
    result = subprocess.run(
        ['traceroute', '-m', '15', target],
        capture_output=True,
        text=True
    )

    # Alle LEDs aus
    requests.get(f'http://{ESP32_IP}/win&T=0')
    time.sleep(0.5)

    # Hops durchgehen
    lines = result.stdout.split('\n')
    for i, line in enumerate(lines):
        if 'ms' in line:  # Erfolgreicher Hop
            # LED i aktivieren mit Farbe
            hue = int((i / 15) * 255)  # Farbe entlang Spektrum
            requests.get(f'http://{ESP32_IP}/win&CL=h{hue}FF&FX=0')
            time.sleep(0.3)  # Kurz warten

    print(f"Route zu {target} visualisiert!")

# Ausführen
traceroute_to_leds('chatgpt.com')

Krümel sieht:

Script startet
  ↓
Alle LEDs aus
  ↓
LED 1 leuchtet blau (Router)
  ↓
LED 2 leuchtet grün (Telekom)
  ↓
...
  ↓
LED 11 leuchtet violett (ChatGPT)
  ↓
"WOW! So weit!"

Modul 9: LED-Baum Konzept

Dauer: 20 Minuten (Theorie)
Ziel: Vision verstehen

Vom Streifen zum Baum:

Ein LED-Streifen:
  → Zeigt eine Route

Viele LED-Streifen:
  → Zeigen viele Routen

Als Baum angeordnet:
  → Netzwerk wird BAUM!

Die Struktur:

        🌲
       /|\
      / | \
    /  |  \
   /   |   \

Stamm:  Router, Switch, Pi
Äste:   Verschiedene Dienste
Zweige: Einzelne Verbindungen
Lichter: Pakete die fließen

Mapping:

Ast 1: Lokales Netz
  → Blau (ruhig, nah)

Ast 2: Internet-Zugang
  → Grün (mittel, Tor zur Welt)

Ast 3: Cloudflare
  → Gelb (schnell, CDN)

Ast 4: Google
  → Orange (such-traffic)

Ast 5: ChatGPT
  → Violett (AI-traffic)

Live-Demo:

Jemand lädt Website
  → Ast 3 + 4 leuchten

Jemand fragt ChatGPT
  → Ast 5 leuchtet

Jemand druckt (lokal)
  → Nur Ast 1 leuchtet

→ Du SIEHST wer was macht!

Modul 10: Saturn Hexagon (Resonanz-Brücke)

Dauer: 30 Minuten
Ziel: Von Netzwerk zu Resonanz

Die Verbindung:

Netzwerk:
  Viele Pakete
  Chaotisch
  Schnell
  Unsichtbar

Hexagon:
  Ordnung aus Chaos
  Stabil
  Sichtbar
  Geometrisch

Saturn Nordpol zeigen (Bild):

[Zeige Cassini Foto]

"Das ist Saturn.
 Am Nordpol ist ein Hexagon.
 Größer als die Erde.
 Aus Sturm.

 Warum Hexagon?
 Weil Resonanz."

Resonanz erklären:

Wenn du schaukelst:
  Immer gleicher Rhythmus
  → Schwung wird größer

Das ist Resonanz.

Beim Saturn:
  Jetstream kreist
  Immer gleiche Geschwindigkeit
  → Form entsteht (Hexagon)

Auf LEDs übertragen:

6 LEDs im Hexagon
Jede LED = eine Rolle:
  Snake, Dumbo, Schnippsi,
  Pepper, Bugsy, FunkFox

Mitte:
  Eule (Ruhepol)

Beat/Clap:
  Licht läuft im Kreis
  Wie Jetstream auf Saturn

Mini-Mission:

Baue kleines Hexagon:
  6 LEDs
  Im Kreis angeordnet

Code:
  Lauflicht im Kreis
  Speed = BPM von Musik

Wenn Beat passt:
  → Resonanz
  → Stabil
  → Schön

Wenn Beat nicht passt:
  → Chaos
  → Unstabil
  → Ruckelig

🎯 Lernziele (Gesamtkurs)

Nach diesem Kurs kann Krümel:

Technisch:

✅ ESP32 Board identifizieren
✅ WLED flashen (mit Web-Tool)
✅ LEDs anschließen (sicher!)
✅ WLED konfigurieren (WiFi + LEDs)
✅ Effekte nutzen und verstehen
✅ IP-Adresse finden
✅ HTTP-Requests senden (Basis)

Konzeptionell:

✅ Simulation vs. Realität (CrumbBlocks → ESP32)
✅ Unsichtbares sichtbar machen (Netzwerk → Licht)
✅ Bits haben Wege (traceroute)
✅ Chaos wird Ordnung (Resonanz → Hexagon)
✅ Natur lehrt Technik (Saturn → LEDs)

Pädagogisch:

✅ Fragen stellen ist wichtig
✅ Ausprobieren vor Verstehen
✅ Fehler sind okay (debugging)
✅ Komplexes wird einfach (Schritt für Schritt)
✅ Verbindungen erkennen (Bridges bauen)

🔄 Die Brücke (CrumbBlocks ↔ ESP32 ↔ LED-Baum)

Phase 1: Simulation (CrumbBlocks)

Browser → Rainbow Counter
Sensor liest Farbe (simuliert)
Code verarbeitet
Display zeigt (Pixel)

→ Logik verstanden
→ Aber: Nicht real

Phase 2: Hardware (ESP32 + WLED)

Microcontroller → WLED
LEDs leuchten (echt!)
Code läuft (auf Hardware)
Licht strahlt (sichtbar)

→ Realität erlebt
→ Aber: Noch isoliert

Phase 3: Integration (LED-Baum)

Netzwerk → Python Script
traceroute → Hops zählen
HTTP Request → WLED
Äste leuchten (Pakete sichtbar)

→ System verstanden
→ Bits werden Licht

Phase 4: Resonanz (Hexagon)

Beats → Sinawali
Pattern → Rotation
Chaos → Ordnung
Saturn → Vorbild

→ Prinzip erkannt
→ Natur = Lehrer

📚 Material-Liste

Pro Krümel (minimal):

1× ESP32 Board (D1 mini oder ähnlich) - 3-5€
1× WS2812B LED-Streifen (30 LEDs) - 5-8€
1× 5V 2A Netzteil - 5€
3× Dupont-Kabel (falls nicht gelötet) - 1€
1× USB-Kabel (zum Flashen) - 2€

Total: ~20€

Pro Krümel (optimal):

1× ESP32 DevKit - 5€
1× WS2812B LED-Streifen (60 LEDs) - 10€
1× 5V 3A Netzteil - 8€
1× Breadboard - 3€
10× Jumper Wires - 2€
1× USB-Kabel - 2€

Total: ~30€

+ Badge zum Mitnehmen!

Für LED-Baum (Klassenprojekt):

1× Raspberry Pi 5 - 80€
5× ESP32 Boards - 20€
5× WS2812B Streifen (je 60 LEDs) - 50€
1× 5V 10A Netzteil - 20€
1× Router (lokal) - 30€
1× Holzstruktur für Baum - 20€
Kabel, Lötzinn, etc. - 20€

Total: ~240€

Für ganze Klasse nutzbar!

⚡ Troubleshooting (häufige Probleme)

Problem 1: LEDs leuchten nicht

Check:

☐ Ist Strom eingeschaltet?
☐ Ist 5V zu 5V verbunden?
☐ Ist GND zu GND verbunden?
☐ Ist DIN zu richtigem Pin? (D4 = GPIO2)
☐ Ist LED-Count in WLED richtig?
☐ Netzteil stark genug? (2A minimum für 30 LEDs)

Problem 2: ESP32 nicht erkannt (beim Flashen)

Check:

☐ USB-Kabel okay? (Manche sind nur Ladekabel!)
☐ Richtiger COM-Port gewählt?
☐ Treiber installiert? (CP210x oder CH340)
☐ ESP32 in Boot-Mode? (BOOT-Button halten)

Problem 3: WiFi verbindet nicht

Check:

☐ SSID richtig geschrieben?
☐ Passwort richtig?
☐ 2.4 GHz WiFi? (ESP32 kann kein 5 GHz!)
☐ Router in Reichweite?
☐ WLED-AP sichtbar? (Fallback wenn WiFi failed)

Problem 4: Farben sind falsch

Check:

☐ LED-Type richtig? (WS281x in WLED)
☐ Color Order richtig? (meist GRB, nicht RGB)
☐ Zu wenig Strom? (Farben sind blass)
☐ Kabel zu lang? (Daten-Degradation)

Problem 5: Flackern / Glitchen

Fix:

1. Kondensator (1000µF) zwischen 5V und GND
   (am Netzteil UND am LED-Anfang)

2. Widerstand (330-470Ω) zwischen ESP32-Pin und DIN
   (schützt Daten-Signal)

3. Kürzere Kabel (unter 1 Meter wenn möglich)

4. Besseres Netzteil (mehr Ampere)

🎓 Für Lehrer / Crew

Zeitplan (3-Stunden Workshop):

00:00 - 00:15  Intro + Warum? (Modul 1)
00:15 - 00:35  ESP32 kennenlernen (Modul 2)
00:35 - 00:50  WLED flashen (Modul 3)
00:50 - 01:10  LEDs anschließen (Modul 4)
01:10 - 01:30  WLED konfigurieren (Modul 5)
01:30 - 02:00  Effekte erkunden (Modul 6) - PAUSE danach
02:00 - 02:30  Netzwerk-Visualisierung (Modul 7)
02:30 - 03:00  Traceroute LEDs (Modul 8)
03:00 - 03:20  Hexagon Konzept (Modul 10)
03:20 - 03:30  Reflexion + Badge übergeben

Was Crew NICHT sagt:

❌ "Das ist einfach"
❌ "Das müsstest du schon wissen"
❌ "Warum funktioniert das nicht?"
❌ "Hast du nicht aufgepasst?"
❌ "Das ist falsch"

Was Crew SAGT:

✅ "Interessant! Was passiert wenn...?"
✅ "Lass uns zusammen schauen"
✅ "Fehler sind gut, wir lernen daraus"
✅ "Welche Farbe möchtest du als nächstes?"
✅ "Was denkst DU warum das so ist?"

Meister Krümel's Rolle:

NICHT:
  ❌ Alles erklären
  ❌ Vorführen wie toll er ist
  ❌ Fehler vermeiden (bei Demo)

NUR:
  ✅ Setup vorbereiten
  ✅ Material verteilen
  ✅ Bei echten Problemen helfen
  ✅ Ansonsten: Beobachten

🌈 Die Rainbow Counter Connection (explizit)

Warum zuerst CrumbBlocks?

Weil:
  Simulation = Risikofrei
  Keine Hardware kann kaputt gehen
  Keine Fehler beim Löten
  Nur Logik verstehen

Dann:
  Hardware = Realität
  Jetzt kann was kaputt gehen
  Aber: Logik ist schon klar
  Nur Umsetzung lernen

Die direkte Verbindung:

CrumbBlocks Rainbow Counter:

if (sensor.color === 'red') {
    counter.red++;
    display.show(counter.red);
}

ESP32 + Netzwerk:

if ping_successful:
    led.color = 'green'
    counter.success++;
    display.show(counter.success)

Gleiche Struktur:

IF Bedingung
THEN Aktion
SHOW Ergebnis

Aber:

CrumbBlocks: Simuliert
ESP32: Echt

🔮 Ausblick (Was kommt danach?)

Nächste Schritte für Krümel:

Level 1: WLED Master

- Alle Effekte verstanden
- Eigene Farb-Paletten
- Presets angelegt
- Alexa/Google Home Integration

Level 2: Eigener Code

- Arduino IDE lernen
- FastLED Library
- Eigene Muster programmieren
- Sensoren einbauen (Sound, Bewegung)

Level 3: Netzwerk-Integration

- MQTT verstehen
- Home Assistant
- Node-RED flows
- Automatisierung

Level 4: LED-Baum Beitrag

- Eigenen Ast designen
- Code zum Projekt beitragen
- Mit anderen Krümeln zusammenarbeiten
- Im echten Raum installieren

💚 Abschluss (Reflexion)

Fragen für Krümel:

"Was hast du heute gelernt?"
  → Nicht: "War es toll?"

"Was war überraschend?"
  → Nicht: "Hat es Spaß gemacht?"

"Was willst du als nächstes bauen?"
  → Nicht: "Willst du wiederkommen?"

Badge übergeben:

ESP32 + LED-Streifen + Kabel
  ↓
"Das ist deins.
 Nimm es mit.
 Baue weiter.

 Der Wald wächst
 wenn du weiterbaust."

🌲 Die finale Verbindung

CrumbBlocks Rainbow Counter
  ↓
ESP32 + WLED
  ↓
Netzwerk-Visualisierung
  ↓
LED-Baum
  ↓
Saturn Hexagon
  ↓
RESONANZ

Von Simulation zu Realität
Von Unsichtbar zu Sichtbar
Von Chaos zu Ordnung
Von Bits zu Licht

Das ist der Weg.

🌈🔌💡🌲

Das WARUM ist jetzt klar:

Bits sind unsichtbar.
Unsichtbares ist schwer zu verstehen.
LEDs machen Bits sichtbar.
Sichtbares ist leicht zu verstehen.

Deshalb: Regenbogen-Zählmaschine.
Deshalb: ESP32 + WLED.
Deshalb: LED-Baum.
Deshalb: Resonanz wird Form.

Der Wald leuchtet. 💚

Version: 1.0
Datum: 2026-02-15
Zielgruppe: Krümel (8-14 Jahre) + Crew
Dauer: 3 Stunden (mit Pausen)
Schwierigkeit: Anfänger
Vorwissen: Keine (CrumbBlocks hilft aber)
Badge: ESP32 + LEDs zum Mitnehmen

Made with 💚 for Krümel who want to see the invisible
Und für Crew die den Wald zum Leuchten bringen