2191425

Automatische Bewässerung: Blumen mit Arduino gießen

03.10.2016 | 10:23 Uhr |

Es ist der Horror schlechthin: Man will einige Tage wegfahren und muss feststellen, dass die Nachbarn Gleiches vorhaben. Und das, wo der Wetterbericht doch Tropenhitze angesagt hat. Wer soll denn nun die Blumen gießen?

Die Versorgung der Zimmerpflanzen während des Urlaubs ist ein bekanntes Problem. Meist müssen Bekannte oder Nachbarn herhalten, die möglichst regelmäßig alle paar Tage die Blumen gießen. Eine andere Lösung wäre, die Pflanzen im Vorfeld so sehr mit Wasser zu überschütten, dass sie nahezu überwässert sind, was aber auch problematisch ist, wenn man mehrere Tage fort ist. Außerdem läuft man Gefahr, zumindest Blumen zu ertränken. Eine automatische Bewässerung muss also her. Es gibt diverse Systeme, viele nutzen ziemlich simpel kinetische Energie durch einen oberhalb der Pflanzen stehenden Wasserbehälter. Andere wiederum setzen auf den Kapillar-Effekt. Beides klappt nicht immer zuverlässig und ist zudem vergleichsweise ungeregelt.

Sucht man nun in Online Shops nach steuerbaren Lösungen, findet man meist nur gartentaugliche Bewässerungsanlagen mit elektronischen Steuerungen für den Wasserhahn. Diese sind aber mit ihrem Gartenschaluch-Anschluss vielleicht etwas überdimensioniert für sechs Blumentöpfe; zudem kann hier eine Fehlfunktion im schlimmsten Fall zur kompletten Überflutung der Wohnung/Etage führen. Also bauen wir uns unser Bewässerungssystem selbst.

Das benötigen Sie

  • ARDUINO PRO MINI 328p

  • HC-05 Bluetooth Modul

  • NPN Transistor IRF540 N

  • 220Ohm, 0,25W Widerstand

  • Diode 1N4004

  • Drähte um die Sachen zu verbinden

  • Wasserpumpe 12V

  • Tröpfenbewässerungssystem mit 15 Dippern

  • Netzteil

  • Punktrasterplatine

  • 2 St. Leiterplattenklemmen

  • Spannungsregler L7805CV 5V

  • Kleine Plastikbox für Platine u. Netzteil

  • 5.5mm Niedervolt Steckverbinder (männchen und weibchen)

  • Stiftsockelleiste (männchen/weibchen)

  • RTC DS1307 Uhr für arduino

  • wasserfester Klebstoff

  • Werkzeuge:

  • wasserfester Klebstoff

  • Lötkolben, -zinn, -fett

  • Seitenschneider

  • Teppichmesser

  • Schraubendreher

  • Minisäge um den PCB Connector zu kürzen oder Minifräser mit Sägeaufsatz

  • Bohrmaschine mit 8.5mm Bohrer

  • USB-FTDI Adapter FT232RL um den Arduino Pro Mini zu programmieren

Aufbau des Schlauchsystems:

Zunächst ist es wichtig, zu entscheiden, wieviel Tropfer das System haben soll. Unser System hat zehn Tropfer, wobei unsere Pumpe noch mehr bedienen könnte. Hier ist also Ausbau-Potenzial. Wir haben den Hauptschlauch mit einem Seitenschneider getrennt, und beim Einsetzen der T-Stücke und Tropfer ein wenig wasserfesten Kleber mit aufgetragen, so dass sie nicht nach kurzer Zeit wieder abrutschen können. Das eine Ende des Schlauches verbinden wir mit der Pumpe. Dazu haben wir einen etwas größeren Schlauch benutzt und diesen als Muffe über den originalen, schwarzen Schlauch gestülpt.

Automatischen Türöffner bauen: Wir zeigen, wie's geht

