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.
| Merkmal | Wert |
|---|---|
| Versorgung | 3,3–5,5 V (bei Platinen mit TLC555) |
| Ausgang | Analog, etwa 1,2–3,0 V; hoch bei trocken, niedrig bei nass |
| Stromaufnahme | Etwa 5 mA |
| Anschluss | 3-poliger PH2.0-Stecker: GND, VCC, AOUT |
| Größe | Etwa 98 × 23 mm |
| Oszillator | TLC555 (CMOS), etwa 1,5 MHz; bei Kopien NE555 |
| Spannungsregler | XC6206 mit Aufdruck 662K, 3,3 V |
| Elektroden | Kupfer 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.

| Merkmal | Resistiv (YL-69, FC-28) | Kapazitiv v1.2 |
|---|---|---|
| Messprinzip | Elektrischer Widerstand der Erde | Kapazität (Dielektrizitätszahl) |
| Elektroden | Blankes, vernickeltes Metall | Kupfer unter Lötstopplack |
| Korrosion | Bei Dauerbetrieb innerhalb weniger Wochen | Keine (solange der Lack unbeschädigt ist) |
| Einfluss von Dünger und Salzen | Groß | Gering |
| Ausgang | AO und DO (Komparator LM393) | Nur analog (AOUT) |
| Betrieb mit 3,3 V | Ja | Nur bei Platinen mit TLC555 |
| Lebensdauer | Monate | Jahre, 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üfpunkt | Gute Platine | Problem-Platine | Symptom |
|---|---|---|---|
| 555-Chip | TLC555 (CMOS) | NE555 oder SA555 | Bei 3,3 V ändert sich der Ausgang nicht oder bleibt fest |
| Spannungsregler | Kleiner 3-beiniger Chip mit Aufdruck 662K | Fehlt oder überbrückt | Bei 5 V kann der Ausgang über 3 V steigen |
| 1-MΩ-Ausgangswiderstand | Mit GND verbunden | GND-Verbindung fehlt | Sehr träge Reaktion, Wert bleibt hoch |
| Platinenkanten | Mit Lack oder Epoxid versiegelt | Offene Glasfaser | Messwert driftet innerhalb von Wochen |
Anschluss: Arduino Uno, ESP32 und Raspberry Pi Pico
| Sensor-Pin | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| GND (schwarz) | GND | GND | GND |
| VCC (rot) | 5V | GPIO 25 (3,3 V nur während der Messung) | GP22 (3,3 V nur während der Messung) |
| AOUT (gelb) | A0 | GPIO 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
- Lade den Uno-Code unten ohne angeschlossene Pumpe hoch und öffne den seriellen Monitor mit 9600 Baud.
- 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).
- 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).
- 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.
- 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) | Feuchte | Zustand der Erde | Was tun? |
|---|---|---|---|
| 590 und mehr | 0 % | Luft oder knochentrockene Erde | Prüfen, ob der Sensor richtig in der Erde steckt |
| 510 | 25 % | Trocken | Für die meisten Pflanzen Zeit zum Gießen |
| 430 | 50 % | Leicht feucht | Idealer Bereich; kein Gießen nötig |
| 350 | 75 % | Feucht | Frisch gegossene Erde |
| 270 und weniger | 100 % | Wasser oder Schlamm | Zu 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.
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}
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.
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.
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.
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
| Symptom | Wahrscheinliche Ursache | Lösung |
|---|---|---|
| Am ESP32 oder Pico ändert sich der Wert nie | Auf der Platine sitzt ein NE555, 3,3 V reichen nicht | Chip prüfen; Platine mit TLC555 verwenden oder den NE555 durch einen TLC555 ersetzen |
| Der Wechsel von trocken zu nass dauert Minuten | Der 1-MΩ-Entladewiderstand hat keine GND-Verbindung | Freies Ende des Widerstands mit einem dünnen Draht an GND legen |
| Der Messwert driftet über Wochen langsam weg | Die Kanten saugen Wasser oder die Elektronik wird nass | Kanten und Oberteil mit Lack, Epoxid oder Schrumpfschlauch versiegeln und neu kalibrieren |
| Prozentwert fällt unter null oder steigt über 100 | Kalibrierwerte falsch oder vertauscht | DRY_VALUE muss der Trockenwert (größer), WET_VALUE der Nasswert (kleiner) sein |
| Die Werte springen ständig | Langes Kabel, Störungen oder lockere Erde | Messwerte mitteln, Kabel kurz halten, Erde um den Sensor andrücken |
| Der Arduino startet neu, wenn die Pumpe anläuft | Die Pumpe hängt an der 5V-Leitung des Arduino | Pumpe aus einer eigenen Quelle versorgen und Massen verbinden |
| Am ESP32 spinnen die Werte, sobald das WLAN an ist | Der Sensor hängt an einem ADC2-Pin | AOUT 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.
Projekte, die du danach bauen kannst
Alle Projekte ansehen
Intelligente Bewässerungsstation
Ein Gärtner, der deine Pflanzen von selbst gießt, damit sie im Urlaub nicht vertrocknen.

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…

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…

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.

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.

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.

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.
Weitere Artikel
BlueGrays-App
Diese Schaltung Schritt für Schritt auf dem Handy nachbauen
Schaltplan, Code und Teileliste auf einem Bildschirm. Über 500 Arduino-, ESP32- und Pico-Projekte zum Nachbauen.
Mit dem Handy scannen
Richte die Kamera auf den Code, dann öffnet sich der App-Store deines Handys.
oder im Store öffnen

