#esp32-c3mini

[draegerit]

ESP32 Tutorial: Taster-Interrupt mit Entprellung

Bei vielen Projekten mit dem ESP32 ist es sinnvoll, bestimmte Aktionen – wie z. B. einen Updatevorgang – nur bei Bedarf und klar getrennt von der eigentlichen Programmlogik auszuführen. Anstatt regelmäßig auf einen Taster zu prüfen, bietet sich die Verwendung eines Interrupts mit Entprellung an. In diesem Beitrag zeige ich dir, wie du mit MicroPython einen Taster via Interrupt abfragst und dabei eine einfache Zeitprüfung zur Entprellung integrierst. Dadurch wird sichergestellt, dass ein Tasterdruck nicht mehrfach ausgelöst wird, selbst wenn der Kontakt mechanisch prellt. https://youtu.be/k8WnJxvzstI Die eigentliche Programmlogik – hier symbolisch durch ein einfaches Wechselblinken zweier LEDs dargestellt – läuft dabei unabhängig weiter. So lässt sich der Taster sauber als externer Trigger verwenden, z. B. für einen Updatevorgang, der in einem separaten Beitrag behandelt wird.

Jeder GPIO kann ein Interruptpin sein

Einer der großen Vorteile beim ESP32 ist die Flexibilität der verfügbaren GPIOs: Nahezu jeder freie GPIO-Pin kann als Interruptquelle genutzt werden. Im Gegensatz zu manchen älteren Mikrocontroller-Plattformen, bei denen nur bestimmte Pins Interrupts unterstützen, erlaubt der ESP32 in MicroPython die Verwendung beliebiger Eingänge für Interrupts – solange sie nicht durch Sonderfunktionen blockiert sind (z. B. Flash, Boot-Modus etc.). Das bedeutet konkret: Du kannst deinen Taster einfach an einen freien digitalen Eingang anschließen und diesen Pin mit einer sogenannten Interrupt-Service-Routine (ISR) verknüpfen. Diese ISR wird automatisch aufgerufen, sobald sich der Zustand des Pins ändert – z. B. bei einem Tasterdruck. Dabei lassen sich verschiedene Triggerarten verwenden: - Pin.IRQ_FALLING → löst aus, wenn das Signal von HIGH auf LOW fällt (typisch bei Taster mit Pull-Up) - Pin.IRQ_RISING → löst aus, wenn das Signal von LOW auf HIGH wechselt - Pin.IRQ_RISING | Pin.IRQ_FALLING → löst bei jeder Änderung aus (steigende oder fallende Flanke) So lässt sich der ESP32 sehr flexibel und effizient steuern – insbesondere bei Projekten, in denen Benutzeraktionen sofort und ohne Verzögerung erkannt werden sollen.

Kompakte Schaltung mit dem ESP32-C3 Super Mini

Für dieses Beispiel verwende ich den ESP32-C3 Super Mini, der sich durch seine kompakte Bauweise und vollständige GPIO-Ausführung besonders gut für einfache Demonstrationsschaltungen eignet. Trotz der geringen Größe stehen alle wichtigen Funktionen des ESP32-C3 zur Verfügung – inklusive Interrupt-Fähigkeit, WLAN und geringem Stromverbrauch. Natürlich lässt sich dieses Projekt genauso gut mit jedem anderen ESP32-Modul (z. B. DevKitC, NodeMCU oder ESP32-S3) umsetzen. Die Pinbelegung muss lediglich entsprechend angepasst werden. In der folgenden Schaltung wird ein Taster an GPIO 21 angeschlossen, um per Interrupt einen Befehl auszulösen. Zwei LEDs (blau und grün) sind zusätzlich an GPIO 10 und GPIO 1 angeschlossen und dienen als einfache Aktivitätsanzeige.

Schaltung - ESP32-C3 Mini mit LEDs und Taster über PullUp Widerstand Benötigte Teile Für den Nachbau dieser kleinen Beispielschaltung brauchst du nur wenige, leicht erhältliche Bauteile. Ideal für Einsteiger und Bastelprojekte: - ESP32 Mikrocontroller* Zum Beispiel der kompakte ESP32-C3 Super Mini* – andere Varianten funktionieren ebenso. - Printtaster* (12×12 mm) Ein ganz normaler Drucktaster für Breadboards. Optional mit farbiger Tasterkappe. - Widerstand 10 kΩ* Als Pull-Up-Widerstand, wenn kein interner genutzt wird oder zur Sicherheit bei mechanisch prellenden Tastern. - Breadboard* (Steckbrett) Für schnellen und flexiblen Aufbau ohne Löten. - Breadboardkabel* (Dupont-Kabel) Einige Jumper-Kabel zum Verbinden von Mikrocontroller, Taster und LEDs. Hinweis von mir: Die mit einem Sternchen (*) markierten Links sind Affiliate-Links. Wenn du über diese Links einkaufst, erhalte ich eine kleine Provision, die dazu beiträgt, diesen Blog zu unterstützen. Der Preis für dich bleibt dabei unverändert. Vielen Dank für deine Unterstützung!

Taster per Interrupt anbinden – so geht’s

