ESP32 Bewässerung: automatische Pflanzenbewässerung mit Web-Panel
ESP32 Bewässerung bauen: kapazitiver Bodenfeuchtesensor, Relais, Minipumpe, Web-Panel für Schwelle und Dauer, Kalibrierung, Deep Sleep, Trockenlaufschutz.
Eine ESP32 Bewässerung verbindet einen Sensor, der die Feuchte der Blumenerde misst, mit einer kleinen Wasserpumpe – so wird deine Pflanze im richtigen Moment gegossen, auch wenn du nicht zu Hause bist. Fällt die Bodenfeuchte unter den eingestellten Wert, lässt der ESP32 die Pumpe über ein Relais ein paar Sekunden laufen, wartet, bis das Wasser eingezogen ist, und misst erneut. Dank WLAN siehst du die Feuchte auf dem Handy und änderst Schwelle und Gießdauer über ein Web-Panel.
In dieser Anleitung gehen wir Schritt für Schritt vor: von der Kalibrierung des kapazitiven Bodenfeuchtesensors über einen kompletten Bewässerungs-Sketch mit Web-Panel bis zur Akku-Version mit Deep Sleep für Balkone ohne Steckdose. Außerdem geht es darum, die Schwelle je nach Pflanze zu wählen, die Pumpzeit aus der Fördermenge zu berechnen und – am wichtigsten – die Pumpe vor Trockenlauf zu schützen, wenn der Tank leer ist.

