Robotanik ist ein Roboter der die Aufgabe hat eine Pflanze möglichst selbstständig am Leben zu erhalten. Das bedeutet, dass die Feuchtigkeit des Bodens in der näheren Umgebung der Pflanze regelmäßig gemessen wird und die Pflanze gegossen wird, wenn die Feuchtigkeit zu gering ist.

Unser Roboter hat die Aufgabe eine Pflanze am Leben zu erhalten.

Im Detail heißt das, dass alle 5 Minuten die Feuchtigkeit im Blumentopf von einem Feuchtigkeitsmesser gemessen und an den Arduino übermittelt wird. Sollte die Feuchtigkeit einen vorher festgelegten Grenzwert unterschreiten, ist der Arduino so programmiert, dass er das elektrische Ventil, welches den Wasserfluss blockiert für kurze Zeit öffnet und so die Pflanze bewässert. Sollte der Boden im Blumentopf beim nächsten Messvorgang immer noch zu gering sein wird der Arduino den Gießvorgang so lange wiederholen, bis die Feuchtigkeit den Grenzwert überschreitet.

Des weiteren schreibt der Arduino bei jedem Messvorgang den Messwert und die seit dem Start des Roboters vergangene Zeit in Sekunden auf eine SD-Karte. So kann beim Auslesen nachvollzogen werden, ob der Roboter seit dem letzten Start funktioniert hat oder ob es Fehlfunktionen gegeben hat.

Es gibt bereits Roboter, die die gleichen Aufgaben erfüllen und noch wesentlich mehr können als Robotanik.