Die Programmierung eines Taster-Interrupts mit MicroPython ist unkompliziert. Der Taster wird an einen freien GPIO angeschlossen – in diesem Beispiel an GPIO 21 – und anschließend mit einer Interrupt-Service-Routine (ISR) verknüpft: # Taster an GPIO 21 (z. B. mit externem Pull-Up-Widerstand oder internem PullUp) taster = Pin(21, Pin.IN) taster.irq(trigger=Pin.IRQ_FALLING, handler=taster_auswertung) ⚠️ Achte darauf, wie der Taster beschaltet ist! Damit ein stabiler HIGH-Pegel im Ruhezustand anliegt, ist ein Pull-Up-Widerstand erforderlich. Beim Drücken des Tasters wird der Pin gegen GND gezogen (LOW), wodurch der Interrupt ausgelöst wird.

ESP32-C3 Pinout Du hast zwei Möglichkeiten: - ✅ Externer Pull-Up-Widerstand (z. B. 10 kΩ zwischen GPIO und 3.3 V): Sicherste Variante, funktioniert an jedem Pin. - ✅ Interner Pull-Up aktivieren (nur wenn der verwendete GPIO dies unterstützt): taster = Pin(21, Pin.IN, Pin.PULL_UP) 🚫 Aber Vorsicht: Nicht alle GPIOs des ESP32 unterstützen interne Pull-Ups. Prüfe im Datenblatt oder in der GPIO-Referenz deines Moduls, ob der gewählte Pin einen internen Pull-Up unterstützt, bevor du darauf vertraust. # ============================================= # Titel: Wechselblinkende LEDs und Taster-Interrupt mit Entprellung am ESP32 # Beschreibung: # In diesem Beispiel wird gezeigt, wie zwei LEDs abwechselnd blinken, # während ein Taster über einen Interrupt ausgewertet wird. Eine Entprellung # erfolgt softwareseitig durch zeitgesteuerte Prüfung innerhalb der Interruptfunktion. # # Autor: Stefan Draeger # Webseite: https://draeger-it.blog # ============================================= from machine import Pin import time # Letzter gültiger Tastendruck (für Entprellung) letzter_ausloeser = 0 sperrzeit_ms = 500 # Mindestabstand zwischen zwei Auslösungen in Millisekunden # Interrupt-Service-Routine für den Taster def taster_auswertung(pin): global letzter_ausloeser aktuelle_zeit = time.ticks_ms() # Nur auslösen, wenn Sperrzeit überschritten wurde if time.ticks_diff(aktuelle_zeit, letzter_ausloeser) > sperrzeit_ms: letzter_ausloeser = aktuelle_zeit print("Taster gedrückt – Aktion ausgelöst!") # Taster an GPIO 21 (z. B. mit externem Pull-Up-Widerstand oder internem PullUp) taster = Pin(21, Pin.IN) taster.irq(trigger=Pin.IRQ_FALLING, handler=taster_auswertung) # LEDs an GPIO 10 und GPIO 1 led_blau = Pin(10, Pin.OUT) led_gruen = Pin(1, Pin.OUT) # Intervall für das Wechselblinken in Millisekunden blink_intervall = 500 # Startzustand für Blinksteuerung letzter_wechsel = time.ticks_ms() zustand = False # False = LED blau an, grün aus # Hauptprogramm while True: aktuelle_zeit = time.ticks_ms() # Wechseln, wenn Intervall abgelaufen ist if time.ticks_diff(aktuelle_zeit, letzter_wechsel) > blink_intervall: zustand = not zustand led_blau.value(zustand) led_gruen.value(not zustand) letzter_wechsel = aktuelle_zeit # Kurze Pause, um CPU-Auslastung zu reduzieren (nicht blockierend) time.sleep(0.05) Read the full article

[draegerit]

Automatische Pumpensteuerung mit Schwimmschalter, ESP32 und Shelly Outdoor Plug

