Just brushing up on my Japanese family structure :)
Any tips or helpful criticisms are fully welcome!

seen from Portugal
seen from China
seen from United States

seen from Portugal
seen from China
seen from China
seen from Malaysia
seen from Australia

seen from United States
seen from Australia
seen from Singapore
seen from United Kingdom
seen from Portugal

seen from Singapore
seen from Portugal

seen from Italy
seen from Portugal
seen from China

seen from China
seen from China
Just brushing up on my Japanese family structure :)
Any tips or helpful criticisms are fully welcome!

Anya is live and ready to show you everything. Watch her strip, dance, and perform exclusive shows just for you. Interact in real-time and make your fantasies come true.
Free to watch âą No registration required âą HD streaming
Just practicing my ă adjective forms, Iâm still just writing in hiragana but any tips on my handwriting or any corrections are fully welcome! As always Iâm open to chatting with you guys about your japanese learning experiences and tips :)
Programmierbarer Osterhase: ESP32-C3 Lötkit mit Touch & Drehpoti
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.
Im nÀchsten Beitrag zeige ich dir, wie das Projekt im JFZ gemeinsam mit Teilnehmern umgesetzt wurde.