,
22 Mai

(Boden-)Feuchtigkeit messen mit Arduino: Teil 1

In diesem zweiteiligen Tutorial zeige ich euch, wie ihr einen (Boden-)Feuchtigkeitssensor an euer Arduino Uno anschließen und die Werte auslesen könnt. Heute gibt es Teil 1: Das Grundgerüst mit ein paar Basis-Funktionen.

Bodenfeuchtigkeit messen mit einem Arduino Feuchtigkeitssensor bzw soil moisture sensor - Grundversion, einfache Basisanleitung

 

 

Allgemein

Egal ob ihr Gartennerds seid oder messen wollt, wie viel Wasser noch in der Blumenvase ist – der Arduino Feuchtigkeitssensor mit den zwei ‚Zinken‘ hilft euch weiter.  Es gibt verschiedene Modelle, teils mit und teils ohne Zusatzplatine. Bei meinem Sensor handelt es sich um einen Sensor mit der Modellnummer YL-69* (samt ‚Zusatzmodul‘ YL-38, das die technische Seite übernimmt). Ich würde vielleicht nicht meine allerwertvollste Lieblingspflanze an den Sensor hängen, aber für Spielereien sollte die Genauigkeit ausreichen. 😉

Um mein Tutorial nachzubauen, braucht ihr:

  • Arduino Uno mit USB-Kabel oder ein anderes Uno-kompatibles Board (Amazon | eBay)*
  • Sensor YL-69 plus YL-38 bzw HC-38, wird meist im Set verkauft. (Amazon | eBay)*
  • 6 Jumperkabel: 4x male-female (YL-38 <-> Arduino Uno) und 2x female-female (YL-38 <-> YL-69) (Amazon | eBay)*

 

Zweiteiliger Feuchtigkeitssensor für Arduino: YL-38 (links) und YL-69 (rechts)

Zweiteiliger Feuchtigkeitssensor für Arduino: YL-38 (links) und YL-69 (rechts).

 

 

Bodenfeuchtigkeitssensor und Arduino Uno verkabeln

Um euch die Verkabelung zu erleichtern, habe ich eine extrem entschlackte Pinout-Grafik für das YL-38 gebastelt. 😉

Pinout: YL-38 (wird für Anschluss von YL-69 benötigt)

Rudimentäres Pinout: YL-38 (wird für Anschluss von YL-69 benötigt).

Ihr müsst mit den zwei female-female-Jumperkabeln die zwei Pins des YL-69 und die zwei unbeschrifteten Pins des YL-38 (auf der rechten Seite) verkabeln. Es ist scheinbar egal, welcher Pin mit welchem verbunden ist. (Zumindest bei meinem Sensor machte das keinen Unterschied.)

Verbindet dann YL-38 und Arduino Uno:

  • VCC (YL-38) mit 5V (Uno) – man kann zwar angeblich auch 3V verwenden, aber bei mir hat das keine Ergebnisse gebracht. 🙁
  • GND (YL-38) mit GND (Uno).
  • DO  (YL-38) mit (Digital-)Pin 11 (Uno).
  • AO (YL-38) mit A0 (Uno).

Fertig! Okay, fast… 😉

Feuchtigkeitssensor YL-38 mit Arduino Uno verbunden

Feuchtigkeitssensor YL-69 und YL-38 mit Arduino Uno verbunden.

 

 

Erster Code und erster Test

Für den Test solltet ihr jetzt z.B. ein Glas mit etwas Wasser bereithalten. Oder vielleicht einen nassen und einen trockenen Blumentopf. (Ich habe Wasser genommen, weil auf meinem Schreibtisch nicht so viel Platz war.) Nehmt am besten irgendetwas, das nicht so leicht umkippen und euer Board und eure Tastatur unter Wasser setzen kann. Schließt dann das USB-Kabel an das Board an und öffnet die Arduino IDE. Gebt den Code ein und öffnet den Seriellen Monitor (Tools -> Serieller Monitor), um die vom Sensor zum Uno gesendeten Daten anzusehen.

Für ein allererstes Auslesen der Werte von digitalem und analogem Pin könnt ihr folgenden Code verwenden:

