Smarte Pflanzenbewässerung leicht gemacht: Der automatische Gärtner

Heute bauen wir uns ein einfaches automatisches Bewässerungssystem. Das Prinzip ist simpel: Ein Feuchtigkeitssensor misst durchgehend, wie trocken die Blumenerde ist. Sobald die Pflanze Durst hat, schaltet unser System eine kleine Wasserpumpe ein und gießt für uns. Wir verwenden dafür einen ESP32 (einen kompakten und sehr beliebten Mikrocontroller) und ein paar günstige Standard-Bauteile.

Was wir dafür brauchen (Stückliste)

Für dieses Projekt setzen wir auf Standard-Bauteile, die sich einfach verkabeln lassen:

• ESP32 Entwicklerboard (das Gehirn unseres Projekts)
• Kapazitiver Bodenfeuchtesensor (Version 1.2): Wichtig: Nimm keinen günstigen, resistiven Sensor mit zwei offenen Goldkontakten! Bei diesen fließt der Strom direkt durch die feuchte Erde. Das führt zu Oxidation (Rost) und der Sensor ist nach wenigen Wochen unbrauchbar. Der kapazitive Sensor misst die Feuchtigkeit über ein elektrisches Feld und hält ewig.
• 3,3V Relais-Modul: Das Relais dient als mechanischer Schalter. Da der ESP32 mit 3,3V Logikspannung arbeitet, muss das Relais-Modul explizit für 3,3V Steuersignale geeignet sein (am besten mit Optokoppler).
• 5V Mini-Tauchpumpe mit passendem Silikonschlauch.
• Freilaufdiode (z. B. 1N4007 oder 1N4001): Ein absolutes Muss, um die mechanischen Kontakte des Relais vor Funkenflug (beim Abschalten der Pumpe) zu schützen. Mehr Details siehe weiter unten.
• 5V USB-Netzteil (ausreichend stark, ca. 2 Ampere).

⚠️ Sicherheitshinweis: Wasser und Strom! Wir arbeiten hier in der Nähe von Wasser. Arbeite bei diesem Projekt ausschließlich mit ungefährlicher 5-Volt-Gleichspannung aus einem USB-Netzteil! Bringe niemals 230 Volt Netzspannung in die Nähe der Schaltung.

Der Verdrahtungsplan

Damit alles reibungslos läuft, müssen alle GND-Verbindungen (Ground / Masse / Minuspol) im System miteinander verbunden sein, um einen gemeinsamen Bezugspunkt zu haben.

Das Herzstück: Die Kalibrierung des Feuchtigkeitssensors

Bevor wir den Automatikbetrieb starten können, müssen wir dem ESP32 beibringen, was „knochentrocken“ und was „patschnass“ bedeutet.
Der analoge Eingang des ESP32 liest nämlich keine Prozentwerte aus, sondern nur rohe, ungenaue Digitalwerte zwischen 0 und 4095 (ADC-Werte). Da jeder Sensor und jede Eingangsspannung leicht variiert, müssen wir diese Werte selbst ermitteln.

Schritt-für-Schritt-Kalibrierung:

1. Den Sensor trocken messen: Lege den Sensor komplett trocken auf den Tisch. Er darf nichts berühren. Schließe den ESP32 an den PC an und lasse dir die rohen Werte des analogen Pins (GPIO 34) über den Seriellen Monitor anzeigen (analogRead(34)).
   • Notiere dir diesen Wert. Bei mir liegt er bei kapazitiven Sensoren an 3.3V im Bereich von 2400 bis 2500. Das ist dein Wert für 0 % Feuchtigkeit (VAL_DRY).
2. Den Sensor nass messen: Fülle ein Glas mit Wasser und stecke den Sensor bis zur markierten Grenze (die weiße Linie auf dem Board, auf keinen Fall die Elektronik oben ins Wasser tauchen!) hinein.
   • Lies erneut den analogen Wert im Seriellen Monitor ab. Du wirst sehen: Je nasser es wird, desto kleiner wird der gemessene Wert! Meist liegt er im Wasser bei ca. 600 bis 700. Das ist dein Wert für 100 % Feuchtigkeit (VAL_WET).

Lass dir die Sensorwerte gleich im Programm über den sogenannten „Seriellen Monitor“ der Arduino IDE anzeigen.

