Automatische Pflanzenbewässerung mit Beleuchtung

Neben dem Nährboden braucht eine Pflanze vor allem zwei Dinge: Licht und Wasser. Trotzdem schaffen wir es nicht immer die geliebten Zimmerpflanzen ausreichend damit zu versorgen. In unserem Experiment möchten wir zeigen, wie man dieses Alltagsproblem mit wenigen Elektronischen Komponenten in den Griff bekommt.

Achtung

1. Zielstellung

Was möchten wir mit unserem Smarten-Blumentopf erreichen?

2. Materialauswahl

2.1 Steuerung

Für die Steuerung haben wir uns einen kostengünstigen Mikrocontroller ausgesucht: den Arduino Nano. Das gute Stück kann mit 7-12V betrieben werden und hat jede Menge Ein- und Ausgänge zum Steuern und Messen.

Bei Amazon ist dieser bereits für knapp 10€ im Dreierset zu haben. Ich würde auch mindestens zwei Exemplare kaufen, weil es leider auch mal passieren kann das so ein Ding abraucht. Dann muss man wieder warten bis der Nächste geliefert wird….

Hier der Link zum Arduino Nano bei Amazon
Zu Amazon *

Passend zu dem Arduino benötigen wir außerdem Relais mit denen man die Stromzufuhr für Beleuchtung, Lüfter und Pumpe An-/Ausschalten kann. Dafür haben wir zwei Doppelrelais besorgt die mit mit 5V aus dem Arduino betrieben werden.

Hier der Link zu den Relais bei Amazon:
Zu Amazon *

2.2 Beleuchtung

Als Beleuchtung wird in diesem Projekt eine Pflanzenlampe als LED-Streifen genutzt. Diese Pflanzenlampen strahlen nur Blaues und Rotes Licht ab. Das sind die Lichtstrahlen die von den meisten Pflanzen aufgenommen werden.

Interessant: Unter dem rot-blauen Licht wirken die sonst grünen Blätter nur noch dunkel-braun. Daran siehst du, dass die Pflanze fast das gesamte Licht absorbiert. Unter Tageslicht sieht man vor allem das grüne Licht, das die Pflanzen nicht gebrauchen können, weshalb die meisten Blätter grün aussehen.

Wir haben uns bei Amazon für folgenden 12V LED-Streifen entschieden:
Zu Amazon *

Damit die Beleuchtung nicht mitten in der Nacht angeht, muss der Arduino wissen zu welchen Tageszeiten er die Lampe Ein- bzw Ausschalten soll. Dafür braucht er eine RTC (Real Time Clock) die Ihn mit der aktuellen Uhrzeit versorgt.

Bei Amazon haben wir uns für folgendes Modell entschieden:
Zu Amazon *

2.3 Bewässerung

Zur Bewässerung haben wir uns für eine Tauchpumpe entschieden. Diese wird in einem Wassertank versenkt und befördert das Wasser durch einen Schlauch, wenn man die Versorgungsspannung anlegt.

Bei Amazon haben wir folgende 12V Tauchpumpe für ca. 5€ gefunden:
Zu Amazon*

Am einfachsten wäre es wohl im festen Stundentakt die Pumpe kurz an- und auszuschalten. Die Chance dabei die Pflanze zu überschwemmen – weil sie jedes mal etwas zu viel Wasser bekommt – ist dabei allerdings zu hoch.

Deshalb haben wir dazu einen Bodenfeuchte-Sensor besorgt. Mit diesem lässt sich die Bodenfeuchtigkeit immer wieder messen und die Bewässerung nur bei Bedarf zu starten.

Bei Amazon haben wir folgenden Bodenfeuchte Sensor gekauft:
Zu Amazon*

2.4 Belüftung

Bei der Beleuchtung mit einer Pflanzenlampe strahlt natürlich viel Licht an der Pflanze vorbei und geht verloren. Baut man deshalb eine Box um den Blumentopf, dann sollte man eine Belüftung nicht vergessen. Pflanzen müssen mit CO2 und Sauerstoff versorgt werden. Am einfachsten erreicht man das mit einem kleinen Lüfter.

