Bauteile · 9 Min. Lesezeit

Kapazitiver Bodenfeuchtesensor Arduino: Kalibrierung und Code

Kapazitiver Bodenfeuchtesensor v1.2 am Arduino: Unterschied zum resistiven Sensor, TLC555/NE555 und 3,3 V, Kalibrierung, Prozenttabelle, ESP32 und Pico.

Ein kapazitiver Bodenfeuchtesensor misst, wie feucht die Erde im Blumentopf oder im Garten ist, ohne dass eine Metallelektrode die Erde berührt. Deshalb hat er nicht das Problem klassischer gabelförmiger resistiver Sensoren, die innerhalb weniger Wochen korrodieren und ausfallen, und hält in automatischen Bewässerungsprojekten mit Arduino Monate oder sogar Jahre. Meist steht "Capacitive Soil Moisture Sensor v1.2" oder v2.0 darauf, er liefert einen einzigen Analogausgang und wird mit drei Kabeln an einen Arduino Uno, ESP32 oder Raspberry Pi Pico angeschlossen.

Diese günstigen Module haben allerdings wichtige Tücken: Auf manchen Platinen sitzt der falsche 555-Chip, sodass sie mit 3,3 V nicht funktionieren, bei anderen fehlt die Verbindung eines Widerstands, und die Schnittkanten saugen Wasser auf und lassen den Messwert innerhalb von Wochen wandern. In dieser Anleitung lernst du, wie der Sensor funktioniert, worin er sich vom resistiven Sensor unterscheidet, wie du eine gute Platine erkennst, wie du ihn trocken und nass kalibrierst und wie du den Analogwert in Prozent Feuchte umrechnest. Danach folgen automatische Bewässerung mit dem Uno, ein batteriebetriebener Pflanzenwächter mit dem ESP32 und MicroPython-Code für den Pico.

Wie funktioniert ein kapazitiver Bodenfeuchtesensor?

Die breite Kupferfläche an der Spitze des Sensors und die umgebende GND-Fläche wirken wie die beiden Platten eines Kondensators, das Dielektrikum dazwischen ist die Erde selbst. Wasser hat eine Dielektrizitätszahl von etwa 80, trockene Erde 3–5 und Luft 1; je nasser die Erde, desto größer die Kapazität. Der 555-Chip im oberen Teil erzeugt ein Rechtecksignal von etwa 1,5 MHz, das die Sonde über einen Widerstand lädt und entlädt; danach machen eine Diode und ein kleiner Filter daraus eine Gleichspannung. Steigt die Kapazität, sinkt die Amplitude an der Sonde, und so gilt: In trockener Erde ist die Ausgangsspannung hoch, in nasser Erde niedrig. Da die Elektroden mit Lötstopplack überzogen sind, fließt kein Strom durch die Erde. Wie der 555 arbeitet, kannst du mit dem 555-Timer-Werkzeug ausprobieren.

MerkmalWert
Versorgung3,3–5,5 V (bei Platinen mit TLC555)
AusgangAnalog, etwa 1,2–3,0 V; hoch bei trocken, niedrig bei nass
StromaufnahmeEtwa 5 mA
Anschluss3-poliger PH2.0-Stecker: GND, VCC, AOUT
GrößeEtwa 98 × 23 mm
OszillatorTLC555 (CMOS), etwa 1,5 MHz; bei Kopien NE555
SpannungsreglerXC6206 mit Aufdruck 662K, 3,3 V
ElektrodenKupfer unter Lötstopplack; kein Stromfluss durch die Erde

Unterschied zum resistiven Sensor: keine Korrosion

Resistive Sensoren (YL-69, FC-28) schicken Strom zwischen zwei blanken Metallzinken durch die Erde und messen deren Widerstand. Dieser Gleichstrom verursacht in feuchter Erde Elektrolyse: Das Metall am Pluspol löst sich auf, bei Dauerbetrieb ist die Beschichtung nach wenigen Wochen weg, und die Messwerte wandern ständig. Außerdem hängt der Wert stärker von Salzen und Dünger ab als vom Wasser; am Tag, an dem du düngst, wirkt die Erde nass. Ein kapazitiver Sensor misst dagegen die dielektrische Wirkung des Wassers, reagiert deshalb viel weniger auf Salze und korrodiert nicht, weil kein Metall offen liegt. Den resistiven Sensor haben wir in Bodenfeuchtesensor behandelt.