Damit diese Verbindung wasserdicht ist, und kein Leck entsteht, haben wir noch einen Kupferdraht herum gewickelt. Jetzt müssen wir noch die Wasserpumpe vorbereiten. Der ursprüngliche Sinn unserer Pumpe ist, es Kraftstoff aus einem Tank zu pumpen. Deshalb hat sie auch zwei Krokodilklemmen am Kabel, die wir jedoch abschneiden; die Isolierung entfernen wir etwas, um dann den Niedervolt-Stecker (männlich) anzulöten. Bitte bedenken Sie, dass der Center-Pin solcher Stecker positiv ist, also löten wir hier den roten Draht an. Bei Unsicherheiten bezüglich der Lötfahnen kann man mit einem Multimeter den Widerstand durchmessen, um herauszufinden welche zum Center-Pin gehört.

Aufbau des Schlauchsystems
Vergrößern Aufbau des Schlauchsystems

Die Steuerung aufbauen

Wir benötigen eine Lochrasterplatine mit einer Stiftsockelleiste. Sie wird später den Controller halten, ebenso die Bluetootheinheit, das RTC-Modul, einen Leistungstransistor mit eine Schutzdiode, einen Widerstand, Verbindungsdrähte und einen 5V-Spannungsregler. Das fritzing-Schema zeigt den Aufabu. Dazu muss der Lötkolben bemüht werden.

Ein fritzing-Schema mit einer vereinfachten Darstellung der Platine
Vergrößern Ein fritzing-Schema mit einer vereinfachten Darstellung der Platine

Wir schneiden zunächst die weiblichen PCB-Stiftsockel zu. Wir benötigen zwei 12-Pin-Steckverbinder für den Microcontroller, und ebenfalls zwei Pin-Verbinder für die entsprechenden A4 und A5 Pins auf dem Microcontroller. Weiterhin brauchen wir einen 6-Pin-Verbinder für die Bluetooth-Einheit und einen 5-Pin-Verbinder für das RTC DS1307 .

Nachdem wir die Stiftsockelleiste in passende Stücke geschnitten haben, können wir sie auf die Rückseite der Punktrasterplatine löten.

Die Baugruppen der Steuerung.
Vergrößern Die Baugruppen der Steuerung.

Dann werden die zwei KF301-2P-Leiterplattenklemmen verlötet.

Der L7805CV 5V wird innerhalb des Microcontroller-Einbauorts auf die Lochplatte montiert und ebenfalls verlötet.

Es folgen der NPN IRF540N-Transistor und die 1N4004-Schutzdiode.

Den 220 Ohm-Widerstand löten wir zwischen den entsprechenden Digital-Pin 5 und dem Transistor-Base-Pin.

Der Arduino auf der Trägerplatine.
Vergrößern Der Arduino auf der Trägerplatine.

Nun löten wir etwas dickere Drähte zwischen den Transistor und den KF301-2P-Stecker (rot und schwarz wie auf dem entsprechenden Bild zu sehen).

Wir löten die roten (+), schwarzen (-) und weißen (Signal) Drähte genauso, wie es das Fritzing-Schema zeigt.

Danach löten wir die männlichen Pins auf den Microcontroller, dazu benötigen wir 12 männliche Pins auf der Seite, zwei männliche Pins für A4 und A5, und 6 gebogene Pins zum Programmieren.

Die Rückansicht mit der kompletten Verkabelung.
Vergrößern Die Rückansicht mit der kompletten Verkabelung.

Anschließend löten wir fünf männliche Pins auf den RTC DS1307, und schließen eine 3,3V-Batterie an.

Wir platzieren den Microcontroller, die Bluetooth-Einheit und das RTC-Modul auf den weiblichen PCB-Connector und drücken beides sehr behutsam zusammen, so dass alle Pins gut kontaktieren und nicht verbiegen.

Die Abdeckung bauen

