Kapazitiver Bodenfeuchte-Sensor mit Arduino auslesen & richtig kalibrieren

Warum kapazitiv statt resistiv?

Es gibt zwei Bauarten von Bodenfeuchte-Sensoren, und der Unterschied ist entscheidend für die Lebensdauer:

Der kapazitive Sensor misst nicht den Widerstand zwischen zwei Metallstäben, sondern die Änderung der elektrischen Kapazität rund um die (vollständig lackierte) Sensorfläche. Feuchte Erde hat eine völlig andere Dielektrizität als trockene – und genau das erfasst der Sensor, ohne dass jemals Strom durch die Erde fließt. Dadurch gibt es keine Elektrolyse, keine Korrosion und keine driftenden Werte. Genau deshalb steckt er in jeder ernsthaften automatischen Pflanzenbewässerung.

Das brauchst du

1Verkabelung: nur drei Leitungen

Der Sensor hat drei Pins: VCC, GND und AOUT (Analog-Ausgang). Er wird an einen Analogeingang deines Boards angeschlossen. Am Arduino UNO ist das z. B. A0, am ESP32 ein ADC1-Pin wie GPIO 34.

2Rohwerte auslesen – der erste Test

Bevor du irgendetwas umrechnest, musst du sehen, was der Sensor überhaupt liefert. Der folgende Sketch gibt einfach den rohen Analogwert im seriellen Monitor aus. Am Arduino UNO liegt der ADC bei 10 Bit (0–1023), am ESP32 bei 12 Bit (0–4095).

// Fuer Arduino UNO (10 Bit, 0-1023)
#define SENSOR_PIN A0

void setup() {
  Serial.begin(9600);
}

void loop() {
  int roh = analogRead(SENSOR_PIN);
  Serial.print("Rohwert: ");
  Serial.println(roh);
  delay(500);
}

Für den ESP32 ist der Code fast identisch – nur der Pin und die Baudrate ändern sich:

// Fuer ESP32 (12 Bit, 0-4095)
#define SENSOR_PIN 34

void setup() {
  Serial.begin(115200);
}

void loop() {
  int roh = analogRead(SENSOR_PIN);
  Serial.print("Rohwert: ");
  Serial.println(roh);
  delay(500);
}

Lade den Sketch hoch und beobachte den seriellen Monitor. Du wirst eine wichtige Eigenheit bemerken: Bei diesem Sensor bedeutet ein hoher Rohwert trockene Erde und ein niedriger Wert feuchte Erde. Das ist umgekehrt, als man intuitiv denkt – und der Grund, warum wir gleich sauber kalibrieren.

3Die Kalibrierung: der wichtigste Schritt

Jeder Sensor, jede Erde und jede Versorgungsspannung ist ein bisschen anders. Deshalb gibt es keine allgemeingültige Formel – du musst deine beiden Extremwerte selbst ermitteln: den Wert bei komplett trockener Luft und den Wert in ganz nasser Erde. Genau zwischen diesen beiden Punkten liegt dein Messbereich.

So gehst du vor:

1. Lade den Rohwert-Sketch aus Schritt 2 hoch und öffne den seriellen Monitor.
2. Trockenwert messen: Halte den Sensor einfach in die Luft (oder in staubtrockene Erde). Notiere den stabilen Rohwert – das ist dein TROCKEN-Wert (der höchste).
3. Nasswert messen: Stecke den Sensor bis zur Maximallinie in ein Glas Wasser oder in klatschnasse Erde. Notiere den Rohwert – das ist dein NASS-Wert (der niedrigste).
4. Trage beide Werte in den nächsten Sketch ein.

4Von Rohwert zu Prozent: die map()-Funktion

Jetzt rechnen wir die Rohwerte in einen schönen Prozentwert um: 0 % = staubtrocken, 100 % = klatschnass. Das Werkzeug dafür ist Arduinos map()-Funktion. Weil hoher Rohwert = trocken ist, drehen wir die Zuordnung um, sodass am Ende hohe Prozente feuchte Erde bedeuten.

// Fuer Arduino UNO – DEINE kalibrierten Werte eintragen!
#define SENSOR_PIN A0

const int TROCKEN = 620;   // dein Luftwert (hoch)
const int NASS    = 310;   // dein Wasserwert (niedrig)

void setup() {
  Serial.begin(9600);
}