Resistiver Bodenfeuchtesensor YL-69 mit LM393-Platine
Resistiver YL-69: Die blanken Metallzinken leiten Strom durch die Erde und tragen sich bei Dauerbetrieb in Wochen ab.
MerkmalResistiv (YL-69, FC-28)Kapazitiv v1.2
MessprinzipElektrischer Widerstand der ErdeKapazität (Dielektrizitätszahl)
ElektrodenBlankes, vernickeltes MetallKupfer unter Lötstopplack
KorrosionBei Dauerbetrieb innerhalb weniger WochenKeine (solange der Lack unbeschädigt ist)
Einfluss von Dünger und SalzenGroßGering
AusgangAO und DO (Komparator LM393)Nur analog (AOUT)
Betrieb mit 3,3 VJaNur bei Platinen mit TLC555
LebensdauerMonateJahre, wenn die Kanten geschützt sind

Versionen v1.2 und v2.0: TLC555, NE555 und das 3,3-V-Problem

Die aufgedruckte Versionsnummer ist keine Garantie; entscheidend ist die Beschriftung des achtbeinigen Chips. Gute Platinen tragen einen CMOS-TLC555, der bis hinunter auf 2 V problemlos läuft. Manche billigen Kopien verwenden dagegen den klassischen NE555, der mindestens 4,5 V braucht; an den 3,3 V eines ESP32 oder Pico ändert sich der Ausgang nicht oder bleibt auf einem sinnlosen Wert stehen. Der zweite Prüfpunkt ist der kleine Regler mit dem Aufdruck 662K: Fehlt er oder ist er überbrückt, kann der Ausgang bei 5 V Versorgung über 3 V steigen. In manchen Chargen fehlt die GND-Verbindung des 1-MΩ-Entladewiderstands am Ausgang; auf solchen Platinen dauert der Wechsel von trocken zu nass Minuten, oder der Wert bleibt immer hoch. Und schließlich saugt das offene Glasfasermaterial an den Schnittkanten mit der Zeit Wasser auf und lässt die Messung driften.

PrüfpunktGute PlatineProblem-PlatineSymptom
555-ChipTLC555 (CMOS)NE555 oder SA555Bei 3,3 V ändert sich der Ausgang nicht oder bleibt fest
SpannungsreglerKleiner 3-beiniger Chip mit Aufdruck 662KFehlt oder überbrücktBei 5 V kann der Ausgang über 3 V steigen
1-MΩ-AusgangswiderstandMit GND verbundenGND-Verbindung fehltSehr träge Reaktion, Wert bleibt hoch
PlatinenkantenMit Lack oder Epoxid versiegeltOffene GlasfaserMesswert driftet innerhalb von Wochen
Die Analogeingänge von ESP32 und Raspberry Pi Pico vertragen nicht mehr als 3,3 V. Versorge den Sensor an diesen Boards immer mit 3,3 V. Betreibst du eine Platine ohne Regler mit 5 V, kann der Ausgang über 3,3 V steigen und den Eingang beschädigen; bist du unsicher, miss den Ausgang vor dem Anschließen mit einem Multimeter. Liegt die Spannung mit dem Sensor an der Luft unter 3,3 V, ist die Platine unbedenklich.

Anschluss: Arduino Uno, ESP32 und Raspberry Pi Pico

Sensor-PinArduino UnoESP32Raspberry Pi Pico
GND (schwarz)GNDGNDGND
VCC (rot)5VGPIO 25 (3,3 V nur während der Messung)GP22 (3,3 V nur während der Messung)
AOUT (gelb)A0GPIO 34 (ADC1)GP26 (ADC0)
Relais IN (Pumpe im Uno-Beispiel)D7——