Zunächst entfernen wir die Abdeckung des Netzteils mit Hilfe unserer Minifräse. Nachdem wir sie vorsichtig geöffnet haben, können wir die Platine herausnehmen, die vier Drähte entlöten und sie dann komplett aus dem Kunststoffgehäuse entfernen.

Die Platine mit Speicherbatterie, Arduino und Bluetooht-Modul.
Vergrößern Die Platine mit Speicherbatterie, Arduino und Bluetooht-Modul.

Unsere neue Elektronik-Box besteht aus zwei Teilen: Auf der inneren Rückenseite der Box, entfernen wir zunächst den Kunststoff-Pin mit unserem Minifräser. In unserer Box ist nicht sonderlich viel Platz; deshalb müssen wir vorsichtig sein, dass wir nicht die vier Schraubenhalter wegfräsen. In die Gehäusefront bohren wir nun mittig ein 8,5 mm großes Loch, wie auf dem Bild zu sehen. Hier montieren wir einen weiblichen 5,5 mm-Niedervolt Steckverbinder.

Das handelsübliche Steckernetzteil vor dem Umbau.
Vergrößern Das handelsübliche Steckernetzteil vor dem Umbau.

Jetzt löten wir den Leiter und Rückleiter der Netzteilplatine mit den Kontaktstiften des Steckers zusammen, welcher am Gehäuse montiert ist. Danach löten wir zwei Drähte, rot und weiss, für den positiven und negativen 12V-Ausgang. Diese Drähte gehen auf den rechten KF301-2P-Verbinder auf unserer Platine. Nun können wir die Netzteilplatine mit doppelseitigem Klebeband auf die Gehäuseinnenseite kleben.

Smart Home: Kühlschrank mit Innenkamera bauen

Zwei Drähte löten wir nun an die Niedervoltbuchse auf der Gehäuseinnenseite. Bedenken Sie auch hier wieder die Polarität des Center-Pins (+) haben. Um sicher zu gehen prüfen wir mit einem Messgerät, welches die richtige Löftfahne ist. Die anderen Enden der Kabel gehen dann auf die linke Seite des KF301-2P.

Das ausgelöste Innenleben des Netzteils.
Vergrößern Das ausgelöste Innenleben des Netzteils.

Nun ist es Zeit, mit etwas Schaumstoff unsere selbst gebaute Platine und die Platine des Netzteils zu trennen. Für Testzwecke haben wir die Platine „schwebend“ in dem Gehäuse belassen. Aber durch den geringen Platz und zusätzlichem Schaumstoff kann sie sich sowieso kaum bewegen.

Das neue Gehäuse, das alle Bauteile aufnehmen wird.
Vergrößern Das neue Gehäuse, das alle Bauteile aufnehmen wird.

Der Code

Wir sind schon fast am Ziel, müssen nun aber noch unseren Arduino programmieren.

Der Niedervoltanschluss für die Pumpe.
Vergrößern Der Niedervoltanschluss für die Pumpe.

Folgende Aspekte sind dabei zu berücksichtigen und einzupflegen:

  • Durch das RTC-Modul weiß das System die Uhrzeit.

  • Die Software Serial Library soll mit dem HT-05-Bluetooth-Modul kommunizieren, es wartet auf die Bewässerungskommandos, und es bestimmt den Zeitpunkt der Bewässerung sowie die Dauer. Die Kommandos lauten: "watering hour:watering minute:watering seconds number".

  • In der Hauptschleife wird das Bluetooth-Modul serielll geprüft, und, sofern die Befehle gelesen sind, werden sie gesetzt/ausgeführt. Wir prüfen ebenfalls eine Routine die sich ‘isWateringTime’ nennt. Wenn ‚true‘ zurückkehrt beginnt der Bewässerungsprozess.

