Componenten · 10 min leestijd

Capacitieve bodemvochtsensor met Arduino: kalibratie en code

Een capacitieve bodemvochtsensor v1.2 gebruiken met Arduino: verschil met resistief, het TLC555/NE555-probleem op 3,3 V, droog-nat-kalibratie, percentagetabel, ESP32, Pico.

Een capacitieve bodemvochtsensor is een module die meet hoe nat de grond in een pot of tuin is, zonder dat een metalen elektrode de grond raakt. Daardoor heeft hij geen last van het probleem van klassieke resistieve vorkprobes, die binnen een paar weken corroderen en uitvallen. In automatische bewateringsprojecten met Arduino gaat hij maanden of zelfs jaren mee. Hij heet meestal "Capacitive Soil Moisture Sensor v1.2" of v2.0, heeft één analoge uitgang en sluit je met drie draden aan op een Arduino Uno, ESP32 of Raspberry Pi Pico.

Deze goedkope modules hebben wel belangrijke valkuilen: sommige boards gebruiken de verkeerde 555-chip en werken niet op 3,3 V, bij andere ontbreekt een weerstandsverbinding, en de afgezaagde randen zuigen water op, waardoor de metingen binnen enkele weken gaan afwijken. In deze gids leer je hoe de sensor werkt, hoe hij verschilt van een resistieve sensor, hoe je een goed board herkent, hoe je hem droog en nat kalibreert en hoe je de analoge waarde omrekent naar een vochtpercentage. Daarna volgen automatisch bewateren met een Uno, een plantenmonitor op batterijen met een ESP32 en MicroPython-code voor de Pico.

Hoe werkt een capacitieve bodemvochtsensor?

Het brede koperen vlak aan de punt van de sensor en het GND-vlak eromheen werken als de twee platen van een condensator, en de isolator ertussen is de grond zelf. Water heeft een diëlektrische constante van ongeveer 80, droge grond 3–5 en lucht 1: hoe natter de grond, hoe hoger de capaciteit. De 555-chip bovenaan maakt een blokgolf van ongeveer 1,5 MHz die de probe via een weerstand oplaadt en ontlaadt, waarna een diode en een klein filter het signaal omzetten in een gelijkspanning. Als de capaciteit stijgt, daalt de amplitude van de golf op de probe, dus de uitgangsspanning is hoog in droge grond en laag in natte grond. Omdat de elektroden door soldeermasker zijn bedekt, loopt er geen stroom door de grond. Met de 555-timertool kun je experimenteren met de werking van de 555.

EigenschapWaarde
Voeding3,3–5,5 V (op boards met een TLC555)
UitgangAnaloog, ongeveer 1,2–3,0 V; hoog bij droog, laag bij nat
StroomOngeveer 5 mA
Connector3-pins PH2.0: GND, VCC, AOUT
AfmetingenOngeveer 98 × 23 mm
OscillatorTLC555 (CMOS), ongeveer 1,5 MHz; NE555 op namaakboards
RegelaarXC6206 met opdruk 662K, 3,3 V
ElektrodenKoper geïsoleerd door soldeermasker; er loopt geen stroom door de grond

Verschil met een resistieve sensor: geen corrosie

Resistieve sensoren (YL-69, FC-28) sturen stroom tussen twee blanke metalen pennen in de grond en meten de weerstand ervan. In natte grond veroorzaakt die gelijkstroom elektrolyse: het metaal van de positieve pen lost op, bij continue voeding is de metaallaag binnen een paar weken weg en blijven de metingen afwijken. De meting hangt bovendien meer af van zouten en meststof dan van water; op de dag dat je je planten voedt, lijkt de grond nat. Een capacitieve sensor meet in plaats daarvan het diëlektrische effect van het water, dus zouten hebben veel minder invloed, en omdat er geen blank metaal is, corrodeert hij niet. De resistieve sensor behandelden we in bodemvochtsensor.