Wie funktioniert eine ESP32 Bewässerung?
Das System läuft in einer einfachen Schleife. Alle 10 Sekunden nimmt der ESP32 16 Messungen vom Sensor, bildet den Mittelwert und rechnet ihn in eine Feuchte zwischen 0 % (völlig trocken) und 100 % (im Wasser) um. Liegt die Feuchte unter deiner Schwelle, ist Wasser im Tank und seit dem letzten Gießen genug Zeit vergangen, läuft die Pumpe für die eingestellte Dauer. Danach beginnt eine Wartezeit, in der sich das Wasser in der Erde verteilt; vorher wird nicht erneut gegossen. Alle Einstellungen änderst du im Web-Panel, und der ESP32 speichert sie in seinem Flash.
| Bauteil | Aufgabe | Hinweis |
|---|---|---|
| ESP32 DevKit | Messen, entscheiden, Web-Panel bereitstellen | Nur 2,4-GHz-WLAN |
| Kapazitiver Bodenfeuchtesensor v1.2 | Wandelt die Bodenfeuchte in eine Analogspannung um | Korrodiert nicht; läuft mit 3,3–5,5 V |
| 1-Kanal-Relaismodul | Schaltet die Pumpe ein und aus | Ein Modell wählen, das mit 3,3 V schaltet |
| 3–6-V-Mini-Tauchpumpe und Schlauch | Fördert Wasser vom Tank in den Topf | Etwa 100–200 mA |
| Schwimmerschalter | Meldet einen leeren Tank | Schützt die Pumpe vor Trockenlauf |
| 5-V-Netzteil mit 2 A | Versorgt ESP32, Relais und Pumpe | Alle Massen verbunden |
| Diode 1N4007 oder 1N5819 | Fängt die Spannungsspitze beim Abschalten der Pumpe ab | Kathode an den Pluspol der Pumpe |
Kapazitiv oder resistiv? Der richtige Bodenfeuchtesensor
Billige resistive Sensoren (zwei Metallzinken wie eine Gabel) messen, indem sie Strom direkt durch die Erde schicken. Dieser Strom verursacht an den Zinken Elektrolyse: Nach wenigen Wochen korrodiert das Metall, die Werte driften, und Metallionen gelangen in die Erde. Beim kapazitiven Sensor liegen die Elektroden unter einer isolierenden Schicht und berühren die Erde elektrisch nicht; der Sensor misst, wie das Wasser in der Erde seine Kapazität verändert. Deshalb kann er monate- oder sogar jahrelang im Boden bleiben. Für eine dauerhaft laufende Bewässerung ist ein kapazitiver Sensor praktisch Pflicht. Einen ausführlichen Vergleich beider Typen findest du in Bodenfeuchtesensor.
Schaltplan: ESP32, Sensor, Relais und Pumpe
| Verbindung | ESP32-Pin | Hinweis |
|---|---|---|
| Sensor AOUT | GPIO 34 | ADC1-Kanal; auch bei aktivem WLAN lesbar |
| Sensor VCC | 3V3 (in der Akku-Version GPIO 25) | Am Akku nur während der Messung versorgt |
| Sensor GND | GND | Gemeinsame Masse |
| Relais IN | GPIO 26 | Die meisten Module schalten bei LOW |
| Relais VCC / GND | VIN (5 V) / GND | Die Relaisspule braucht 5 V |
| Schwimmerschalter | GPIO 27 und GND | INPUT_PULLUP; Kontakt geschlossen, solange Wasser da ist |
| Pumpe | 5 V, über Relais COM–NO | Der Pumpenstrom fließt nicht durch den ESP32 |
Beim Abschalten erzeugt der Pumpenmotor eine Gegenspannungsspitze, die den ESP32 zurücksetzen kann; schalte deshalb eine Diode in Sperrrichtung parallel zur Pumpe (Kathode an Plus) und setz nahe am 5-V-Eingang des ESP32 einen Kondensator mit 100–470 µF. Die Massen von Relaismodul, Pumpe und ESP32 müssen verbunden sein. Stell den Tank tiefer als den Topf und lass den Schlauch oberhalb des Wasserspiegels im Tank enden; sonst läuft das Wasser nach dem Abschalten durch den Saugheber-Effekt weiter, und der Topf läuft über. Wie man die Pumpe ansteuert, erklären wir ausführlich in Arduino Wasserpumpe.
Schritt 1: Sensor kalibrieren (Trocken- und Nasswert)
Jeder kapazitive Sensor, jede Kabellänge und jede Versorgungsspannung liefert leicht andere Werte; deshalb stellst du den Code auf die beiden Endwerte deines eigenen Sensors ein. Lade den folgenden Code hoch und öffne den seriellen Monitor mit 115200 Baud. Halte den Sensor zuerst in die Luft und notiere den Wert: Das ist RAW_DRY, also 0 %. Tauch den Sensor dann bis zur Markierung in ein Glas Wasser und notiere den neuen Wert: Das ist RAW_WET, also 100 %. Beim kapazitiven Sensor sinkt der Wert mit steigender Feuchte; den Prozentwert berechnest du mit Feuchte % = (RAW_DRY − Rohwert) × 100 / (RAW_DRY − RAW_WET).
1// Kalibrasyon: sensörü önce havada, sonra bardak suda tut / calibration: hold the sensor in air, then in a glass of water
2const int SOIL_PIN = 34; // sensör AOUT, ADC1 kanalı / sensor AOUT, an ADC1 channel
3
4void setup() {
5 Serial.begin(115200);
6}
7
8void loop() {
9 long sum = 0;
10 for (int i = 0; i < 16; i++) { // 16 ölçümün ortalaması / average of 16 readings
11 sum += analogRead(SOIL_PIN);
12 delay(5);
13 }
14 Serial.print("Ham deger / raw value: ");
15 Serial.println(sum / 16); // havada → RAW_DRY, suda → RAW_WET / in air → RAW_DRY, in water → RAW_WET
16 delay(1000);
17}| Zustand | Rohwert (Beispiel) | Feuchte (%) |
|---|---|---|
| In der Luft (völlig trocken) | ≈ 3000 | 0 (RAW_DRY) |
| Trockene Erde | ≈ 2500–2700 | 17–29 |
| Feuchte Erde (für die meisten Pflanzen ideal) | ≈ 1800–2200 | 46–69 |
| Frisch gegossene Erde | ≈ 1500–1700 | 74–86 |
| Im Wasserglas | ≈ 1250 | 100 (RAW_WET) |
Die richtige Gießschwelle für deine Pflanze
| Pflanzenart | Gießschwelle | Hinweis |
|---|---|---|
| Kakteen und Sukkulenten | 15–25 % | Erde fast ganz austrocknen lassen |
| Zimmerpflanzen (Efeutute, Monstera, Ficus) | 30–40 % | Wenn die oberen 2–3 cm trocken sind |
| Gemüse und Jungpflanzen (Tomate, Basilikum, Paprika) | 45–60 % | Erde immer leicht feucht halten |
| Farne und feuchtigkeitsliebende Pflanzen | 55–70 % | Nie ganz austrocknen lassen |
Zwei Einstellungen sind so wichtig wie die Schwelle: Pumpzeit und Wartezeit. Eine Minipumpe mit 100 l/h fördert theoretisch etwa 28 ml pro Sekunde; mit dünnem Schlauch und einigen Zentimetern Förderhöhe sind es in der Praxis eher 15–20 ml pro Sekunde. Am besten lässt du die Pumpe 10 Sekunden in einen Messbecher laufen und misst die echte Fördermenge. Für einen Topf mit 15 cm Durchmesser reichen pro Gießvorgang meist 80–150 ml, also 5–8 Sekunden. Die Wartezeit sorgt dafür, dass sich das Wasser in der Erde verteilt und den Sensor erreicht: Ohne sie ist der Sensor noch trocken, das System pumpt immer wieder und setzt den Topf unter Wasser. 30 Minuten sind ein guter Startwert.
Schritt 2: ESP32-Bewässerungscode mit Web-Panel
Der Haupt-Sketch erledigt die automatische Bewässerung und liefert zusätzlich ein kleines Panel fürs Handy. Es aktualisiert alle 3 Sekunden Feuchte, Pumpen- und Tankstatus sowie die Zeit seit dem letzten Gießen. Im Formular änderst du Schwelle, Pumpzeit und Wartezeit, und mit „Water now“ gießt du von Hand. Die Einstellungen landen über die Bibliothek Preferences im Flash und bleiben auch nach einem Stromausfall erhalten. Klappt die WLAN-Verbindung nicht, läuft der Code nach 20 Sekunden trotzdem weiter, und die automatische Bewässerung arbeitet normal. Trag die beiden Kalibrierwerte in die Zeilen RAW_DRY und RAW_WET ein:
1#include <WiFi.h>
2#include <WebServer.h>
3#include <Preferences.h>
4
5const char* ssid = "AgAdi"; // Wi-Fi adın / your Wi-Fi name
6const char* password = "Sifre123"; // Wi-Fi şifren / your Wi-Fi password
7
8const int SOIL_PIN = 34; // sensör AOUT (ADC1) / sensor AOUT (ADC1)
9const int RELAY_PIN = 26; // röle IN / relay IN
10const int FLOAT_PIN = 27; // şamandıra, diğer ucu GND / float switch, other leg to GND
11const bool RELAY_ACTIVE_LOW = true; // çoğu röle modülü LOW'da çeker / most relay modules switch on LOW
12const int RAW_DRY = 3000; // havadaki değer (%0) / reading in air (0%)
13const int RAW_WET = 1250; // sudaki değer (%100) / reading in water (100%)
14
15WebServer server(80);
16Preferences prefs;
17
18int threshold = 35; // bu nemin altında sula (%) / water below this moisture (%)
19int durationS = 5; // pompa süresi (sn) / pump run time (s)
20int soakMin = 30; // iki sulama arası bekleme (dk) / soak time between waterings (min)
21
22int moisture = 0; // son nem (%) / last moisture (%)
23bool pumpOn = false, tankLow = false, everWatered = false;
24unsigned long pumpStart = 0, lastWater = 0, lastCheck = 0;
25
26const char PAGE[] PROGMEM = R"HTML(<!DOCTYPE html><html><head><meta charset="utf-8">
27<meta name="viewport" content="width=device-width,initial-scale=1"><title>ESP32 Sulama</title>
28<style>body{font-family:sans-serif;margin:16px;max-width:420px}input{width:70px}button{padding:8px 14px;margin-top:8px}</style></head>
29<body><h2>ESP32 Sulama / Watering</h2>
30<p>Nem / Moisture: <b id="m">--</b> %</p>
31<p>Pompa / Pump: <b id="p">--</b> · Depo / Tank: <b id="k">--</b></p>
32<p>Son sulama / Last watering: <b id="l">--</b></p>
33<form action="/save" method="POST">
34<p>Esik / Threshold (%): <input name="th" type="number" min="5" max="90" value="%TH%"></p>
35<p>Sure / Duration (s): <input name="du" type="number" min="1" max="60" value="%DU%"></p>
36<p>Bekleme / Soak (min): <input name="so" type="number" min="1" max="720" value="%SO%"></p>
37<button>Kaydet / Save</button></form>
38<form action="/water" method="POST"><button>Simdi sula / Water now</button></form>
39<script>
40function upd() {
41 fetch('/data').then(r => r.json()).then(d => {
42 document.getElementById('m').textContent = d.m;
43 document.getElementById('p').textContent = d.p ? 'ON' : 'OFF';
44 document.getElementById('k').textContent = d.k ? 'BOS / EMPTY' : 'OK';
45 document.getElementById('l').textContent = d.l < 0 ? '--' : Math.round(d.l / 60) + ' dk / min';
46 });
47}
48upd(); setInterval(upd, 3000);
49</script></body></html>)HTML";
50
51void setPump(bool on) {
52 pumpOn = on;
53 digitalWrite(RELAY_PIN, (on != RELAY_ACTIVE_LOW) ? HIGH : LOW);
54}
55
56bool waterAvailable() { // şamandıra yukarıda: kontak kapalı, LOW / float up: contact closed, LOW
57 return digitalRead(FLOAT_PIN) == LOW;
58}
59
60int readMoisture() {
61 long sum = 0;
62 for (int i = 0; i < 16; i++) { sum += analogRead(SOIL_PIN); delay(5); }
63 int pct = map(sum / 16, RAW_DRY, RAW_WET, 0, 100); // kuru → 0, ıslak → 100 / dry → 0, wet → 100
64 return constrain(pct, 0, 100);
65}
66
67void startWatering() {
68 if (pumpOn || !waterAvailable()) return; // su yoksa pompayı asla çalıştırma / never run the pump dry
69 setPump(true);
70 pumpStart = lastWater = millis();
71 everWatered = true;
72}
73
74void handleRoot() {
75 String page = PAGE;
76 page.replace("%TH%", String(threshold));
77 page.replace("%DU%", String(durationS));
78 page.replace("%SO%", String(soakMin));
79 server.send(200, "text/html", page);
80}
81
82void handleData() {
83 long ago = everWatered ? (long)((millis() - lastWater) / 1000) : -1;
84 server.send(200, "application/json", "{\"m\":" + String(moisture) + ",\"p\":" + String(pumpOn ? 1 : 0) +
85 ",\"k\":" + String(tankLow ? 1 : 0) + ",\"l\":" + String(ago) + "}");
86}
87
88void handleSave() {
89 threshold = constrain(server.arg("th").toInt(), 5, 90);
90 durationS = constrain(server.arg("du").toInt(), 1, 60);
91 soakMin = constrain(server.arg("so").toInt(), 1, 720);
92 prefs.putInt("th", threshold); // flaşa kaydet, elektrik kesilse de kalır / saved to flash, survives power cuts
93 prefs.putInt("du", durationS);
94 prefs.putInt("so", soakMin);
95 server.sendHeader("Location", "/");
96 server.send(303);
97}
98
99void handleWater() {
100 startWatering(); // elle sulama / manual watering
101 server.sendHeader("Location", "/");
102 server.send(303);
103}
104
105void setup() {
106 Serial.begin(115200);
107 pinMode(RELAY_PIN, OUTPUT);
108 setPump(false); // açılışta pompa kapalı / pump off at boot
109 pinMode(FLOAT_PIN, INPUT_PULLUP);
110 prefs.begin("sulama", false);
111 threshold = prefs.getInt("th", threshold);
112 durationS = prefs.getInt("du", durationS);
113 soakMin = prefs.getInt("so", soakMin);
114
115 WiFi.mode(WIFI_STA);
116 WiFi.begin(ssid, password);
117 for (int i = 0; i < 40 && WiFi.status() != WL_CONNECTED; i++) delay(500); // en fazla 20 sn bekle / wait 20 s at most
118 Serial.print("IP: ");
119 Serial.println(WiFi.localIP()); // Wi-Fi yoksa da sulama çalışır / watering works even without Wi-Fi
120
121 server.on("/", handleRoot);
122 server.on("/data", handleData);
123 server.on("/save", HTTP_POST, handleSave);
124 server.on("/water", HTTP_POST, handleWater);
125 server.begin();
126}
127
128void loop() {
129 server.handleClient();
130 unsigned long now = millis();
131 if (pumpOn) {
132 tankLow = !waterAvailable();
133 if (now - pumpStart >= (unsigned long)durationS * 1000UL || tankLow) setPump(false); // süre ya da su bitti / time or water ran out
134 }
135 if (now - lastCheck >= 10000) { // 10 sn'de bir kontrol / check every 10 s
136 lastCheck = now;
137 moisture = readMoisture();
138 tankLow = !waterAvailable();
139 bool soaked = !everWatered || now - lastWater >= (unsigned long)soakMin * 60000UL;
140 if (!pumpOn && !tankLow && moisture < threshold && soaked) startWatering();
141 Serial.printf("Nem / Moisture: %d %% Depo / Tank: %s\n", moisture, tankLow ? "BOS / EMPTY" : "OK");
142 }
143}| Codeteil | Was er macht |
|---|---|
| RAW_DRY / RAW_WET | Die beiden Endwerte aus der Kalibrierung |
| map() + constrain() | Rechnet den Rohwert in 0–100 % um und begrenzt ihn |
| Preferences | Speichert Schwelle, Pumpzeit und Wartezeit im Flash |
| soakMin | Wartet zwischen zwei Gießvorgängen, bis sich das Wasser verteilt hat |
| waterAvailable() | Meldet der Schwimmer einen leeren Tank, startet die Pumpe nicht oder stoppt sofort |
| /save und /water | Speichern die Formulareinstellungen und starten das Gießen von Hand |
Öffne nach dem Hochladen die IP-Adresse aus dem seriellen Monitor auf einem Handy im selben WLAN. Je nach Einbaulage des Schwimmerschalters kann der Kontakt bei vorhandenem Wasser auch offen sein; zeigt das Panel den Tank immer als „EMPTY“, ändere in waterAvailable() LOW in HIGH. Das Panel hat kein Passwort, nutze es also nur im Heimnetz; wenn du statt der IP eine einprägsame Adresse und eine lebendigere Oberfläche möchtest, ergänze die Methoden aus ESP32 Async Webserver und WebSocket.
Die Pumpe schützen, wenn das Wasser ausgeht
Mini-Tauchpumpen werden vom durchfließenden Wasser gekühlt und geschmiert. Laufen sie trocken, werden sie innerhalb weniger Minuten heiß, Dichtungen und Laufrad verschleißen; eine Pumpe, die einen ganzen Urlaub lang im leeren Tank läuft, ist meist hinüber. Eine gute Bewässerung schützt die Pumpe deshalb mehrstufig:
- Schwimmerschalter: Sinkt das Wasser im Tank unter eine bestimmte Höhe, öffnet der Kontakt, und der Code startet die Pumpe gar nicht erst; geht das Wasser während des Gießens aus, stoppt er sie sofort. Details zum Anschluss in Schwimmerschalter.
- Zeitlimit: Die Pumpe läuft nie länger als die eingestellte Zeit (höchstens 60 s); die Software schaltet sie in jedem Fall ab.
- Wartezeit: Zwischen zwei Gießvorgängen vergehen mindestens soakMin Minuten; ein defekter Sensor kann das System also nicht zum Dauergießen bringen.
- Kontrolle des Feuchteanstiegs: Ist die Feuchte nach dem Gießen nicht gestiegen, kannst du einen Fehlerzähler führen; nach drei erfolglosen Versuchen stoppst du die Automatik und schickst eine Warnung per Telegram-Bot. Das hilft, wenn der Schlauch herausgerutscht ist oder der Sensor nicht mehr in der Erde steckt.
- Berührungsloser Füllstandssensor: Statt eines Schwimmers misst ein XKC-Y25 von außen durch die Tankwand, und kein Teil muss ins Wasser.
Akkubetriebene Bewässerung mit Deep Sleep
Um das System auf einem Balkon oder im Garten ohne Steckdose mit Akku zu betreiben, schickst du den ESP32 zwischen den Messungen in den Deep Sleep. Die folgende Version verzichtet auf das Web-Panel, denn dauerhaftes WLAN würde den Akku in wenigen Tagen leeren. Das Board wacht alle 30 Minuten auf, versorgt den Sensor nur während der Messung über GPIO 25, lässt bei Bedarf die Pumpe laufen und schläft wieder ein. Weck- und Gießzähler liegen mit RTC_DATA_ATTR im RTC-Speicher und überstehen so den Schlaf. In der Akku-Version zieht eine 5-V-Relaisspule viel Strom und zieht bei niedriger Spannung womöglich nicht an; besser treibst du die Pumpe mit einem Logic-Level-MOSFET, Details in MOSFET am Arduino.
1// Pilli sürüm: 30 dk'da bir uyan, ölç, gerekirse sula, uyu / battery version: wake every 30 min, measure, water if needed, sleep
2const int SOIL_PIN = 34; // sensör AOUT / sensor AOUT
3const int SENSOR_PWR = 25; // sensör VCC bu pinden / sensor VCC from this pin
4const int PUMP_PIN = 26; // röle IN ya da MOSFET gate / relay IN or MOSFET gate
5const int FLOAT_PIN = 27; // şamandıra / float switch
6const bool PUMP_ACTIVE_LOW = true; // MOSFET kullanıyorsan false / false if you use a MOSFET
7const int RAW_DRY = 3000, RAW_WET = 1250;
8const int THRESHOLD = 35; // %
9const int DURATION_S = 5; // sn / s
10const uint64_t SLEEP_US = 30ULL * 60 * 1000000; // 30 dakika / 30 minutes
11
12RTC_DATA_ATTR int wakeCount = 0; // deep sleep'te silinmez / survives deep sleep
13RTC_DATA_ATTR int waterCount = 0;
14
15void pump(bool on) {
16 digitalWrite(PUMP_PIN, (on != PUMP_ACTIVE_LOW) ? HIGH : LOW);
17}
18
19void setup() {
20 Serial.begin(115200);
21 wakeCount++;
22 pinMode(PUMP_PIN, OUTPUT);
23 pump(false);
24 pinMode(FLOAT_PIN, INPUT_PULLUP);
25 pinMode(SENSOR_PWR, OUTPUT);
26 digitalWrite(SENSOR_PWR, HIGH); // sensörü yalnız ölçerken aç / power the sensor only while measuring
27 delay(200); // çıkışın oturmasını bekle / let the output settle
28 long sum = 0;
29 for (int i = 0; i < 16; i++) { sum += analogRead(SOIL_PIN); delay(5); }
30 digitalWrite(SENSOR_PWR, LOW);
31 int pct = constrain(map(sum / 16, RAW_DRY, RAW_WET, 0, 100), 0, 100);
32 bool water = digitalRead(FLOAT_PIN) == LOW;
33 Serial.printf("Uyanma / Wake %d: nem / moisture %d %%, depo / tank %s, sulama / waterings %d\n",
34 wakeCount, pct, water ? "OK" : "BOS / EMPTY", waterCount);
35
36 if (pct < THRESHOLD && water) {
37 pump(true);
38 unsigned long start = millis();
39 while (millis() - start < DURATION_S * 1000UL && digitalRead(FLOAT_PIN) == LOW) delay(10); // su biterse hemen dur / stop at once if the tank empties
40 pump(false);
41 waterCount++;
42 }
43 esp_sleep_enable_timer_wakeup(SLEEP_US);
44 esp_deep_sleep_start(); // uyanınca setup() baştan başlar / wakes up into setup()
45}
46
47void loop() {
48}Über die Akkulaufzeit entscheidet vor allem der Schlafstrom des Boards. Ein gewöhnliches ESP32 DevKit zieht wegen Spannungsregler und USB-Seriell-Chip im Schlaf 5–10 mA: Bei 10 mA hält ein 3000-mAh-Akku nur 300 Stunden, also rund 12 Tage. Mit einem stromsparenden Board, das im Schlaf 0,15 mA braucht, sieht es anders aus: 48 Aufwachvorgänge pro Tag (je 0,5 Sekunden mit 50 mA), 0,15 mA Schlafstrom und ein 5-Sekunden-Pumpenlauf pro Tag ergeben zusammen etwa 4,3 mAh; derselbe Akku hielte theoretisch fast zwei Jahre, in der Praxis begrenzt die Selbstentladung das auf einige Monate. Rechne mit deinen Werten im Tool Akkulaufzeit; wie du den Schlafstrom senkst, steht in ESP32 Deep Sleep.
Projektideen und Erweiterungen
- Mehrere Töpfe: Gib jedem Topf einen eigenen Sensor und eine eigene Pumpe; die ADC1-Pins des ESP32 reichen für bis zu sechs Töpfe.
- Benachrichtigungen: Schick dir per Telegram eine Nachricht, wenn der Tank leer ist oder die Erde zu lange trocken bleibt.
- Feuchte-Protokoll: Speichere die Messwerte in Google Sheets und sieh im Diagramm, wie oft deine Pflanze Wasser braucht.
- Solarbetrieb: Lade den Akku tagsüber mit einem kleinen Solarmodul und einem TP4056.
- Regenprüfung: Im Freien einen Regensensor ergänzen und bei Regen nicht gießen.
- Smartes Gewächshaus: Mit Temperatur, Luftfeuchte und Lüfter wird daraus ein Gewächshaus-Projekt.
Häufige Fehler und Lösungen
| Symptom | Wahrscheinliche Ursache | Lösung |
|---|---|---|
| Feuchte immer 0 % oder unverändert | Sensor an ADC2-Pin bei aktivem WLAN | Sensor an einen der GPIO 32–39 legen |
| Werte springen ständig | Störungen oder Sensor sitzt schlecht in der Erde | 16 Messungen mitteln, Sensor fest eindrücken |
| ESP32 startet beim Pumpen neu | Spannungseinbruch, keine Diode | Diode und 470-µF-Kondensator ergänzen, 2-A-Netzteil verwenden |
| Relais fällt nie ab | 5-V-Relais erkennt das 3,3-V-HIGH nicht | 3,3-V-taugliches Relais oder MOSFET nutzen, RELAY_ACTIVE_LOW prüfen |
| Topf läuft über | Wartezeit zu kurz oder Saugheber-Effekt | soakMin erhöhen, Schlauchende über den Wasserspiegel legen |
| Pumpe läuft, aber es kommt kein Wasser | Luft in der Pumpe oder Tank leer | Pumpe ganz untertauchen, Schwimmer prüfen |
| Einstellungen nach Stromausfall weg | Werte werden nicht im Flash gespeichert | Prüfen, dass die Zeilen mit prefs.putInt() ausgeführt werden |
Weil sie Messen, Entscheiden, Sicherheit und Fernsteuerung in einem Projekt vereint, ist diese ESP32 Bewässerung auch ein toller Einstieg in die Hausautomation. Wenn du eine Bewässerungsschaltung Schritt für Schritt sehen willst, findest du in der BlueGrays-App beim Projekt Intelligente Bewässerungsstation den Schaltplan und fertigen Code für eine Arduino-Version.
Häufige Fragen
Wie baue ich eine automatische Bewässerung mit dem ESP32?
Schließ einen kapazitiven Bodenfeuchtesensor an einen ADC1-Pin des ESP32 und ein Relaismodul an einen Digitalpin an, und versorge die Minipumpe über das Relais aus einem separaten 5-V-Netzteil. Kalibriere den Sensor in Luft und Wasser und leg im Code eine Feuchteschwelle fest; fällt die Feuchte darunter, läuft die Pumpe einige Sekunden, und das System wartet, bis das Wasser eingezogen ist.
An welchen ESP32-Pin kommt der Bodenfeuchtesensor?
Schließ den Analogausgang an einen der ADC1-Pins GPIO 32 bis 39 an; in dieser Anleitung nutzen wir GPIO 34. ADC2-Pins lassen sich bei aktivem WLAN nicht mit analogRead() lesen, deshalb gehört der Sensor in WLAN-Projekten immer an ADC1.
Ab wie viel Prozent Bodenfeuchte sollte man gießen?
Das hängt von der Pflanze ab: 15–25 % für Kakteen und Sukkulenten, 30–40 % für die meisten Zimmerpflanzen und 45–60 % für Gemüse wie Tomaten und Basilikum sind gute Startwerte. Da die Prozente von der Kalibrierung abhängen, beobachte die Pflanze ein paar Tage und passe die Schwelle an.
Pumpe mit Relais oder MOSFET schalten?
Bei einem Aufbau mit Netzteil ist ein Relaismodul, das mit 3,3 V schaltet, praktisch und sicher. Für Akkubetrieb oder wenn du die Pumpendrehzahl per PWM regeln willst, braucht ein Logic-Level-MOSFET weniger Strom und arbeitet lautlos; in beiden Fällen gehört eine Freilaufdiode an die Pumpe.
Geht eine Minipumpe bei Trockenlauf kaputt?
Ja. Mini-Tauchpumpen werden vom durchfließenden Wasser gekühlt und geschmiert und überhitzen und verschleißen trocken innerhalb von Minuten. Ein Schwimmerschalter oder ein berührungsloser Füllstandssensor im Tank, der die Pumpe per Software stoppt, ist der einfachste Schutz.
Wie lange läuft eine ESP32-Bewässerung mit Akku?
Mit dauerhaft aktivem WLAN ist der Akku nach wenigen Tagen leer. Mit Deep Sleep hängt es vom Schlafstrom des Boards ab: Ein gewöhnliches DevKit mit 10 mA im Schlaf schafft mit 3000 mAh etwa 12 Tage, ein sparsames Board mit 0,15 mA hält monatelang.
Projekte, die du danach bauen kannst
Alle Projekte ansehen
Intelligente Bewässerungsstation
Ein Gärtner, der deine Pflanzen von selbst gießt, damit sie im Urlaub nicht vertrocknen.