Unauffällig: Die Steuerung von oben.
Vergrößern Unauffällig: Die Steuerung von oben.
Die Platine aus dem alten Netzteil wird mit den Steckkontakten verbunden.
Vergrößern Die Platine aus dem alten Netzteil wird mit den Steckkontakten verbunden.
Wichtig; Die Platinen werden mit Styropor-oder Schaumstoffband im Gehäuse fixiert.
Vergrößern Wichtig; Die Platinen werden mit Styropor-oder Schaumstoffband im Gehäuse fixiert.

Zu Testzwecken werden Bewässerungszeit und -dauer über die Bluetooth seriell geschrieben. Die benötigten Bibliotheken sind: "Wire", "RTClib", "SoftwareSerial". Die ersten zwei Bibliotheken werden für das RTC-Modul benötigt und die dritte für das Bluetooth-Modul. Wenn das Ganze das erste Mal läuft, und das RTC bis jetzt nicht programmiert ist, sollten wir folgende Zeile auskommentieren: "rtc.adjust(DateTime(__DATE__, __TIME__));" und es einfach hochladen. Das wird automatisch auf dem RTC-Modul dann die gleiche Zeit einstellen wie auf unserem Computer. Danach setzen wir die Zeile in Kommentarzeichen und laden die Datei erneut hoch.

Der Code

//bt device ..5A:50

#include #include "RTClib.h" #include

const int waterPumpPin = 5;

//Stelle dies ein um die Pumpe mit mehr oder weniger Leistung arbeiten zu lassen: const int waterPumpPower = 255; int lastMinute = 0;

char buffer[] = {' ',' ',' ',' ', ' ', ' ', ' ', ' '}; int commands[] = {17,56,10};//run_hour:run_minute:watering_seconds

RTC_DS1307 rtc; SoftwareSerial bluetooth(10, 11); // RX, TX

