#jfz

Just brushing up on my Japanese family structure :)

Die Idee für diesen programmierbaren Osterhasen hatte ich schon lange im Kopf – nur die Zeit zur Umsetzung hat bisher gefehlt. Im Rahmen meiner EasyEDA-Reihe habe ich das Projekt endlich realisiert und aus einer Skizze ein echtes PCB-Design gemacht, das anschließend bei JLCPCB gefertigt wurde.

Herausgekommen ist ein Osterhase als Lötkit mit 7 LEDs, Touchfläche, Drehpoti und einem ESP32-C3 als Herzstück. Ein kleines Projekt mit erstaunlich vielen Möglichkeiten – perfekt zum Löten, Programmieren und Weiterentwickeln.

In diesem Beitrag zeige ich dir, wie aus einer Idee eine fertige Platine wurde – und vielleicht inspiriert dich das Ganze zu deinem eigenen kreativen PCB-Projekt.

https://youtu.be/fG2GFyeFG_c

Hinweis zum Projekt: Dieses Lötkit wird zu Ostern im örtlichen JFZ gemeinsam mit Kids und jung Gebliebenen aufgebaut und programmiert. Dabei können die Teilnehmer selbst entscheiden, ob sie den ESP32-C3 klassisch in C/C++ (Arduino IDE) oder mit MicroPython programmieren möchten.

Aufbau und Idee hinter dem Bausatz

Der Aufbau des Osterhasen ist bewusst einfach gehalten. Ziel war es, ein Projekt zu entwickeln, das sich gut löten lässt, überschaubar bleibt und trotzdem genug Spielraum für eigene Ideen bietet.

Im Mittelpunkt stehen sieben 3 mm LEDs, die in der Blume des Hasen platziert sind. Diese werden direkt vom ESP32-C3 angesteuert. Da wir lediglich eine Handvoll LEDs steuern möchten, ist die Schaltung entsprechend simpel aufgebaut – ohne aufwendige Treiber oder zusätzliche Logikbausteine.

Schaltung - ESP32-C3 Super Mini mit LEDs und Drehpotentiometer

Theoretisch hätte man die LED-Effekte auch mit einer festen IC-Schaltung oder einem einfachen Blink-Controller realisieren können. Technisch wäre das völlig ausreichend gewesen. Mir persönlich würde dabei jedoch der eigentliche Reiz fehlen – denn für mich gehört zum Projekt nicht nur das Löten, sondern vor allem das Programmieren.

Genau deshalb kommt hier ein ESP32-C3 zum Einsatz. Er macht das Projekt flexibel, erweiterbar und offen für eigene Ideen. Ob einfache Lauflichter, dimmbare Effekte über das Drehpoti oder sogar spätere Erweiterungen per WiFi oder Bluetooth – alles ist möglich, muss aber nicht.

Der Gedanke hinter dem Bausatz ist also klar: Ein einfaches Grundprojekt, das sofort funktioniert – aber genügend Freiheit bietet, kreativ zu werden und eigene Funktionen zu entwickeln.

Hardware im Überblick

Auch wenn der Osterhase auf den ersten Blick verspielt wirkt, steckt technisch mehr drin, als man vermuten würde. Die verwendeten Komponenten sind bewusst ausgewählt – einfach im Aufbau, aber flexibel in der Nutzung.

ESP32-C3 Super Mini

Das Herzstück der Platine ist ein ESP32-C3 Super Mini. Er übernimmt die komplette Steuerung der LEDs, verarbeitet die Touch-Eingabe und liest das Drehpotentiometer aus.

ESP32-C3 Super Mini

Der Vorteil: Genug Leistung für einfache LED-Effekte – aber auch ausreichend Reserven für spätere Erweiterungen wie WiFi- oder Bluetooth-Funktionen. Für dieses Projekt nutzen wir nur einen Bruchteil der Möglichkeiten, behalten aber volle Flexibilität.

7 × 3 mm LEDs