Der winzige ESP32-C3 Mini eignet sich hervorragend für Automatisierungsprojekte – trotz seiner kompakten Bauweise bietet er genügend freie Pins für Sensoren und Aktoren. Dank integrierter WiFi-Funktionalität und leistungsstarker Keramikantenne lässt er sich ideal in dein Smarthome einbinden.In diesem Beitrag zeige ich dir, wie du mit dem neuen Shelly Outdoor Plug eine Pumpe smart steuern kannst – und dabei einen Schwimmschalter clever in deine Logik integrierst. Und das Ganze: kostengünstig und einfach umzusetzen! https://youtu.be/zqWIirrkjp8 Im letzten Beitrag „Füllstandskontrolle mit Shelly: Schwimmschalter richtig anschließen“ habe ich dir gezeigt, wie du einen Schwimmschalter am Shelly Plus 1 über das AddOn-Modul anschließt und damit über eine Szene einen Shelly Outdoor Plug steuern kannst.Diese Lösung funktioniert zuverlässig – ist aber durch das AddOn nicht ganz günstig. Wenn du lediglich diese eine Aufgabe umsetzen möchtest, zeige ich dir hier eine clevere und kostengünstige Alternative mit einem ESP32-C3 Mini. Schaltung - ESP32-C3 Mini mit Schwimmschalter - Fail Schaltung - ESP32-C3 Mini mit Schwimmschalter - OK Shelly Outdoor Plug mit ESP32-C3 Mini und Schwimmschalter - aktiviert Shelly Outdoor Plug mit ESP32-C3 Mini und Schwimmschalter - deaktiviert Wie soll das kleine Projekt funktionieren? Der kompakte ESP32-C3 Mini übernimmt die Auswertung des Schwimmschalters, der mit einem 10 kΩ PullDown-Widerstand an einem digitalen Eingang angeschlossen ist. Schaltung - ESP32-C3 Mini mit Schwimmschalter - Kontakt geöffnet Schaltung - ESP32-C3 Mini mit Schwimmschalter - Kontakt geschlossen Eine kleine 3 mm Dual-Color-LED (Rot/Grün) visualisiert den Zustand direkt am Gerät: - Grün leuchtet: Füllstand in Ordnung - Rot leuchtet: Fass ist leer Zusätzlich bietet der ESP32 eine HTTP-Schnittstelle an, über die sich der aktuelle Status im lokalen Netzwerk abfragen lässt. Die Antwort ist bewusst einfach gehalten: - OK → Füllstand in Ordnung - FAIL → Fass leer Der Shelly Outdoor Plug übernimmt die Steuerung der Pumpe. Über ein kleines JavaScript-Programm (Shelly Script) wird festgelegt, zu welchen Zeiten die Pumpe überhaupt laufen darf.Bevor sie jedoch startet, wird zusätzlich der Füllstand über den ESP32 abgefragt. Nur wenn dieser ein OK zurückliefert, wird die Pumpe eingeschaltet. Ist der Füllstand zu niedrig, bleibt die Pumpe aus.Diese Logik schützt die Pumpe zuverlässig vor dem Trockenlaufen und möglichen Schäden durch Leerlauf. Die Schaltung – klein, aber effektiv Als Erstes zeige ich dir die kleine Schaltung, die für dieses Projekt verwendet wird. Sie ist bewusst einfach gehalten, erfüllt aber zuverlässig ihren Zweck:Der ESP32-C3 Mini erfasst den Zustand des Schwimmschalters, visualisiert ihn über eine Dual-Color-LED und stellt die Daten über eine HTTP-Schnittstelle bereit. Schaltung - ESP32-C3 Mini mit Schwimmschalter und Dual-Color-LED Trotz der wenigen Bauteile ist die Schaltung effizient und stabil – perfekt geeignet für die geplante Anwendung. Sehr gute Idee! Damit wird dein Beitrag nicht nur informativer, sondern auch praxisnah und direkt nachvollziehbar.Hier ist dein bereits vorhandener Abschnitt aus der Programmbeschreibung mit passenden Codebeispielen nach jedem Punkt: Welche Bauteile werden für das Projekt benötigt? Für dieses Projekt kommen bewusst einfache und kostengünstige Komponenten zum Einsatz. Die Schaltung ist schnell aufgebaut und lässt sich bei Bedarf problemlos erweitern. Folgende Bauteile werden benötigt: Shelly Outdoor Plug*Dieser Plug übernimmt die eigentliche Schaltaufgabe. Er bezieht den Füllstand vom ESP32 per WLAN und aktiviert bei Bedarf die angeschlossene Pumpe. Shelly Outdoor Plug ESP32-C3 Mini*Der Mikrocontroller übernimmt die Auswertung des Schwimmschalters und stellt den Füllstand über eine HTTP-Schnittstelle bereit. ESP32-C3 Mini Dual-Color-LED* (gemeinsame Anode) mit zwei 220 Ω Widerständen*Zur visuellen Anzeige des Füllstands: Grün = OK, Rot = Fass leer. Dual-Color-LED mit Widerstände Zwei 2-fach Schraubklemmen*Für den sicheren Anschluss externer Kabel, z. B. zur Spannungsversorgung und zum Schwimmschalter. Schraubklemmen Diode 1N4001*Dient als Verpolungsschutz für die Stromversorgung der Schaltung. Diode 1N4001 Lochrasterplatine*Zur stabilen und dauerhaften Verdrahtung aller Komponenten – alternativ wäre auch ein Breadboard möglich. Lochrasterplatinen AWG 18/20 Kabel*Für die interne Verdrahtung der Bauteile auf der Platine. Kabel AWG20 IP44-Gehäuse mit transparentem Deckel*Schützt die Elektronik vor Staub und Spritzwasser – perfekt für den Außeneinsatz im Garten oder an der Zisterne. IP44 Gehäuse Schwimmschalter (magnetisch)*Erkennt, ob ein bestimmter Wasserstand erreicht ist. Je nach Einbaulage öffnet oder schließt er einen Kontakt. Schwimmschalter Hinweis von mir: Die mit einem Sternchen (*) markierten Links sind Affiliate-Links. Wenn du über diese Links einkaufst, erhalte ich eine kleine Provision, die dazu beiträgt, diesen Blog zu unterstützen. Der Preis für dich bleibt dabei unverändert. Vielen Dank für deine Unterstützung! Das Programm für den ESP32-C3 Mini im Detail Für dieses Projekt wird der ESP32-C3 Mini mit der Arduino IDE programmiert. Das Programm erfüllt mehrere Aufgaben gleichzeitig und sorgt dafür, dass der Füllstand des Behälters jederzeit über das lokale Netzwerk abgefragt werden kann. Zusätzlich wird der aktuelle Zustand durch eine Dual-Color-LED direkt am Gerät visualisiert. WLAN-Verbindung aufbauen Nach dem Start verbindet sich der ESP32 automatisch mit dem WLAN. Die Zugangsdaten werden aus einer separaten Datei (secrets.h) geladen. Während die Verbindung aufgebaut wird, blinkt die interne LED an GPIO 8, um den Status zu signalisieren. Sobald die Verbindung steht, bleibt die LED dauerhaft an und die zugewiesene IP-Adresse wird auf der seriellen Schnittstelle ausgegeben. WiFi.begin(ssid, password); while (WiFi.status() != WL_CONNECTED) { delay(500); digitalWrite(LED_WIFI_STATUS, counter % 2 == 0 ? HIGH : LOW); counter++; } digitalWrite(LED_WIFI_STATUS, LOW); // Dauerhaft an bei Erfolg Serial.println("nWLAN verbunden!"); Serial.print("IP-Adresse: "); Serial.println(WiFi.localIP()); Ausgabe des ESP32-C3 auf der seriellen Schnittstelle nachdem aufbauen der WiFi Verbindung HTTP-Schnittstelle bereitstellen Der ESP32 startet einen Webserver auf Port 80. Wird die Adresse http:///fuellstand im Browser oder durch ein Skript aufgerufen, prüft der ESP32 den Status des Schwimmschalters (GPIO 21): server.on("/fuellstand", () { String status = (digitalRead(SCHALTER_PIN) == LOW) ? "OK" : "FAIL"; server.send(200, "text/plain", status); }); server.begin(); HTTP-Anfrage Füllstandssensor - FAIL LED-Statusanzeige Die kleine Dual-Color-LED zeigt den aktuellen Zustand direkt am Gerät an: - Grün bei Füllstand okay - Rot wenn das Fass leer ist Da es sich um eine LED mit gemeinsamer Anode handelt, müssen die entsprechenden Pins auf LOW gesetzt werden, damit sie leuchten. if (digitalRead(SCHALTER_PIN) == LOW) { digitalWrite(LED_GRUEN, LOW); // grün an digitalWrite(LED_ROT, HIGH); // rot aus } else { digitalWrite(LED_GRUEN, HIGH); // grün aus digitalWrite(LED_ROT, LOW); // rot an } Hauptloop Der Loop verarbeitet Webserver-Anfragen und prüft den aktuellen Zustand. Die LED wird entsprechend gesetzt. void loop() { server.handleClient(); // LED-Logik siehe vorheriger Abschnitt delay(100); // Entlastung } kompletter Quellcode Nachfolgend der komplette Quellcode zum Download: Programm: ESP32-C3 Mini mit Schwimmschalter & Status LEDHerunterladen #include // WLAN-Funktionalität für den ESP32 #include // Webserver-Bibliothek zur Bereitstellung von HTTP-Endpunkten #include "secrets.h" // Externe Datei mit WLAN-Zugangsdaten (ssid, password) // === GPIO-Konfiguration === #define SCHALTER_PIN 21 // Eingang für den Schwimmschalter #define LED_ROT 3 // Ausgang zur roten LED (Kathode) – LOW = leuchtet #define LED_GRUEN 4 // Ausgang zur grünen LED (Kathode) – LOW = leuchtet #define LED_WIFI_STATUS 8 // Interne Status-LED (BUILD_IN_LED) – leuchtet bei LOW // Webserver-Instanz auf Port 80 (Standard für HTTP) WebServer server(80); // === HTTP-Handler für /fuellstand === // Gibt den aktuellen Zustand des Schwimmschalters zurück void handleFuellstand() { // Wenn der Pin HIGH ist, ist der Füllstand leer → "FAIL" // Wenn der Pin LOW ist, ist der Füllstand OK → "OK" String status = (digitalRead(SCHALTER_PIN) == HIGH) ? "FAIL" : "OK"; server.send(200, "text/plain", status); } void setup() { // Serielle Schnittstelle starten (für Debug-Ausgabe) Serial.begin(115200); // === GPIO-Modi setzen === pinMode(SCHALTER_PIN, INPUT_PULLDOWN); // Schwimmschalter mit internem Pulldown pinMode(LED_ROT, OUTPUT); // LED-Ausgänge pinMode(LED_GRUEN, OUTPUT); pinMode(LED_WIFI_STATUS, OUTPUT); // LED für WLAN-Statusanzeige // === WLAN verbinden === WiFi.begin(ssid, password); Serial.print("Verbinde mit WLAN..."); long counter = 0; // Solange keine Verbindung besteht, blinkt die Status-LED while (WiFi.status() != WL_CONNECTED) { delay(500); Serial.print("."); // LED blinkt: alle 500 ms an/aus (HIGH = LED aus bei common-anode) digitalWrite(LED_WIFI_STATUS, counter % 2 == 0 ? HIGH : LOW); counter++; } Serial.println(""); digitalWrite(LED_WIFI_STATUS, LOW); // Verbindung steht → LED dauerhaft an (LOW = leuchtet) // === Verbindung erfolgreich === Serial.println("nWLAN verbunden!"); Serial.print("IP-Adresse: "); Serial.println(WiFi.localIP()); // === HTTP-Endpunkt einrichten === server.on("/fuellstand", handleFuellstand); // Reaktion auf Aufruf /fuellstand server.begin(); Serial.println("HTTP-Server gestartet"); } void loop() { // Webserver-Anfragen bearbeiten server.handleClient(); // WLAN-Verbindung überwachen → falls getrennt, Status-LED deaktivieren if (WiFi.status() != WL_CONNECTED) { Serial.println("WiFi - AUS"); digitalWrite(LED_WIFI_STATUS, HIGH); // LED aus (HIGH bei common-anode) } // === Füllstand auswerten === if (digitalRead(SCHALTER_PIN) == LOW) { // Füllstand OK → grüne LED an, rote LED aus digitalWrite(LED_GRUEN, LOW); // LED an digitalWrite(LED_ROT, HIGH); // LED aus } else { // Füllstand leer → rote LED an, grüne LED aus digitalWrite(LED_GRUEN, HIGH); // LED aus digitalWrite(LED_ROT, LOW); // LED an } delay(100); // Kurze Pause zur Entlastung des Mikrocontrollers } Shelly Script: Automatisches Schalten per Füllstand Der folgende JavaScript-Code läuft direkt auf dem Shelly Outdoor Plug und sorgt dafür, dass eine angeschlossene Pumpe nur dann eingeschaltet wird, wenn der Füllstand in der Zisterne oder dem Fass ausreichend hoch ist. Die Abfrage erfolgt über den zuvor konfigurierten ESP32-C3 Mini, der den Schwimmschalter überwacht und den Status per HTTP bereitstellt. Das Script eignet sich ideal für Anwendungen wie: - automatisches Umpumpen bei drohender Überfüllung - smarte Wasserverteilung in Gartenanlagen - zuverlässige Steuerung ohne externe Cloud // Funktion zum Schalten des Ausgangs am Shelly Outdoor Plug function setShellyOutput(status) { // Wir erstellen ein Objekt mit den Steuerparametern: let params = { id: 0, // Ausgang 0 (der erste bzw. einzige Ausgang des Plugs) on: status // true = Einschalten, false = Ausschalten }; // Schalte den Ausgang mit den angegebenen Parametern Shelly.call("Switch.Set", params); } // Funktion zum Abfragen des Füllstands vom ESP32-C3 Mini function callESP() { // Wir erstellen ein Objekt mit den Einstellungen für den HTTP-Request let params = { method: "GET", // Wir wollen Daten abrufen (GET-Anfrage) url: "http://192.168.178.96/fuellstand" // Adresse des ESP32 im Netzwerk }; // Sende die HTTP-Anfrage an den ESP32 Shelly.call("http.get", params, function(result, error_code, error_message) { // Wenn ein Fehler auftritt (z. B. ESP32 nicht erreichbar): if (error_code != 0) { print("Fehler beim Senden der Daten: " + error_message); print(params); // Ausgabe der Parameter zur Fehleranalyse } else { // Anfrage erfolgreich → Antwort wurde empfangen print("Daten erfolgreich empfangen."); print(result); // zeige den vollständigen Inhalt der Antwort // Wenn die Antwort "OK" ist → Füllstand ausreichend → Pumpe einschalten // Wenn die Antwort "FAIL" ist → Füllstand zu niedrig → Pumpe ausschalten setShellyOutput(result.body === 'OK'); } }); } // Rufe die Funktion callESP alle 2500 Millisekunden (2,5 Sekunden) wiederholt auf Timer.set(2500, true, callESP); Das Script fragt alle 2,5 Sekunden den ESP32 ab. Wird OK zurückgegeben, schaltet der Shelly die Pumpe ein. Bei FAIL wird sie ausgeschaltet. So lässt sich zuverlässig verhindern, dass die Pumpe im Leerlauf läuft oder das Fass überläuft. 📘 Tipp:Du möchtest mehr darüber erfahren, wie man JavaScript direkt auf Shelly-Geräten einsetzt? Auf meinem Blog und YouTube-Kanal findest du eine eigene Beitragsreihe zu Shelly Scripting, inklusive Einstieg, Variablen, Bedingungen, Callbacks und Praxisprojekten.👉 Zur Beitragsreihe: draeger-it.blog/?s=Shelly+Scripting 💡 Hinweis: In einem kommenden Beitrag zeige ich dir, wie du dieses Setup für eine smarte Gartenbewässerung weiterentwickeln kannst – inklusive Zeitsteuerung und Wetteranbindung. Fazit & Ausblick Mit dieser Schaltung hast du die Grundlage für eine einfache, aber zuverlässige Pumpensteuerung per Schwimmschalter geschaffen. Der ESP32-C3 Mini übernimmt die Füllstandserkennung, der Shelly Outdoor Plug reagiert darauf – komplett lokal, ohne Cloud und jederzeit erweiterbar. Im nächsten Beitrag zeige ich dir, wie du mit dieser Basis eine smarte Gartenbewässerung umsetzen kannst. Du brauchst dafür kaum zusätzliche Hardware, sondern nur etwas mehr Code – sei also gespannt! Read the full article