• Lege den Sensor trocken auf den Tisch und notiere dir die Zahl (z. B. 3100).
• Stelle den Sensor in ein Wasserglas und notiere dir diese Zahl (z. B. 1200). Diese beiden Zahlen trägst du gleich im Code ein.

Mit diesen beiden Werten nutzen wir im Programm die map()-Funktion. Sie übersetzt den gemessenen Sensorwert stufenlos in einen Prozentwert. Damit nichts schiefgeht, fangen wir Ausreißer (z.B. wenn der Sensor noch trockener wird als beim Testen) mit constrain() ab, damit wir keine Minuswerte oder 120 % angezeigt bekommen:

int sensorValue = analogRead(wertmessung);

int percent = map(sensorValue, VAL_DRY, VAL_WET, 0, 100);

percent = constrain(percent, 0, 100); // Begrenzt den Wert strikt zwischen 0 und 100%

Warum die Pumpe nicht stottern darf (Die Hysterese)

Stell dir vor, du sagst dem System: „Schalte bei 40 % Feuchtigkeit ein und bei 41 % aus.“ Sobald der erste Tropfen Wasser die Erde berührt, würde die Pumpe sofort wieder stoppen. Das Wasser versickert, der Wert fällt wieder auf 40 %, die Pumpe springt für einen Bruchteil einer Sekunde wieder an. Das stottert furchtbar! Wir programmieren stattdessen einen Puffer (eine Hysterese): Die Pumpe geht erst an, wenn die Erde wirklich durstig ist (unter 30 %), und pumpt dann gemütlich so lange, bis die Erde im Topf gut durchfeuchtet ist (über 60 %).

Der Code (C++ Sketch)

Hier ist das fertige Programm für die Arduino IDE. Es liest den Sensor aus, rechnet die rohen Zahlen mit der map()-Funktion in saubere 0 bis 100 Prozent um und steuert die Pumpe. Liegt auch auf https://github.com/prilchen

Passe einfach nur die beiden Werte bei VAL_DRY und VAL_WET mit deinen eigenen gemessenen Zahlen an und lade den Sketch hoch!

// Pin-Belegung festlegen
const int SENSOR_PIN = 34; // Hier ist der Sensor angeschlossen
const int RELAY_PIN = 23;  // Hier ist das Relais angeschlossen

// Achtung: Viele 3,3V Relais schalten "Active LOW" 
// Das heißt: 0 Volt schaltet das Relais EIN, 3.3 Volt schaltet es AUS.
const int RELAY_ON = LOW;  
const int RELAY_OFF = HIGH; 

// --- KALIBRIERUNG (Bitte mit deinen eigenen Werten anpassen!) ---
const int VAL_DRY = 2500; // gemessener Sensorwert an der trockenen Luft (0%)
const int VAL_WET = 600; // gemessener Sensorwert im Wasserglas (100%)

// Hysterese: Wann soll gegossen werden?
const int THRESHOLD_ON = 30;  // Pumpe AN, wenn Feuchtigkeit unter 30%
const int THRESHOLD_OFF = 60; // Pumpe AUS, wenn Feuchtigkeit über 60%

// Merkt sich, ob die Pumpe gerade läuft
bool pumpIsRunning = false;

void setup() {
  Serial.begin(115200); // Startet die Ausgabe für den PC

  // Relais-Pin als Ausgang setzen und zur Sicherheit sofort ausschalten
  pinMode(RELAY_PIN, OUTPUT);
  digitalWrite(RELAY_PIN, RELAY_OFF);

  Serial.println("Prilchen LABS: Automatischer Gärtner gestartet!");
}