In der Blume des Hasen sitzen sieben klassische 3 mm LEDs. Sie werden direkt über GPIO-Pins angesteuert und jeweils mit einem passenden Vorwiderstand betrieben.

Durch die Einzelansteuerung lassen sich:

- Lauflichter - Blinkmuster - sanfte Übergänge - oder komplett eigene Animationen

realisieren.

3mm LEDs Touchfläche

Auf der Vorderseite befindet sich eine einfache Kupferfläche, die als Touchsensor dient.

Der ESP32-C3 besitzt zwar keine dedizierten kapazitiven Touch-Pins, dennoch lässt sich eine Art Touch-Funktion realisieren. Hierzu wird ein analoger Eingang (ADC) verwendet.

Berührt man die Kupferfläche mit dem Finger, verändert die körpereigene Kapazität den gemessenen Analogwert. Diese kleine Spannungsänderung wird vom Mikrocontroller erkannt und kann softwareseitig ausgewertet werden.

Auf diese Weise entsteht eine einfache, aber effektive „kapazitive“ Touchlösung – ganz ohne zusätzliche Bauteile oder spezielle Sensor-ICs.

Über diese Fläche können beispielsweise:

- Modi gewechselt - Effekte gestartet - oder Funktionen aktiviert werden

Ein Finger genügt – kein Taster, keine Mechanik.

Touchfläche auf der Platine Drehpotentiometer

Auf der Rückseite der Platine sitzt ein Drehpotentiometer. Dieses wird über einen analogen Eingang (ADC) des ESP32-C3 ausgelesen.

Damit lässt sich zum Beispiel:

- die Geschwindigkeit eines Effekts - die Helligkeit - oder ein bestimmter Modus feinjustieren

Das macht das Projekt interaktiver und lebendiger.

verschiedene Drehpotentiometer Stromversorgung

Die Platine wird bequem über USB mit Strom versorgt. Das vereinfacht den Aufbau und ermöglicht gleichzeitig eine direkte Programmierung über die Arduino IDE oder via MicroPython.

Warum dieses ESP32-C3 Lötkit perfekt für Maker ist

Dieses ESP32-C3 Lötkit eignet sich ideal für Einsteiger, da nur wenige Komponenten verbaut werden und der Aufbau übersichtlich bleibt. Man verliert sich nicht im Schaltplan – und kommt schnell zum ersten Erfolg.

Trotzdem sind die Möglichkeiten nahezu unbegrenzt.

Der ESP32-C3 kann wahlweise in C/C++ oder MicroPython programmiert werden. Von einfachen Lauflichtern bis hin zu Fade-Effekten mit PWM lässt sich hier einiges lernen. Gerade beim Dimmen der LEDs bekommt man ein gutes Verständnis für PWM-Signale.

Das Drehpotentiometer kann flexibel eingesetzt werden – etwa zur Steuerung der Effektgeschwindigkeit oder zur Anpassung der Touch-Empfindlichkeit.

Drehpoti am Osterhase PCB zum steuern der Empfindlichkeit oder der Geschwindigkeit der LEDs

Und wer noch einen Schritt weitergehen möchte, kann auf dem ESP32 sogar eine kleine Weboberfläche bereitstellen und die LED-Effekte bequem per Smartphone steuern.

Einfach im Aufbau – groß im Potenzial.

Vom Entwurf zur fertigen Platine

Wie so oft begann alles mit einer Idee im Kopf. Ein Osterhase als Platine – verspielt im Design, aber technisch sinnvoll aufgebaut.

Um aus dieser groben Vorstellung ein konkretes Konzept zu machen, habe ich mir Unterstützung geholt: Mit Hilfe von ChatGPT entstand zunächst ein passendes Motiv. Über ein gezieltes Prompt wurde ein Bild erzeugt, das als Grundlage für das spätere Platinenlayout diente.

In mehreren „Unterhaltungen“ über das Projekt reifte die Idee weiter. Welche Komponenten sind sinnvoll? Wie viele LEDs? Touch oder Taster? Reicht ein einfacher Controller oder darf es etwas flexibler sein? Durch diesen iterativen Prozess bekam das Projekt Schritt für Schritt seinen finalen Charakter.