[draegerit]

ESP32-C3 Mini: Die perfekte Basis für eine moderne Timerschaltung

In einem früheren Beitrag habe ich mit der Arduino-gestützten Eieruhr bereits eine flexible Countdown-Anzeige mit akustischem Alarm vorgestellt. Die ursprüngliche Version, die ich auf meinem Blog unter diesem Link veröffentlicht habe, basierte auf einem klassischen Arduino. Doch nun wird es Zeit für ein Upgrade: Der ESP32-C3 Mini bietet nicht nur mehr Leistung mit seinen 160 MHz, sondern bringt auch WiFi- und Bluetooth-Konnektivität mit – und das in einem äußerst kompakten Format. https://youtu.be/5CGeBJfi6Gc Die Portierung der bestehenden Arduino-Schaltung auf den ESP32-C3 Mini war erstaunlich einfach, da dieser ebenfalls in der Arduino IDE programmiert werden kann. Der eigentliche Fokus lag jedoch darauf, die Schaltung auf eine eigene Platine (PCB) zu bringen, um sie für ein bevorstehendes Event im JFZ Schöningen einsatzbereit zu machen.

In diesem Beitrag zeige ich, wie die Timerschaltung mit dem ESP32-C3 Mini realisiert wurde, welche Anpassungen notwendig waren und wie die finale Version als fertige Platine umgesetzt wurde.