In den ESP32- und Pico-Beispielen hängt VCC des Sensors nicht direkt am 3V3-Pin, sondern an einem GPIO. Da der Sensor nur 5 mA zieht, kann ein Pin ihn problemlos versorgen; so ist der Sensor zwischen den Messungen komplett aus, und der Akku hält länger. Nutze am ESP32 für die Analogmessung die ADC1-Pins (GPIO 32–39), die auch bei eingeschaltetem WLAN funktionieren. Am Uno läuft der Sensor mit 5V, dank des Reglers auf der Platine bleibt der Ausgang aber bei etwa 3 V; deshalb nutzt der Uno nicht den ganzen 10-Bit-Bereich, sondern nur ungefähr 250 bis 600.

Kalibrierung: Trocken- und Nasswert ermitteln

  1. Lade den Uno-Code unten ohne angeschlossene Pumpe hoch und öffne den seriellen Monitor mit 9600 Baud.
  2. Halte den Sensor trocken und sauber in die Luft; notiere nach ein paar Sekunden den stabilen Rohwert als DRY_VALUE (am Uno meist 520–600).
  3. Tauche den Sensor in ein Glas Wasser, ohne die Linie auf der Platine zu überschreiten, und notiere den Wert als WET_VALUE (meist 250–300).
  4. Für ein realistischeres Ergebnis miss ein zweites Mal: Nutze die Werte in völlig ausgetrockneter Blumenerde und in derselben Erde nach gründlichem Gießen und 30 Minuten Abtropfen.
  5. Lade den Code erneut hoch; jetzt zeigt der serielle Monitor eine Feuchte zwischen 0 und 100 Prozent. Jeder Sensor liefert etwas andere Werte, kalibriere deshalb jeden einzeln.
Rohwert (Uno, Beispielkalibrierung)FeuchteZustand der ErdeWas tun?
590 und mehr0 %Luft oder knochentrockene ErdePrüfen, ob der Sensor richtig in der Erde steckt
51025 %TrockenFür die meisten Pflanzen Zeit zum Gießen
43050 %Leicht feuchtIdealer Bereich; kein Gießen nötig
35075 %FeuchtFrisch gegossene Erde
270 und weniger100 %Wasser oder SchlammZu viel Wasser; Gefahr von Wurzelfäule

Die Prozentwerte der Tabelle wurden mit % = (590 − Rohwert) × 100 / (590 − 270) für DRY_VALUE = 590 und WET_VALUE = 270 berechnet. Das ist keine Labormessung, sondern ein relativer Wert zwischen den beiden Kalibrierpunkten: „50 %“ bedeutet nicht, dass die Hälfte des Erdvolumens Wasser ist. Die Kennlinie des Sensors ist auch nicht ganz linear, für die Entscheidung, wann gegossen wird, reicht sie aber völlig aus. Verdichtung, Temperatur und Erdart verschieben den Wert ebenfalls um ein paar Punkte; drücke die Erde nach dem Einstecken leicht um den Sensor an, um Lufteinschlüsse zu schließen. Wie die Analogmessung funktioniert, erklären wir ausführlich in Was ist ein ADC?.

Code für den Arduino Uno: Feuchte in Prozent und automatische Bewässerung

Der folgende Code liest den Sensor 10-mal, bildet den Mittelwert, rechnet ihn in Prozent um und gibt ihn im seriellen Monitor aus. Fällt die Feuchte unter 35 %, beginnt die Bewässerung und läuft, bis die Feuchte über 60 % steigt; der Abstand zwischen beiden Schwellen (Hysterese) verhindert, dass die Pumpe ständig ein- und ausschaltet. Gegossen wird nicht auf einmal, sondern in 4-Sekunden-Portionen, nach jeder Portion wartet der Code 1 Minute, damit sich das Wasser in der Erde verteilt. Weil der Sensor das Wasser erst mit einigen Sekunden Verzögerung bemerkt, würde eine dauerlaufende Pumpe den Topf überfluten.

