Smarte Bewässerung mit Shelly The Pill – Pflanzen automatisch gießen

Eine smarte Bewässerung für Pflanzen muss nicht kompliziert sein. In einem früheren Projekt habe ich bereits gezeigt, wie sich mit einem Shelly Plus und dem passenden Add-on eine automatische Bewässerung umsetzen lässt. Der Aufbau funktioniert zuverlässig, hat aber einen entscheidenden Nachteil: Für die Installation ist ein Zugriff auf das 230-V-Stromnetz erforderlich. Gerade für Einsteiger ist das nicht unbedingt die beste Lösung.

Mit The Pill von Shelly lässt sich das deutlich einfacher und anfängerfreundlicher umsetzen. In Kombination mit dem Analog Add-on kann ein analoger Bodenfeuchtesensor direkt ausgewertet werden, ohne dass dafür an der Netzspannung gearbeitet werden muss.

In diesem Projekt zeige ich dir, wie du die Bodenfeuchtigkeit einer Pflanze misst und daraus eine kleine smarte Bewässerung aufbaust. Wird die Erde zu trocken, kann anschließend beispielsweise ein Shelly Plug S eine kleine Wasserpumpe einschalten und die Pflanze automatisch bewässern.

So entsteht mit wenigen Komponenten eine praktische Smart-Home-Lösung, die sich auch von Einsteigern problemlos nachbauen lässt.

Einleitung und Ziel des Projekts

Ziel dieses Projekts ist eine smarte Pflanzenbewässerung, bei der keine offene 230-V-Netzspannung verdrahtet werden muss.

The Pill von Shelly wird einfach über ein 5-V-USB-Netzteil betrieben. Über das Analog Add-on erfassen wir die Bodenfeuchtigkeit. Wird die Erde zu trocken, schaltet ein Shelly Plug S eine kleine Wasserpumpe beziehungsweise deren Steckernetzteil ein.

The Pill besitzt leider nur eine Add-on-Schnittstelle. Das SSR-Relais-Add-on könnte zwar eine kleine DC-Pumpe bis 30 V schalten, lässt sich aber nicht gleichzeitig mit dem benötigten Analog Add-on verwenden. Eine zukünftige Version mit zwei Add-on-Schnittstellen wäre für solche Projekte daher besonders interessant.

Der Ablauf ist damit einfach:

Benötigte Komponenten

Für den Aufbau der Bodenfeuchtemessung benötige ich nur wenige Komponenten:

• Shelly The Pill* inklusive USB-Kabel und passendem 5-V-USB-Netzteil
• 5-Terminal Add-on* für The Pill, sowie
• Analog Terminal Add-on* für The Pill
• Kapazitiver Bodenfeuchtesensor* mit analogem Ausgang
• 3 Breadboardkabel*, ca. 10 cm, männlich auf männlich

Der kapazitive Bodenfeuchtesensor wird über die drei Breadboardkabel mit 5 V, GND und dem Analogeingang des Analog Terminal Add-ons verbunden.

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!

Der Shelly Plug S sowie die Wasserpumpe kommen erst später hinzu, wenn aus der reinen Bodenfeuchtemessung die automatische Bewässerung wird.

Kapazitiver oder resistiver Bodenfeuchtesensor?

Neben kapazitiven Bodenfeuchtesensoren gibt es auch sehr einfache resistive Sensoren mit zwei offenliegenden Metallkontakten. Diese sind meist besonders günstig, haben aber einen entscheidenden Nachteil: Durch den dauerhaften Kontakt mit feuchter Erde und die anliegende Spannung können die Metallflächen mit der Zeit korrodieren beziehungsweise sich zersetzen. Dadurch verändert sich nicht nur der Sensor selbst, sondern langfristig auch der gemessene Wert.

Für dieses Projekt verwende ich deshalb einen kapazitiven Bodenfeuchtesensor. Dieser misst die Feuchtigkeit ohne offenliegende Messelektroden und ist damit für einen dauerhaften Einsatz in der Blumenerde deutlich besser geeignet.

Erster Aufbau – Bodenfeuchtesensor anschließen