void setup() {
 Serial.begin(9600); // Serial-Port öffnen und auf 9600 Baud setzen
 pinMode (11, INPUT); // Pin 11 (digital) auf Input setzen
 pinMode (A0, INPUT); // Pin A0 (analog) auf Input setzen
 }

void loop() {
 int istTrocken = digitalRead(11); // Pin 11 auslesen -> in Variable istTrocken
 int feuchtigkeit = analogRead(A0); // Pin A0 auslesen -> in Variable feuchtigkeit
 Serial.print("istTrocken: "); // Variablenname für Übersichtlichkeit im Serial Monitor
 Serial.println(istTrocken); // Wert von "istTrocken" ausgeben
 Serial.print("feuchtigkeit: "); // Variablenname für Übersichtlichkeit im Serial Monitor
 Serial.println(feuchtigkeit); // Wert von "feuchtigkeit" ausgeben
 delay(1000); // 1 Sekunde warten
}

 

 

Erster Code: Zerpflückt und genauer betrachtet

Schauen wir uns die einzelnen Codeblöcke zunächst einmal genauer an, beginnend mit dem Setup-Teil:

void setup() {
 Serial.begin(9600); // Serial-Port öffnen und auf 9600 Baud setzen
 pinMode (11, INPUT); // Pin 11 (digital) auf Input setzen
 pinMode (A0, INPUT); // Pin A0 (analog) auf Input setzen
 }

Zuerst wird der Serial-Port geöffnet und die Geschwindigkeit auf 9600 Baud festgelegt. Die Pins 11 und A0 werden auf Input gesetzt, um Daten empfangen zu können.

Nächster Block ist auch schon der Loop, also das, was während der (gesamten) Laufzeit des Programms ausgeführt wird:

int istTrocken = digitalRead(11); // Pin 11 auslesen -> in Variable istTrocken
 int feuchtigkeit = analogRead(A0); // Pin A0 auslesen -> in Variable feuchtigkeit

An Pin 11 und Pin A0 werden Werte ausgelesen und in sinnvollen Variablen gespeichert.

Serial.print("istTrocken: "); // Variablenname für Übersichtlichkeit im Serial Monitor
 Serial.println(istTrocken); // Wert von "istTrocken" ausgeben
 Serial.print("feuchtigkeit: "); // Variablenname für Übersichtlichkeit im Serial Monitor
 Serial.println(feuchtigkeit); // Wert von "feuchtigkeit" ausgeben
 delay(1000); // 1 Sekunde warten

Im Seriellen Monitor werden jetzt erst die jeweiligen Variablennamen und dann deren Werte ausgegeben. Damit der Text nicht unlesbar über den Bildschirm rast, wird danach immer 1000 Millisekunden (= 1 Sekunde) gewartet. Danach wird der Loop erneut ausgeführt, die Werte werden also wieder ausgelesen.

Wenn der Code auf das Board hochgeladen wurde und der Serielle Monitor geöffnet ist, könnte euch Folgendes angezeigt werden:

Serieller Monitor: Ausgabe der Variablennamen und -werte

Serieller Monitor: Ausgabe der Variablennamen und -werte.

Während der serielle Monitor lief, habe ich den trockenen Sensor in ein Glas mit Wasser getunkt. Die Zahlen scheinen dem auf den ersten Blick zu widersprechen: istTrocken = 1 (also true), aber Feuchtigkeit von 1023? Wie kann das sein?

 

 

Feuchtigkeitssensor: Das wollen uns die Zahlen sagen

Wenn euer Sensor auch eine Feuchtigkeit von 1023 anzeigt und gleichzeitig angibt, trocken zu sein, ist das ganz eindeutig kein defekt. Das muss so.

Das Prinzip, nach dem der Sensor die Feuchtigkeit der Erde misst, beruht auf dem elektrischen Widerstand. Sind die Kontakte komplett in Wasser eingetaucht (oder verbindet man beide Sensor-Pins von YL-38 miteinander), ist der Widerstand am geringsten. Wenn aber die Beine des Sensors trocken sind (oder kein Sensor angeschlossen ist), ist der Widerstand am größten. Das heißt: je höher der Wert, desto trockener. Der höchstmögliche vom Sensor ausgegebene Wert (= staubtrocken oder kein Sensor) ist 1023. Der niedrigste Wert (erreicht durch Kurzschließen des YL-38) ist 0. Wichtig: Der Sensor misst nicht in Ohm. Soweit ich sehen konnte sind es lediglich Relativwerte.

