In einem früheren Projekt habe ich eine automatische Pflanzenbewässerung mit einem Arduino UNO vorgestellt. In diesem Projekt hier gehst du einen Schritt weiter: Du baust ein Bewässerungssystem mit einem ESP8266 Webserver. Das bedeutet zunächst, dass du den aktuellen Feuchtigkeitswert der Pflanzenerde auf einer Webseite sehen kannst. Zusätzlich startet der ESP2866 die Wasserpumpe für eine festgelegte Zeit, sobald ein bestimmter Wert über- bzw. unterschritten wurde. Kurze Zeit später siehst du den neuen Wert auf der Webseite.
Die Webseite sieht hierbei – je nachdem, wie du das Diagramm einstellst – folgendermaßen aus:
Eine Art Tacho-Diagramm zeigt dir den aktuellen Feuchtigkeitswert an – farblich hervorgehoben ist hierbei die Spanne, in der die Erde feucht genug ist. Sobald der Feuchtigkeitssensor einen Wert übermittelt, der darüber liegt, startet die Wasserpumpe. Anschließend siehst du die Nadel auf der Anzeige wieder fallen.
Diese Bauteile brauchst du
- 1× ESP8266-Entwicklungsboard z. B. NodeMCU oder Wemos D1 mini; WLAN-fähig und per USB programmierbar.
- 1× Bodenfeuchtesensor Für analoge Feuchtemessung; kapazitiver Sensor ist langlebiger als eine Widerstandssonde.
- 1× 5-V-Relaismodul, 1 Kanal Zum Schalten der Niedervolt-Wasserpumpe.
- 1× Spannungswandler 3,3 V auf 5 V Zur Pegelanhebung für Relais und Sensor, wie im Projekt beschrieben.
- 1× Niedervolt-Miniwasserpumpe Keine netzbetriebene Pumpe verwenden.
- 1× Batterie- bzw. Akkuversorgung für die Wasserpumpe Spannung passend zur gewählten Pumpe wählen.
- 1× Jumper-Kabel Zum Verbinden von ESP8266, Sensor, Relais und Spannungswandler.
- 1× Silikonschlauch für Wasserpumpe Innendurchmesser passend zum Pumpenanschluss.
Affiliate-Links: Kaufst du über diese Links, erhält Pollux Labs eine kleine Provision – für dich ohne Mehrkosten.
Der Aufbau der Pflanzenbewässerung
Damit du ein 5V-Relais am ESP8266 betreiben kannst, benötigst du einen Spannungswandler, um die ausgehenden 3,3V auf 5V zu konvertieren. Auch den Feuchtigkeitssensor betreibst du dann mit 5V. Die Wasserpumpe benötigt zusätzliche Batterien, die über das Relais zugeschaltet werden. Orientiere dich beim Aufbau an folgender 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. Viele 5V-Relaismodule schalten außerdem „active LOW“, d.h. ein LOW-Signal schaltet die Pumpe ein und ein HIGH-Signal sie aus – genau umgekehrt zum Sketch. Läuft deine Pumpe verkehrt herum, tauschst du im Sketch einfach HIGH und LOW. Bitte schließe auch keine Wasserpumpe an, die mit Netzspannung betrieben wird – das ist für dieses Projekt zu gefährlich!
Und 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.
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 wie dieses, 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. Anschluss und Sketch bleiben gleich – nur der ausgelesene Wertebereich unterscheidet sich. Ermittle deinen Minimal- und Maximalwert deshalb wie weiter unten beschrieben und trage sie im Diagramm und im Schwellwert entsprechend ein.
Der Sketch und weitere Dateien
Wie jedes andere Arduino- oder ESP8266-Projekt hat auch dieses einen Sketch – aber nicht nur das. Da du im Prinzip einen Webserver baust, benötigst du auch etwas HTML und CSS für die Webseite. Außerdem kommt hier noch JavaScript für das Tacho-Diagramm zum Einsatz.
Der Code hierfür ist in entsprechenden Dateien gespeichert, die du mit Hilfe von LittleFS auf deine ESP8266 überträgst und dort speicherst. Falls das noch neu für dich ist, findest du auf Pollux Labs ein entsprechendes LittleFS-Tutorial.
Inzwischen kannst du LittleFS auch mit der aktuellen Arduino IDE 2.x nutzen. Dafür installierst du das Plugin arduino-littlefs-upload (ab IDE 2.2.1). Nach der Installation öffnest du mit Strg + Umschalt + P (am Mac ⌘ + Umschalt + P) die Befehlspalette und wählst „Upload LittleFS to Pico/ESP8266/ESP32″. Wie das genau funktioniert, zeigt dir das oben verlinkte LittleFS-Tutorial. Alternativ funktioniert nach wie vor die ältere IDE 1.8.19 mit dem klassischen Uploader-Plugin.
Noch ein Hinweis: Dieses Projekt baut auf der Vorarbeit von Random Nerd Tutorials auf. Die nötigen Anpassungen in den HTML-, CSS- und JS-Dateien sowie den Sketch kannst du dir hier herunterladen. Wie du mit dem in der ZIP-Datei enthaltenen Ordner data umgehst, lernst du ebenfalls im oben verlinkten Tutorial.
Die benötigten Bibliotheken
Für den Sketch benötigst du eine Reihe von Bibliotheken:
#include <Arduino.h>
#include <ESP8266WiFi.h>
#include <ESPAsyncTCP.h>
#include <ESPAsyncWebServer.h>
#include "LittleFS.h"
#include <Arduino_JSON.h>Die ersten beiden sollten bei dir schon vorinstalliert sein. Die drei Bibliotheken ESPAsyncTCP, ESPAsyncWebServer und Arduino_JSON findest du wie gewohnt in Bibliotheksmanager. Achte bei letzterer darauf, die Version von Arduino zu laden. Die ähnlich geschriebene Bibliothek ArduinoJson von Benoit Blanchon wäre für dieses Projekt die falsche.
Die JavaScript-Datei
Mit Hilfe von JavaScript erstellst du das Diagramm, auf dem der Feuchtigkeitswert angezeigt wird. Zum Einsatz kommt hierbei eine vorgefertigte Bibliothek, die alles beinhaltet, was du für dieses Projekt benötigst.
Öffne die Datei in einem Texteditor deiner Wahl. Wie du siehst, kannst du darin allerhand einstellen und an deine Vorlieben anpassen. Nähere Informationen findest du in der Dokumentation der Bibliothek. Zwei Stellen sind allerdings besonders wichtig und hängen von deinem Feuchtigkeitssensor und der Pflanze, die du gießen möchtest, ab.
Dein Sensor überträgt Messwerte in einem Bereich, den du vorab kurz ermitteln musst. Der Maximalwert ist 1024, der ausgegeben wird, wenn der Sensor nicht in der Erde steckt. Das ist sozusagen also der Wert für absolute Trockenheit. Den Minimalwert kannst du ermitteln, wenn du ihn längere Zeit in die feuchte Erde deiner Pflanze oder auch in ein Glas Wasser steckst. Sobald du die Pflanzenbewässerung aufgebaut und die Dateien sowie den Sketch übertragen hast, gibt dein ESP8266 diesen Wert im Seriellen Monitor aus. Bei mir sinkt der Wert kontinuierlich bis auf den Wert 680.
In der Datei script.js findest du zunächst die folgende Stelle. Dort kannst du den Minimal- und Maximalwert eintragen:
minValue: 680,
maxValue: 1024,Außerdem kannst du ein Stück weiter unten noch die Skalenwerte festlegen, die auf dem Diagramm sichtbar sein sollen:
majorTicks: [
"680",
"800",
"900",
"1024"
],Und noch eine dritte Stelle ist interessant. Dort kannst du die Feuchtigkeitswerte innerhalb bestimmter Bereiche farblich kennzeichnen:
highlights: [
{
"from": 680,
"to": 700,
"color": "#346eeb"
},
{
"from": 700,
"to": 800,
"color": "#03C0C1"
},
{
"from": 800,
"to": 900,
"color": "#ebd534"
},
{
"from": 900,
"to": 1024,
"color": "#eb5834"
}
],Im obigen Beispiel sind das die Werte von 700 – 800, die farblich hervorgehoben sind (hier in Türkis), um zu signalisieren, dass die Erde eine optimale Feuchtigkeit hat. Welche Werte das bei dir sind, kannst du folgendermaßen leicht herausfinden:
Sobald du die Pflanzenbewässerung aufgebaut und die Dateien sowie den Sketch übertragen hast, gibt dein ESP8266 den aktuell gemessenen Feuchtigkeitswert im Seriellen Monitor aus. Stecke nun den Sensor in Erde, die so trocken ist, dass du sie jetzt bewässern würdest. Im Seriellen Monitor siehst du nun ersten Wert.
Gieße jetzt die Pflanze, bis sie feucht genug ist – im Seriellen Monitor siehst du nun deinen zweiten Wert. Trage diesen Wert im JavaScript-Code ein, dieser Bereich wird dann farblich markiert. Über den Hexadezimalwert hinter color kannst du die Farbe dabei selbst auswählen.
So könnte dann das Diagramm beispielsweise aussehen:
Die HTML-Datei
Das HTML für deine Webseite ist recht überschaubar:
<!DOCTYPE html>
<html>
<head>
<title>ESP8266 Pflanzenbewässerung</title>
<meta name="viewport" content="width=device-width, initial-scale=1">
<meta charset="utf-8">
<link rel="icon" type="image/png" href="favicon.png">
<link rel="stylesheet" type="text/css" href="style.css">
<script src="gauge.min.js"></script>
</head>
<body>
<div class="topnav">
<h1>ESP8266 Pflanzenbewässerung</h1>
</div>
<div class="content">
<div class="card-grid">
<div class="card">
<p class="card-title">Feuchtigkeit</p>
<canvas id="gauge-humidity"></canvas>
</div>
</div>
</div>
<script src="script.js"></script>
</body>
</html>Darin findest du den Seitentitle title sowie die Überschrift h1 und den card-title, die du nach Belieben benennen kannst. Das Script für das Diagramm (gauge.min.js) liegt zusammen mit den übrigen Dateien im Ordner data und wird lokal von deinem ESP8266 ausgeliefert – so funktioniert die Anzeige auch dann, wenn das anzeigende Gerät gerade keinen Internetzugang hat. Wenn du nichts anpassen möchtest, kannst du diese Datei so lassen wie sie ist – das gilt auch für die CSS-Datei im Ordner data, auf die ich hier nicht eigens eingehe.
Wichtige Anpassungen im Sketch
Nun zum Kernstück des Projekts. Hier musst du ein paar wichtige Anpassungen vornehmen, damit deine Pflanzenbewässerung wie gewünscht funktioniert. Hinterlege zunächst deine WLAN-Daten:
const char* ssid = "DEIN NETZWERK";
const char* password = "DEIN PASSWORT";Weiter geht es mit einer Variablen. Diese gibt den Intervall vor, in dem die Webseite (und damit die Messdaten des Feuchtigkeitssensors) aktualisiert werden sollen. Voreingestellt sind hier 30 Sekunden, du kannst diese Zeitspanne jedoch beliebig verlängern und verkürzen.
unsigned long timerDelay = 30000;Weiter oben im Sketch findest du außerdem einen Block mit Einstellungen, über den du das Gießverhalten steuerst:
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)
// Relais-Logik: Viele 5V-Relaismodule schalten "active LOW".
// Läuft deine Pumpe verkehrt herum, tausche einfach die beiden Werte.
const int PUMPE_AN = HIGH;
const int PUMPE_AUS = LOW;Setze für die voreingestellten 900 beim schwellwert den Wert ein, den du in der trockenen Erde ermittelt hast. Liegt der Messwert darüber, springt die Pumpe an. Ein Hinweis: In diesem Projekt gehe ich davon aus, dass die Werte mit der Trockenheit der Erde steigen. Falls das bei dir genau andersherum ist, drehe die Abfrage im Loop mit dem Zeichen < entsprechend um. Über die giessdauer legst du fest, wie lange die Pumpe pro Durchgang läuft, und die einweichPause ist eine Wartezeit nach dem Gießen (dazu gleich mehr).
Im Loop selbst wird die Pumpe dann nicht blockierend gesteuert. Das ist beim ESP8266 wichtig: Ein delay() würde den Webserver für diese Zeit anhalten, sodass die Webseite nicht mehr reagiert. Stattdessen merkt sich der Sketch mit millis(), wann die Pumpe gestartet wurde, und schaltet sie nach Ablauf der giessdauer wieder aus – ganz ohne den Rest des Programms aufzuhalten:
// Pumpe steuern – nicht blockierend, damit der Webserver weiterläuft
if (pumpeLaeuft) {
// Pumpe läuft; nach der giessdauer wieder ausschalten
if (jetzt - pumpeStart >= giessdauer) {
digitalWrite(pumpPin, PUMPE_AUS);
pumpeLaeuft = false;
letzterGuss = jetzt;
Serial.println("Pumpe aus - Wasser einsickern lassen");
}
} else {
// Nur gießen, wenn die Erde zu trocken ist UND die Einweich-Pause vorbei ist
if (humidity > schwellwert && (letzterGuss == 0 || jetzt - letzterGuss >= einweichPause)) {
Serial.println("Erde trocken - Pumpe an");
digitalWrite(pumpPin, PUMPE_AN);
pumpeLaeuft = true;
pumpeStart = jetzt;
}
}Der entscheidende Punkt ist die einweichPause: Nach jedem Gießvorgang wartet der ESP8266 (voreingestellt 30 Minuten), bevor er überhaupt wieder gießen darf. So bekommt das Wasser Zeit, durch die Erde bis zum Sensor durchzusickern. Ohne diese Pause würde der ESP8266 die noch trockene Oberfläche sofort wieder gießen und die Pflanze überwässern. Die Messwerte auf der Webseite werden davon unabhängig weiterhin alle 30 Sekunden aktualisiert.
Und das war es auch schon. Mit den richtigen Anpassungen sollte deine Pflanzenbewässerung nun automatisch deine Lieblingspflanze bewässern während du z.B. auf dem Smartphone die Feuchtigkeit der Erde überwachst. 🙂
Wie geht es weiter?
Natürlich gibt es noch einige Verbesserungen, die deiner Bewässerungsanlage hinzufügen könntest. Wie wäre z.B. mit einer WhatsApp-Nachricht, die dein ESP8266 schickt, wenn die Erde zu trocken ist? Eine andere Idee könnte auch ein Button auf der Webseite sein, der den Gießvorgang manuell startet.
Sicherlich fallen dir noch weitere Optimierungen ein – viel Erfolg dabei!