Der Garduino (http://www.instructables.com/id/Garduino-Gardening-Arduino/) schaltet Lampen über den Pflanzen an, wenn es draußen zu dunkel ist, damit diese 15 Stunden Licht am Tag bekommen. Außerdem misst er die Temperatur in der Nähe der Pflanzen und schlägt Alarm, wenn diese unter 10 Grad Celsius sinkt.

Der Farmbot (https://farmbot.io/) beherrscht alle Funktionen des Garduinos und ist sogar noch ein Stück umfangreicher. Er kann mit verschiedenen Modifikationen wie Solarpanels, Regen-Sammelanlagen und kleinen Wetterstationen kombiniert werden um Ihn noch umweltfreundlicher und effektiver zu machen.

Beide Roboter sind sowohl als Baukasten käuflich, oder können dank detaillierter Bauanleitung mit eigenen Teilen selber zusammengebaut werden.

Der Bau des Roboters lässt sich im wesentlichen in vier Phasen unterteilen. Begonnen haben wir mit dem Bau des Gestells, bestehend aus dem Blumentopf und der Halterung für Gießvorrichtung und Elektronik. Darauf folgte die Entwicklung des Bewässerungssystems, welches aus dem Wasserbehälter, den Schläuchen und dem elektrischen Ventil zusammengesetzt ist. Ein weiterer Schritt war das Anschließen des Feuchtigkeitssensors und das Schreiben des Programmcodes. Letzteres galt es das ganze System mit Strom zu versorgen. Dies erreichten wir mit einem umgebauten 12 Volt Ladegerät.

Funktionen die wir bewusst weggelassen haben sind beispielsweise das Pflanzen der Pflanze und das regelmäßige Düngen der Pflanze. Ersteres hätte einen erheblichen Arbeitsaufwand bedeutet, da wir uns eine Konstruktion hätten ausdenken müssen, die eine kleines Loch aushebt, die Pflanze bzw. den Samen vorsichtig einsetzt und anschließend das Loch wieder mit Erde verschließt. Das Düngen der Pflanze hingegen erschien uns zu nichtig, da dies nur in sehr großen Abständen und mit wenig Aufwand nötig wäre und deshalb auch von Hand gemacht werden könnte.

Der Bau des Gestells war die erste Aufgabe die es lösen galt, da es die Basis für die restlichen Baugruppen sein würde. Bei der Auswahl des Blumentopfes entschieden wir uns für eine Variante mit Löchern am Boden und einem Untersetzer, da so überschüssiges Wasser aus dem Topf in den Untersetzer fließen kann und die Pflanze nicht “ertrinkt”. Zudem platzierten wir Steine am Boden des Blumentopfes die als Gegengewicht für den Wasserbehälter dienen.

Die Halterung für den Bewässerungsmechanismus und das Breadboard bauten wir aus einem eckigen Holzstab, an dessen Ende wir einen weiteren kurzen Holzstab anbrachten, sodass sich eine T-Form ergab. Diese sollte der Halterung zusätzliche Stabilität verleihen.

An dem Holzstab befestigten wir dann noch einen Klettverschluss, der später den Wasserbehälter halten würde und eine kleine Ablage für das Breadboard. Um die Halterung an der schrägen Wand des Blumentopfes zu befestigen zu können sägten wir uns kleine Holzblöcke zurecht, die wir zwischen der Halterung und dem Blumentopf an brachten um die Schräge auszugleichen.

Abschließend befestigten wir die Halterung mit Schrauben am Blumentopf und zogen diese mit Flügelmuttern fest.

• Holz
• Schrauben
• Muttern
• Klettverschluss

Für den Bewässerungsmechanismus haben wir uns eine simple Konstruktion überlegt, die sich die Gravitation zu nutze macht um die Pflanze im Blumentopf mit Wasser zu versorgen.

Gespeichert wird das Wasser in einer handelsüblichen 1,5 Liter PET Flasche, die mit Hilfe des Klettverschlusses kopfüber an unserem Gestell befestigt wird. Durch den Deckel der Flasche verlaufen zwei Schläuche die das Wasser aus der Flasche und Luft in die Flasche führen. Am Ende des Schlauches, der Luft in die Flasche leitet um einer Deformierung der Flasche vorzubeugen befindet sich ein Schwimmer aus Kork. Dieser stellt sicher, dass sich das Ende des Schlauches immer oberhalb der Wasseroberfläche befindet und somit kein Wasser aus diesem Schlauch fließen kann. Der Schlauch, der Wasser aus der Flasche führt ist an das elektronische Ventil angeschlossen, welches durch das Anlegen einer Spannung geöffnet werden kann.

Das elektrische Ventil haben wir aus einem anderen Roboter ausgebaut und wiederverwertet. Es ist das Herzstück des Bewässerungsmechanismus, da auf diese Weise genau festgelegt werden kann, wann und wie lange die Pflanze gegossen wird. Der obere Einlauf des Ventils ist über einen Schlauch mit dem Wasserbehälter verbunden. Am unteren Auslauf des Ventils ist einen weiterer Schlauch befestigt, der das Wasser in den Blumentopf leitet. Gesteuert wird das Öffnen und Schließen des Ventils von unserem Arduino beziehungsweise unserem Robotanik-Driver. Das Programm erkennt, wenn die Feuchtigkeit im Blumentopf einen festgelegten Grenzwert unterschreitet und legt anschließend eine Spannung von 12 Volt an das Ventil an. Dadurch öffnet sich das Ventil und Wasser kann für 5 Sekunden aus dem Wasserbehälter in den Blumentopf fließen.

• Ventil
• Wasserbehälter
• Schläuche

Einen großen Teil unserer Zeit haben wir mit dem elektrischen Verbinden von unseren Bauteilen mit dem Arduino, dem Herzstück des Roboters verbracht. Es gibt 3 Dinge die angeschlossen werden müssten: den Feuchtigkeitsmesser, das Ventil und die SD Karte, bzw. das SD Karten-Lesegerät. Jede davon ist mit mehr oder weniger Schwierigkeiten verbunden.

Der Feuchtigkeitsmesser war noch am simpelsten anzuschließen. Er besteht nur aus zwei Elektroden, die mit jeweils einem Pin des Arduino verbunden werden müssen. Es wird eine Spannung zwischen den Pins angelegt, und der Spannungsabfall über die Erde, also die Feuchtigkeit wird gemessen. Zuerst wurde er jedoch über weitere Elektronik, die mitgeliefert wurde angeschlossen. Zwar ist diese für manche Zwecke nützlich, wir nutzen aber keine ihrer Funktionen richtig aus.

Das Ventil bereitete uns schon mehr Schwierigkeiten. Es handelt sich um ein Magnetventil, das eine Spannung von 12 V braucht. Der Arduino hat nur eine Spannung von 5 V. Deshalb wurde ein 12 V Netzteil als Spannungsquelle für das Ventil benutzt. Um das Ventil durch den Arduino steuern zu können braucht es jetzt einen Transistor. Dadurch kann mit einer Spannung des Arduinos der Strom durch das Ventil und damit die Öffnung des Ventils gesteuert werden. Es muss jedoch genau darauf geachtet werden, wie die Pins des Transistors verbunden werden. Die Pins des Transistors sind nämlich in keiner Weise beschriftet oder gekennzeichnet, weswegen nur das Datasheet und große Sorgfalt aushelfen können.

Da wir nun schon eine 12 V Spannungsquelle haben, können wir auch den Arduino darüber mit Strom versorgen. Er kann durch seinen integrierten Spannungsregler Spannungen von bis zu 20 V als Eingangsspannung aushalten. Dafür wird einfach der positive Pol des Netzteils mit dem V_in Pin und der negative Pol mit einem Ground pin des Arduino verbunden.

Letztlich war noch das SD-Karten-Lesegerät anzuschließen. Es braucht Strom über 5 V und Ground Pins und überträgt die Daten durch einige digitale Pins. Hier haben wir uns an das Pin Layout aus dem Arduino SD-Beispielcode gehalten, da wir sonst hätten herausfinden müssen was die einzelnen Pins bewirken.

• Arduino Nano Microprozessor
• 12 V Netzteil
• Feuchtigkeitsmesser
• SD-Kartenlesegerät
• Breadboard
• Kabel

Das Schreiben des Codes für den Arduino war ein weiterer großer Teil unserer Arbeit. Er muss die Teile des Roboters koordinieren und steuern. Im Zentrum des Programmes steht eine Systemzeit, welche über die Systemzeit des Arduinos berechnet wird. Diese kann man durch die Funktion millis() in Millisekunden abrufen. Wir rechnen sie zu Sekunden um, da unser Roboter keine so genaue Zeitangabe braucht. Die millis() Funktion läuft ca. alle 70 Tage über, weswegen die Direkte Umwandlung in Sekunden eigentlich schon reicht. Wir haben allerdings eine Variable in der vermerkt wird wie oft die Zeit übergelaufen ist, wodurch unsere Systemzeit mehrere Tausend Jahre zum überlaufen braucht.

Alle 300 Sekunden, also alle 5 Minuten wird die Feuchtigkeit in dem Blumentopf gemessen. Hierzu wird eine Spannung über den Feuchtigkeitsmesser und damit über die Erde angelegt und der Spannungsabfall über die Erde gemessen. Danach wird die Spannung wieder abgestellt, wodurch die Korrosion des Sensors stark verlangsamt wird. Ist der gemessene Feuchtigkeitswert unter einem experimentell festgestellten Wert, so wird die Pflanze gegossen, indem an einen Pin eine Spannung angelegt wird, die den Transistor und damit das Ventil für 5 Sekunden öffnet. Der Messwert und falls gegossen wurde eine Nachricht die das aussagt werden zusammen mit der aktuellen Systemzeit auf die SD-Karte geschrieben.

Das Ergebnis unser zweieinhalb monatigen Bauphase ist, dass alle Funktionen des Roboters zumindest für einen kurzen Zeitraum erfüllt sind.

Die Lebensdauer des Feuchtigkeitsmessers und das undichte Ventil sind die größten Schwachstellen. Der Feuchtigkeitsmesser ist nur für wenige Tage zuverlässig, danach sind die Messergebnisse aufgrund der Elektrolyse bedingten Korrosion nicht mehr wahrheitsgemäß.

Das Ventil ist nicht vollständig abgedichtet, was zu minimalem Wasserverlust führt. Leider ist ein gänzlich abgedichtetes System sehr schwer bis nicht nicht realisierbar.

Eine Lösung für das Korrosionsproblem haben wir jedoch wahrscheinlich gefunden. Indem wir die Spannung über den Feuchtigkeitsmesser nur zu der Messung anstellen, müsste die Zeit in der Elektrolyse stattfindet drastisch reduziert und die Haltbarkeit des Sensors enorm erhöht werden. Langzeittests, die wir noch nicht durchführen konnten, müssten dies jedoch erst noch bestätigen.

Es gibt noch viele andere Dinge, welche die Benutzung des Roboters vereinfachen würden. Der Code könnte um einiges robuster sein, also zum Beispiel Fehler in den Messwerten erkennen, oder ein anschließen einer SD-Karte nach dem Start erkennen. Auch einige Knöpfe, wie zum Beispiel zum manuellen „Gießen“, oder zum Testen auf korrekten Wasserfluss beim nachfüllen des Wassertanks wären äußerst hilfreich. Solche Dinge werden nur durch mangelnde Zeit und eventuell durch den knappen Arbeitsspeicher auf den Arduino Nano begrenzt.

Letztlich macht unser Roboter seinen Job als Prototyp sehr gut, da er seine Aufgaben erfüllen kann.

robotanikcode.zip leider ohne SPI library, da ich diese nicht finden konnte

#include <SPI.h>
#include <SD.h>
 
unsigned long sysTime; //die Zeit des Systems in Sekunden
unsigned long prevMillis; //speichert vorherige Zeit in Millisekunde, damit überprüft werden kann, ob sie sich verändert hat
unsigned int overflowedXTimes = 0; //speichert wie oft die millis() Funktion übergelaufen ist
 
unsigned long lastWatering = 0; //speichert bei welcher Systemzeit zuletzt Gewässert wurde
unsigned long ranAt = 0; //speichert wann die Hauptschleife von loop() zuletzt gelaufen ist
 
int measureIntervall = 300; //wie oft in Sekunden soll die Feuchtigkeit gemessen werden? hier 5 min
int humidityThreshhold = 350; //der Grenzwert ab dem Gewässert werden soll
boolean sdConnected = false; //speichert ob eine SD-Karte angeschlossen ist
File logFile; //die Datei auf der SD-Karte, wo die Feuchtigkeitsdaten gespeichert werden
 
 
//updated die Variable sysTime auf die aktuelle Zeit
void updateSysTime(){
  long currentMillis = millis();
  if(currentMillis != prevMillis){
    if(((long long)prevMillis - (long long)currentMillis) > 10){
      overflowedXTimes++;
    }
  }
  prevMillis = currentMillis;
  sysTime = (currentMillis / 1000) + overflowedXTimes * 4294967.295;
}
 
//misst die Feuchtigkeit indem der A0 Pin gemessen und der Wert zurückgegeben wird
int measureHumidity(){
  digitalWrite(3, HIGH); //legt eine Spannung über den Boden an
  int reading = analogRead(A0); //Feuchtigkeit wird gemessen
  digitalWrite(3, LOW); //Spannung wird wieder aufgehoben
  return reading;
}
 
//wässert die Pflanze und schreibt eine Nachricht auf die SD-Karte
void waterPlant(){
  int pin = 2; //Pin mit dem das Ventil gesteuert wird
  Serial.println("Watering...");
  writeToSd(-1); //schreibt Systemzeit und "Watering" auf die SD-Karte
  digitalWrite(pin, HIGH);
  delay(5000);
  digitalWrite(pin, LOW);
}
 
//initialisiert die SD-Karte mit dem Arduino und öffnet die Log-Datei
void connectSdCard(){
  if (!SD.begin(4)) { //wenn die SD-Karte nicht verbunden werden kann wird das 
	//					auf die Konsole ausgegeben und sdConnected reflektiert diesen Fakt
    Serial.println("SD initialization failed!");
    return;
  }
  Serial.println("SD is connected");
  sdConnected = true;
  logFile = SD.open("log.txt", FILE_WRITE);
  if(!logFile){
    sdConnected = false;
    Serial.println("Failed to open File!");
  }else{
    Serial.println("File has been opened");
  }
}
 
//schreibt einen Feuchtigkeitswert oder eine Nachricht, dass gewässert wurde, mit der Systemzeit auf die SD-Karte
void writeToSd(int message){
  if(sdConnected){
    if(message > 0){
    logFile.println((String)sysTime + "\t" + (String)message);
    }else{
      logFile.println((String)sysTime + "\t" + "Watering");
    }
    logFile.flush();
  }
}
 
void setup() {
  Serial.begin(9600);
  pinMode(2, OUTPUT); //Ventilpin wird als output definiert, damit er genug Spannung liefert um den Transistor auszulösen
  pinMode(3, OUTPUT);
  connectSdCard();
  if(sdConnected){
    logFile.println("(Re)Starting");
    Serial.println("(Re)Starting");
  }
}
 
void loop() {
  updateSysTime();
 
  if(sysTime != ranAt && sysTime % measureIntervall == 0){ //wenn es zu dieser Systemzeit noch nicht ausgeführt wurde und es Zeit ist zu messen
    ranAt = sysTime; //merken das die Schleife zu dieser Systemzeit ausgeführt wurde
    int measurement; //speichert den Feuchtigkeitsmesswert
    if((measurement = measureHumidity()) < humidityThreshhold){ //wenn die Feuchtigkeit unter dem Grenzwert liegt
      if((sysTime - lastWatering) > (measureIntervall * 2)){ //wenn das Letzte Wässern schon länger her ist
        waterPlant();
        lastWatering = sysTime; //merken wann gewässert wurde
      }
    }
    writeToSd(measurement); //Messwert auf die SD-Karte schreiben und auf die Konsole ausgeben
    Serial.println((String)sysTime + "\t" + (String)measurement);
  }
}