Resistieve YL-69-bodemvochtsensor en LM393-board
Resistieve YL-69-sensor: de blanke metalen pennen sturen stroom door de grond en slijten bij continue voeding binnen weken weg.
EigenschapResistief (YL-69, FC-28)Capacitief v1.2
MeetmethodeElektrische weerstand van de grondCapaciteit (diëlektrische constante)
ElektrodenBlank vernikkeld metaalKoper geïsoleerd door soldeermasker
CorrosieBinnen enkele weken bij continue voedingGeen (tenzij het masker is bekrast)
Invloed van meststof en zoutenGrootKlein
UitgangAO en DO (LM393-comparator)Alleen analoog (AOUT)
Werkt op 3,3 VJaAlleen op boards met een TLC555
LevensduurMaandenJaren, als de randen beschermd zijn

Versies v1.2 en v2.0: TLC555, NE555 en het 3,3 V-probleem

Het versienummer op het board is geen garantie; wat telt is de opdruk op de chip met acht pinnen. Goede boards hebben een CMOS-TLC555, die prima werkt vanaf 2 V. Sommige goedkope namaakboards gebruiken in plaats daarvan de klassieke NE555, die minstens 4,5 V nodig heeft; op de 3,3 V van een ESP32 of Pico verandert de uitgang dan niet of blijft hij op een betekenisloze waarde hangen. Het tweede om te controleren is de kleine regelaar met opdruk 662K: als die ontbreekt of is overbrugd, kan de uitgang op 5 V voeding boven 3 V komen. Bij sommige series ontbreekt de GND-verbinding van de ontlaadweerstand van 1 MΩ op de uitgang; op die boards duurt de overgang van droog naar nat minuten of blijft de waarde hoog. Tot slot zuigt het blanke glasvezel aan de afgezaagde randen na verloop van tijd water op, waardoor de metingen gaan afwijken.

ControleGoed boardProblematisch boardVerschijnsel
555-chipTLC555 (CMOS)NE555 of SA555Op 3,3 V verandert de uitgang niet of blijft hij vast
RegelaarKleine chip met 3 pinnen, opdruk 662KOntbreekt of is overbrugdOp 5 V kan de uitgang boven 3 V komen
Uitgangsweerstand van 1 MΩVerbonden met GNDGND-verbinding ontbreektZeer trage reactie, waarde altijd hoog
Randen van het boardBedekt met lak of epoxyBlank glasvezelMetingen wijken binnen weken af
De analoge ingangen van de ESP32 en de Raspberry Pi Pico kunnen niet meer dan 3,3 V hebben. Voed de sensor op deze boards altijd met 3,3 V. Als je een board zonder regelaar met 5 V voedt, kan de uitgang boven 3,3 V komen en de ingang beschadigen; als je het niet zeker weet, meet de uitgang dan met een multimeter voordat je aansluit. Als de spanning die je met de sensor in de lucht meet onder 3,3 V ligt, is het board veilig.

Bedrading: Arduino Uno, ESP32 en Raspberry Pi Pico

SensorpinArduino UnoESP32Raspberry Pi Pico
GND (zwart)GNDGNDGND
VCC (rood)5VGPIO 25 (alleen 3,3 V tijdens het meten)GP22 (alleen 3,3 V tijdens het meten)
AOUT (geel)A0GPIO 34 (ADC1)GP26 (ADC0)
Relais IN (pomp in het Uno-voorbeeld)D7——

In de voorbeelden voor ESP32 en Pico gaat de VCC van de sensor naar een GPIO in plaats van rechtstreeks naar de 3V3-pin. Omdat de sensor maar 5 mA trekt, kan een pin hem makkelijk voeden; zo gaat de sensor tussen de metingen helemaal uit en gaat de batterij langer mee. Gebruik op de ESP32 voor de analoge meting ADC1-pins (GPIO 32–39), die blijven werken als Wi-Fi aanstaat. Op de Uno draait de sensor op 5V, maar dankzij de regelaar op het board blijft de uitgang rond 3 V; daarom gebruikt de Uno maar ongeveer 250–600 van zijn 10-bits bereik.