void loop() {
  int roh = analogRead(SENSOR_PIN);

  // roh von [NASS..TROCKEN] auf [100..0] abbilden
  int prozent = map(roh, NASS, TROCKEN, 100, 0);
  prozent = constrain(prozent, 0, 100);   // sauber begrenzen

  Serial.print("Roh: ");     Serial.print(roh);
  Serial.print("   Feuchte: "); Serial.print(prozent);
  Serial.println(" %");
  delay(1000);
}

Die Zeile constrain(prozent, 0, 100) ist wichtig: Sollte der Sensor mal kurz einen Wert außerhalb deines kalibrierten Bereichs liefern (z. B. noch trockener als beim Kalibrieren), verhindert sie hässliche Werte wie -5 % oder 108 %. So bleibt die Anzeige immer sauber zwischen 0 und 100.

int leseMittelwert(int pin) {
  long summe = 0;
  for (int i = 0; i < 20; i++) {
    summe += analogRead(pin);
    delay(5);
  }
  return summe / 20;   // Durchschnitt aus 20 Messungen
}

5Anzeige auf dem OLED – ohne PC ablesbar

Ein Sensor, der seine Werte nur im seriellen Monitor zeigt, ist im Blumentopf nutzlos. Mit einem 0,96-Zoll-OLED baust du eine kleine, autarke Anzeige. Das OLED hängt am I2C-Bus (SDA/SCL) und braucht die Bibliotheken Adafruit_GFX und Adafruit_SSD1306.

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

#define SENSOR_PIN A0
#define TROCKEN 620
#define NASS    310

Adafruit_SSD1306 oled(128, 64, &Wire, -1);

void setup() {
  oled.begin(SSD1306_SWITCHCAPVCC, 0x3C);
  oled.clearDisplay();
  oled.setTextColor(SSD1306_WHITE);
}

void loop() {
  int roh = analogRead(SENSOR_PIN);
  int prozent = constrain(map(roh, NASS, TROCKEN, 100, 0), 0, 100);

  oled.clearDisplay();
  oled.setTextSize(1);
  oled.setCursor(0, 0);
  oled.println("Bodenfeuchte");

  oled.setTextSize(3);
  oled.setCursor(0, 20);
  oled.print(prozent);
  oled.println(" %");

  // kleiner Fortschrittsbalken
  oled.drawRect(0, 55, 128, 8, SSD1306_WHITE);
  oled.fillRect(0, 55, map(prozent, 0, 100, 0, 128), 8, SSD1306_WHITE);

  oled.display();
  delay(1000);
}

Jetzt zeigt das Display groß den Feuchte-Prozentwert und darunter einen Balken, der sich mit der Feuchte füllt. Steck den Sensor in deine Zimmerpflanze, häng das Display daneben – fertig ist der Feuchte-Monitor. Wie du das OLED noch mit Grafiken und Icons aufwertest, steht im Artikel OLED Display SSD1306 mit Arduino.

6Die Königsdisziplin: automatisch gießen

Der logische nächste Schritt: Unterschreitet die Feuchte eine Schwelle, schaltet der Arduino über ein Relais eine kleine Pumpe ein und gießt, bis die Erde wieder feucht genug ist. Damit die Pumpe nicht dauernd an- und ausflattert, arbeiten wir mit einer Hysterese: Einschalten bei z. B. 30 %, Ausschalten erst wieder bei 60 %.

#define SENSOR_PIN A0
#define RELAIS_PIN 7
#define TROCKEN 620
#define NASS    310

const int GIESSEN_UNTER = 30;   // unter 30 % -> Pumpe an
const int STOPP_UEBER   = 60;   // ueber 60 % -> Pumpe aus
bool pumpeLaeuft = false;

void setup() {
  Serial.begin(9600);
  pinMode(RELAIS_PIN, OUTPUT);
  digitalWrite(RELAIS_PIN, LOW);   // Pumpe aus
}

void loop() {
  int roh = analogRead(SENSOR_PIN);
  int feuchte = constrain(map(roh, NASS, TROCKEN, 100, 0), 0, 100);

  if (!pumpeLaeuft && feuchte < GIESSEN_UNTER) {
    pumpeLaeuft = true;
    digitalWrite(RELAIS_PIN, HIGH);
    Serial.println("Zu trocken -> Pumpe AN");
  }
  else if (pumpeLaeuft && feuchte > STOPP_UEBER) {
    pumpeLaeuft = false;
    digitalWrite(RELAIS_PIN, LOW);
    Serial.println("Feucht genug -> Pumpe AUS");
  }

  Serial.print("Feuchte: "); Serial.print(feuchte); Serial.println(" %");
  delay(2000);
}

Praxistipps für zuverlässige Messungen

Troubleshooting