Im ersten Schritt konzentrieren wir uns ausschließlich auf die Messung der Bodenfeuchtigkeit. Eine Pumpe oder automatische Bewässerung kommt zunächst noch nicht zum Einsatz. Der kapazitive Bodenfeuchtesensor wird dafür einfach in die Erde der Pflanze gesteckt und anschließend mit The Pill verbunden.

The Pill wird über den USB-C-Anschluss mit 5 V versorgt. Am Micro-USB-Anschluss wird zunächst das Terminal Add-on angeschlossen, auf welches anschließend das Analog Add-on gesteckt wird.

Auf dem Analog Add-on befindet sich ein kleiner Pfeil mit der Beschriftung „The Pill“, der die korrekte Einsteckrichtung zeigt. Viel falsch machen kann man hierbei allerdings nicht: Die Anschlüsse besitzen unterschiedliche Abstände, sodass sich das Add-on auch mechanisch nur in der richtigen Richtung aufstecken lässt.

Der Bodenfeuchtesensor wird anschließend mit drei Breadboardkabeln verbunden:

Damit ist der erste Aufbau bereits abgeschlossen. Nach dem Einschalten von The Pill können wir nun die vom Bodenfeuchtesensor ausgegebene Spannung in Volt betrachten und daraus im nächsten Schritt die Bodenfeuchtigkeit ableiten.

Analogeingang in der Shelly Cloud konfigurieren

Die Konfiguration in der Shelly Cloud ist recht schnell erledigt. Für den angeschlossenen Bodenfeuchtesensor muss zunächst der passende Eingang ausgewählt werden.

Dazu wird für den Eingang die Funktion „Analogeingang (Voltmeter)“ aktiviert. Anschließend wähle ich zusätzlich die Option „0–30 V (Zusatzmodul erforderlich)“ aus.

Damit weiß The Pill, dass der Messwert über das angeschlossene Analog Add-on erfasst wird.

Nach dem Speichern der Einstellungen wird die am Analogeingang anliegende Spannung direkt in der Shelly-Oberfläche angezeigt. Im nächsten Schritt können wir nun prüfen, wie sich dieser Wert bei trockener und feuchter Erde verändert.

Was sagt die gemessene Spannung aus?

Bei dem hier verwendeten kapazitiven Bodenfeuchtesensor gilt: Je trockener die Erde ist, desto höher ist die gemessene Spannung. Je feuchter die Erde wird, desto niedriger fällt die Spannung aus.

Der Grund dafür ist recht einfach: Der Sensor erkennt, wie stark sich die elektrischen Eigenschaften der Umgebung um seine Messfläche verändern. Wasser beeinflusst diese stärker als trockene Erde. Je mehr Feuchtigkeit sich also im Boden befindet, desto deutlicher verändert sich das Signal des Sensors.

Die Elektronik auf dem Sensor wandelt diese Veränderung anschließend in eine Spannung um. Bei meinem Sensor bedeutet das:

hohe Spannung = trockene Erde
niedrige Spannung = feuchte Erde

Der Sensor liefert dabei nicht direkt einen Wert wie „35 % Bodenfeuchtigkeit“, sondern zunächst nur diese Spannung. Im nächsten Schritt bestimmen wir deshalb eigene Referenzwerte für trockene und feuchte Erde, aus denen sich später ein verständlicher Prozentwert ableiten lässt.

Wichtig: Version des Bodenfeuchtesensors beachten

Bei den kapazitiven Bodenfeuchtesensoren gibt es einen Punkt, der schnell zu falschen Ergebnissen führen kann: Am Markt sind unterschiedliche Versionen erhältlich, die nicht dieselben Spannungswerte ausgeben.

Besonders häufig findet man die Version 1.2 sowie die Version 2.0. Beide funktionieren nach dem gleichen Prinzip, liefern bei trockener beziehungsweise sehr feuchter Umgebung jedoch unterschiedliche Werte.

Das ist vor allem dann wichtig, wenn später aus der gemessenen Spannung eine Bodenfeuchtigkeit in Prozent berechnet oder ein Grenzwert für die automatische Bewässerung festgelegt werden soll.

Würde ich beispielsweise für einen Sensor der Version 2.0 einfach die Werte der Version 1.2 übernehmen, wäre die spätere Berechnung entsprechend ungenau.