Bei Amazon haben wir folgenden 12V-Lüfter besorgt:
Zu Amazon*

2.5. Netzteil

Wie man vielleicht bereits gemerkt hat werden alle hier ausgewählten Komponenten mit 12V versorgt. Das macht die Schaltung umso einfacher. Grundsätzlich brauchen wir also nur einen 12V-Trafo, der stark genug für den Fall ist, dass alle Komponenten gleichzeitig „Strom ziehen“. Also die Lampe leuchtet, der Lüfter dreht sich, die Pumpe pumpt und der Arduino ist an.

Zusammen gerechnet wird also etwa folgende Leistung benötigt:

Lampe
Auf dem Streifen sind 3 LED-Chips pro 5cm. Diese SMD 5050 verbrauchen etwa 0,24W pro Chip. Bei 35 cm LED-Streifen sind das ca 5 Watt.

Pumpe
Wenn man den Angaben dieser etwas „billigen“ Modelle trauen kann, dann braucht unsere Pumpe etwa 3 Watt

Lüfter
Nach Herstellerangaben verbraucht der Lüfter 2,88 Watt.

Arduino & Sensoren
Den Arduino mit seinen ca. 30mA Stromaufnahme, die RTC und den Feuchtigkeitssensor konnten wir durch den geringen Verbrauch außer Acht lassen.

Ein Netzteil mit knapp 11W reicht also aus. Wir haben bei Amazon folgenden 12W Trafo besorgt:

Zu Amazon*

3. Konzept

Grundsätzlich ist die Steuerung recht einfach aufgebaut. Der Trafo erzeugt 12V und versorgt damit zunächst nur den Arduino. Dieser schaltet dann die Relais welche das Licht, die Pumpe und den Lüfter mit 12V versorgen. Die Relais selber werden mit den vom Arduino erzeugten 5V betrieben. Die RTC für die Uhrzeit und der Bodenfeuchte-Sensor arbeiten ebenfalls mit den 5V.

Zusätzlich haben wir noch einen Schalter an den Arduino angeklemmt, mit der die Beleuchtung zwischen verschiedenen Beleuchtungsdauern gewechselt werden kann (In der obigen Darstellung ist er nicht zu sehen)

Die elektronischen Komponenten haben wir in zwei Verteilerdosen untergebracht. Auf dem folgenden Bild sieht man den Aufbau eines ersten Prototypen. Bei dieser Version befindet sich in der rechten Box noch die Zuleitung zu einer 230V Lampe, die aus Sicherheitsgründen von der linken 12V Dose getrennt ist.

In der linken 12V Dose befinden sich dann neben dem Arduino und der RTC noch die Relais für Lüftung und Pumpe.

4. Steuerung

Jetzt geht es nur noch an das Ablaufprogramm des Arduinos. Dieses besteht wie immer beim Arduino aus der einmaligen Setup-Funktion und der permanent ablaufenden Loop-Funktion. Im Setup wird der Arduino einmalig eingerichtet und in der Loop passiert dann die eigentliche Steuerung.

Wir gehen jetzt einmal Stück für Stück durch den Arduino Code

#include <Wire.h>
#include "RTClib.h"

Das sind die benötigten „libraries“ für die Kommunikation mit den Komponenten.

// Konfiguration
int FEUCHTIGKEIT_MINIMUM = 600; // Hohe Zahl heißt trocken
int INTERVALL_PUMPE_CHECKUP = 28800; // Alle 8 Stunden Feuchtigkeit prüfen
int INTERVALL_LUEFTER_CHECKUP = 7200; // Alle 2 Stunden lüften

// Schalter
int winterLight = 0; // 12h Sonne

// Uhr
RTC_DS1307 rtc;
long lastPumpeCheckCycle = 0; 
long lastLuefterCheckCycle = 0; 

Hier stellen wir ein paar Parameter ein:

