Automatische Pflanzenbewässerung

Wenn du deinem Arduino mehr vertraust als deinem grünen Daumen, ist dieses Projekt das richtige für dich. Ein Sensor kontrolliert die Feuchtigkeit im Boden – sobald ein bestimmter Wert unterschritten wird, springt eine Wasserpumpe an und gießt deine Pflanze. Ist der Boden wieder feucht genug, stoppt dein Arduino die Pumpe.

Aufbau des Projekts mit dem Arduino UNO

Für deine automatische Pflanzenbewässerung benötigst du neben einem Arduino einen Feuchtigkeitssensor, eine Wasserpumpe, ein 5V-Relais und eine Box für vier Batterien mit 1,5 V. Das können wie auf dem Bild unten AAA-Batterien sein, ich selbst habe den gängigen Typ AA verwendet. Die Extra-Batterien benötigst du, weil dein Arduino nicht genug Strom für die Wasserpumpe liefert.

Das Breadboard benötigst du nur, um die Erde und die 5V vom Arduino an den Sensor und das Relais weiterzuleiten – du kannst dir hierfür natürlich auch eine andere Lösung überlegen.

Orientiere dich beim Aufbau des Projekts an obiger Skizze. Ein Hinweis zum Relais: Die Belegung der Pins kann bei deinem Modell variieren – achte darauf den richtigen Pin für das Signal mit deinem Arduino zu verbinden.

So funktioniert das Projekt

Bevor wir uns dem Sketch zuwenden, zunächst ein paar Worte zur Funktionsweise: Der Feuchtigkeitssensor steckt natürlich in der Erde der Pflanze, die du automatisch gießen lassen möchtest. Am Analogpin (blaues Kabel) liest dein Arduino den aktuellen Feuchtigkeitswert aus. Sobald ein von dir festgelegter Wert überschritten wird, sendet der Arduino ein Signal an das Relais (grünes Kabel).

Nun öffnet das Relais die Verbindung zwischen den Pins NO (Normally Open) und COM (Common Pin). Somit kann also der Strom von den Batterien zur Wasserpumpe fließen. Noch ein Hinweis zur Sicherheit: Ich rate dringend davon ab, Haushaltsgeräte, die nicht für Experimentieren mit Arduino & Co gedacht sind, über ein Relais zu steuern.

Die Pumpe selbst liegt im Wasser und beginnt nun selbiges über einen Schlauch in die Pflanzenerde zu pumpen. Hierdurch verringert sich der Feuchtigkeitswert (obwohl die Feuchtigkeit natürlich steigt). Sobald ein bestimmter Wert unterschritten wurde, die Erde also feucht genug ist, sendet dein Arduino das Signal an das Relais, die Verbindung zwischen Wasserpumpe und Batterien zu schließen.

Der Sketch für die Pflanzenbewässerung

Um dein Projekt in Betrieb zu nehmen, sind nur wenige Zeilen Code nötig. Kopiere den folgenden Sketch und lade ihn auf deinen Arduino:

const int humidityPin = A0;   // Feuchtigkeitssensor
const int pumpPin = 7;        // Signalpin zum Relais

// Einstellungen – hier passt du dein Projekt an:
const int schwellwert = 900;                      // ab diesem Wert wird gegossen (höher = trockener)
const unsigned long giessdauer = 3000;            // wie lange die Pumpe pro Gießvorgang läuft (in ms)
const unsigned long einweichPause = 1800000;      // Pause nach dem Gießen: 30 Minuten (in ms)
const unsigned long messIntervall = 2000;         // wie oft gemessen wird (in ms)

// Relais-Logik: Viele 5V-Relaismodule schalten "active LOW",
// d.h. LOW schaltet ein und HIGH aus. Läuft deine Pumpe genau
// verkehrt herum, tausche einfach die beiden Werte.
const int PUMPE_AN  = HIGH;
const int PUMPE_AUS = LOW;

// Die drei Phasen des Projekts
enum Zustand { MESSEN, GIESSEN, EINWEICHEN };
Zustand zustand = MESSEN;

unsigned long letzterWechsel = 0;   // Zeitpunkt des letzten Phasenwechsels
int humidity = 0;

void setup() {
  Serial.begin(9600);
  pinMode(humidityPin, INPUT);
  pinMode(pumpPin, OUTPUT);
  digitalWrite(pumpPin, PUMPE_AUS);   // Pumpe zu Beginn sicher ausschalten
}

void loop() {
  unsigned long jetzt = millis();

  switch (zustand) {

    case MESSEN:
      // Alle paar Sekunden den Feuchtigkeitswert prüfen
      if (jetzt - letzterWechsel >= messIntervall) {
        letzterWechsel = jetzt;
        humidity = analogRead(humidityPin);
        Serial.print("Feuchtigkeit: ");
        Serial.println(humidity);

        if (humidity > schwellwert) {
          Serial.println("Erde trocken - Pumpe an");
          digitalWrite(pumpPin, PUMPE_AN);
          zustand = GIESSEN;
          letzterWechsel = jetzt;
        }
      }
      break;

    case GIESSEN:
      // Pumpe läuft, bis die giessdauer erreicht ist
      if (jetzt - letzterWechsel >= giessdauer) {
        digitalWrite(pumpPin, PUMPE_AUS);
        Serial.println("Pumpe aus - Wasser einsickern lassen");
        zustand = EINWEICHEN;
        letzterWechsel = jetzt;
      }
      break;

    case EINWEICHEN:
      // Warten, bis das Wasser durchgesickert ist – ohne den Rest zu blockieren
      if (jetzt - letzterWechsel >= einweichPause) {
        zustand = MESSEN;
        letzterWechsel = jetzt;
      }
      break;
  }
}

