Intelligenter Pflanzenkommunikator: Arduino MKR IoT Bundle für automatisiertes Gärtnern

Komponenten & Materialien

Komponente	Menge
Arduino MKR IoT Bundle (enthält MKR1000, Sensoren, Aktoren, Breadboard, Kabel, etc.)	1

Apps & Online-Dienste

• Zapier (Automatisierungsdienst für Webhooks & E-Mail-Versand)
• ThingSpeak API (Datenvisualisierung in der Cloud)

Über dieses Projekt

Hinweis: Dieses Tutorial könnte veraltet sein. Für eine aktuelle Version hier klicken.

Einführung

Wie der englische Dichter William Wordsworth sagte: „Dein Geist ist der Garten, deine Gedanken die Samen, die Ernte können Blumen oder Unkraut sein.“

Pflanzen am Leben zu erhalten ist eine Herausforderung – sie kommunizieren schlecht. Man könnte sie überallhin mitnehmen, aber wer will schon einen Kaktus in der Jackentasche tragen? Die meisten Pflanzen mögen auch keine Kälte.

Nach monatelangen Versuchen, mit unserer Grünlilie (Spider Plant) zu kommunizieren, gaben wir auf und nutzten die MKR IoT Bundle Komponenten, um ein Gerät zu bauen, das das Wohlbefinden jeder Pflanze fernüberwacht.

Kurzfassung

In diesem Experiment lernst du:

• Pflanzen schützen & ihr Überleben sichern mit Arduino-Magie
• Feuchtigkeit, Temperatur & Licht überwachen für glückliche Pflanzen
• Tägliche E-Mails mit Daten & Grafiken senden, bei Bedarf Benachrichtigungen erhalten

Verwendete Sensoren (aus dem Bundle)

• TMP36 Temperatursensor
• Phototransistor (Lichtsensor)
• DIY-Feuchtesensor (selbstgebaut)

Lernziele

• Zapier Internet-Dienst kennenlernen
• HTTP-Requests senden
• Real Time Clock (RTC) & Alarme verwalten
• DIY-Feuchtesensor bauen
• Werte mit ThingSpeak plotten #ProTip
• E-Mails mit HTML & CSS stylen #ProTip
• APIs mit Postman testen #ProTip

Mehr erfahren?

Dieses Tutorial ist Teil einer Serie zur MKR1000 & IoT. Alle Experimente lassen sich mit dem MKR IoT Bundle bauen:

• Love You Pillow
• Puzzle Box
• Pavlov's Cat
• The Nerd
• Plant Communicator (dieses Projekt)

Zapier einrichten

Zapier ist ein Online-Automatisierungstool, das APIs anderer Apps verwaltet – ideal für komplexe APIs, die ein Arduino nicht direkt handhaben kann. Wir nutzen es, um E-Mails mit Arduino-Daten zu versenden.

Schritte zum eigenen Zap:

1. Zapier Account erstellen, „Make a Zap“ wählen
2. Trigger: „Webhooks by Zapier“ → „Catch Hook“ → URL kopieren
3. Test: URL im Browser aufrufen mit Parametern: deine_webhook_URL?temperature=0&moisture=0&light=0&warning=0
4. Erfolgreiche Antwort bestätigt: HTTP-Request funktioniert! Genau das wird der Arduino tun – nur mit echten Sensorwerten.
5. Action: „Gmail“ → „Send Email“ → Konto verbinden, Betreff & Body gestalten (Platzhalter für Parameter nutzen)
6. Zap aktivieren & testen: E-Mail im Postfach prüfen.

Für fortgeschrittenes API-Testing siehe #ProTip „Postman“ unten.

Board einrichten (MKR1000)

Benötigte Libraries (via Library Manager):

• WiFi101 (Internet & Netzwerkscan)
• RTCZero (zeitgesteuerte Events)

Für Zapier-API (und die meisten Online-Dienste) müssen Zertifikate auf den MKR1000 hochgeladen werden. Beispiel „FirmwareUpdater“ aus WiFi101 öffnen, Domain hooks.zapier.com hinzufügen, hochladen. Im Arduino Web Editor noch nicht möglich – Desktop-App nötig.

HTTP-Request senden

Nun HTTP-Request vom Arduino an Zapier senden. Zuerst Testwerte, später Sensorwerte.

#include <WiFi101.h> 
#include <WiFiSSLClient.h> 

const char* ssid = SECRET_SSID; 
const char* password = SECRET_PSWD; 
String httpsRequest = SECRET_REQUEST; // Deine Zapier Webhook URL (nur der Pfad nach Domain) 
const char* host = "hooks.zapier.com"; 
WiFiSSLClient client; 