Warum der ESP32-C3 Mini besser als ein Arduino ist

Zunächst einpaar Gründe warum der ESP32-C3 Mini besser als ein Arduino ist: ✔ WiFi & Bluetooth integriert – Kein extra Modul nötig, ideal für IoT. ✔ Mehr Leistung & Speicher – 160 MHz, 384 KB RAM vs. 16 MHz, 2 KB RAM beim Arduino. ✔ Energieeffizient – Sleep-Modi für geringen Stromverbrauch. ✔ Vielseitigere GPIOs – Mehr analoge Eingänge, PWM, SPI, I2C, UART gleichzeitig nutzbar. ✔ Moderne Programmierung – Neben der Arduino IDE auch MicroPython & ESP-IDF unterstützt.

ESP32-C3 Super Mini

Benötigte Bauteile für die Timerschaltung

Für den Aufbau der Schaltung werden folgende Komponenten benötigt. Diese ermöglichen eine einfache Umsetzung und sind flexibel auf einem 800-Pin-Breadboard testbar. - 1x ESP32-C3 Mini – Der Mikrocontroller als Steuerzentrale - 4x Taster mit Köpfen – Zur Steuerung der Timer-Funktionen - 1x 3mm LED mit 220-Ohm-Vorwiderstand – Statusanzeige - 2x 5mm LED mit 220-Ohm-Vorwiderstand – Visuelles Feedback beim Alarm - 2x Piezo-Buzzer – Akustischer Signalgeber - diverse Breadboardkabel – Zur Verbindung der Komponenten - 1x 800-Pin-Breadboard – Für eine flexible Verdrahtung Hinweis von mir: Die mit einem Sternchen (*) markierten Links sind Affiliate-Links. Wenn du über diese Links einkaufst, erhalte ich eine kleine Provision, die dazu beiträgt, diesen Blog zu unterstützen. Der Preis für dich bleibt dabei unverändert. Vielen Dank für deine Unterstützung!