void setup () { Serial.begin(9600); bluetooth.begin(9600); Wire.begin(); rtc.begin(); pinMode(waterPumpPower, OUTPUT); analogWrite(waterPumpPin, 0); // Entferne die Kommentarzeichen dieses Kommentars um die Zeit das erste mal einzustellen //rtc.adjust(DateTime(__DATE__, __TIME__)); DateTime now = rtc.now(); lastMinute = now.minute(); }

void loop () { if (bluetooth.available()) { for(int i=0;i<3;i++){ String value = bluetooth.readStringUntil(':'); int numericVal = value.toInt(); commands[i] = numericVal; } printCurrentTime(); Serial.print("Set for:");Serial.print(commands[0]);Serial.print(":");Serial.println(commands[1]); Serial.print("Duration:");Serial.print(commands[2]);Serial.println(" s"); bluetooth.print("Set for:");bluetooth.print(commands[0]);bluetooth.print(":");bluetooth.println(commands[1]); bluetooth.print("Duration:");bluetooth.print(commands[2]);bluetooth.println(" s"); } if (isWateringTime()) { Serial.println("watering.."); bluetooth.println("watering.."); startWatering(commands[2]); delay(60000); } delay(300); }

void startWatering(int duration) { analogWrite(waterPumpPin, waterPumpPower); delay(duration * 1000); analogWrite(waterPumpPin, 0); }

boolean isWateringTime() { DateTime now = rtc.now(); if (now.minute() != lastMinute) { printCurrentTime(); lastMinute = now.minute(); } return now.hour() == commands[0] && now.minute() == commands[1]; }

void printCurrentTime() { DateTime now = rtc.now(); Serial.print("Current time: ");Serial.print(now.hour(), DEC);Serial.print(':');Serial.print(now.minute(), DEC);Serial.println(); bluetooth.print("Current time: ");bluetooth.print(now.hour(), DEC);bluetooth.print(':');bluetooth.print(now.minute(), DEC);bluetooth.println(); }

Betrieb des Systems, Abstimmung und finale Gedanken

Zunächst ein Wort über „Sicherheit geht vor!“.

Obwohl dies Konzept sicherer ist als Ventile, die am aufgedrehten Wasserhanh angeschlossen sind, haben wir es hier mit einem System zu tun, das auf Basis von Versuchen aufgebaut wurde und demnach auch noch Fehler enthalten kann. Es kann unter Umständen gerade in der Anfangsphase dazu kommen, dass das System fehlerbedingt das komplette Wasser auf einmal durchpumpt, weshalb es sich empfiehlt, die Anlage zunächst dort in Betrieb zu nehmen wo ein übermäßiger Wasserfluss nicht zu riesigen Schäden führen kann. Eine Waschküche, der Balkon oder die Badewanne bieten sich hier an. Um eventuellen Hardware-Fehlern auf den Grund zu gehen, sollte man die Box nicht eher schließen, bis das System einwandfrei läuft. Dazu sollten fünf Schritte erfolgreich absolviert worden sein:

Die beiden Anschlüsse der Platine dienen der Stromversorgung und der Pumpensteuerung
Vergrößern Die beiden Anschlüsse der Platine dienen der Stromversorgung und der Pumpensteuerung

Wir verbinden das System mit irgendeiner Bluetooth-App (Android oder iOS). Zunächst sollten wir nach unserem Bluetooth-Gerät suund verbinden. Dann gehen wir in den CMD-Line-Modus. Es gibt hierfür sehr viel Tutorials, weshalb wir darauf nicht noch detaillierter eingehen.

Hier erkennt man deutlich, wie die Platine verkabelt ist.
Vergrößern Hier erkennt man deutlich, wie die Platine verkabelt ist.

Wenn allesgeklappt hat, sollte man jetzt die aktuelle Stunde und Minute sehen, die sich minütlich aktualisiert.

Setzen Sie nun die „end flag“ auf „nothing“.

Jetzt werden die Geräte-Ausgabe-Kommandos programmiert:

HH:MM:tt:

HH ist die Wässerungsstunde

MM ist die Bewässerungsminute

tt ist die Nummer der arbeitenden Sekunden

Der Doppelpunkt „:“ zwischen den Nummern ist sehr wichtig. Nachdem man dieses Kommando geschrieben hat, versendet man es umgehend. Jetzt sollte eine Nachricht zu sehen sein: „Set for HH:MM“ und „Duration: tt s“. Dies bedeutet, dass die Zeit erfolgreich eingestellt wurde.

Am Ende finden sowohl die Stromversorgung als auch die Steuerung in dem neuen Gehäuse Platz.
Vergrößern Am Ende finden sowohl die Stromversorgung als auch die Steuerung in dem neuen Gehäuse Platz.

Wenn die interne Uhr die programmierte Zeit erreicht hat, wird die Pumpe für eine eingestellte Dauer laufen. Dies wiederholt sich dann jeden Tag.

Fertig: Der Testlauf kann beginnen. Möglichst an einer Stelle, an der Fehlfunktionen keinen Wasserschaden anrichten
Vergrößern Fertig: Der Testlauf kann beginnen. Möglichst an einer Stelle, an der Fehlfunktionen keinen Wasserschaden anrichten

Fazit

Das Bewässerungssystem arbeitet, einmal richtig eingestellt, zuverlässig und vor allem sehr dosiert. Der mächste Schritt könnte jetzt noch sein, es netzwerkfähig zu machen.

Geniale & kuriose Gadgets vom MWC 2016
0 Kommentare zu diesem Artikel

PC-WELT Hacks - Technik zum Selbermachen?

Raspberry Pi erfreut sich gerade unter Bastlern einer großen Beliebtheit. Kein Wunder, denn mit der 35-Euro-Platine lassen sich viele spannende Projekte realisieren. Vom Mediacenter, Netzwerkspeicher, Fotomaschine bis hin zum Überwachungssystem ist alles möglich. Dieser Bereich ist aber nicht nur dem Raspberry Pi gewidmet, sondern bietet auch viele Tipps, Tricks und Anleitungen für andere spannende Bastelprojekte.

2191425