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!
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.
Inhaltsverzeichnis
- Wie soll das kleine Projekt funktionieren?
- Die Schaltung – klein, aber effektiv
- Das Programm für den ESP32-C3 Mini im Detail
- Shelly Script: Automatisches Schalten per Füllstand
- Fazit & Ausblick
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.
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 OrdnungFAIL→ 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.
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.
ESP32-C3 Mini*
Der Mikrocontroller übernimmt die Auswertung des Schwimmschalters und stellt den Füllstand über eine HTTP-Schnittstelle bereit.
Dual-Color-LED* (gemeinsame Anode) mit zwei 220 Ω Widerständen*
Zur visuellen Anzeige des Füllstands: Grün = OK, Rot = Fass leer.
Zwei 2-fach Schraubklemmen*
Für den sicheren Anschluss externer Kabel, z. B. zur Spannungsversorgung und zum Schwimmschalter.
Diode 1N4001*
Dient als Verpolungsschutz für die Stromversorgung der Schaltung.
Lochrasterplatine*
Zur stabilen und dauerhaften Verdrahtung aller Komponenten – alternativ wäre auch ein Breadboard möglich.
AWG 18/20 Kabel*
Für die interne Verdrahtung der Bauteile auf der Platine.
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.
Schwimmschalter (magnetisch)*
Erkennt, ob ein bestimmter Wasserstand erreicht ist. Je nach Einbaulage öffnet oder schließt er einen Kontakt.
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());
HTTP-Schnittstelle bereitstellen
Der ESP32 startet einen Webserver auf Port 80. Wird die Adresse http://<IP-Adresse>/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();
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:
#include <WiFi.h> // WLAN-Funktionalität für den ESP32
#include <WebServer.h> // 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!