Bei vollem Eintunken liefert das von mir verwendete Setup aus Sensor und örtlichem Leitungswasser in einem alten Marmeladenglas einen Tiefstwert von ca. 150-280.  Ich weiß, das ist nicht sehr präzise. 😉 Diese Diskrepanz liegt zum einen am spezifischen Widerstand, zum anderen am Sensor selbst. Möglicherweise spielt auch die Stromzufuhr für Arduino Uno/YL-38 mit hinein.

 

Feuchtigkeit mit Arduino messen: Eine etwas schickere Basis-Version

Mit ein paar Änderungen im Loop könnt ihr die Basis-Version eures Bodenfeuchtigkeitsmessers verschönern.

void loop() {
 int istTrocken = digitalRead(11); // Pin 11 auslesen -> in Variable istTrocken
 int feuchtigkeit = analogRead(A0); // Pin A0 auslesen -> in Variable feuchtigkeit
 Serial.print("Ist der Sensor trocken? "); // Kurzerklärung zum folgenden Wert
 if (istTrocken) // prüfen, ob istTrocken=1 (also true) ist ...
 { 
 Serial.println("Ja"); // ... wenn ja, dann "Ja" ausgeben ...
 }
 else // ... ansonsten ...
 { 
 Serial.println("Nein"); // ... "Nein" ausgeben
 }
 
 Serial.print("Gemessene Feuchtigkeit: "); // Kurzerklärung zum folgenden Wert
 Serial.println(feuchtigkeit); // Wert von "feuchtigkeit" ausgeben
 
delay(1000); // 1 Sekunde warten
}

Das ist natürlich nur eine kosmetische Modifikation. Ausgegeben wird nämlich weiterhin der Wert von istTrocken und die „Feuchtigkeit“ des Sensors. Bei Letzterer handelt es sich in diesem Stadium aber eher um die Trockenheit. 😉

Wirklich verändert wurde nur die Ausgabeform des Wertes von istTrocken:

 Serial.print("Ist der Sensor trocken? "); // Kurzerklärung zum folgenden Wert
 if (istTrocken) // prüfen, ob istTrocken=1 (also true) ist ...
 { 
 Serial.println("Ja"); // ... wenn ja, dann "Ja" ausgeben ...
 }
 else // ... ansonsten ...
 { 
 Serial.println("Nein"); // ... "Nein" ausgeben
 }

Mittels if-else-Verzweigung wird auf den jeweiligen Wert von istTrocken (1 oder 0) reagiert. Statt „Ja“/“Nein“ könnte hier genauso gut „Der Sensor ist trocken“/“Der Sensor ist nass“ stehen. Genauso wie die Variable istTrocken nur einen der beiden Wert haben kann, wird auch hier nur eine der beiden Möglichkeiten angezeigt.

Anmerkung: In meinem Beispiel ist istTrocken eine Variable vom Datentyp Integer. Stattdessen könnte man auch Boolean verwenden, weil der digitale Output (DO) von YL-38 sowieso nur 1 oder 0 ausgibt…

 

Im Seriellen Monitor sieht die verschönerte Basisversion folgendermaßen aus:

Feuchtigkeitssensor: Eigentlich müsste die gemessene "Feuchtigkeit" gemessene "Trockenheit" sein.

Feuchtigkeitssensor: Eigentlich könnte die gemessene „Feuchtigkeit“  auch gemessene „Trockenheit“ sein.

 

 

So viel zur absoluten Basis-Version. Wie ihr aus dem Feuchtigkeits-/Trockenheitswert eine Prozentangabe machen und zur verbesserten Genauigkeit einen Mittelwert berechnen könnt, zeige ich euch in Teil 2. 

 

Ein Gedanke zu „(Boden-)Feuchtigkeit messen mit Arduino: Teil 1

  1. Pingback: (Boden-)Feuchtigkeit messen mit Arduino: Teil 2 - Frau Nerd

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.

Diese Website verwendet Akismet, um Spam zu reduzieren. Erfahre mehr darüber, wie deine Kommentardaten verarbeitet werden .