C++ (Arduino IDE)
1const byte SENSOR_PIN = A0;          // sensör AOUT / sensor AOUT
2const byte PUMP_PIN = 7;             // röle IN (pompa) / relay IN (pump)
3const byte RELAY_ON = HIGH;          // röle LOW ile çekiyorsa LOW yap / use LOW for active-low relays
4const int DRY_VALUE = 590;           // kuru: havada ya da kuru toprakta / dry: in air or dry soil
5const int WET_VALUE = 270;           // ıslak: suda ya da yeni sulanmış toprakta / wet: in water or just-watered soil
6const byte START_PCT = 35;           // bunun altında sulamaya başla / start watering below this
7const byte STOP_PCT = 60;            // bunun üstünde sulamayı bitir / stop watering above this
8const unsigned long PUMP_MS = 4000;  // tek seferde en fazla pompa süresi / max pump time per pulse
9const unsigned long SOAK_MS = 60000; // suyun toprağa yayılması için bekle / let the water spread
10
11bool watering = false;
12
13int readAverage() {                  // 10 okumanın ortalaması / average of 10 readings
14  long sum = 0;
15  for (byte i = 0; i < 10; i++) {
16    sum += analogRead(SENSOR_PIN);
17    delay(10);
18  }
19  return sum / 10;
20}
21
22int toPercent(int raw) {             // ham değeri yüzdeye çevir / raw value to percent
23  long pct = (long)(DRY_VALUE - raw) * 100 / (DRY_VALUE - WET_VALUE);
24  return constrain(pct, 0, 100);
25}
26
27void setup() {
28  Serial.begin(9600);
29  pinMode(PUMP_PIN, OUTPUT);
30  digitalWrite(PUMP_PIN, !RELAY_ON);   // pompa kapalı başlasın / start with the pump off
31}
32
33void loop() {
34  int raw = readAverage();
35  int pct = toPercent(raw);
36  Serial.print(F("Ham / raw: "));
37  Serial.print(raw);
38  Serial.print(F("   Nem / moisture: %"));
39  Serial.println(pct);
40
41  if (!watering && pct < START_PCT) watering = true;    // histerezis / hysteresis
42  if (watering && pct >= STOP_PCT) watering = false;
43
44  if (watering) {
45    digitalWrite(PUMP_PIN, RELAY_ON);  // kısa bir doz su ver / give a short dose of water
46    delay(PUMP_MS);
47    digitalWrite(PUMP_PIN, !RELAY_ON);
48    delay(SOAK_MS);                    // tekrar ölçmeden önce bekle / wait before measuring again
49  } else {
50    delay(2000);
51  }
52}
Mini-Tauchpumpe für Wasser
3–6-V-Mini-Tauchpumpe: wird über ein Relaismodul oder einen MOSFET aus einer separaten Quelle versorgt.

Schließe die Pumpe nie direkt an einen Arduino-Pin an; versorge sie über ein Relaismodul oder einen MOSFET aus einer separaten 5-V-Quelle und verbinde die Massen. Manche Relaismodule schalten bei LOW; ist das bei deinem so, setze die Konstante RELAY_ON im Code auf LOW. Zur Wahl der Pumpe und zum Anschluss des Schlauchs findest du alles im Artikel zur Mini-Wasserpumpe. Ein zusätzlicher Wasserstandssensor erkennt einen leeren Tank und verhindert, dass die Pumpe trocken läuft und durchbrennt.

Batteriebetriebener Pflanzenfeuchte-Wächter mit dem ESP32

Der Deep-Sleep-Modus des ESP32 macht es möglich, den Sensor monatelang mit Akkus zu betreiben. Nach dem Aufwachen schaltet der folgende Code den Sensor über GPIO 25 ein, wartet 1 Sekunde, bis sich der Ausgang eingependelt hat, mittelt 16 Messungen, schaltet den Sensor wieder ab und gibt das Ergebnis aus. Liegt die Erde unter 30 %, blinkt die eingebaute LED dreimal; danach schläft der ESP32 30 Minuten. Der mit RTC_DATA_ATTR markierte Zähler bleibt im Deep Sleep erhalten. Da der ADC des ESP32 12 Bit hat, liegen die Kalibrierwerte im Bereich 0–4095 und weichen von denen des Uno ab; miss sie mit deinem Sensor neu.