Die Werte aus der Tabelle sind deshalb vor allem eine gute Orientierung. Für eine möglichst zuverlässige Messung empfehle ich, den eigenen Sensor einmal selbst zu testen:

• Trockenwert: Sensor außerhalb der Erde beziehungsweise vollständig trocken messen.
• Feuchtwert: Den Messbereich des Sensors in Wasser oder sehr feuchte Erde halten und die Spannung erneut ablesen.

Wichtig: Beim Test mit Wasser darf nur der dafür vorgesehene Messbereich des Sensors eingetaucht werden. Die Elektronik am oberen Ende der Platine sollte trocken bleiben.

Mit diesen beiden selbst ermittelten Werten lässt sich der Sensor anschließend wesentlich genauer auf die eigene Pflanze und die verwendete Erde abstimmen.

Warum verwende ich ein Shelly Script?

Grundsätzlich ließe sich die Bewässerung auch mit Actions oder Szenen umsetzen. Für einfache Regeln wie „Wenn ein bestimmter Wert unterschritten wird, dann schalte die Pumpe ein“ wäre das durchaus ausreichend.

Für dieses Projekt verwende ich trotzdem ein Shelly Script, weil sich die spätere Bewässerungslogik damit deutlich übersichtlicher pflegen lässt. Aus der gemessenen Spannung berechnen wir zunächst die Bodenfeuchtigkeit in Prozent. Anschließend können wir direkt im Script festlegen, wie bei unterschiedlichen Feuchtigkeitsbereichen reagiert werden soll.

Ein weiterer großer Vorteil: Shelly Scripts laufen lokal auf dem Gerät. Das gilt ebenso für viele Actions. Unsere Bewässerung ist damit nicht darauf angewiesen, dass ständig eine Verbindung zur Shelly Cloud oder zum Internet besteht.

Auch wenn die Internetverbindung ausfällt oder die Shelly Cloud einmal nicht erreichbar sein sollte, kann The Pill weiterhin die Bodenfeuchtigkeit auswerten und die festgelegte Logik ausführen.

Später könnte die Steuerung beispielsweise so aussehen:

• 0–20 % → Pumpe 10 Sekunden einschalten
• 21–30 % → Pumpe 5 Sekunden einschalten
• 31–40 % → Pumpe 2 Sekunden einschalten
• über 40 % → keine Bewässerung

Ändert sich später die Pflanze, die verwendete Erde oder die Fördermenge der Pumpe, müssen lediglich die Grenzwerte und Laufzeiten im Script angepasst werden. Die komplette Logik bleibt damit an einer zentralen Stelle und lässt sich bei Bedarf zusätzlich um Wartezeiten, maximale Pumpenlaufzeiten oder weitere Sicherheitsabfragen erweitern.

Bodenfeuchtigkeit im Shelly Script berechnen

Nachdem der analoge Eingang eingerichtet ist, können wir die gemessene Spannung direkt in einem Shelly Script auslesen und daraus einen verständlichen Prozentwert für die Bodenfeuchtigkeit berechnen.

// -------------------------------------------------------
// Bodenfeuchtigkeit mit Shelly The Pill
// Voltmeter-ID: 200
// -------------------------------------------------------

// Kalibrierwerte des verwendeten Sensors
let SPANNUNG_TROCKEN = 1.9;  // 0 % Bodenfeuchtigkeit
let SPANNUNG_NASS = 0.8;     // 100 % Bodenfeuchtigkeit

// Wie oft soll gemessen werden?
let MESSINTERVALL = 5000;    // Millisekunden = 5 Sekunden


// -------------------------------------------------------
// Bodenfeuchtigkeit berechnen
// -------------------------------------------------------