void setup() { 
  Serial.begin(9600); 
  while (!Serial); 
  delay(2000); 
  Serial.print("Verbinde Wifi: "); 
  Serial.println(ssid); 
  while (WiFi.begin(ssid, password) != WL_CONNECTED) { 
    Serial.print("."); 
    delay(500); 
  } 
  Serial.println(""); 
  Serial.println("WiFi verbunden"); 
} 

void loop() { 
  float temperature = 22; 
  int moisture = 150; 
  int light = 40; 
  String warning = "Dies ist eine Warnmeldung"; 
  warning.replace(" ", "%20"); // URL-Encoding: Leerzeichen → %20 
  send_email(temperature, moisture, light, warning); 
  delay(20000); // Alle 20s (Vorsicht: Zapier Free = 100 Requests/Monat!) 
} 

void send_email(float temperature, int moisture, int light, String warning) { 
  String _temperature = String(temperature); 
  String _moisture = String(moisture); 
  String _light = String(light); 
  String _warning = warning; 
  if (client.connect(host, 443)) { 
    client.println("POST " + httpsRequest + "?temperature=" + _temperature + "&moisture=" + _moisture + "&light=" + _light + "&warning=" + _warning + " HTTP/1.1"); 
    client.println("Host: " + String(host)); 
    client.println("Connection: close"); 
    client.println(); 
    delay(1000); 
    while (client.available()) { 
      char c = client.read(); 
      Serial.write(c); 
    } 
    client.stop(); 
  } else { 
    Serial.println("Verbindung zum Server fehlgeschlagen"); 
  } 
}

RTC & Alarme (täglicher Versand)

MKR1000's Echtzeituhr nutzen, um täglich zur gewünschten Zeit eine E-Mail zu senden. Beispiel: Startzeit 16:00, 4.12.2017 → Alarm täglich um 16:01.

Wichtig: Alarm löst Interrupt aus → keine delays in der Interrupt-Funktion! Boolean-Flag in loop() auswerten.

#include <RTCZero.h> 
RTCZero rtc; 

const byte seconds = 0, minutes = 0, hours = 16; 
const byte day = 4, month = 12, year = 17; 
bool email_already_sent = false; 

void setup() { 
  Serial.begin(9600); 
  while (!Serial); delay(2000); 
  rtc.begin(); 
  rtc.setTime(hours, minutes, seconds); 
  rtc.setDate(day, month, year); 
  rtc.setAlarmTime(16, 1, 0); // Täglich 16:01 
  rtc.enableAlarm(rtc.MATCH_HHMMSS); 
  rtc.attachInterrupt(alarmMatch); 
} 

void loop() { 
  if (!email_already_sent) { 
    // send_email(); 
    email_already_sent = true; 
  } 
} 

void alarmMatch() { 
  Serial.println("Alarm Match!"); 
  email_already_sent = false; 
}

DIY-Bodenfeuchtesensor

Zwei Drähte im Topf bilden einen variablen Widerstand: Widerstand ändert sich mit Bodenfeuchte. Als Spannungsteiler mit 1 MΩ Widerstand angeschlossen liefert er dem Arduino eine proportionale Spannung. Je feuchter der Boden, desto niedriger die gemessene Spannung.

Kalibrierung: Sketch hochladen, in trockener Erde testen, Wert notieren → Schwelle (threshold) setzen. Bei Unterschreitung → Notfall-E-Mail.

int moisturePin = A2; 
int threshold = 800; // An trockener/feuchter Erde kalibrieren 

void setup() { 
  Serial.begin(9600); 
  while (!Serial); delay(2000); 
} 

void loop() { 
  Serial.println(get_average_moisture()); 
  delay(5000); 
} 

int get_average_moisture() { 
  int tempValue = 0; 
  for (int a = 0; a < 10; a++) { 
    tempValue += analogRead(moisturePin); 
    delay(100); 
  } 
  return tempValue / 10; 
}

Temperatur- & Lichtsensor hinzufügen

Verdrahtung siehe Schaltplan unten. Lesefunktionen:

float get_temperature() { 
  int reading = analogRead(A1); 
  float voltage = reading * 3.3 / 1024.0; 
  float temperatureC = (voltage - 0.5) * 100; // TMP36: 10mV/°C, 500mV Offset 
  // float temperatureF = (temperatureC * 9.0 / 5.0) + 32.0; // Für Fahrenheit 
  return temperatureC; 
} 

int get_light() { 
  return analogRead(A0); 
}

#ProTip: Werte mit ThingSpeak plotten