void loop() {
  // 1. Rohwert vom Sensor messen
  int rawValue = analogRead(SENSOR_PIN);
  
  // 2. Den Rohwert in saubere 0 bis 100 Prozent umrechnen
  int percent = map(rawValue, VAL_DRY, VAL_WET, 0, 100);
  percent = constrain(percent, 0, 100); // Verhindert Werte wie -5% oder 110%

  // 3. Zur Kontrolle im Seriellen Monitor ausgeben
  Serial.print("Sensor-Rohwert: ");
  Serial.print(rawValue);
  Serial.print(" | Feuchtigkeit in der Erde: ");
  Serial.print(percent);
  Serial.println(" %");

  // 4. Pumpen-Logik (Die Hysterese)
  if (percent < THRESHOLD_ON && !pumpIsRunning) {
    // Erde ist zu trocken -> Pumpe einschalten
    digitalWrite(RELAY_PIN, RELAY_ON);
    pumpIsRunning = true;
    Serial.println("--> Erde zu trocken: Pumpe AN!");
  } 
  else if (percent > THRESHOLD_OFF && pumpIsRunning) {
    // Erde ist nass genug -> Pumpe ausschalten
    digitalWrite(RELAY_PIN, RELAY_OFF);
    pumpIsRunning = false;
    Serial.println("--> Erde nass genug: Pumpe AUS!");
  }

  // 2 Sekunden warten, dann erneut messen
  delay(2000); 
}

Kontrolle im Seriellen Monitor:

Hier sieht man deutlich wie beim giessen die Messwerte steigen und die Pumpe abschalten. Somit ist schon eure Lösung am Laufen.

Maximale Einstecktiefe

Die maximale Einstecktiefe entspricht der Länge des Sondenbereichs, also bei meinem Modul sind es maximal 7 cm bis zur angezeigten Sicherheitslinie. Die darüberliegende elektronik mus frei liegen. Weitere Details zum Modul siehe Kapazitiver Bodenfeuchtesensor – HSHL Mechatronik

Das war’s auch schon! Sobald der Code auf dem ESP32 läuft, arbeitet dein digitaler Gärtner völlig selbstständig.

Viel Spaß beim Nachbauen

Optional:

Detailierte Info zur Freilaufdiode

Die Diode arbeitet in dieser Schaltung als sogenannte Freilaufdiode und fungiert als elektronisches Überdruckventil, das dein Relais und den ESP32 vor dem sicheren Hitzetod rettet.

Das Problem: Der magnetische Rückschlag In der kleinen Wasserpumpe steckt ein Elektromotor, der aus einer Kupferspule besteht. Wenn Strom hindurchfließt, baut diese Spule ein Magnetfeld auf. Schaltest du nun das Relais plötzlich aus, wird der Stromkreis hart unterbrochen. Das Magnetfeld bricht schlagartig zusammen und erzeugt dabei extrem schnell einen heftigen Stromstoß (Induktionsspannung) in die entgegengesetzte Richtung.

Stell dir das wie bei einer Wasserleitung vor: Wenn das Wasser mit vollem Druck durch ein Rohr schießt und du den Hahn schlagartig zudrehst, knallt das Wasser mit seiner ganzen Wucht gegen das Ventil. Dieser enorme Druckanstieg (Druckschlag) kann Rohre platzen lassen.

Genau das passiert in unserer Schaltung. Obwohl wir nur ein kleines 5V-Netzteil nutzen, kann der Rückschlag der Motor-Spule kurzzeitig enorm hoch werden. Ohne Schutz würde dieser Blitz winzige Blitze (Funken) im Relais erzeugen und die Kontakte mit der Zeit wegbrennen, oder er schlägt rückwärts in den empfindlichen ESP32 ein und zerstört ihn.

Die Lösung: Das Bypass-Ventil Um das zu verhindern, klemmen wir die Diode parallel zur Pumpe – und zwar absichtlich „falsch herum“ (in Sperrrichtung).

• Im Normalbetrieb (Pumpe an): Der 5V-Strom kommt aus dem Netzteil, möchte zur Pumpe und drückt gegen den silbernen Ring der Diode. Da die Diode in diese Richtung wie eine Straßensperre wirkt, fließt der Strom ganz normal nur durch die Pumpe.
• Beim Ausschalten (Rückschlag): Das Relais klackt, der Strom ist weg, das Magnetfeld bricht zusammen und der gefährliche Stromstoß schießt rückwärts aus der Pumpe heraus. Jetzt trifft er die Diode von der schwarzen Seite. In diese Richtung ist die Straße frei! Die Diode öffnet sich und leitet den schädlichen Stromstoß einfach im Kreis durch die Motorspule selbst zurück, wo er sich innerhalb von Millisekunden gefahrlos totläuft.

Deine restliche Schaltung bekommt von diesem Mini-Gewitter überhaupt nichts mit.