C++ (Arduino IDE)
1const int SENSOR_PIN = 34;           // AOUT, ADC1 pini / ADC1 pin
2const int SENSOR_POWER_PIN = 25;     // sensörün VCC'si / sensor VCC
3const int LED_PIN = 2;               // dahili LED: kuru uyarısı / onboard LED: dry warning
4const int DRY_VALUE = 3100;          // 12 bit, havada / 12-bit, in air
5const int WET_VALUE = 1350;          // 12 bit, suda / 12-bit, in water
6const uint64_t SLEEP_MIN = 30;       // ölçüm aralığı (dakika) / interval (minutes)
7
8RTC_DATA_ATTR int bootCount = 0;     // derin uykuda korunur / kept through deep sleep
9
10void setup() {
11  Serial.begin(115200);
12  bootCount++;
13  pinMode(SENSOR_POWER_PIN, OUTPUT);
14  pinMode(LED_PIN, OUTPUT);
15
16  digitalWrite(SENSOR_POWER_PIN, HIGH);        // sensörü aç / power the sensor
17  delay(1000);                                 // çıkış otursun / let the output settle
18  long sum = 0;
19  for (int i = 0; i < 16; i++) sum += analogRead(SENSOR_PIN);
20  digitalWrite(SENSOR_POWER_PIN, LOW);         // sensörü kapat / switch it off
21  int raw = sum / 16;
22  int pct = constrain(map(raw, DRY_VALUE, WET_VALUE, 0, 100), 0, 100);
23  Serial.printf("#%d raw %d moisture %d%%\n", bootCount, raw, pct);
24
25  if (pct < 30) {                              // kuruysa 3 kez yanıp sön / blink 3 times if dry
26    for (int i = 0; i < 3; i++) {
27      digitalWrite(LED_PIN, HIGH);
28      delay(200);
29      digitalWrite(LED_PIN, LOW);
30      delay(200);
31    }
32  }
33  esp_sleep_enable_timer_wakeup(SLEEP_MIN * 60ULL * 1000000ULL);   // mikrosaniye / microseconds
34  esp_deep_sleep_start();                      // 30 dk uyu / sleep for 30 min
35}
36
37void loop() {
38}

Schätzen wir die Akkulaufzeit grob ab: Bei jedem Aufwachen zieht der ESP32 etwa 1,5 Sekunden lang 40–50 mA; bei einem Weckintervall von 30 Minuten ergibt das im Mittel nur 50 × 1,5 / 1800 ≈ 0,04 mA. Entscheidend ist der Schlafstrom: Ein gewöhnliches DevKit mit USB-Seriell-Chip und Spannungsregler zieht selbst im Schlaf mehrere mA und leert einen 2000-mAh-Akku in zwei bis drei Wochen. Mit einem nackten ESP32-Modul und einem verlustarmen Regler sinkt der Schlafstrom auf einige Dutzend Mikroampere, und der Akku hält monatelang. Rechne deine Schaltung mit dem Akkulaufzeit-Rechner durch; Details in ESP32 Deep Sleep.

Kapazitiver Sensor am Raspberry Pi Pico (MicroPython)

Schließe am Raspberry Pi Pico den AOUT-Pin des Sensors an GP26 (ADC0) und VCC an GP22 an. In MicroPython liefert read_u16() Werte von 0 bis 65535; an der Luft siehst du etwa 50000–53000, im Wasser rund 22000–26000. Da der ADC des Pico eine 3,3-V-Referenz nutzt, deckt der Ausgang eines Sensors mit Regler den Bereich gut ab. Der Code misst alle 10 Sekunden und stuft die Erde als dry, ok oder wet ein.