Kalibratie: de droge en natte waarde vinden

  1. Upload de Uno-code hieronder zonder aangesloten pomp en open de Serial Monitor op 9600 baud.
  2. Houd de sensor droog en schoon in de lucht; noteer na een paar seconden de gestabiliseerde ruwe waarde als DRY_VALUE (meestal 520–600 op de Uno).
  3. Dompel de sensor in een glas water, zonder voorbij de lijn op het board te gaan, en noteer de meting als WET_VALUE (meestal 250–300).
  4. Voor een realistischer resultaat doe je een tweede reeks metingen: gebruik de waarden van volledig droge potgrond en van dezelfde grond na flink water geven en 30 minuten uitlekken.
  5. Upload de code opnieuw; de Serial Monitor toont nu een vochtpercentage van 0 tot 100. Elke sensor geeft iets andere waarden, dus kalibreer elke sensor apart.
Ruwe waarde (Uno, voorbeeldkalibratie)VochtToestand van de grondWat te doen
590 en hoger0%Lucht of kurkdroge grondControleer of de sensor goed in de grond zit
51025%DroogTijd om water te geven voor de meeste planten
43050%Licht vochtigIdeaal bereik; water geven is niet nodig
35075%VochtigPas bewaterde grond
270 en lager100%Water of modderTe veel water; kans op wortelrot

De percentages in de tabel zijn berekend met % = (590 − ruw) × 100 / (590 − 270) voor DRY_VALUE = 590 en WET_VALUE = 270. Dit is geen laboratoriummeting maar een relatieve waarde tussen de twee kalibratiepunten: "50%" betekent niet dat de helft van het volume van de grond water is. De respons van de sensor is ook niet perfect lineair, maar ruim voldoende om te bepalen wanneer je water moet geven. Aandrukken van de grond, temperatuur en grondsoort verschuiven de meting ook enkele punten; druk na het inbrengen van de sensor de grond er voorzichtig omheen aan om luchtholtes te dichten. Het analoog uitlezen leggen we uitgebreid uit in Wat is een ADC?.

Arduino Uno-code: vochtpercentage en automatisch bewateren

De code hieronder leest de sensor 10 keer uit en middelt het resultaat, rekent de waarde om naar een percentage en toont het in de Serial Monitor. Als het vocht onder 35% zakt, begint het bewateren en dat gaat door tot het vocht boven 60% komt; het verschil tussen deze twee drempels (hysterese) voorkomt dat de pomp voortdurend aan- en uitschakelt. Er wordt niet in één keer water gegeven, maar in doses van 4 seconden, met na elke dosis 1 minuut wachttijd zodat het water zich door de grond kan verspreiden. Omdat de sensor het water enkele seconden te laat merkt, zou een continu draaiende pomp de pot laten overstromen.

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-dompelpomp
Mini-dompelpomp van 3–6 V: gevoed via een aparte voeding, aangestuurd met een relaismodule of een MOSFET.

Sluit de pomp nooit rechtstreeks aan op een Arduino-pin; voed hem met een aparte 5V-voeding via een relaismodule of een MOSFET en verbind de massa's met elkaar. Sommige relaismodules schakelen in bij een LOW-signaal; als die van jou dat doet, zet je de constante RELAY_ON in de code op LOW. Voor het kiezen van de pomp en het aansluiten van het slangetje, zie het artikel over de mini-waterpomp. Met een waterniveausensor om een leeg reservoir te detecteren voorkom je dat de pomp droog draait en doorbrandt.

Plantenvochtmonitor op batterijen met een ESP32