function berechneBodenfeuchte(spannung) {

  let prozent = (SPANNUNG_TROCKEN - spannung) / (SPANNUNG_TROCKEN - SPANNUNG_NASS) * 100;

  // Auf 0 bis 100 % begrenzen
  if (prozent < 0) {  prozent = 0; }
  if (prozent > 100) { prozent = 100; 
  return prozent;
}


// -------------------------------------------------------
// Sensor auslesen
// -------------------------------------------------------

function leseBodenfeuchte() {

  let status = Shelly.getComponentStatus("voltmeter:200");

  if (status === null || status.voltage === null) {
    print("Fehler: Analogeingang konnte nicht gelesen werden.");
    return;
  }

  let spannung = status.voltage;
  let feuchtigkeit = berechneBodenfeuchte(spannung);

  print(
    "Spannung: " +
    spannung.toFixed(2) +
    " V | Bodenfeuchtigkeit: " +
    feuchtigkeit.toFixed(1) +
    " %"
  );
}


// -------------------------------------------------------
// Messung starten
// -------------------------------------------------------

// Sofort einmal messen
leseBodenfeuchte();

// Danach alle 5 Sekunden messen
Timer.set(MESSINTERVALL, true, leseBodenfeuchte);

Der aktuelle Messwert wird bei The Pill über die Komponente voltmeter:200 bereitgestellt. Mit Shelly.getComponentStatus() lässt sich die Spannung direkt im Script abfragen.

Für meinen Sensor verwende ich folgende Kalibrierwerte:

let SPANNUNG_TROCKEN = 1.9;  // 0 %
let SPANNUNG_NASS = 0.8;     // 100 %

Diese beiden Werte stehen bewusst am Anfang des Scripts. Dadurch lassen sie sich später einfach an einen anderen Bodenfeuchtesensor anpassen, ohne dass die eigentliche Berechnung verändert werden muss.

Die Umrechnung erfolgt anschließend linear zwischen diesen beiden Punkten:

• 1,9 V → 0 % Bodenfeuchtigkeit
• 0,8 V → 100 % Bodenfeuchtigkeit

Liegt die gemessene Spannung beispielsweise ungefähr in der Mitte zwischen beiden Werten, erhalten wir entsprechend etwa 50 % Bodenfeuchtigkeit.

Das Script liest den Messwert regelmäßig aus und gibt sowohl die aktuelle Spannung als auch den berechneten Prozentwert aus:

Zusätzlich wird der berechnete Wert auf den Bereich von 0 bis 100 % begrenzt. Liefert der Sensor beispielsweise einmal eine Spannung außerhalb der zuvor festgelegten Kalibrierwerte, entstehen dadurch keine negativen Werte oder Werte über 100 %.

Damit haben wir nun aus der zunächst wenig aussagekräftigen Analogspannung einen deutlich verständlicheren Messwert erzeugt. Im nächsten Schritt können wir diesen Prozentwert verwenden, um festzulegen, ab welcher Bodenfeuchtigkeit die Pflanze automatisch bewässert werden soll.

Troubleshooting: „Analogeingang konnte nicht gelesen werden“

Erscheint im Script die Meldung: Fehler: Analogeingang konnte nicht gelesen werden.

sollte zunächst geprüft werden, ob die im Script verwendete Voltmeter-ID korrekt ist. Diese kann je nach Gerät beziehungsweise Konfiguration unterschiedlich sein.

Rufe dazu im Browser folgende Adresse auf: http://<IP-Adresse>/rpc/Shelly.GetComponents?include=["config","status"]

<IP-Adresse> ersetzt du durch die lokale IP-Adresse deines The Pill.

In der ausgegebenen JSON-Struktur sollte sich anschließend ein Abschnitt ähnlich diesem finden:

{
  "key": "voltmeter:200",
  "status": {
    "id": 200,
    "voltage": 1.86
  }
}

Entscheidend sind dabei die beiden Einträge:

"key": "voltmeter:200"
"id": 200

In meinem Fall lautet die ID also 200. Genau diese muss auch im Shelly Script verwendet werden:

let status = Shelly.getComponentStatus("voltmeter:200");

Wird bei deinem Gerät beispielsweise voltmeter:100 oder eine andere ID angezeigt, musst du den Wert im Script entsprechend anpassen.

Praktischer Nebeneffekt: Im Feld "voltage": 1.86 siehst du gleichzeitig den aktuell gemessenen Spannungswert des Bodenfeuchtesensors. Damit lässt sich schnell prüfen, ob der Analogeingang grundsätzlich funktioniert.

Zweiter Schritt – Wasserpumpe mit Shelly Plug S steuern

Nachdem wir die Bodenfeuchtigkeit zuverlässig ermitteln können, fehlt nun noch die eigentliche Bewässerung der Pflanze. Dafür verwende ich eine kleine Wasserpumpe, die über einen Shelly Plug S ein- und ausgeschaltet wird.

Zusätzlich benötigte Komponenten für die Bewässerung

Für die eigentliche Bewässerung benötigen wir zusätzlich noch einige wenige Komponenten:

• Shelly Plug S*
• kleine Wasserpumpe*
• Wasserschlauch passend zum Pumpenanschluss
• Wasserbehälter
• optional ein T-Stück, wenn zwei Pflanzen mit einer Pumpe versorgt werden sollen

Der Shelly Plug S übernimmt später das Ein- und Ausschalten der Pumpe. Dadurch muss keine offene Netzspannung verdrahtet werden. Die Pumpe wird einfach über ihr Netzteil mit dem Plug S verbunden.

Welche Pumpengröße sinnvoll ist, hängt vor allem von der benötigten Fördermenge und der Länge beziehungsweise Höhe des Schlauchs ab. Für dieses Projekt reicht bereits eine kleine Pumpe aus.

Shelly Plug S abhängig von der Bodenfeuchtigkeit steuern

// -------------------------------------------------------
// Smarte Bewässerung mit Shelly The Pill
// Bodenfeuchte messen und Shelly Plug S steuern
// -------------------------------------------------------


// -------------------------------------------------------
// Konfiguration Bodenfeuchtesensor
// -------------------------------------------------------

let VOLTMETER_KEY = "voltmeter:200";

let SPANNUNG_TROCKEN = 1.9;  // 0 %
let SPANNUNG_NASS = 0.8;     // 100 %


// -------------------------------------------------------
// Konfiguration Shelly Plug S
// -------------------------------------------------------

let PLUG_IP = "192.168.178.82";
let PLUG_SWITCH_ID = 0;


// -------------------------------------------------------
// Messung und Sperrzeit
// -------------------------------------------------------

let MESSINTERVALL = 5000;         // alle 5 Sekunden messen
let SPERRZEIT = 10 * 60 * 1000;   // 10 Minuten nach Bewässerung

let bewaesserungGesperrt = false;


// -------------------------------------------------------
// Bodenfeuchtigkeit berechnen
// -------------------------------------------------------

function berechneBodenfeuchte(spannung) {

  let prozent =
    (SPANNUNG_TROCKEN - spannung) /
    (SPANNUNG_TROCKEN - SPANNUNG_NASS) * 100;

  if (prozent < 0) {
    return 0;
  }

  if (prozent > 100) {
    return 100;
  }

  return prozent;
}


// -------------------------------------------------------
// Pumpenlaufzeit anhand der Bodenfeuchte bestimmen
// -------------------------------------------------------

function bestimmePumpenzeit(feuchtigkeit) {

  if (feuchtigkeit > 40) {
    return 0;    // ausreichend feucht -> keine Bewässerung
  }

  if (feuchtigkeit <= 20) {
    return 10;   // sehr trocken -> 10 Sekunden
  }

  if (feuchtigkeit <= 30) {
    return 5;    // trocken -> 5 Sekunden
  }

  if (feuchtigkeit <= 40) {
    return 2;    // leicht trocken -> 2 Sekunden
  }

  return 0;
}


// -------------------------------------------------------
// Shelly Plug S einschalten
// -------------------------------------------------------

function startePumpe(sekunden) {

  if (bewaesserungGesperrt) {
    print("Bewässerung aktuell gesperrt.");
    return;
  }

  if (sekunden <= 0) {
    return;
  }

  let url = "http://" + PLUG_IP + "/rpc/Switch.Set?id=" + PLUG_SWITCH_ID + "&on=true&toggle_after=" + sekunden;

  print("Pumpe wird für " + sekunden + " Sekunden eingeschaltet.");

  Shelly.call("HTTP.GET", { url: url, timeout: 5 },
    function(result, errorCode, errorMessage) {
      if (errorCode !== 0) {
        print("Fehler beim Schalten des Shelly Plug S: " + errorMessage);
        return;
      }

      if (result.code !== 200) {
        print("Shelly Plug S antwortet mit HTTP-Code: " + result.code);
        return;
      }

      print("Shelly Plug S wurde eingeschaltet.");

      // Neue Bewässerung zunächst verhindern
      bewaesserungGesperrt = true;

      Timer.set( SPERRZEIT, false, function() {
          bewaesserungGesperrt = false;
          print("Sperrzeit beendet. Bewässerung wieder möglich.");
        }
      );
    }
  );
}

// -------------------------------------------------------
// Bodenfeuchte auslesen und Bewässerung prüfen
// -------------------------------------------------------

function pruefeBodenfeuchte() {

  if (bewaesserungGesperrt) {
    return;
  }

  let status = Shelly.getComponentStatus(VOLTMETER_KEY);

  if (status === null || status.voltage === null) {
    print("Fehler: Analogeingang konnte nicht gelesen werden.");
    return;
  }

  let spannung = status.voltage;
  let feuchtigkeit = berechneBodenfeuchte(spannung);

  print( "Spannung: " + spannung.toFixed(2) + " V | Bodenfeuchtigkeit: " + feuchtigkeit.toFixed(1) + " %" );

  let pumpenzeit = bestimmePumpenzeit(feuchtigkeit);

  if (pumpenzeit === 0) {
    print("Boden ausreichend feucht - keine Bewässerung.");
    return;
  }

  startePumpe(pumpenzeit);
}


// -------------------------------------------------------
// Script starten
// -------------------------------------------------------

pruefeBodenfeuchte();

Timer.set( MESSINTERVALL, true, pruefeBodenfeuchte );

Für ein weiteres Projekt zur automatischen Bewässerung meiner Tomatenpflanzen habe ich mir zwei unterschiedlich große Pumpen zum Testen besorgt. Für dieses Projekt kommt die kleinere Variante zum Einsatz. Trotz ihrer kompakten Größe besitzt sie genügend Leistung, um bei Bedarf auch eine zweite Pflanze mit Wasser zu versorgen.

Sollen zwei Pflanzen gleichzeitig bewässert werden, kann der Schlauch einfach mit einem passenden T-Stück aufgeteilt werden:

Die Pumpe beziehungsweise deren Netzteil wird an den Shelly Plug S angeschlossen. Dadurch müssen wir auch hier keine offene 230-V-Verdrahtung vornehmen. Der Plug S wird lediglich in die Steckdose gesteckt und kann anschließend von The Pill aus angesteuert werden.

Fazit und Ausblick

Mit The Pill von Shelly, dem Analog Add-on und einem kapazitiven Bodenfeuchtesensor lässt sich mit überschaubarem Aufwand eine smarte Pflanzenbewässerung aufbauen. Der große Vorteil dieses Projekts ist, dass für den Aufbau keine offene 230-V-Netzspannung verdrahtet werden muss. The Pill wird einfach über USB versorgt und die Pumpe über einen Shelly Plug S geschaltet.

Besonders interessant finde ich, dass wir den Bodenfeuchtesensor nicht nur auslesen, sondern die gemessene Spannung im Shelly Script in einen Prozentwert umrechnen. Dadurch lässt sich die Bewässerung später sehr flexibel steuern. Je nach Bodenfeuchtigkeit können unterschiedliche Pumpenlaufzeiten definiert und bei Bedarf einfach angepasst werden.

Damit ist der Aufbau jedoch noch nicht ganz am Ende. Eine wichtige Erweiterung wäre die Überwachung des Wasserbehälters. Schließlich sollte die Pumpe nicht eingeschaltet werden, wenn kein Wasser mehr vorhanden ist.

Das Analog Add-on bietet neben dem Analogeingang zusätzlich die beiden digitalen Anschlüsse IO2 und IO3. Darüber lässt sich beispielsweise ein Schwimmschalter anschließen und als Trockenlaufschutz verwenden.

Genau das möchte ich in einem weiteren Projekt umsetzen:

So lässt sich die hier aufgebaute Bewässerung Schritt für Schritt erweitern, ohne die grundlegende Schaltung komplett neu aufbauen zu müssen.

Letzte Aktualisierung am: 25. August 2026