MicroPython
1from machine import ADC, Pin
2import time
3
4sensor = ADC(26)                  # GP26 = ADC0, sensör AOUT / sensor AOUT
5power = Pin(22, Pin.OUT)          # sensörün VCC'si / sensor VCC
6DRY = 52000                       # havada okunan (16 bit) / reading in air (16-bit)
7WET = 24000                       # suda okunan (16 bit) / reading in water (16-bit)
8
9def read_moisture():
10    power.value(1)                # sensörü aç / power on
11    time.sleep(1)                 # çıkış otursun / let the output settle
12    total = 0
13    for _ in range(16):
14        total += sensor.read_u16()
15        time.sleep_ms(5)
16    power.value(0)                # sensörü kapat / power off
17    raw = total // 16
18    pct = (DRY - raw) * 100 // (DRY - WET)
19    return raw, max(0, min(100, pct))
20
21while True:
22    raw, pct = read_moisture()
23    state = "dry" if pct < 30 else ("ok" if pct < 80 else "wet")
24    print("raw:", raw, "moisture %:", pct, state)
25    time.sleep(10)

Wasserschutz: Kanten versiegeln und richtig platzieren

  • Kanten versiegeln: Die offene Glasfaser an den Schnittkanten saugt Wasser auf und lässt den Messwert innerhalb von Wochen driften. Versiegele die Kanten der Sonde mit Nagellack, Klarlack oder einer dünnen Schicht Epoxidharz.
  • Elektronik schützen: Decke den oberen Bereich mit 555-Chip, Regler und Stecker mit Schrumpfschlauch, Heißkleber oder Epoxid ab, damit kein Regen- oder Gießwasser hinkommt.
  • Die Linie nicht überschreiten: Die weiße Linie auf der Platine zeigt, wie tief der Sensor höchstens in die Erde darf; die Elektronik muss immer oberhalb der Erde bleiben.
  • Gerade und fest einstecken: Stecke den Sensor senkrecht ein und drücke die Erde leicht an; Lufteinschlüsse lassen die Erde trockener erscheinen.
  • Position beibehalten: Setze den Sensor 1–2 cm von der Topfwand entfernt in den Wurzelbereich, nicht direkt unter den Gießschlauch. Wenn du ihn versetzt, kalibriere neu.
  • Den Lack nicht zerkratzen: Mit Gewalt in harte Erde gedrückt, verkratzt der Lötstopplack, und freiliegendes Kupfer korrodiert auch beim kapazitiven Sensor. Bohre bei Bedarf vorher mit einem Stab ein Loch.
Nach dem Versiegeln von Kanten und Messbereich können sich Trocken- und Nasswert um einige Stufen ändern. Kalibriere neu, wenn die Beschichtung vollständig getrocknet ist, und trage auf den Messbereich keine dicke Schicht auf, denn sie verringert die Empfindlichkeit.

Projektideen

  • Automatische Topfbewässerung: Gieße deine Pflanzen im Urlaub mit dem Uno-Code, einem Relais und einer Mini-Pumpe.
  • Smartes Gewächshaus: Kombiniere die Bodenfeuchte mit Lufttemperatur und Luftfeuchte zu einem smarten Gewächshaus, das Lüfter und Pumpe steuert.
  • Warnung aufs Handy: Lass den ESP32 über einen Telegram-Bot eine Nachricht schicken, wenn die Erde austrocknet.
  • Feuchtediagramm: Speichere die Messwerte in Google Tabellen und sieh im Diagramm, wie schnell deine Pflanze austrocknet.
  • Pflanzenanzeige mit Display: Zeige die Feuchte als Balken auf einem OLED-Display an.
  • Bei Regen nicht gießen: Starte bei der Gartenbewässerung die Pumpe nicht, wenn ein Regensensor Niederschlag meldet.

Häufige Fehler und Lösungen