Mit FEUCHTIGKEIT_MINIMUM wird der Wert eingestellt, ab wann der Bodensensor die Erde als zu trocken interpretiert. Wird die Erde trocken steigt der Messwert und wir definieren in diesem Fall 600 als Grenze ab wann gegossen werden muss.
Mit INTERVALL_PUMPE_CHECKUP legen wir eine Zeitspanne in Sekunden fest, nach der die Feuchtigkeit erneut geprüft werden soll.
Mit INTERVALL_LUEFTER_CHECKUP legen wir eine Zeitspanne fest, nach der gelüftet wird.
Mit winterLight speichern wir den Zustand des Beleuchtungszeit-Schalters. Bei 0 wird lange Beleuchtet – auf 1 nur kurz.
Als rtc wir das Uhrzeit-Modul (die RealTimeClock) bezeichnet.
In der Variable lastPumpeCheckCycle wird der Zeitpunkt der letzten Feuchtigkeitsmessung gespeichert.
In der Variable lastLuefterCheckCycle wird der Zeitpunkt der letzten Lüftung gespeichert.

// Digital Pins
int RELAIS_LICHT = 3;
int SWITCH_WINTER = 4;
int RELAIS_PUMPE = 5;
int RELAIS_LUEFTER = 6;
int POWER_SENSOR = 7;

// Analog Pins
int PIN_FEUCHTIGKEIT = A3;

Hier wird noch definiert an welchen Pins welche Sensoren anliegen.

Die Digital-Pins 3, 5 und 6 sind zum Schalten der drei Relais. Mit Pin 4 wird der Beleuchtungsdauer-Schalter eingelesen.

Pin 7 dient als Stromversorgung für den Feuchtigkeitssensor. Dieser liefert sein Messsignal dann am Analog-Pin A3. Diese Feuchtigkeitssensoren neigen leider dazu stark zu korrodieren, wenn sie zu oft/lange benutzt werden. Es empfiehlt sich daher, den Sensor nur zum Messen einzuschalten und das auch nicht ganz so oft.

void setup() {
  // Einrichtung der Uhr
  Serial.begin(57600);
  if (! rtc.begin()) {
    Serial.println("Couldn't find RTC");
    while (1);
  }
  
  // Set RTC Time - uncomment next line
  //rtc.adjust(DateTime(__DATE__, __TIME__));

  // Einrichtung des Relais
  // Relais schalten bei GND/LOW
  pinMode(RELAIS_PUMPE, OUTPUT);
  digitalWrite(RELAIS_PUMPE, HIGH); // Erstmal Pumpe Aus lassen
  
  pinMode(RELAIS_LUEFTER, OUTPUT);
  digitalWrite(RELAIS_LUEFTER, HIGH); // Erstmal Lüftung Aus lassen
  
  pinMode(RELAIS_LICHT, OUTPUT);
  digitalWrite(RELAIS_LICHT, HIGH); // Erstmal Licht Aus lassen
  
  pinMode(POWER_SENSOR, OUTPUT);
  digitalWrite(POWER_SENSOR, LOW); // Erstmal Sensor-Versorgung Aus lassen

  pinMode(SWITCH_WINTER, INPUT);
}

In der Setup-Funktion wird zunächst die Verbindung mit der RTC hergestellt. Klappt es nicht, brechen wir ab und werfen einen Fehler.

Anschließend definieren wir nur noch welche Digital-Pins als Ein- bzw Ausgang fungieren und stellen die ersten Zustände ein.