Timerschaltung am Schaltung am ESP32-C3 Mini im Detail

Nachfolgend die Timerschaltung am ESP32-C3 auf einem Breadboard.

ESP32-C3 Mini - Countdown Schaltung Bauteil / PinESP32-C3 Mini4fach 7 SegmentanzeigeCLK > 3 (GPIO3) SDA > 4 (GPIO4) GND > GND VCC > 5VTaster - Start / Stopp5 (GPIO5)Taster - Plus6 (GPIO6)Taster - Minus7 (GPIO7)Taster - Select8 (GPIO8)LED 120 (GPIO20)LED 221 (GPIO21)Status LED9 (GPIO9)Piezo Buzzer - links10 (GPIO10)Piezo Buzzer - rechts2 (GPIO2) Pinout des ESP32-C3 Mini Nachfolgend findest du den Aufbau des ESP32-C3 Mini, der dir hilft, die richtigen Pins für deine Schaltung schneller und einfacher zu identifizieren. Eine klare Übersicht der GPIO-Belegung erleichtert die Verdrahtung und reduziert Fehler beim Anschluss der Komponenten.

ESP32-C3 Pinout Falls du spezielle Funktionen wie PWM, I2C, SPI oder UART nutzen möchtest, lohnt sich ein Blick auf die multiplen Belegungsmöglichkeiten der Pins. Unterschiedliche - 4fach 7Segmentanzeigen Es gibt verschiedene Arten von 7-Segment-Anzeigen auf dem Markt. Einerseits gibt es kompakte, einfache Modelle, andererseits größere Varianten mit farbigen Segmenten. Für dieses Projekt entscheide ich mich für die größere Version, da sie nicht nur besser lesbar ist, sondern durch die unterschiedlichen Farben auch optisch ansprechender wirkt und das Projekt aufwertet.