SymptomWahrscheinliche UrsacheLösung
Am ESP32 oder Pico ändert sich der Wert nieAuf der Platine sitzt ein NE555, 3,3 V reichen nichtChip prüfen; Platine mit TLC555 verwenden oder den NE555 durch einen TLC555 ersetzen
Der Wechsel von trocken zu nass dauert MinutenDer 1-MΩ-Entladewiderstand hat keine GND-VerbindungFreies Ende des Widerstands mit einem dünnen Draht an GND legen
Der Messwert driftet über Wochen langsam wegDie Kanten saugen Wasser oder die Elektronik wird nassKanten und Oberteil mit Lack, Epoxid oder Schrumpfschlauch versiegeln und neu kalibrieren
Prozentwert fällt unter null oder steigt über 100Kalibrierwerte falsch oder vertauschtDRY_VALUE muss der Trockenwert (größer), WET_VALUE der Nasswert (kleiner) sein
Die Werte springen ständigLanges Kabel, Störungen oder lockere ErdeMesswerte mitteln, Kabel kurz halten, Erde um den Sensor andrücken
Der Arduino startet neu, wenn die Pumpe anläuftDie Pumpe hängt an der 5V-Leitung des ArduinoPumpe aus einer eigenen Quelle versorgen und Massen verbinden
Am ESP32 spinnen die Werte, sobald das WLAN an istDer Sensor hängt an einem ADC2-PinAOUT auf einen ADC1-Pin zwischen GPIO 32 und 39 legen

Wählst du die richtige Platine und schützt ihre Kanten, ist der kapazitive Bodenfeuchtesensor das zuverlässigste Bauteil jedes Pflanzen- und Gartenprojekts. Prüfe zuerst den Chip, kalibriere dann in deiner eigenen Erde und gieße mit Hysterese in kurzen Portionen. In der BlueGrays-App findest du eine smarte Bewässerungsstation mit Arduino, dazu Temperatur- und Feuchtemessung, jeweils mit Schritt-für-Schritt-Schaltplan und fertigem Code.

Häufige Fragen

Was ist der Unterschied zwischen kapazitivem und resistivem Bodenfeuchtesensor?

Ein resistiver Sensor leitet Strom zwischen zwei blanken Metallzinken durch die Erde, und diese Zinken korrodieren durch Elektrolyse innerhalb weniger Wochen. Ein kapazitiver Sensor misst die Kapazität der Erde mit isolierten Elektroden, leitet keinen Strom und rostet nicht. Außerdem beeinflussen ihn Dünger und Salze viel weniger.

Funktioniert der kapazitive Bodenfeuchtesensor mit 3,3 V?

Platinen mit TLC555-Chip laufen problemlos mit 3,3 V und lassen sich direkt an einen ESP32 oder Pico anschließen. Kopien mit NE555 brauchen mindestens 4,5 V, bei 3,3 V ändert sich der Ausgang nicht. Welche Variante du hast, verrät der Aufdruck auf dem achtbeinigen Chip.

Wie kalibriere ich einen kapazitiven Bodenfeuchtesensor?

Halte den Sensor in die Luft oder in knochentrockene Erde und notiere den Wert als Trockenwert, stecke ihn dann in Wasser oder frisch gegossene Erde und notiere den Nasswert. Die Feuchte berechnet sich mit % = (trocken − Rohwert) × 100 / (trocken − nass). Jeder Sensor liefert andere Werte, kalibriere also jeden einzeln.

Wie viel Prozent Feuchte sollte die Erde haben?

Der Prozentwert dieses Sensors ist relativ zu seinen eigenen Kalibrierpunkten. Für die meisten Topfpflanzen sind 40–70 % ein guter Bereich; gießen solltest du unter 25–30 % und über 80 % damit aufhören. Bei Sukkulenten und Kakteen wähle eine niedrigere Schwelle.

Ist der kapazitive Bodenfeuchtesensor wasserdicht?

Die Messsonde ist wasserfest, die Schnittkanten und die Elektronik oben aber nicht. Versiegelst du die Kanten mit Lack oder Epoxid und den oberen Teil mit Schrumpfschlauch oder Heißkleber, hält der Sensor viele Jahre. Stecke ihn nicht tiefer als bis zur Linie auf der Platine.

Warum ändert sich der Sensorwert so langsam?

Bei manchen Kopien fehlt die GND-Verbindung des 1-MΩ-Widerstands am Ausgang, sodass sich der Ausgangskondensator nicht entladen kann. Der Wechsel von trocken zu nass dauert dann Minuten. Verbindest du das freie Ende des Widerstands mit einem dünnen Draht mit GND, ist das Problem gelöst.