Das eigentliche Platinenlayout habe ich anschließend in EasyEDA umgesetzt. Dort wurden die Konturen des Hasen nachgezeichnet, die LEDs sauber in der Blume platziert und Vorder- sowie Rückseite sinnvoll strukturiert.

EasyEDA - smarter Osterhase - Platinenlayout

Die Fertigung erfolgte – wie bei vielen meiner Projekte – über JLCPCB. Besonders praktisch ist die enge Verzahnung mit EasyEDA: Mit wenigen Klicks lassen sich die Gerber-Daten direkt übertragen und die Bestellung auslösen. Das spart Zeit und macht den gesamten Workflow sehr unkompliziert.

JLCPCB - Bestellung über EasyEDA auslösen

So wurde aus einer Idee, einem KI-generierten Entwurf und einem digitalen Layout schließlich eine echte Platine, die man in den Händen halten und bestücken kann.

Quellcode zum erzeugen der Effekte am smarten Osterhasen

Für die Programmierung reicht die Arduino IDE bzw. Thonny völlig aus wir benötigen keine zusätzlichen Bibliotheken oder Module.

Quellcode - C/C++ für die Arduino IDE /* ============================================================ Projekt: Programmierbarer Osterhase mit ESP32-C3 Beschreibung: Dieses Programm steuert 7 LEDs auf einem Osterhasen-PCB. Über eine Touchfläche kann zwischen verschiedenen LED-Modi gewechselt werden. Die Empfindlichkeit der Touchfläche wird über ein Drehpotentiometer eingestellt. Modi: 1 = Blume rotiert Stufe 1 2 = Blume rotiert Stufe 2 3 = Blume blinkt Autor: Stefan Draeger ============================================================ */ // ------------------------------------------------------------ // PIN-DEFINITIONEN // ------------------------------------------------------------ // Hier werden die GPIO-Pins definiert, an denen die 7 LEDs // angeschlossen sind. #define ledPin1 5 #define ledPin2 6 #define ledPin3 7 #define ledPin4 8 #define ledPin5 9 #define ledPin6 10 #define ledPin7 20 // Analoger Eingang für das Drehpotentiometer. // Darüber wird die Empfindlichkeit des Touchsensors eingestellt. #define rotaryResistorPin 3 // Analoger Eingang für die Touchfläche. // Der ESP32-C3 besitzt keine dedizierten Touch-Pins, // daher werten wir hier eine Spannungsänderung am ADC aus. #define touchPin 4 // ------------------------------------------------------------ // MODUS-VERWALTUNG // ------------------------------------------------------------ // 'modus' speichert den aktuell aktiven Effekt. // MAX_MODI legt fest, wie viele Effekte insgesamt existieren. int modus = 1; const int MAX_MODI = 3; // ------------------------------------------------------------ // LED-ARRAY // ------------------------------------------------------------ // Die LED-Pins werden in einem Array zusammengefasst. // So können wir später bequem mit Schleifen über alle LEDs gehen. const int NUM_LEDS = 7; int leds = { ledPin1, ledPin2, ledPin3, ledPin4, ledPin5, ledPin6, ledPin7 }; // ------------------------------------------------------------ // ZEITSTEUERUNG FÜR DIE ANIMATIONEN // ------------------------------------------------------------ // FLOWER_PAUSE bestimmt das Zeitintervall zwischen zwei Schritten // der LED-Animation. // flowerLastAction speichert, wann die letzte Änderung stattgefunden hat. int flowerIndex = 0; const int FLOWER_PAUSE = 250; unsigned long flowerLastAction = 0; // ------------------------------------------------------------ // HILFSVARIABLEN FÜR DEN ERSTEN EFFEKT // ------------------------------------------------------------ // stampStatus wird genutzt, um eine zusätzliche LED im Wechsel // blinken zu lassen. // STAMP_PAUSE und stampLastAction sind aktuell vorbereitet, // werden in dieser Version aber nicht aktiv verwendet. const int STAMP_PAUSE = 125; unsigned long stampLastAction = 0; bool stampStatus = false; // ------------------------------------------------------------ // SETUP // ------------------------------------------------------------ // setup() wird genau einmal beim Start des Mikrocontrollers // ausgeführt. void setup() { // Serielle Schnittstelle starten, damit wir Messwerte // im seriellen Monitor der Arduino IDE ausgeben können. Serial.begin(9600); // Alle LED-Pins als Ausgänge konfigurieren. for (int index = 0; index 1) { digitalWrite(leds, LOW); } // Die aktuelle LED einschalten. digitalWrite(leds, HIGH); // Zusätzliche LED 0 bei jedem Durchlauf umschalten. // Dadurch entsteht ein zusätzlicher Blinkeffekt. stampStatus = !stampStatus; digitalWrite(leds, stampStatus); } // ------------------------------------------------------------ // EFFEKT 2: BLUME ROTIERT STUFE 2 // ------------------------------------------------------------ // Dieser Effekt arbeitet mit einem zweiten Index. // LEDs werden der Reihe nach ein- oder ausgeschaltet. // Sobald alle LEDs durchlaufen wurden, wird der Zustand // umgedreht (HIGH LOW). int flowerRotate2Index = 0; bool flowerRotate2Status = false; void flowerRotate2() { // Aktuelle LED auf den gespeicherten Status setzen. digitalWrite(leds, flowerRotate2Status); // Zum nächsten Index wechseln. if (flowerRotate2Index < (NUM_LEDS - 1)) { flowerRotate2Index++; } else { // Wenn alle LEDs durchlaufen wurden: // wieder von vorne beginnen und Status umschalten. flowerRotate2Index = 0; flowerRotate2Status = !flowerRotate2Status; } } // ------------------------------------------------------------ // EFFEKT 3: BLUME BLINKT // ------------------------------------------------------------ // Alle LEDs werden gleichzeitig ein- und ausgeschaltet. void flowerBlink() { // Alle LEDs einschalten. for (int index = 0; index < NUM_LEDS; index++) { digitalWrite(leds, HIGH); } // Kurze Pause mit allen LEDs an. delay(FLOWER_PAUSE); // Alle LEDs ausschalten. for (int index = 0; index (touchLastAction + TOUCH_PAUSE)) { touchLastAction = currentMillis; // Wenn der gemessene Touch-Wert größer als der Potentiometer- // Wert ist, wird dies als Berührung interpretiert. if (touchValue > resistorValue) { // Wenn der letzte Modus erreicht wurde, // wieder von vorne beginnen. if (modus == MAX_MODI) { modus = 0; } // Zum nächsten Modus wechseln. modus++; } } // ---------------------------------------------------------- // LED-EFFEKT ZEITGESTEUERT AUSFÜHREN // ---------------------------------------------------------- // Statt delay() wird hier millis() verwendet, // damit das Programm weiterhin auf Touch reagieren kann. if (currentMillis > (flowerLastAction + FLOWER_PAUSE)) { flowerLastAction = currentMillis; // Je nach aktivem Modus die passende Effektfunktion aufrufen. switch (modus) { case 1: flowerRotate(); break; case 2: flowerRotate2(); break; case 3: flowerBlink(); break; default: // Falls ein ungültiger Modus gesetzt wurde, // auf den ersten Effekt zurückfallen. flowerRotate(); break; } } }

Fazit

Der programmierbare Osterhase ist ein bewusst einfach gehaltenes Projekt, das sich ideal für den Einstieg in die Welt der Mikrocontroller eignet. Durch den Einsatz des ESP32-C3 bleibt das System jedoch offen für zahlreiche Erweiterungen.

Besonders spannend ist die Kombination aus:

- einfachem Hardwareaufbau - flexibler Programmierung - und kreativen Gestaltungsmöglichkeiten

Damit eignet sich das Projekt nicht nur als Lötbausatz, sondern auch als Grundlage für eigene Ideen und Experimente.