Dankzij de deep sleep-modus van de ESP32 kan de sensor maandenlang op batterijen draaien. Bij het ontwaken schakelt de code hieronder de sensor in via GPIO 25, wacht 1 seconde tot de uitgang stabiel is, middelt 16 metingen, schakelt de sensor uit en toont het resultaat. Als de grond onder 30% zit, knippert de ingebouwde led drie keer; daarna slaapt de ESP32 30 minuten. De teller met RTC_DATA_ATTR blijft behouden tijdens deep sleep. Omdat de ADC van de ESP32 12 bits is, liggen de kalibratiewaarden in het bereik 0–4095 en wijken ze af van die van de Uno; meet ze opnieuw met je eigen sensor.

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}

Laten we de levensduur van de batterij grof schatten: bij elk ontwaken trekt de ESP32 gedurende ongeveer 1,5 seconde 40–50 mA; bij ontwaken elke 30 minuten is dat gemiddeld slechts 50 × 1,5 / 1800 ≈ 0,04 mA. Waar het echt om gaat is de slaapstroom: een gewoon DevKit trekt met zijn USB-serieel-chip en regelaar zelfs in slaap enkele mA en maakt een batterij van 2000 mAh in twee of drie weken leeg. Met een kale ESP32-module en een regelaar met weinig verlies zakt de slaapstroom naar tientallen microampères en gaat de batterij maanden mee. Reken je eigen schakeling door met de batterijduurcalculator; details staan in ESP32 deep sleep.

Capacitieve sensor met Raspberry Pi Pico (MicroPython)

Sluit op de Raspberry Pi Pico de AOUT van de sensor aan op GP26, dat is ADC0, en de VCC op GP22. In MicroPython geeft read_u16() waarden van 0 tot 65535; in de lucht zie je ongeveer 50000–53000 en in water rond 22000–26000. Omdat de ADC van de Pico een referentie van 3,3 V gebruikt, past de uitgang van een sensor met regelaar ruim in het bereik. De code leest elke 10 seconden uit en deelt de grond in als dry, ok of wet.

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)

Waterdicht maken: de randen beschermen en de sensor plaatsen

  • Bedek de randen: het blanke glasvezel aan de afgezaagde randen van het board zuigt water op en laat de metingen binnen weken afwijken. Bedek de randen van de probe met nagellak, heldere lak of een dun laagje epoxy.
  • Bescherm de elektronica: bedek het bovenste deel met de 555-chip, de regelaar en de connector met krimpkous, hotglue of epoxy, zodat regen en gietwater er niet bij komen.
  • Ga niet voorbij de lijn: de witte lijn op het board geeft het diepste punt aan dat in de grond mag; de elektronica moet altijd boven de grond blijven.
  • Steek hem recht en stevig erin: breng de sensor verticaal in en druk de grond er voorzichtig omheen aan; luchtholtes laten de grond droger lijken dan hij is.
  • Houd de positie vast: plaats de sensor 1–2 cm van de potwand in de wortelzone, niet direct onder de gietslang. Als je hem verplaatst, kalibreer dan opnieuw.
  • Kras het masker niet: als je hem met kracht in harde grond duwt, krast het beschermende soldeermasker, en blootliggend koper corrodeert ook bij een capacitieve sensor. Maak zo nodig eerst een gat met een stokje.
Na het bedekken van de randen en het meetgebied kunnen de droge en natte waarde van de sensor een paar punten veranderen. Kalibreer opnieuw als de coating helemaal droog is en breng geen dikke laag aan op het meetgebied, want dat verlaagt de gevoeligheid.

Projectideeën

  • Automatisch potten bewateren: geef je planten water terwijl je op vakantie bent, met de Uno-code, een relais en een minipomp.
  • Slimme kas: combineer bodemvocht met luchttemperatuur en luchtvochtigheid in een slimme kas die een ventilator en een pomp aanstuurt.
  • Melding op je telefoon: laat de ESP32 via een Telegram-bot een bericht sturen als de grond uitdroogt.
  • Vochtgrafiek: log de metingen naar Google Sheets en zie in een grafiek hoe lang je plant erover doet om uit te drogen.
  • Plantendisplay: toon het vochtpercentage als balk op een OLED-display.
  • Niet bewateren bij regen: laat bij het bewateren van de tuin de pomp niet draaien als een regensensor regen detecteert.

