Mikrocontrollergesteuerter Blumengießautomat - s

Dominik Groothuis: Mikrocontrollergesteuerter Blumengießautomat
Kurzfassung
Landeswettbewerb Bremen
Mikrocontrollergesteuerter Blumengießautomat
Blumengießen vergessen? Kein Problem. Mit dem Blumengießautomat kann jede Pflanze
aus einem Eimer in der Zimmerecke mit soviel Wasser versorgt werden, wie sie benötigt.
Mit dem ARDUINO-Board und einem dafür selbst geschriebenen Programm können
einzelne Pumpen so angesteuert werden, dass jede Pflanze in unterschiedlichen
Zeiträumen mit genau der richtigen Wassermenge versorgt werden kann.
Ein Feuchtesensor misst den Wassergehalt in der Blumenerde und der Mikrocontroller
entscheidet, ob die Pflanze gegossen werden muss oder nicht.
Die ARDUINO-Plattform ist eine aus Soft- und Hardware bestehende Physical-ComputingPlattform. Die Hardware besteht aus einem einfachen I/O-Board mit einem Mikrocontroller
und analogen und digitalen Ein- und Ausgängen. Die Programmsprache beruht auf
Processing. ARDUINO kann benutzt werden, um eigenständige interaktive Objekte zu
steuern.
Seite 2/11
ID: 3654:106367
Dominik Groothuis: Mikrocontrollergesteuerter Blumengießautomat
Inhaltsverzeichnis
Kurzfassung....................................................................................................................... 2
Inhaltsverzeichnis ............................................................................................................. 3
Einleitung ........................................................................................................................... 4
Theorie ............................................................................................................................... 5
Die ARDUINO-Umgebung ............................................................................................... 5
Die Hardware................................................................................................................... 5
Die Software .................................................................................................................... 6
Ergebnisse ......................................................................................................................... 7
Vorüberlegungen ............................................................................................................. 7
Spannungsteiler ............................................................................................................... 8
Die Programmierung........................................................................................................ 8
Das ARDUINO-Programm ............................................................................................... 9
Zusammenbau und Schaltung des Blumengießautomaten ........................................... 10
Diskussion ....................................................................................................................... 11
Quellen- und Literaturverzeichnis ...................................................................................... 11
Seite 3/11
ID: 3654:106367
Dominik Groothuis: Mikrocontrollergesteuerter Blumengießautomat
Einleitung
Während der Urlaubszeit, besonders in den Sommerferien, kommt bei vielen Urlaubern
immer wieder die Frage auf: Wer gießt meine Blumen, damit sie die Ferien unbeschadet
überstehen. Oft fahren auch die Nachbarn oder Freunde zur selben Zeit in den Urlaub und
können die Fürsorge für die Blumen nicht übernehmen.
Unsere Idee war, einem Automaten diese Aufgabe zu übertragen.
Die einfachste Möglichkeit wäre eine Zeitschaltuhr, die in bestimmten Zeitabständen für
kurze Zeit eine Pumpe einschaltet, die über ein Schlauchsystem Wasser in die
Blumentöpfe pumpt.
Nachteil aber ist, dass alle Pflanzen immer die gleiche Wassermenge bekommen
ungeachtet, ob sie diese Wassermenge auch benötigen.
Also überlegten wir weiter, ob es möglich wäre, den Wasserbedarf für jede einzelne
Pflanze zu ermitteln, um ihr gezielt die benötigte Wassermenge zukommen zu lassen.
Das hieße, dass die in der Blumenerde enthaltene Feuchtigkeit über einen Sensor
ermittelt werden müsste, um der Pflanze dann genau die richtige Wassermenge zu
zuführen. Das wiederum setzt ein intelligentes Steuerungssystem voraus.
Im Rahmen unserer Jufo-AG wurden wir im Internet auf einen Mikrocontroller
aufmerksam, der diese Aufgabe bewältigen könnte.
Wir besorgten uns diesen Mikrocontroller namens ARDUINO, beschäftigten uns mit der
Programmierung dieses Controllers und machten erste Experimente.
Schon nach kurzer Zeit hatten wir uns in den Umgang mit dem ARDUINO-Board
eingearbeitet und waren in der Lage den Mikrocontroller über kleine Programme, die auf
das ARDUINO-Board hochgeladen werden mussten, zu steuern.
Jetzt konnten wir mit der eigentlichen Arbeit, dem Bau des Blumengießautomaten,
beginnen.
Seite 4/11
ID: 3654:106367
Dominik Groothuis: Mikrocontrollergesteuerter Blumengießautomat
Theorie
Die ARDUINO-Umgebung
Die ARDUINO-Plattform ist eine aus
Softund
Hardware
bestehende
Physical-Computing-Plattform.
Beide Komponenten sind im Sinne von
Open Source quelloffen, d.h. sie können
von jedem Anwender benutzt und
verändert werden.
Die Hardware besteht aus einem
einfachen
I/O-Board
mit
einem
Mikrocontroller und analogen und
digitalen Ein- und Ausgängen.
Die Entwicklungsumgebung beruht auf
der Programmiersprache Processing
(einem Java-Dialekt), die vor allem für
Das ARDUINO Board Duemilanove
Nicht-Informatiker gedacht ist.
ARDUINO kann benutzt werden, um eigenständige interaktive Objekte zu steuern oder um
mit Softwareanwendungen auf Computern zu interagieren.
Die Hardware
Die Hardware des ARDUINO Duemilanove basiert auf einem Atmel AVR-Mikrocontroller
dem ATmega328. Alle Boards werden entweder über USB oder eine externe
Spannungsquelle mit 5-9 Volt versorgt und verfügen über einen 16 MHz-Quarzoszillator.
Der Mikrocontroller ist mit einem Boot-Loader (spezielle, grundlegende Software zum
Betrieb des ARDUINO-Boards) vorprogrammiert, wodurch die Programmierung direkt über
die USB – Schnittstelle, ohne externes Programmiergerät erfolgen kann.
Die ARDUINO-Boards stellen die meisten I/O-Pins des Mikrocontrollers zur Nutzung für
elektronische Schaltungen zur Verfügung. Die aktuell gängigen Boards bieten 14 digitale
I/O-Pins und 6 analoge Ein- und Ausgänge.
Für die Erweiterung werden vorbestückte oder teilweise unbestückte Platinen sogenannte „Shields“ - angeboten, die auf das ARDUINO-Board aufsteckbar sind. Es
können aber auch z.B. Steckplatinen für den Aufbau von Schaltungen verwendet werden.
Seite 5/11
ID: 3654:106367
Dominik Groothuis: Mikrocontrollergesteuerter Blumengießautomat
Die Software
ARDUINO bringt eine eigene Integrierte
Entwicklungsumgebung (Abkürzung: IDE,
von englisch: integrated development
environment) mit. Dabei handelt es sich um
eine
plattformunabhängige
JavaAnwendung.
Die Software läuft unter Windows, Mac und
Linux.
Die
Programmiersprache
Processing
basiert auf der stark vereinfachten
Programmierung in C/C++.
Die ARDUINO-IDE bringt einen eigenen
Code-Editor mit und verfügt über einen
integrierten
Compiler
(Programmübersetzer) zur Überprüfung des Programmcodes.
Zusätzlich wird die Programmierung durch
weitere ARDUINO-Libraries (Programmbibliotheken) stark vereinfacht.
Der ARDUINO Code-Editor
Für ein funktionstüchtiges Programm genügt
es, zwei Funktionen zu definieren:
void setup() - wird beim Start des Programms aufgerufen, nützlich um z.B. Pins als
Eingang oder Ausgang zu definieren und
void loop() - wird durchgehend durchlaufen, solange bis das ARDUINO-Board
ausgeschaltet wird.
Hier ein Beispiel für ein Programm (in der ARDUINO-Sprache Sketch genannt), das eine
an das ARDUINO-Board angeschlossene LED blinken lässt:
/*
Programm "Blink"
Schaltet abwechselnd eine LED für eine Sekunde an
und dann für eine Sekunde aus. Der Vorgang wiederholt sich.
*/
int LEDPin = 13;
//Die LED ist an Pin 13 angeschlossen
void setup() {
pinMode(LEDPin, OUTPUT); //Der Pin 13 wird als Ausgang festgelegt.
}
void loop() {
digitalWrite(LEDPin, HIGH);
delay(1000);
digitalWrite(LEDPin, LOW);
delay(1000);
}
Seite 6/11
//LED an
//1 Sekunde warten
//LED aus
//1 Sekunde warten
ID: 3654:106367
Dominik Groothuis: Mikrocontrollergesteuerter Blumengießautomat
Ergebnisse
Vorüberlegungen
Zunächst mussten einige Vorüberlegungen angestellt werden, welche Geräte benutzt und
angeschafft werden sollten. Als Wasserpumpe sollte eine 12 Volt-Pumpe aus dem
Campingbereich dienen.
Der Atmega Controller auf dem ARDUINO-Board hat einen maximalen zulässigen
Ausgangsstrom von 40 mA pro Ausgang, der nicht überschritten werden darf.
Unsere Pumpe hatte aber eine größere Stromaufnahme. Also musste sie über ein Relais
geschaltet werden. Aber auch ein Relais hat eine größere Stromaufnahme als 40 mA.
Wenn mit dem ARDUINO ein Relais angesteuert werden soll, so ist das nur mit einem
vorgeschalteten Transistor und einer Freilaufdiode möglich oder es wird ein DarlingtonArray (in einer integrierten Schaltung (IC)) verwendet. Wir entschlossen uns für die
Verwendung des ULN2003 - IC’s.
Der ULN2003 beinhaltet 7 solcher Darlington Transistorkombinationen. Des Weiteren
enthält er bereits die notwendigen Freilaufdioden. Er ist also ideal dazu geeignet um
größere Verbraucher zu schalten. Der Strom zur Steuerung der Relais und für die Pumpe
selbst, wird dabei von einer externen Stromquelle zur Verfügung gestellt.
Mit dem Darlington Array ULN2003 lassen sich also insgesamt 7 Relais steuern und damit
sieben verschiedene Bewässerungsprogramme durchführen. (In unserer Schaltung
benutzen wir beispielhaft nur ein Relais).
Nachfolgend ein schematischer Aufbau in dem alle 7 Arrays verwendet werden:
Der Anschluss des ULN2003 an das ARDUINO-Board
Schaltung des ULN2003
Ein weiteres Problem stellte die Messung der Feuchtigkeit in der Blumenerde dar. Wir
entschieden uns für den Feuchtesensor KFS33 der Firma Hygrosens. Allerdings stellte
sich heraus, dass sich der Anschluss an das ARDUINO-Board sehr schwierig gestaltete.
Wir nahmen Kontakt zur Herstellerfirma auf. Die Herstellerfirma riet uns von einer
Verwendung des Sensors in Blumenerde ab, sodass wir uns um andere Möglichkeiten der
Feuchtebestimmung kümmern mussten.
Wir führten Experimente mit der Messung des Ohmschen Widerstandes in Blumenerde
durch und stellten schnell fest, dass sich das Verfahren gut für unsere Zwecke eignete.
Feuchte Blumenerde hat, je nach Wassergehalt, einen elektrischen Widerstand von
10 k€ - 1000 k€, trockene Erde einen sehr großen Widerstand, der nicht mehr messbar
war. Also nahmen wir als Sensorersatz zwei Edelstahl-Schaschlikspieße, die wir im
Abstand von ca. 3 cm in die Blumenerde steckten und mit dem ARDUINO-Board
verbanden.
Seite 7/11
ID: 3654:106367
Dominik Groothuis: Mikrocontrollergesteuerter Blumengießautomat
Die Schaschlikspieße stellten in Kombination mit einem Vorwiderstand von 620 k€ einen
Spannungsteiler dar. Auf diese Weise konnten am Analogeingang des ARDUINO-Boards
Spannungen von 0 Volt – 5 Volt, je nach Feuchtigkeit der Erde, gemessen werden.
Je größer die Spannung, desto trockener die Blumenerde.
Nach einigen Experimenten legten wir einen Wert fest, ab dem die Blume begossen
werden sollte.
Spannungsteiler
Der Analogeingang des ARDUINO wandelt eine
Spannung von 0 Volt bis 5 Volt in einen Zahlenwert von
0 bis 1023 um. Der Wert 1 entspricht demnach einer
5 Volt
Spannung von
€ 0, 0049 Volt .
1024
Das
Verhältnis
aus
Vorwiderstand
und
Sensorwiderstand
bestimmt die am Analogeingang gemessene Spannung. Der
eingestellte Wert von 700 entspricht also einer Spannung
von 3,42 Volt oder einem Widerstand von 1340 k€. Wird am
Sensor also eine Spannung von 3,42 Volt bis 5 Volt
gemessen, ist der elektrische Widerstand der Blumenerde
größer als 1340 k€, die Erde zu trocken und die Pflanze
muss begossen werden.
Die Programmierung
Unser Ziel war es nun, ein Programm für das ARDUINO-Board zu schreiben, dass die
Topfblumen automatisch gießt, wenn sie Wasser benötigen.
Im Programmkopf haben wir zunächst alle Anschlüsse des ARDUINO-Boards und die
daran angeschlossenen Bauteile sowie alle Anfangseinstellungen festgelegt (int bedeutet
dabei Initialisierung - Herstellen eines bestimmten Anfangszustands).
Im Setup wird festgelegt, welcher Anschluss als Ein- bzw. Ausgang arbeiten soll.
Mit dem Befehl Serial.begin (9600) wird der Serialmonitor mit einer Datenrate von 9600
Baud (9600 Zeichen pro Sekunde) gestartet, der in einem Extrafenster die gemessenen
Werte auf dem Computerbildschirm ausgibt.
Mit der Bewässerungszeit kann die Wassermenge, die in den Blumentopf gepumpt wird,
festgelegt werden.
Das Messintervall steht für den Zeitraum zwischen zwei Messungen.
Die Programmschleife (voidloop ()) beginnt mit dem Auslesen des Sensorwertes bzw.
des Ohmschen Widerstandes der Blumenerde. Danach wird der gemessene Wert auf dem
Serialmonitor ausgegeben.
Damit die Pflanze nicht ständig unter Strom steht, wird die Spannung am Sensor nur für
die kurze Dauer der Messung eingeschaltet.
Die drei LED’s (grün, gelb, rot), dienen der Kontrolle des Programmablaufes.
Wenn die rote LED leuchtet, heißt das, dass die Blume zu trocken ist. Nach 4 Sekunden
(die Zeit kann man beliebig einstellen), leuchtet die gelbe LED und die Pumpe wird für die
Dauer der Bewässerungszeit gestartet und die Pflanze gegossen. Wenn die Pflanze zum
Zeitpunkt der Messung noch feucht ist, geht die grüne LED an und ARDUINO wartet bis
zur nächsten Messung. Wurde die Pflanze bei der letzten Messung gegossen, bleibt die
rote LED eingeschaltet.
Seite 8/11
ID: 3654:106367
Dominik Groothuis: Mikrocontrollergesteuerter Blumengießautomat
Das ARDUINO-Programm
/*
Jugend forscht - Projekt 2011
Blumengießautomat
Projektteilnehmer: Dominik Groothuis
*/
int Relais1 = 2;
int Relais2 = 3;
int Relais3 = 4;
int Relais4 = 5;
int Relais5 = 6;
int Relais6 = 7;
int Relais7 = 8;
int LEDrot = 11;
int LEDgelb = 12;
int LEDgruen = 13;
int Sensor = A5;
int Sensorwert = 0;
int Bewaesserungszeit = 3000;
int Messintervall = 10000;
float Sensorspannung = A0;
float Spannung;
void setup(){
pinMode(Sensor, INPUT);
pinMode(Sensorspannung, OUTPUT);
pinMode(Relais1, OUTPUT);
pinMode(Relais2, OUTPUT);
pinMode(Relais3, OUTPUT);
pinMode(Relais4, OUTPUT);
pinMode(Relais5, OUTPUT);
pinMode(Relais6, OUTPUT);
pinMode(Relais7, OUTPUT);
pinMode(LEDgruen, OUTPUT);
pinMode(LEDgelb, OUTPUT);
pinMode(LEDrot, OUTPUT);
Serial.begin(9600);
}
void loop(){
digitalWrite(Sensorspannung, HIGH);
delay(1000);
Sensorwert = analogRead(Sensor);
Serial.print("Sensorwert: ");
Serial.println(Sensorwert);
Spannung = Sensorwert*5.00/1024;
Serial.print("Spannung am Sensor: ");
Serial.print(Spannung);
Serial.println(" Volt");
Serial.print("Widerstand der Blumenerde: ");
Serial.print(620*Spannung/(5-Spannung));
Serial.println(" kOhm");
delay(1000);
digitalWrite(Sensorspannung, LOW);
if (Sensorwert > 700)
{
digitalWrite(LEDgruen, LOW);
digitalWrite(LEDrot, HIGH);
delay(2000);
digitalWrite(LEDgelb, HIGH);
digitalWrite(Relais1, HIGH);
delay(Bewaesserungszeit);
digitalWrite(LEDgelb, LOW);
digitalWrite(Relais1, LOW);
}
else
{
digitalWrite(LEDrot, LOW);
digitalWrite(LEDgruen, HIGH);
}
delay(Messintervall);
}
Seite 9/11
//Relais 1 an Port 2
//Relais 2 an Port 3
//Relais 3 an Port 4
//Relais 4 an Port 5
//Relais 5 an Port 6
//Relais 6 an Port 7
//Relais 7 an Port 8
//LED anschliessen an Port 11
//LED anschliessen an Port 12
//LED anschliessen an Port 13
//Feuchtesensor an Analogeingang 5
//initialisiert den Sensorwert
//legt fest, wie lange die Pumpe läuft
//legt das Messintervall fest
//A0 versorgt den Sensor mit 5 Volt
//Sensoreingang
//Spannungsausgang
//Relaisausgang 1
//Relaisausgang 2
//Relaisausgang 3
//Relaisausgang 4
//Relaisausgang 5
//Relaisausgang 6
//Relaisausgang 7
//LEDgrün Ausgang
//LEDgelb Ausgang
//LEDrot Ausgang
//Start des Serial Monitors
//Einschalten der Sensorspannung
//Wartezeit 1 Sekunde
//Lesen des Sensorwertes
//Ausgabe des Sensorwertes auf den Monitor
//Ausgabe der Spannung am Sensor
//Ausgabe des Widerstandes der Blumenerde
//Wartezeit 1 Sekunde
//Ausschalten der Sensorspannung
//Prüfen des Sensorwertes
//Ausschalten der grünen LED
//Einschalten der roten LED
//Wartezeit 2 Sekunden
//Einschalten der gelben LED
//Einschalten der Pumpe
//Einschaltdauer der Pumpe
//Ausschalten der gelben LED
//Ausschalten der Pumpe
//Ausschalten der roten LED
//Einschalten der grünen LED
//Wartezeit Messintervall
ID: 3654:106367
Dominik Groothuis: Mikrocontrollergesteuerter Blumengießautomat
Zusammenbau und Schaltung des Blumengießautomaten
Jetzt konnten wir mit dem Zusammenbau unseres Gießautomaten beginnen.
Wir besorgten uns die Wasserpumpe aus einem Laden für Campingartikel und alle
weiteren Komponenten im Elektronikfachhandel.
Der Übersicht halber entschlossen wir uns den Automaten beispielhaft nur mit einem
Gießprogramm zu bauen. Den Aufbau der gesamten Schaltung haben wir schematisch mit
dem Programm FRITZING, der Fachhochschule Potsdam erstellt:
Als externe Spannungsquelle benutzten wir ein 12 Volt
Netzgerät aus der Schulsammlung.
Die gesamte Schaltung konnten wir auf zwei Breadboards
(Steckleiterplatte) unterbringen und mit wenigen Kabeln mit
dem ARDUINO-Board, dem Netzteil, der Pumpe und den
Schaschlikspießen (unser Feuchtesensor) verbinden. Als
Testblumen dienten zwei kleine Blumentöpfe mit feuchter
bzw. trockener Erde. Die 12 Volt-Tauchpumpe taten wir in
einen gefüllten Wassereimer.
Um während des Tests
zwischen zwei Messungen
nicht zu lange warten zu
müssen, stellten wir das
Messintervall
(zeitlicher
Abstand
zwischen
zwei
Messungen) auf 30 Sekunden ein (im richtigen Betrieb sollte
diese Zeit 24 Stunden betragen). Die Bewässerungszeit
entspricht einer Wassermenge von etwa 100 ml.
Der erste Test verlief gleich erfolgreich. Steckten unsere
Spieße in der trockenen Erde, sprang alle 30 Sekunden die
Pumpe für 3 Sekunden an. Befanden sich die Spieße in der
feuchten Erde, wurde kein Wasser gepumpt und die grüne
LED leuchtete.
Seite 10/11
ID: 3654:106367
Dominik Groothuis: Mikrocontrollergesteuerter Blumengießautomat
Diskussion
Wir haben in der Jufo-AG unserer Schule ungefähr ein halbes Jahr an unserem Projekt
gearbeitet. Die Hälfte der Zeit haben wir uns in den Umgang und die Programmierung des
ARDUINO-Boards eingearbeitet. Ohne große Vorkenntnisse in Elektronik und Informatik
waren wir sehr schnell in der Lage kleine Programme zu schreiben, die sofort mit dem
ARDUINO in die Tat umgesetzt werden konnten. Wir waren sehr schnell von der
Einfachheit und der Robustheit des ARDUINO begeistert. Mit diesem Mikrocontroller
eröffnen sich unbegrenzte Möglichkeiten in zahllosen Projekten. Man bekommt schnell
Erfolgserlebnisse und der Ergeiz, kompliziertere Programme und Schaltungen zu
entwerfen, wächst ständig.
Dass unser Blumengießautomat auf Anhieb funktionierte, zeigt wie einfach das Arbeiten
mit dem ARDUINO-Board ist.
Der Blumengießautomat lässt sich auf 7 verschiedene Gießprogamme erweitern, so dass
der Mikrocontroller auf den unterschiedlichen Wasserbedarf einzelner Pflanzen eingestellt
werden kann. Im Programm des Automaten ist das bereits berücksichtigt.
Auch kann als Erweitung des Projektes die Luftfeuchtigkeit und die Raumtemperatur bei
der Bewässerung der Pflanzen berücksichtigt werden. Zu diesem Zweck können noch
weitere Sensoren an das ARDUINO-Board angeschlossen und in das Programm integriert
werden.
Die Arbeit an diesem Projekt und mit dem ARDUINO hat soviel Spaß gemacht, dass wir in
unserer Jufo-AG vermutlich weitere Projekte mit diesem Multitalent versuchen werden zu
realisieren.
Quellen- und Literaturverzeichnis
Bücher:
Odendahl, Finn, Wenger: ARDUINO - Physical Computing für Bastler, Designer und
Geeks, O’Reilly, Köln 2009
Internetseiten:
http://de.wikipedia.org/wiki/Arduino-Plattform
http://www.arduino.cc/
http://www.datasheetcatalog.com/datasheets_pdf/U/L/N/2/ULN2003.shtml
http://www.freeduino.de/
http://fritzing.org/
Seite 11/11
ID: 3654:106367