Ausbau einer LED In der Schaltung kommen drei LEDs zum Einsatz, die sich durch ihre hohe Leuchtkraft und lange Lebensdauer auszeichnen. Sie dienen nicht nur als Statusanzeige, sondern ermöglichen auch eine visuelle Rückmeldung über den aktuellen Betriebszustand der Timerschaltung. Die LEDs werden über einen GPIO-Pin des ESP32-C3 Mini angesteuert und mit einem 220-Ohm-Vorwiderstand in Reihe geschaltet, um den Stromfluss zu begrenzen und die Lebensdauer der LEDs zu erhöhen. Durch diese Beschaltung ist sichergestellt, dass die LEDs effizient betrieben werden, ohne den Mikrocontroller zu überlasten. Beim Einbau einer LED ist darauf zu achten, dass sie richtig gepolt angeschlossen wird. Die Kathode (Minuspol) wird mit dem Vorwiderstand verbunden, der anschließend an GND führt. Die Anode (Pluspol) hingegen wird direkt mit dem entsprechenden GPIO-Pin des ESP32-C3 Mini verbunden. Eselsbrücke: Die Kathode erkennt man am kürzeren Bein der LED.

Aufbau einer LED Falls du mehr über die Funktionsweise und den Anschluss von LEDs erfahren möchtest, findest du eine detaillierte Erklärung auf der Seite "Bauteile: Leuchtdiode (LED)", wo ich dieses Bauteil ausführlich vorstelle.

Programmieren in der Arduino IDE