Veelgemaakte fouten en hoe je ze oplost

VerschijnselWaarschijnlijke oorzaakOplossing
De waarde verandert nooit op een ESP32 of PicoHet board heeft een NE555 en 3,3 V is niet genoegControleer de chip; gebruik een board met een TLC555 of vervang de NE555 door een TLC555
De waarde heeft minuten nodig om van droog naar nat te gaanDe ontlaadweerstand van 1 MΩ is niet verbonden met GNDVerbind het vrije uiteinde van de weerstand met een dunne draad met GND
De meting drijft langzaam weg over enkele wekenDe randen zuigen water op of de elektronica wordt natBedek de randen en de bovenkant met lak, epoxy of krimpkous en kalibreer opnieuw
Het percentage komt onder nul of boven 100De kalibratiewaarden zijn fout of verwisseldDRY_VALUE moet de droge waarde zijn (de grotere) en WET_VALUE de natte waarde (de kleinere)
De waarden blijven springenLange kabel, ruis of losse grondMiddel de metingen, houd de kabel kort en druk de grond rond de sensor aan
De Arduino reset als de pomp startDe pomp wordt gevoed vanaf de 5V-lijn van de ArduinoVoed de pomp met een aparte voeding en verbind de massa's met elkaar
De ESP32-metingen gaan fout als Wi-Fi aangaatDe sensor zit op een ADC2-pinVerplaats AOUT naar een ADC1-pin tussen GPIO 32 en 39

Als je het juiste board kiest en de randen beschermt, is de capacitieve bodemvochtsensor het betrouwbaarste onderdeel van elk plant- of tuinproject. Controleer eerst de chip, kalibreer dan in je eigen grond en geef water met hysterese in korte doses. In de BlueGrays-app vind je een slim bewateringsstation met Arduino, naast temperatuur- en luchtvochtigheidsmeting, elk met stap-voor-stap-schakelschema's en kant-en-klare code.

Veelgestelde vragen

Wat is het verschil tussen capacitieve en resistieve bodemvochtsensoren?

Een resistieve sensor stuurt stroom tussen twee blanke metalen pennen in de grond, en elektrolyse laat die pennen binnen enkele weken corroderen. Een capacitieve sensor meet de capaciteit van de grond met geïsoleerde elektroden, stuurt geen stroom door de grond en corrodeert niet. Hij wordt ook veel minder beïnvloed door meststof en zouten.

Werkt de capacitieve bodemvochtsensor op 3,3 V?

Boards met een TLC555-chip werken prima op 3,3 V en kun je rechtstreeks aansluiten op een ESP32 of Pico. Namaakboards met een NE555 hebben minstens 4,5 V nodig en op 3,3 V verandert de uitgang niet. Aan de opdruk op de chip met acht pinnen op het board zie je welke je hebt.

Hoe kalibreer je een capacitieve bodemvochtsensor?

Houd de sensor in de lucht of in kurkdroge grond en noteer de meting als droge waarde, zet hem daarna in water of pas bewaterde grond en noteer de meting als natte waarde. Het percentage bereken je met % = (droog − ruw) × 100 / (droog − nat). Elke sensor geeft andere waarden, dus kalibreer ze stuk voor stuk.

Welk vochtpercentage moet de grond hebben?

Het percentage van deze sensor is relatief ten opzichte van zijn eigen kalibratiepunten. Voor de meeste kamerplanten is 40–70% een goed bereik; water geven heeft zin als het onder 25–30% zakt en stoppen boven 80%. Gebruik voor vetplanten en cactussen een lagere drempel.

Is de capacitieve bodemvochtsensor waterdicht?

De meetprobe is waterbestendig, maar de afgezaagde randen van het board en de elektronica bovenaan zijn dat niet. Bedek de randen met lak of epoxy en de bovenkant met krimpkous of hotglue, dan gaat de sensor jaren mee. Duw hem niet dieper dan de lijn op het board.