void loop() {
  long nowTime = rtc.now().secondstime();
  if(lastPumpeCheckCycle == 0 || (nowTime - lastPumpeCheckCycle) > INTERVALL_PUMPE_CHECKUP)
  {
    Serial.println("Zeit für Feuchtigkeits-Check");
    lastPumpeCheckCycle = nowTime;
    
    // 1. Feuchtigkeit messen
    digitalWrite(POWER_SENSOR, HIGH);
    delay(500); // Warten um Sensor Zeit zum starten zu geben
    int feuchtigkeitWert = analogRead(PIN_FEUCHTIGKEIT);
    Serial.print("Feuchtigkeit: ");
    Serial.print(feuchtigkeitWert);
    Serial.println();
    digitalWrite(POWER_SENSOR, LOW);
    
    // 2. Pumpe ggf starten
    if(feuchtigkeitWert > FEUCHTIGKEIT_MINIMUM){
      Serial.println("Pumpe an");
      digitalWrite(RELAIS_PUMPE, LOW);
      delay(1000);
      digitalWrite(RELAIS_PUMPE, HIGH);
      Serial.println("Pumpe aus");
    }else{
      Serial.println("Pumpe nicht erforderlich");
    }
  }
  else
  {
    Serial.println("Kein Feuchtigkeits-Check");
  }

Und schon geht es in die Loop. Diese Funktion wird immer wieder durchlaufen und macht grundsätzlich drei Unter-Funktionen.

Im ersten Durchlauf wird geprüft ob der letzte Bodenfeuchtigkeitscheck länger her ist, als wir mit INTERVALL_PUMPE_CHECKUP definiert haben (also länger als 8 Stunden). Ist dem so, dann schalten wir die Stromversorgung des Sensors ein. Dann warten eine halbe Sekunde damit der Sensor Zeit zum Messen hat. Daraufhin lesen wir den Messwert aus, speichern ihn in ‚feuchtigkeitWert‘ und schalten den Sensor wieder ab.

Ist der Feuchtigkeitswert nun größer (also trockener) als unser Grenzwert (FEUCHTIGKEIT_MINIMUM), dann wird die Pumpe für eine Sekunde eingeschaltet.

  // 3. Lüfter starten
  if(lastLuefterCheckCycle == 0 || (nowTime - lastLuefterCheckCycle) > INTERVALL_LUEFTER_CHECKUP){
    Serial.println("Zeit für Lüften");
    lastLuefterCheckCycle = nowTime;
    Serial.println("Lüfter an");
    digitalWrite(RELAIS_LUEFTER, LOW);
    delay(10000);
    digitalWrite(RELAIS_LUEFTER, HIGH);
    Serial.println("Lüfter aus");
  }

Im zweiten Teilbereich gucken wir, ob der Lüftungsablauf länger her ist, als wir in INTERVALL_LUEFTER_CHECKUP definiert haben. Ist dem so, dann wird 10 Sekunden der Lüfter eingeschaltet

  // 4. Lampe checken
  // Schalter Position prüfen
  winterLight = digitalRead(SWITCH_WINTER);
  Serial.print("Winterlicht: ");
  Serial.println(winterLight);
  if(winterLight && rtc.now().hour() >= 8 && rtc.now().hour() < 20
    || !winterLight && rtc.now().hour() >= 6 && rtc.now().hour() < 22){
    Serial.println("Licht an");
    digitalWrite(RELAIS_LICHT, LOW);
  }else{
    Serial.println("Licht aus");
    digitalWrite(RELAIS_LICHT, HIGH);
  }
  
  delay(10000); // 10 Sekunden nichts tun
}

Abschließend wird noch geprüft auf welcher Position der Lichtschalter steht. Ist er auf Winterlicht, dann soll die Lampe nur 12 Stunden am Tag leuchten und das zwischen 8 und 20 Uhr. Ist er auf Sommerlicht, dann soll sie nur zwischen 6 und 22 Uhr leuchten. Dafür brauchen wir auch die RTC, sonst weiß der Arduino nicht wie spät es ist.

Dann darf der Arduino für 10 Sekunden nichts tun bevor er die Loop-Funktion wieder durchläuft.

Ergebnis

Der gesamte Aufbau hat wunderbar funktioniert und rettet bis heute unsere etwas sensibleren Pflanzen wie beispielsweise die Chilis.

In unserem Experiment steht der Blumentopf im Wassertank, so dass bei einer Fehlfunktion der Anlage kein Wasserschaden in der Wohnung entstehen kann. Hier ein Bild des Aufbaus:

Den Schlauch an der Pumpe haben wir am Rand des Topfes befestigt und mit mehreren Löchern versehen. Dadurch wird die Erde gleichmäßig befeuchtet.

Mit der Zeit haben wir natürlich noch einige Verbesserungen vorgenommen, die hier demnächst in Teil 2 erscheinen werden.