ESP32 Async-Webserver (mit IP-Anzeige auf dem LCD)
Wir machen den ESP32 zu einem asynchronen Webserver, den du per Handy oder Computer im selben WLAN steuerst. Dank der Bibliothek ESPAsyncWebServer verarbeitet der Server mehrere Anfragen gleichzeitig (er blockiert nicht wie das klassische WebServer.h bei einer einzigen Anfrage). Öffne im Browser die IP-Adresse des ESP32 und schalte mit den Tasten ON/OFF (Adressen /on und /off) die LED an GPIO 5 ein und aus.

ESP32-WLAN-STA-Verbindung (mit LCD-Display)
In diesem Projekt verbinden wir den ESP32 im Station-Modus (STA) sicher und fehlertolerant mit dem heimischen WLAN. Wir lagern SSID und Passwort in eine separate secrets.h-Datei aus, um Leaks zu Git zu verhindern, richten einen Auto-Reconnect-Mechanismus ein und zeigen RSSI-Signalpegel und IP-Adresse auf einem I2C-LCD-Display an. Die interne LED dient als Statusanzeige. Ein Verbindungsmanager auf Produktionsniveau.

ESP32 Deep Sleep – Batteriesparmodus (OLED + RTC-RAM-Zähler)
Im Deep-Sleep-Modus schaltet der ESP32 die CPU und die meisten Peripheriegeräte ab und senkt den Strom auf etwa 10µA, entscheidend für batteriebetriebene IoT-Geräte. Das Projekt nutzt drei Weckquellen: einen Timer (15 s), einen externen Pin (EXT0, Taster an GPIO 33) und einen Touch-Pin (T0/GPIO 4). Mit RTC_DATA_ATTR markierte Zähler bleiben im Deep Sleep erhalten.

