#esp32-c3mini

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

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

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