Waarom verandert de meting van mijn sensor zo langzaam?

Bij sommige namaakboards is de weerstand van 1 MΩ op de uitgang niet verbonden met GND, waardoor de uitgangscondensator zich niet kan ontladen. De overgang van droog naar nat duurt dan minuten. Als je het vrije uiteinde van de weerstand met een dunne draad met GND verbindt, is het probleem opgelost.

Alle projecten bekijken
Slim bewateringsstation
AR-83Gevorderd
Premium

Slim bewateringsstation

Een tuinier die je planten zelf water geeft, zodat ze niet uitdrogen terwijl jij op vakantie bent.

5.0(42)
57
Temperatuur en luchtvochtigheid met DHT11
AR-55Gemiddeld

Temperatuur en luchtvochtigheid met DHT11

Hoe warm is je kamer, en is de lucht vochtig of droog? De DHT11-sensor meet temperatuur en luchtvochtigheid en de Arduino schrijft de waarden op een lcd-scherm met twee regels, dat om de paar…

4.7(47)
83
Lichtsterkte meten met een LDR
AR-11Beginner

Lichtsterkte meten met een LDR

Wil je zien hoe licht je kamer is, als getal? De LDR, een klein onderdeel dat op licht reageert, meet het licht om je heen en de Arduino schrijft de waarde elke halve seconde naar je computerscherm.

4.6(83)
143
Lichtsterkte meten met de ESP32 en een LDR-module
ES-11Beginner

Lichtsterkte meten met de ESP32 en een LDR-module

Volg in de Serial Monitor in realtime de ruwe ADC-waarde van de LDR-module en het relatieve lichtpercentage, berekend uit referentiewaarden voor donker en licht. Dit percentage is geen luxmeting. Je leert hoe de module gekalibreerd wordt. Ideaal om vóór Project 10 te doen, want je gebruikt het om de drempelwaarde te bepalen.

4.6(36)
55
ESP32 DHT22 temperatuur en luchtvochtigheid (met LCD)
ES-15Gemiddeld

ESP32 DHT22 temperatuur en luchtvochtigheid (met LCD)

Dit project meet de omgevingstemperatuur en luchtvochtigheid met een DHT22-sensor en toont de gegevens in realtime op een 16x2 I2C-LCD. De data wordt met het one-wire-protocol via de Adafruit DHT-bibliotheek uit de sensor gelezen. Dit project is de basis voor IoT-weerstations, slimme domotica of omgevingsbewaking in kassen. De communicatie met de DHT22 loopt via pin GPIO 4 van de ESP32.

4.8(38)
57
ESP32-temperatuurlogger (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Gevorderd
Premium

ESP32-temperatuurlogger (DHT22 + DS1307 RTC + microSD + OLED)

Bouw met de ESP32 een temperatuur- en vochtigheidslogger met tijdstempel! Een DHT22-sensor meet elke minuut temperatuur en luchtvochtigheid en elke meting wordt als CSV op een microSD-kaart opgeslagen, met de actuele tijd van de DS1307 RTC-module. Het OLED-display toont in grote letters live de laatste temperatuur, vochtigheid, tijdstempel en het totale aantal records.

4.7(7)
12
ESP32 ledhelderheid regelen met een potmeter (analoog → PWM)
ES-13Gemiddeld
Premium

ESP32 ledhelderheid regelen met een potmeter (analoog → PWM)

In dit project regel je de helderheid van een led analoog met een potmeter. De ADC-pin van de ESP32 leest de spanning van 0–3,3 V van de potmeter; die waarde wordt omgezet in een PWM-signaal (pulsbreedtemodulatie) en naar de led gestuurd. Als je aan de potmeter draait, wordt de led dus geleidelijk helderder en zwakker. Met Arduino Core 3.0+ kun je analogWrite() direct gebruiken; op de ESP32-S2/S3 ligt de ADC-resolutie vast op 12 bit.

4.5(19)
32