Zuerst legst du die beiden Pins für den Feuchtigkeitssensor (A0) und das Relais (7) fest. Darunter folgen die Einstellungen, mit denen du dein Projekt anpasst: der schwellwert, ab dem gegossen wird (je höher, desto trockener die Erde), die giessdauer – also wie lange die Pumpe pro Durchgang läuft –, die einweichPause als Wartezeit nach dem Gießen und das messIntervall, das festlegt, wie oft der Sensor abgefragt wird.

Ein wichtiger Hinweis zur Relais-Logik: Viele der gängigen 5V-Relaismodule schalten „active LOW“. Das bedeutet, dass ein LOW-Signal die Pumpe ein– und ein HIGH-Signal sie ausschaltet – also genau umgekehrt zu dem, was man erwartet. Deshalb arbeitet der Sketch mit den beiden Konstanten PUMPE_AN und PUMPE_AUS. Läuft deine Pumpe verkehrt herum, tauschst du einfach deren Werte (HIGH und LOW) – am restlichen Code musst du nichts ändern.

Das Projekt durchläuft drei Phasen – MESSEN, GIESSEN und EINWEICHEN. Damit der Arduino während des Gießens und der langen Einweich-Pause nicht „einfriert“, steuern wir diese Phasen nicht mit delay(), sondern mit millis(). Diese Funktion gibt die Zeit in Millisekunden seit dem Start des Arduino zurück. Statt den Programmablauf anzuhalten, merken wir uns im letzterWechsel nur den Zeitpunkt des letzten Phasenwechsels und prüfen in jedem Durchlauf, ob seitdem genug Zeit vergangen ist. So bleibt der Arduino jederzeit ansprechbar – der Serielle Monitor läuft weiter und du könntest problemlos weitere Aufgaben ergänzen.

Im Setup startest du den Seriellen Monitor, legst den jeweiligen pinMode fest und schaltest die Pumpe mit digitalWrite(pumpPin, PUMPE_AUS) sicherheitshalber aus. So verhinderst du, dass die Pumpe beim Einschalten des Arduino kurz unkontrolliert anläuft.

Im Loop entscheidet die switch-Anweisung, was in der aktuellen Phase zu tun ist. In der Phase MESSEN liest der Arduino im Takt des messIntervall über analogRead() den Feuchtigkeitswert aus und zeigt ihn im Seriellen Monitor an – je trockener die Erde, desto höher der Wert. Man könnte fast von einem „Trockenheitswert“ sprechen. 😉 Überschreitet dieser den schwellwert, schaltet der Arduino die Pumpe ein und wechselt in die Phase GIESSEN.

In der Phase GIESSEN läuft die Pumpe genau so lange, wie es die giessdauer vorgibt – also immer nur einen kurzen, kontrollierten Moment. Danach schaltet der Arduino sie wieder aus und geht in die Phase EINWEICHEN über. Dort wartet er die einweichPause ab, bis das Wasser durch die Erde bis zum Sensor durchgesickert ist, bevor er erneut misst. Dieser Schritt ist entscheidend – ohne die Pause würde der Arduino die noch trockene Oberfläche sofort wieder gießen und die Pflanze überwässern. Anschließend beginnt der Kreislauf in der Phase MESSEN von vorn.

So ermittelst du den richtigen Wert: Warte bis die Pflanzenerde so trocken geworden ist, dass du sie eigentlich gießen würdest. Stecke nun den Feuchtigkeitssensor hinein und lies den Wert aus. Diese Zahl kannst du dann als schwellwert in deinem Sketch verwenden. Genauso lohnt es sich, die giessdauer passend zu deiner Pumpe und Topfgröße einzustellen – lieber mit einem kurzen Wert starten und dich langsam herantasten.

Tipp: Kapazitiver statt resistiver Sensor

Die klassischen, sehr günstigen Feuchtigkeitssensoren mit zwei blanken Metallzinken sind resistiv: Zwischen den Zinken fließt ständig ein kleiner Strom durch die feuchte Erde – und genau das lässt sie mit der Zeit korrodieren. Schon nach einigen Wochen im Dauerbetrieb werden ihre Messwerte ungenau. Für ein Projekt, das dauerhaft in der Erde steckt, empfehle ich dir daher einen kapazitiven Feuchtigkeitssensor. Er misst berührungslos über ein Feld statt über direkten Stromfluss, korrodiert dadurch nicht und hält deutlich länger. Der Anschluss und der Code bleiben identisch – nur der ausgelesene Wertebereich unterscheidet sich, weshalb du den Schwellwert wie oben beschrieben neu kalibrierst.

Noch ein Wort zur Sicherheit: Achte darauf, dass die Pumpe nie trocken läuft – die meisten kleinen Tauchpumpen nehmen das übel. Sorge also für einen ausreichend großen Wasservorrat und behalte dein Projekt gerade in den ersten Tagen im Blick. Die feste giessdauer im Sketch begrenzt zwar die Laufzeit pro Durchgang, ein leerer Wassertank bleibt aber trotzdem tabu.

Ein weiterer Pflanzenwächter

Ist dir dieses Projekt zu groß für die Fensterbank? Auf Pollux Labs findest du noch das Projekt Pflanzenwächter, das einen ATtiny85 verwendet und mit dem Strom einer 1,5V Knopfbatterie auskommt. Allerdings kann dich dieses Projekt nur mit einer LED über zu trockene Erde informieren und nicht selbst gießen.