ThingSpeak für schöne Grafiken nutzen. Schritte:

1. ThingSpeak Channel erstellen, Write API Key notieren
2. ThingSpeak Library installieren
3. Sketch mit WiFi-Credentials & API-Keys hochladen → Werte minütlich in Cloud

#include <WiFi101.h> 
#include <WiFiSSLClient.h> 
#include "ThingSpeak.h" 

const char* ssid = SECRET_SSID; 
const char* password = SECRET_PSWD; 
WiFiClient ThingSpeakClient; 
unsigned long myChannelNumber = 356392; 
const char * myWriteAPIKey = SECRET_WRITE_API; 

int lightPin = A0, tempPin = A1, moisturePin = A2; 

void setup() { 
  Serial.begin(9600); 
  while (!Serial); delay(2000); 
  Serial.print("Verbinde Wifi: "); Serial.println(ssid); 
  while (WiFi.begin(ssid, password) != WL_CONNECTED) { Serial.print("."); delay(500); } 
  Serial.println("WiFi verbunden"); 
  ThingSpeak.begin(ThingSpeakClient); 
} 

void loop() { 
  ThingSpeak.setField(1, get_light()); 
  ThingSpeak.setField(2, get_temperature()); 
  ThingSpeak.setField(3, get_average_moisture()); 
  ThingSpeak.writeFields(myChannelNumber, myWriteAPIKey); 
  Serial.println("Daten an Cloud gesendet"); 
  delay(60000); // Jede Minute 
} 
// get_temperature(), get_average_moisture(), get_light() wie oben definiert

Im vollständigen Pro-Sketch (unten) ist der Upload an RTC-Alarm (minütlich) gekoppelt. Gmail erlaubt keine eingebetteten Grafiken/Iframes in E-Mails – aber Link zu ThingSpeak-Grafik als Button in E-Mail einbinden (siehe nächster ProTip). Alternativen: Dweet.io, freeboard.io.

#ProTip: E-Mails mit HTML & CSS stylen

Zapier erlaubt HTML/CSS im E-Mail-Body. So sehen E-Mails professionell aus:

In Zapier: Body-Type auf „HTML“ setzen, eigenes HTML/CSS einfügen.

Template kopieren & anpassen:

<!doctype html> 
<html> 
<head> 
<meta name="viewport" content="width=device-width, initial-scale=1.0"> 
<style> 
.container{ margin: 0 10%; background:#ECF1F1; min-height:100%; padding:5% 0 10%; font-family:monospace; letter-spacing:2px; } 
.title{ text-align:center; color:#0CA1A6; font-size:1.5em; padding-top:0.2vh; } 
.subtitle{ text-align:center; color:#0CA1A6; font-size:1.1em; padding:0 4% 4%; } 
.data{ padding:2% 5%; margin:0 15%; background:#F7F9F9; text-align:left; color:#4E5B61; font-size:1em; font-weight:bold; } 
.bttn{ padding:3%; margin:10% 25% 0; background:#00979D; text-align:center; color:#F7F9F9; font-size:1.4em; } 
.disclaimer{ text-align:center; color:#DA5B4A; font-size:1.1em; font-weight:bold; margin-top:10%; } 
.bttn:hover{ background:#008184; } a{ text-decoration:none; } 
</style> 
</head> 
<body> 
<div class="container"> 
<h2 class="title">HALLO !</h2> 
<h4 class="subtitle">Hier ist dein tägliches Garten-Update ☘</h4> 
<div class="data"> ♨ Temperatur: {{querystring__temperature}} °C </div> 
<div id="humidity" class="data"> ☔ Feuchtigkeit: {{querystring__moisture}}</div> 
<div class="data"> ☀ Licht: {{querystring__light}}</div> 
<div class="disclaimer">{{querystring__warning}}</div> 
<a href="dein_thingSpeak_link"><div class="bttn">DIAGRAMM ANSEHEN</div></a> 
</div> 
</body> 
</html>

#ProTip: API mit Postman testen

HTTP-Requests bauen kann knifflig sein. Postman hilft: URL einfügen, Parameter hinzufügen, senden → Server-Antwort sehen & fertige URL erhalten.

Kompletter Pro-Sketch (mit allen ProTip-Features)

Der vollständige Sketch kombiniert: RTC-Alarm (tägliche E-Mail), ThingSpeak-Upload (minütlich), HTML-E-Mail via Zapier, DIY-Feuchtesensor, TMP36, Phototransistor. Im Original als „Complete sketch“ und „#ProTips complete sketch“ verlinkt.

Schaltplan