ESP32 DHT22 Temperatur und Luftfeuchtigkeit (mit LCD-Display)
Bei diesem Projekt werden die Umgebungstemperatur und die Luftfeuchtigkeit mit einem DHT22-Sensor gemessen und in Echtzeit auf einem 16x2 I2C-LCD angezeigt. Mithilfe der Adafruit-DHT-Bibliothek werden die Daten über das One-Wire-Protokoll vom Sensor ausgelesen. Dieses Projekt bildet die Grundlage für IoT-Wetterstationen, Smart-Home-Automatisierung oder Umgebungsüberwachungssysteme in Gewächshäusern. Die Kommunikation mit dem DHT22 erfolgt über den GPIO-4-Pin des ESP32.

ESP32 Intelligente Beleuchtung (PIR + LDR + Relais + OLED)
Mit ESP32, PIR-Bewegungssensor, LDR-Lichtsensor und Relaismodul machen wir aus Flur, Bad oder Vorratskammer eine smarte Beleuchtung. Ist es hell, bleibt das Licht trotz Bewegung aus, so brennt es tagsüber nicht umsonst und spart Energie. Das Licht bleibt 30 Sekunden an; solange Bewegung erkannt wird, verlängert sich die Zeit automatisch.

ESP32 Temperatur-Datenlogger (DHT22 + DS1307 RTC + microSD + OLED)
Bau mit dem ESP32 einen zeitgesteuerten Temperatur- und Feuchtigkeitslogger! Ein DHT22 misst einmal pro Minute Temperatur und Luftfeuchtigkeit; jeder Wert landet mit einem Zeitstempel des RTC-Moduls DS1307 im CSV-Format auf einer microSD-Karte. Das OLED zeigt live und in großer Schrift die letzte Temperatur, die Luftfeuchtigkeit, den Zeitstempel und die Zahl der Einträge.
Weitere Artikel
BlueGrays-App
Diese Schaltung Schritt für Schritt auf dem Handy nachbauen
Schaltplan, Code und Teileliste auf einem Bildschirm. Über 500 Arduino-, ESP32- und Pico-Projekte zum Nachbauen.
Mit dem Handy scannen
Richte die Kamera auf den Code, dann öffnet sich der App-Store deines Handys.
oder im Store öffnen