Alle Projekte ansehen
Intelligente Bewässerungsstation
AR-83Fortgeschritten
Premium

Intelligente Bewässerungsstation

Ein Gärtner, der deine Pflanzen von selbst gießt, damit sie im Urlaub nicht vertrocknen.

5.0(42)
57
Temperatur und Luftfeuchtigkeit mit DHT11
AR-55Mittel

Temperatur und Luftfeuchtigkeit mit DHT11

Wie warm ist dein Zimmer, und ist die Luft feucht oder trocken? Der DHT11-Sensor misst Temperatur und Luftfeuchtigkeit, und der Arduino schreibt die Werte auf ein zweizeiliges LCD und aktualisiert…

4.7(47)
83
Lichtstärke messen mit LDR
AR-11Anfänger

Lichtstärke messen mit LDR

Willst du sehen, wie hell dein Zimmer ist, und zwar als Zahl? Der LDR, ein kleines lichtempfindliches Bauteil, misst das Umgebungslicht, und der Arduino schreibt den Wert jede halbe Sekunde auf…

4.6(83)
143
Messung der Lichtintensität mit dem ESP32-LDR-Modul
ES-11Anfänger

Messung der Lichtintensität mit dem ESP32-LDR-Modul

Echtzeit-Anzeige des ADC-Rohwerts des LDR-Moduls und des anhand von Dunkel- und Hellreferenzwerten berechneten relativen Lichtwerts in Prozent im Serial Monitor. Dieser Prozentwert ist keine Lux-Messung. Vermittelt die Kalibrierungslogik des Moduls. Sollte idealerweise vor Projekt 10 durchgeführt werden, da es zur Festlegung des Schwellenwerts dient.

4.6(36)
55
ESP32 DHT22 Temperatur und Luftfeuchtigkeit (mit LCD-Display)
ES-15Mittel

ESP32 DHT22 Temperatur und Luftfeuchtigkeit (mit LCD-Display)

Bei diesem Projekt werden die Umgebungstemperatur und die Luftfeuchtigkeit mit einem DHT22-Sensor gemessen und in Echtzeit auf einem 16x2 I2C-LCD angezeigt. Mithilfe der Adafruit-DHT-Bibliothek werden die Daten über das One-Wire-Protokoll vom Sensor ausgelesen. Dieses Projekt bildet die Grundlage für IoT-Wetterstationen, Smart-Home-Automatisierung oder Umgebungsüberwachungssysteme in Gewächshäusern. Die Kommunikation mit dem DHT22 erfolgt über den GPIO-4-Pin des ESP32.

4.8(38)
57
ESP32 Temperatur-Datenlogger (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Fortgeschritten
Premium

ESP32 Temperatur-Datenlogger (DHT22 + DS1307 RTC + microSD + OLED)

Bau mit dem ESP32 einen zeitgesteuerten Temperatur- und Feuchtigkeitslogger! Ein DHT22 misst einmal pro Minute Temperatur und Luftfeuchtigkeit; jeder Wert landet mit einem Zeitstempel des RTC-Moduls DS1307 im CSV-Format auf einer microSD-Karte. Das OLED zeigt live und in großer Schrift die letzte Temperatur, die Luftfeuchtigkeit, den Zeitstempel und die Zahl der Einträge.

4.7(7)
12
ESP32: LED-Helligkeit mit Potentiometer (Analog → PWM)
ES-13Mittel
Premium

ESP32: LED-Helligkeit mit Potentiometer (Analog → PWM)

In diesem Projekt steuern wir die Helligkeit einer LED analog über ein Potentiometer. Der ADC-Pin des ESP32 liest die vom Potentiometer kommende Spannung von 0-3,3 V aus, woraufhin dieser Wert in ein PWM-Signal (Pulsweitenmodulation) umgewandelt und an die LED gesendet wird. So leuchtet die LED beim Drehen des Potentiometers stufenweise auf und erlischt wieder. Mit Arduino Core 3.0+ kann analogWrite() direkt verwendet werden; bei ESP32-S2/S3 ist die ADC-Auflösung auf 12 Bit festgelegt.

4.5(19)
32