Wie bereits erwähnt, habe ich dieses kleine Projekt zuvor für den Arduino entwickelt und programmiert. Dadurch war die Portierung auf den ESP32-C3 Mini relativ unkompliziert – es mussten lediglich die Pinbelegungen angepasst werden. Eine zusätzliche Optimierung bestand darin, die Start- und Stopp-Funktion auf einen einzigen Taster zu legen, anstatt zwei separate Taster zu verwenden. Dadurch spart man nicht nur einen GPIO-Pin, sondern macht die Bedienung auch kompakter und effizienter. Dies ist besonders vorteilhaft, da der ESP32-C3 Mini im Vergleich zu einem klassischen Arduino weniger verfügbare GPIOs hat. Programm: Timerschaltung am ESP32-C3 Mini in der Arduino IDEHerunterladen fertiges Programm für eine Timerschaltung am ESP32-C3 Mini /* * Autor: Stefan Draeger * Webseite: https://draeger-it.blog * Beitrag: https://draeger-it.blog/esp32-c3-mini-die-perfekte-basis-fuer-eine-moderne-timerschaltung/ * * Beschreibung: * Diese Firmware steuert eine Timerschaltung mit einer 7-Segment-Anzeige (TM1637), * Tastern zur Zeiteinstellung, LEDs zur Statusanzeige und einem akustischen Alarm über einen Buzzer. * Die Zeit kann in Sekunden oder Minuten eingestellt und per Start/Stopp-Taste gesteuert werden. * * Funktionen: * - Anzeige der verbleibenden Zeit auf einer TM1637 7-Segment-Anzeige * - Steuerung der Zeit über Taster (Erhöhung/Verringerung in Sekunden oder Minuten) * - Akustischer Alarm nach Ablauf des Timers mit abwechselnden LED-Signalen * - Speicherung und Aktualisierung des Timers in der Loop * - Start/Stopp-Funktion für den Timer */ #include // Bibliothek für 7-Segment-Anzeige TM1637 #include // Bibliothek für die Taster-Entprellung // Definition der LED-Pins #define led1 20 #define led2 21 // Definition der Pins für die 7-Segment-Anzeige (TM1637) #define segmentanzeige_CLK 3 #define segmentanzeige_DIO 4 TM1637Display display(segmentanzeige_CLK, segmentanzeige_DIO); // Anzeige-Objekt erstellen // Definition der Taster-Pins #define tasterStartStopp 5 #define tasterPlus 6 #define tasterMinus 7 #define tasterSelect 8 // Taster-Objekte für die Entprellung Bounce bceTasterStartStopp = Bounce(); Bounce bceTasterPlus = Bounce(); Bounce bceTasterMinus = Bounce(); Bounce bceTasterSelect = Bounce(); // Definition der Pins für Buzzer und Status-LED #define buzzerLeft 10 #define buzzerRight 2 #define statusLed 9 // Variablen für die Timer-Logik unsigned int timeAuswahl = 0; // Auswahlmodus für Zeit (Sekunden/Minuten) unsigned int seconds = 0; // Aktuelle Zeit in Sekunden const unsigned int PAUSE = 1000; // Zeitintervall für Timer-Update (1 Sekunde) const unsigned int PAUSE_ALARM = 250; // Zeitintervall für Alarmton unsigned long lastAction = 1L; // Zeitstempel für letzte Aktion bool clockStarted = false; // Timer läuft oder nicht bool clockAlarm = false; // Alarmstatus bool lastStateLED = false; // Zustand der LEDs für Alarm void setup() { // Setzt die Pin-Modi für LEDs, Buzzer und Status-LED pinMode(led1, OUTPUT); pinMode(led2, OUTPUT); pinMode(buzzerLeft, OUTPUT); pinMode(buzzerRight, OUTPUT); pinMode(statusLed, OUTPUT); // Helligkeit der 7-Segment-Anzeige einstellen (0-7, hier maximale Helligkeit) display.setBrightness(7); // Anzeige mit allen Segmenten aktivieren (zum Test) uint8_t data = { 0xff, 0xff, 0xff, 0xff }; display.setSegments(data); // Taster mit Pullup-Widerständen initialisieren und Entprellzeit setzen bceTasterStartStopp.attach(tasterStartStopp, INPUT_PULLUP); bceTasterStartStopp.interval(5); bceTasterPlus.attach(tasterPlus, INPUT_PULLUP); bceTasterPlus.interval(5); bceTasterMinus.attach(tasterMinus, INPUT_PULLUP); bceTasterMinus.interval(5); bceTasterSelect.attach(tasterSelect, INPUT_PULLUP); bceTasterSelect.interval(5); // LEDs und Status-LED ausschalten digitalWrite(led1, LOW); digitalWrite(led2, LOW); digitalWrite(statusLed, LOW); displayTime(); // Startanzeige aktualisieren } // Zeigt die aktuelle Zeit auf der 7-Segment-Anzeige an void displayTime() { int minutes = seconds / 60; // Maximale Anzeige auf 99 Minuten begrenzen if (minutes > 99) { minutes = 99; } // Anzeige im Format MM:SS int fourDigitValue = (minutes * 100) + (seconds % 60); display.showNumberDecEx(fourDigitValue, 0b01000000, true, 4, 4); } // Reduziert die verbleibende Zeit um eine Sekunde void incrementTime() { unsigned long currentMillis = millis(); if ((lastAction + PAUSE) lastAction = currentMillis; if (seconds > 0) { seconds--; // Eine Sekunde abziehen if (seconds == 0) { clockAlarm = true; // Timer abgelaufen, Alarm aktivieren } } } displayTime(); } // Spielt einen akustischen Alarm ab und wechselt die LEDs void playAlarm() { unsigned long currentMillis = millis(); if ((lastAction + PAUSE_ALARM) lastAction = currentMillis; // Wechselton für den Alarm (zwei verschiedene Frequenzen) if (lastStateLED) { noTone(buzzerRight); tone(buzzerLeft, 1400); } else { noTone(buzzerLeft); tone(buzzerRight, 700, 175); } // LED-Zustand ändern, um visuelles Signal zu erzeugen digitalWrite(led1, lastStateLED); digitalWrite(led2, !lastStateLED); lastStateLED = !lastStateLED; } } void loop() { // Taster-Status aktualisieren bceTasterPlus.update(); bceTasterMinus.update(); bceTasterSelect.update(); // Wenn der Timer nicht läuft, kann die Zeit eingestellt werden if (!clockStarted) { bool buttonPressed = false; // Umschalten zwischen Sekunden- und Minutenmodus if (bceTasterSelect.fell()) { timeAuswahl = (timeAuswahl == 0) ? 1 : 0; } // Zeit erhöhen if (bceTasterPlus.fell()) { buttonPressed = true; if (timeAuswahl == 0) { seconds++; } else { seconds += 60; } } // Zeit verringern, falls Sekunden > 0 sind if (bceTasterMinus.fell() && seconds > 0) { buttonPressed = true; if (timeAuswahl == 0) { seconds--; } else { seconds -= 60; } } // Anzeige aktualisieren, falls sich die Zeit geändert hat if (buttonPressed) { displayTime(); } } // Falls der Timer läuft und der Alarm noch nicht aktiv ist, Zeit herunterzählen else if (clockStarted && !clockAlarm) { incrementTime(); } if (clockStarted && clockAlarm) { playAlarm(); } // Start/Stopp-Taster auslesen bceTasterStartStopp.update(); // Timer starten oder stoppen if (bceTasterStartStopp.fell()) { clockStarted = !clockStarted; clockAlarm = false; digitalWrite(statusLed, clockStarted); // LEDs zurücksetzen digitalWrite(led1, LOW); digitalWrite(led2, LOW); noTone(buzzerRight); noTone(buzzerLeft); } }

Aufbau der Schaltung mit EasyEDA

Die Platine habe ich in der Online Version von EasyEDA entwickelt, durch die große Bibliothek welche vom Hersteller und der Community gepflegt wird ist diese meine erste Wahl.

Das Hintergrundbild also quasi den "Wecker" habe ich mir recht günstig bei Etsy.com gekauft und somit sogar noch einen anderen Creator mit diesem Projekt unterstützt ;).

Ausblick

Als nächstes möchte ich dieses Projekt, wie bereits erwähnt, für das Jugendfreizeitzentrum Schöningen umsetzen. Besonders spannend daran ist, dass die Teilnehmer nicht nur das Löten auf einer Platine erlernen, sondern auch erste Erfahrungen im Programmieren sammeln können. Zudem lässt sich der Code erweitern, um beispielsweise die aktuelle Uhrzeit aus dem Internet über einen NTP-Server auf der Segmentanzeige darzustellen. Der ESP32-C3 Mini eröffnet dabei viele weitere Möglichkeiten für kreative Erweiterungen. Read the full article