Arduino-project slimme kas: sensoren, bewatering, ventilator en code
Bouw een slimme kas met Arduino: DHT22-, bodemvocht- en LDR-sensoren, ventilator, verwarming, pomp en leds via relais en MOSFET, hysterese, LCD en ESP32-code.
Een Arduino-project voor een slimme kas is een automatiseringssysteem waarin een Arduino of ESP32 de luchttemperatuur, luchtvochtigheid, bodemvocht en het licht in een kas meet en zelfstandig de ventilator, verwarming, waterpomp en kweeklampen aanstuurt. Het is een van de populairste onderwerpen voor wetenschapsbeurzen, schoolwedstrijden en techniekles, omdat je het resultaat zo goed ziet: de pomp start als de grond uitdroogt, de ventilator draait als het binnen warm wordt en de leds gaan 's avonds aan. Sterker nog: tussen een modelkas van een opbergbox en een echte minikas op je balkon zit bijna geen verschil in schakeling of code.
In deze gids beginnen we met wat planten echt nodig hebben en bouwen we daarna stap voor stap de modelkas: de onderdelenlijst en de globale kosten, de bedrading van de sensoren (DHT22, capacitieve bodemvochtsensor, LDR) en de actuatoren (ventilator, verwarming, pomp en leds via relais en een MOSFET), het voedingsplan en de pintabel. Daarna leggen we de logica van drempels en hysterese uit, die voorkomt dat de relais voortdurend klikken, de complete Arduino-code zonder delay() en het 16x2-LCD. In de laatste hoofdstukken lees je hoe je de kas met een ESP32 op je telefoon volgt, vind je een MicroPython-versie voor de Raspberry Pi Pico, tips voor presentaties op school en wetenschapsbeurzen en veelgemaakte fouten.





Hoe werkt een slimme kas?
Elke slimme kas draait dezelfde lus van vier stappen: meten, beslissen, handelen, tonen. De sensoren meten de omgeving: hoe warm is het binnen, hoe vochtig is de lucht, is de grond uitgedroogd, is er genoeg licht? De Arduino vergelijkt die waarden met de regels die jij instelt: "als de temperatuur boven 30 °C komt, laat de ventilator draaien", "als het bodemvocht onder 35% zakt, geef water". De actuatoren voeren het besluit uit: relais schakelen de ventilator, verwarming en pomp aan en uit en een MOSFET stelt de helderheid van de ledstrip in. Tot slot tonen het LCD en je telefoon je de huidige toestand van de kas. De klimaatcomputers in echte kassen werken met precies deze lus; ze gebruiken alleen meer sensoren en grotere motoren.
| Wat wordt gemeten? | Sensor | Actuator | Regel (voorbeeld) |
|---|---|---|---|
| Luchttemperatuur | DHT22 | Ventilator en verwarming | Ventilator start bij 30 °C, verwarming gaat aan bij 16 °C |
| Relatieve luchtvochtigheid | DHT22 | Fan | Ventilator start bij 85% en stopt bij 75% |
| Bodemvocht | Capacitieve bodemvochtsensor | Mini-dompelpomp | Geeft water in pulsen van 3 seconden onder 35% |
| Licht | LDR | Ledstrip (MOSFET) | Als het donker wordt, blijven de leds maximaal 4 uur aan |
| Water in het reservoir | Vlotterschakelaar voor waterniveau | Pompvergrendeling | Als het reservoir leeg is, draait de pomp nooit |
Wat hebben planten nodig? Streeftemperatuur, luchtvochtigheid en licht
Voordat je regels schrijft, moet je weten waar je naartoe werkt. De meeste planten willen overdag en 's nachts een andere temperatuur; een beetje afkoelen 's nachts helpt de plant rusten. Blijft de luchtvochtigheid lange tijd boven 85%, dan condenseert er water op de bladeren en verspreiden schimmelziektes zoals schimmel en valse meeldauw zich snel; daarom draait de ventilator in een kas niet alleen om te koelen, maar ook om vocht af te voeren. Voor licht willen de meeste groentezaailingen 14–16 uur per dag, maar ze hebben ook een donkere periode van minstens 6–8 uur nodig; de leds de hele nacht aan laten doet de plant meer kwaad dan goed. De onderstaande waarden zijn een goed uitgangspunt; pas ze aan voor wat je zelf kweekt.
| Plant | Dag | Nacht | Relatieve luchtvochtigheid | Opmerking |
|---|---|---|---|---|
| Tomaat | 21–27 °C | 15–18 °C | 60–75% | Bloemen kunnen afvallen boven 32 °C |
| Paprika | 21–29 °C | 16–20 °C | 60–75% | Gevoeliger voor kou dan tomaten |
| Sla en spinazie | 15–20 °C | 10–15 °C | 60–70% | Schiet vroeg door bij hitte en lange dagen |
| Aardbei | 18–24 °C | 10–13 °C | 60–75% | Risico op grauwe schimmel stijgt bij hoge luchtvochtigheid |
| Zaailingen en kieming | 20–25 °C | 18–20 °C | 70–85% | Bodemtemperatuur is belangrijker dan luchttemperatuur |
De modelkas bouwen
De makkelijkste en goedkoopste behuizing is een doorzichtige opbergbox met deksel: een box van 40–60 liter is genoeg voor twee of drie potten, hij is waterdicht en makkelijk te boren met een hobbymes of een verwarmde punt. Wil je het realistischer, bouw dan een frame van houten latjes en bekleed het met 2–3 mm doorzichtig acryl (plexiglas) of PETG-platen; een kas met een schuin dak ziet er bij een presentatie veel beter uit. Rond 50×35×40 cm is een goede beginmaat. Welke behuizing je ook kiest, het deksel of één zijwand moet open kunnen; je moet er met je handen in om planten water te geven, de sensor te verplaatsen en kabels op te ruimen.
- Elektronica buiten: De binnenkant van een kas is vochtig en 's ochtends condenseert er water op de wanden. Zet de Arduino, de relaismodule en de voeding in een aparte doos buiten de kas; alleen de sensoren, ventilator, verwarming, pompslang en leds gaan naar binnen.
- Ventilatie: Warme lucht stijgt, dus monteer de ventilator in het bovenste deel van een van de korte wanden, blazend naar buiten. Maak in het onderste deel van de tegenoverliggende wand een luchtinlaat ter grootte van de ventilator en bedek die met insectengaas; verse lucht komt dan onderin binnen en warme, vochtige lucht verlaat de kas bovenin.
- Verwarming: Monteer de verwarming dicht bij de bodem op een aluminium plaat of een keramische tegel, minstens 5 cm van de kunststof wanden en de planten. De warme lucht circuleert door de hele kas terwijl ze stijgt.
- Ledverlichting: Plak de ledstrip aan de binnenkant van het deksel, 15–30 cm boven de planten. Monteer je de strip op een dun aluminium profiel, dan voert hij warmte beter af en komt de lijm na verloop van tijd niet los.
- Sensoren: Plaats de DHT22 op plantenhoogte, waar hij geen direct zonlicht of ledlicht krijgt. Begraaf de bodemvochtsensor in de wortelzone, weg van de rand van de pot. De LDR mag de leds niet zien: zet hem buiten de kas, op het dak, gericht op de lucht.
- Watertank: Een reservoir van 1–2 liter is genoeg voor de pomp en de vlotterschakelaar. Zet druipbakjes onder de potten; overtollig water verzamelt zich dan in het bakje in plaats van de bodem van de box onder te laten lopen.
Onderdelenlijst en kosten
| Onderdeel | Aantal | Functie | Prijsniveau |
|---|---|---|---|
| Arduino Uno R3 of ESP32 DevKit | 1 | De hersenen van de kas | Gemiddeld |
| DHT22 (AM2302) temperatuur- en vochtigheidsmodule | 1 | Luchttemperatuur en luchtvochtigheid | Laag |
| Capacitieve bodemvochtsensor (v1.2) | 1 (één per pot) | Bodemvocht | Laag |
| LDR (GL5528) en weerstand van 10 kΩ | 1 + 1 | Omgevingslicht | Zeer laag |
| Vlotterschakelaar voor waterniveau | 1 | Vergrendelt de pomp als het reservoir leeg is | Laag |
| 4-kanaals 5V-relaismodule (optocoupler, met JD-VCC) | 1 | Ventilator, verwarming en pomp | Laag |
| Logic-level N-kanaals MOSFET (IRLZ44N), weerstanden van 220 Ω en 100 kΩ | 1 set | Helderheid van de ledstrip (PWM) | Zeer laag |
| 3–6 V mini-dompelpomp en 1 m siliconenslang | 1 | Bewatering | Laag |
| 12 V computerventilator van 80 mm | 1–2 | Ventilatie en vochtafvoer | Laag |
| 12 V PTC-verwarming (10–30 W) en thermische zekering | 1 + 1 | Verwarming | Laag |
| 12 V ledstrip (kweeklamp of koudwit), ongeveer 1 m | 1 | Bijbelichting | Laag |
| I2C 16x2 LCD | 1 | Statusdisplay | Laag–gemiddeld |
| 12 V 5 A voedingsadapter en LM2596 buck-converter | 1 + 1 | Voeding | Gemiddeld |
| 1N5819- of 1N4007-diode, condensator van 470 µF, schroefklemmen, jumperdraden | – | Bescherming en aansluitingen | Zeer laag |
| Doorzichtige opbergbox met deksel of acrylplaat, potten, druipbakjes | – | Kasbehuizing | Gemiddeld |
Prijzen verschillen sterk per verkoper, dus hier een globaal budget in plaats van exacte bedragen. Zonder het board kost de basisversie (DHT22, bodemvochtsensor, LDR, 2-kanaals relais, pomp en een 5V-ventilator) meestal ongeveer 25–40 dollar. De volledige versie met verwarming, ledstrip, LCD, 12V-adapter, LM2596, vlotterschakelaar en behuizing komt uit op ongeveer 70–120 dollar; het grootste deel van het budget gaat naar het board, de adapter, het display en de behuizing. Heb je een Arduino-starterset, dan zijn het board, de breadboard, draden, LDR, weerstanden en vaak ook het LCD al gedekt. Heb je weinig budget, bewaar de verwarming en leds dan voor een tweede fase; bewatering en ventilatie alleen vormen al een zinvol, werkend project.
Sensoren: DHT22, bodemvochtsensor en LDR
Voor een kas raden we de DHT22 (AM2302) aan. Hij kost iets meer dan de DHT11, maar meet temperatuur van −40 tot 80 °C met ±0,5 °C en luchtvochtigheid over 0–100% met ongeveer ±2%; de DHT11 is tussen 0 en 50 °C slechts nauwkeurig tot ±2 °C en ziet geen vochtigheid boven 90%. Omdat een kas 's ochtends boven 90% vochtigheid kan komen en in de winter onder nul, past de DHT22 veel beter. De sensor kan hooguit eens per 2 seconden een meting doen, dus de code leest hem elke 2,5 seconden uit. Zet je de sensor waar de zon of de leds er direct op schijnen, dan warmt zijn behuizing op en meet hij een paar graden boven de luchttemperatuur; afschermen met een wit kapje met gaatjes voorkomt dat. Bedrading en bibliotheekdetails vind je in het artikel DHT11- en DHT22-temperatuur- en vochtsensor.

Kies voor bodemvocht een capacitieve sensor. Goedkope resistieve sensoren (YL-69, FC-28) hebben twee metalen pinnen die direct contact maken met de grond en als ze continu onder spanning staan, corroderen ze binnen een paar weken door elektrolyse; ze zijn niet geschikt voor een systeem dat maandenlang draait. De elektrode van een capacitieve sensor is gecoat, dus er raakt geen metaal aan de grond. De uitgang is analoog en daalt naarmate de grond natter wordt: op een Uno meet een sensor in de lucht ruwweg 500–600 en in water ongeveer 250–300. Deze getallen verschillen per sensor, dus lees voordat je de hoofdcode uploadt de waarden van jouw sensor in lucht en in water uit in de Serial Monitor en schrijf ze in de constanten SOIL_DRY_RAW en SOIL_WET_RAW. De code zet deze twee waarden met map() om naar 0–100%. Meer details staan in het artikel bodemvochtsensor.
Voor licht is de LDR (GL5528) uit je set genoeg. Sluit de LDR aan als spanningsdeler met een weerstand van 10 kΩ: 5V → LDR → A1 → 10 kΩ → GND. Naarmate het licht toeneemt, daalt de weerstand van de LDR en stijgt de waarde op A1; de code zet deze waarde ook om naar 0–100%, op basis van twee getallen die je in het donker en in zonlicht meet. Een LDR is geen nauwkeurige luxmeter, maar beantwoordt betrouwbaar de vraag "is het donker geworden, is het bewolkt, is het zonnig?". Wil je nauwkeuriger lichtmetingen, dan kun je overstappen op een I2C-lichtsensor zoals de BH1750. Gebruik de tool Spanningsdeler voor de berekening van de deler en het artikel LDR-lichtsensor voor details.
Actuatoren: relais of MOSFET?
Een Arduino-pin kan maar ongeveer 20 mA leveren, terwijl de ventilator, verwarming, pomp en ledstrip honderden milliampères of zelfs meerdere ampères trekken. Daarom wordt elke belasting aangestuurd via een relais of een MOSFET. Een relais is een mechanische schakelaar: het schakelt een belasting in een volledig gescheiden stroomkring aan en uit, wissel- of gelijkstroom, maar het kan alleen aan of uit, het klikt telkens en de contacten hebben een beperkte levensduur. Een MOSFET is een stille elektronische schakelaar; hij werkt alleen met gelijkstroombelastingen, maar omdat hij honderden keren per seconde kan schakelen, kan hij helderheid en snelheid instellen met PWM. In dit project gebruiken we een 4-kanaals relaismodule voor de verwarming, ventilator en pomp en een MOSFET voor de helderheid van de ledstrip.
| Belasting | Typische waarde | Driver | Waarom? |
|---|---|---|---|
| 12 V PTC-verwarming | 10–30 W, ongeveer 1–2,5 A | Relais (IN2) | Hoge stroom, alleen aan/uit nodig |
| 12 V 80 mm fan | 0,1–0,2 A | Relais (IN1) of MOSFET | Een relais is simpel; een MOSFET maakt ook PWM-snelheidsregeling mogelijk |
| 3–6 V mini-dompelpomp | 0,1–0,25 A, meer bij het opstarten | Relais (IN3) of MOSFET met een diode | Draait in korte pulsen; motorruis moet worden onderdrukt |
| 12 V ledstrip (5050, 60 leds/m) | Ongeveer 1,2 A per meter | Logic-level MOSFET | PWM-helderheidsregeling en geruisloze werking |

Afhankelijk van de slanghoogte levert een mini-dompelpomp ruwweg 1–1,5 liter per minuut, dus een pulse van 3 seconden geeft de pot 50–75 mL water. Daarom laten we de pomp niet continu draaien "tot de grond nat is", maar in korte pulsen: 3 seconden water geven, 60 seconden wachten tot het water is ingetrokken en dan opnieuw meten. Als de sensor opnieuw werd uitgelezen voordat het water hem bereikte, zou de grond nog droog lijken en zou de pomp doorlopen tot de pot overstroomt. Een pomp die droog draait, wordt heet en valt binnen minuten uit; de vlotterschakelaar in het reservoir vergrendelt de pomp als het water op is. Elke keer dat de motor stopt, produceert de spoel een omgekeerde spanningspiek; een in sperrichting geplaatste diode over de pompaansluitingen (1N5819 of 1N4007, de streep naar de +-kant) beschermt zowel de relaiscontacten als de Arduino tegen deze ruis. Pompkeuze en aanstuurmethoden komen aan bod in het artikel minipomp.
Gebruik voor verwarming een 12 V PTC-verwarming. De weerstand van PTC-keramiek (positieve temperatuurcoëfficiënt) stijgt naarmate het opwarmt, waardoor de oppervlaktetemperatuur zichzelf begrenst op een vaste waarde; dat is veel veiliger dan een blote gloeiende weerstandsdraad. Kies in een kunststof behuizing een lagetemperatuurmodel waarvan het oppervlak is beperkt tot ongeveer 80 °C. Een verwarming van 24 W trekt volgens P = V × I bij 12 V 2 A; de eerste seconden dat hij koud is, is de stroom iets hoger. Voor verlichting kun je een rood-blauwe kweeklamp-ledstrip of een koudwitte ledstrip gebruiken; planten gebruiken voor fotosynthese vooral rood (rond 660 nm) en blauw (rond 450 nm) licht. Stuur de strip aan met een logic-level MOSFET zoals de IRLZ44N: de gate gaat via een weerstand van 220 Ω naar D9 en via een weerstand van 100 kΩ naar GND; de + van de strip gaat naar 12 V, de − naar de drain van de MOSFET en de source naar GND. Standaard MOSFET-modules zoals de IRF520 gaan bij een gatespanning van 5 V niet volledig open en worden warm bij belastingen van meerdere ampères; details staan in het artikel een MOSFET gebruiken met Arduino. Met de tool Wet van Ohm kun je stroom en vermogen berekenen.
Voedingsplan: 12V- en 5V-rails
De meeste problemen in slimme kassen ("de Arduino reset als de pomp draait", "vreemde tekens op het LCD") komen van de voeding. De schoonste oplossing is twee rails te halen uit één 12 V 5 A-adapter. De 12V-rail voedt de verwarming, ventilatoren en ledstrip rechtstreeks en gaat ook naar de DC-jack van de Arduino Uno. Dezelfde 12 V voedt ook een LM2596 buck-converter, ingesteld op 5 V; de relaisspoelen, de pomp en het LCD draaien op deze 5V-rail. Als je de JD-VCC-jumper op de relaismodule verwijdert, komt de spoelstroom volledig van de LM2596 en laat de Arduino-kant alleen de leds van de optocouplers branden. Voed de sensoren (DHT22, bodemvochtsensor en LDR-deler) vanaf de eigen 5V-pin van de Arduino: analogRead() meet ten opzichte van de eigen 5 V van het board, dus als je de analoge sensoren op dezelfde spanning voedt, blijven de metingen stabiel. Verbind altijd de GND's van de adapter, de LM2596 en de Arduino met elkaar.
| Belasting | Rail | Ongeveer stroom |
|---|---|---|
| PTC-verwarming (24 W) | 12 V | 2 A (meer op het eerste moment als hij koud is) |
| Ledstrip (1 m) | 12 V | 1–1,2 A |
| Twee ventilatoren van 80 mm | 12 V | 0,2–0,4 A |
| Arduino Uno en sensoren (via de DC-jack) | 12 V | Ongeveer 0,06–0,08 A |
| Ingang van de LM2596 (terwijl de 5V-kant 1 A trekt) | 12 V | Ongeveer 0,5 A |
| Relaismodule (drie relais bekrachtigd) | 5 V | 0,2–0,25 A |
| Mini-dompelpomp | 5 V | 0,1–0,25 A (meer bij het opstarten) |
| I2C-LCD (achtergrondverlichting aan) | 5 V | 20–30 mA |
Zelfs als alles tegelijk draait, ligt de totale stroom rond 4–4,5 A, dus een 12 V 5 A (60 W)-adapter laat genoeg marge. In de praktijk draaien de verwarming en de temperatuurventilator nooit tegelijk, omdat er een grote afstand tussen hun drempels zit. Meet voordat je de LM2596 op de schakeling aansluit zijn uitgang met een multimeter en stel hem met de trimmer op het printje in op 5,0 V; af fabriek kan hij bijna de volle 12 V doorlaten. Je kunt de Arduino voeden via USB tijdens het uploaden van code en via de DC-jack in het veld; beide tegelijk aansluiten is bij de Uno geen probleem. Details staan in de gids voeding van Arduino.
Bedrading en pintabel
De onderstaande tabel toont de pins die de drie programma's in deze gids gebruiken. Op de Uno hebben we de MOSFET die de ledstrip aanstuurt op D9 aangesloten, dat PWM ondersteunt; op de Uno is PWM alleen beschikbaar op D3, D5, D6, D9, D10 en D11. De vlotterschakelaar en de relais hebben geen PWM nodig. Omdat het LCD alleen de I2C-bus gebruikt (A4 en A5), neemt het heel weinig pins in beslag; op de Uno blijven A2, A3 en een paar digitale pins vrij voor een tweede bodemsensor of een knop. Op de ESP32 hebben we de analoge sensoren op ADC1-pins aangesloten (GPIO 34 en 35), die blijven werken terwijl Wi-Fi aan staat. De pinindeling van je board zie je in de tool Pinout.
| Aansluiting | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| DHT22 DATA | D2 | GPIO 4 | GP15 |
| Vlotterschakelaar (andere draad naar GND) | D3 | GPIO 13 | GP14 |
| Relais IN3: pomp | D4 | GPIO 25 | GP18 |
| Relais IN1: ventilator | D7 | GPIO 26 | GP16 |
| Relais IN2: verwarming | D8 | GPIO 27 | GP17 |
| MOSFET-gate (via 220 Ω): led | D9 | GPIO 18 | GP19 |
| Bodemvochtsensor AOUT | A0 | GPIO 34 | GP26 |
| Middelpunt van de LDR-deler | A1 | GPIO 35 (deler vanaf 3V3) | GP27 (deler vanaf 3V3) |
| I2C LCD SDA / SCL | A4 / A5 | GPIO 21 / 22 | GP4 / GP5 |
| Sensorvoeding | 5V | 3V3 | 3V3 |
Drempels en hysterese: waarom klapperen relais?
Stel je voor dat je de ventilator met één drempel aanstuurt: "laat hem draaien als de temperatuur boven 30 °C is, stop hem anders". Terwijl de temperatuur tussen 29,9 en 30,1 °C schommelt (wat vaak gebeurt door sensorruis), schakelt het relais bij elke meting aan en uit. Zowel de relaiscontacten als de ventilatormotor slijten, en bij de verwarming krijgen de bedrading en de adapter bij elke inschakeling een onnodige klap. De oplossing is hysterese: je gebruikt twee aparte drempels voor aan- en uitschakelen. De ventilator start bij 30 °C, maar stopt pas als de temperatuur is gedaald tot 27 °C. In de dode zone van 3 graden daartussen behoudt het systeem zijn laatste toestand. Kamerthermostaten voor ketels en koelkasten werken volgens hetzelfde principe.
| Regeling | Schakelt aan | Schakelt uit | Dode zone |
|---|---|---|---|
| Ventilator (temperatuur) | ≥ 30 °C | ≤ 27 °C | 3 °C |
| Ventilator (luchtvochtigheid) | ≥ 85% | ≤ 75% | 10% |
| Verwarming | ≤ 16 °C | ≥ 19 °C | 3 °C |
| Bewatering | Bodem ≤ 35% | Bodem ≥ 50% | 15% |
| Ledverlichting | Licht ≤ 25% | Licht ≥ 35% of na 4 uur | 10% |
De breedte van de dode zone is een afweging: te smal en het relais schakelt nog steeds vaak; te breed en de temperatuur drijft te ver van het doel af. Ongeveer 2–3 °C voor temperatuur, 8–10% voor luchtvochtigheid en 10–15% voor bodemvocht is een goed begin. We hebben ook een grote afstand gelaten tussen 19 °C, waarbij de verwarming uitgaat, en 30 °C, waarbij de ventilator start, zodat de verwarming en de temperatuurventilator nooit tegen elkaar in werken. In de code zit hysterese in een kleine functie hysteresis(), zodat je haar niet voor elke regeling opnieuw hoeft te schrijven: is de aan-drempel groter dan de uit-drempel, dan betekent dat "aan bij stijgen" (ventilator); is hij kleiner, dan "aan bij dalen" (verwarming, bewatering, leds). Wil je ook pieken in de sensordata gladstrijken, bekijk dan het artikel sensordata filteren.
Codestructuur: meten, beslissen, handelen, tonen
De belangrijkste regel in de kascode is dat geen enkele taak op een andere wacht. Als je na de pomp een hele minuut wachtte met delay(60000), zou de ventilator in die tijd niet draaien en het display niet verversen. Daarom bestaat de code uit kleine functies die de tijd meten met millis(), elk verantwoordelijk voor één taak; loop() roept ze om beurten duizenden keren per seconde aan en elke functie doet alleen iets als haar tijd gekomen is. Bewatering is een kleine toestandsmachine met drie toestanden: wachten (IDLE), water geven (PUMPING) en het water laten intrekken (SOAKING). Alle instellingen staan als constanten bovenaan de code, zodat je niet door de code hoeft te zoeken om een drempel te wijzigen. De redenering achter deze aanpak vind je in de artikelen millis() en delay() en toestandsmachines op Arduino. De code bevat ook deze veiligheidsmaatregelen:
- Veilig opstarten: De "uit"-waarde wordt naar de relaispins geschreven voordat pinMode() wordt aangeroepen, zodat de relais zelfs niet een moment klikken terwijl de Arduino opstart.
- Sensorstoring: Als de DHT22 drie keer achter elkaar niet kan worden uitgelezen, schakelt de code over naar een veilige toestand: hij zet de verwarming uit, laat de ventilator draaien en toont "Sensor hatasi" (sensorfout) op het LCD. Een systeem dat de temperatuur niet kent, mag de verwarming nooit aan laten staan.
- Reservoirbeveiliging: Als de vlotterschakelaar meldt dat het reservoir leeg is, start de pomp helemaal niet, en als hij draait, stopt hij onmiddellijk.
- Overloopbeveiliging: Als het bodemvocht na zes pulsen in één bewateringscyclus geen 50% bereikt, is de sensor misschien uit de grond gekomen of is de slang eraf; de code stopt dan met bewateren en toont "Sulama hatasi" (bewateringsfout). De waarschuwing verdwijnt vanzelf zodra de grond weer nat is.
- Datalogging: Elke 10 seconden schrijft de code de metingen als een met komma's gescheiden regel (CSV) naar de Serial Monitor; je kunt deze regels kopiëren en er grafieken van maken in Excel.
Stap voor stap bouwen en testen
- Bereid de behuizing voor: maak de gaten voor de ventilator, luchtinlaat, slang en kabels en plaats de elektronicadoos buiten de kas.
- Zet de voedingsrails op: sluit de 12V-adapter aan op een schroefklem, stel de LM2596 met een multimeter in op 5,0 V en verbind alle GND's.
- Sluit het I2C-LCD aan en laat er wat tekst op verschijnen. Toont het display niets, probeer dan de scannersketch en de contrasttrimmer uit het artikel I2C-LCD.
- Voeg de sensoren één voor één toe en test ze in de Serial Monitor: noteer de metingen van de DHT22, de ruwe waarde van de bodemsensor in lucht en in water en de waarde van de LDR in het donker en in zonlicht.
- Test de relais eerst zonder belasting, kijk naar hun leds en luister naar het klikken. Sluit daarna de ventilator aan, de pomp (met een vol reservoir) en tot slot de verwarming.
- Sluit de ledstrip aan via de MOSFET en verander de waarde van analogWrite() om de helderheid te zien veranderen.
- Upload de hoofdcode, vul je kalibratiewaarden in de constanten in en laat het systeem enkele uren onder toezicht draaien: wordt er verkeerd bewaterd, blijft een relais klikken of wordt een onderdeel te heet?
Complete code voor de Arduino Uno
Om de code te compileren installeer je via de Library Manager de DHT sensor library van Adafruit (samen met de afhankelijkheid Adafruit Unified Sensor) en de bibliotheek LiquidCrystal I2C van Frank de Brabander; Wire wordt met de Arduino IDE meegeleverd. Het adres van het LCD is meestal 0x27, bij sommige modules 0x3F. Schrijf voor het uploaden de kalibratiewaarden die je hebt gemeten in de constanten SOIL_DRY_RAW, SOIL_WET_RAW, LDR_DARK_RAW en LDR_BRIGHT_RAW. Opent je vlotterschakelaar bij water in plaats van te sluiten, zet TANK_OK dan op HIGH; is je relaismodule active HIGH, wissel dan de waarden RELAY_ON en RELAY_OFF om.
1#include <Wire.h>
2#include <LiquidCrystal_I2C.h>
3#include <DHT.h>
4
5// Pinler / Pins
6const byte DHT_PIN = 2, FLOAT_PIN = 3, PUMP_RELAY = 4, FAN_RELAY = 7, HEATER_RELAY = 8;
7const byte LED_PIN = 9; // MOSFET gate (PWM)
8const byte SOIL_PIN = A0, LDR_PIN = A1;
9
10// Kalibrasyon: kendi ölçümlerini yaz / Calibration: write your own readings
11const int SOIL_DRY_RAW = 520, SOIL_WET_RAW = 260; // havada ve suda / in air and in water
12const int LDR_DARK_RAW = 60, LDR_BRIGHT_RAW = 900; // karanlık ve güneş / dark and sunlight
13
14// Eşikler (açma, kapama) / Thresholds (on, off)
15const float FAN_ON_C = 30, FAN_OFF_C = 27; // sıcaklıkta fan / fan on heat
16const float HUM_ON = 85, HUM_OFF = 75; // nemde fan / fan on humidity
17const float HEAT_ON_C = 16, HEAT_OFF_C = 19; // ısıtıcı / heater
18const float SOIL_DRY = 35, SOIL_OK = 50; // sulama başla, dur / start, stop watering
19const float DARK_ON = 25, DARK_OFF = 35; // ışık % / light %
20
21// Zamanlar / Timing
22const unsigned long READ_MS = 2500; // DHT22: en az 2 sn / at least 2 s
23const unsigned long PUMP_MS = 3000; // tek sulama darbesi / one watering pulse
24const unsigned long SOAK_MS = 60000; // suyun yayılması / let the water soak in
25const byte MAX_PULSES = 6; // fazlası arıza / more means a fault
26const unsigned long EXTRA_LIGHT_MS = 4UL * 3600000UL; // günü 4 saat uzat / extend the day by 4 h
27const byte LED_LEVEL = 200; // LED parlaklığı 0-255 / LED brightness 0-255
28const byte RELAY_ON = LOW, RELAY_OFF = HIGH; // aktif LOW röle / active-LOW relay
29const byte TANK_OK = LOW; // şamandıra suyla kapanır / float closes with water
30
31DHT dht(DHT_PIN, DHT22);
32LiquidCrystal_I2C lcd(0x27, 16, 2);
33
34float tempC = NAN, hum = NAN, soil = 0, light = 0;
35byte dhtErrors = 0, pulses = 0, page = 0;
36bool fanByTemp = false, fanByHum = false, fanOn = false, heaterOn = false;
37bool needWater = false, pumpFault = false, isDark = false, ledOn = false, tankOk = true;
38unsigned long lastRead = 0, lastLcd = 0, lastLog = 0, pumpAt = 0, darkSince = 0;
39
40enum PumpState { IDLE, PUMPING, SOAKING };
41PumpState pumpState = IDLE;
42
43// onAt > offAt: yükselince aç (fan) / turn on when rising (fan)
44// onAt < offAt: düşünce aç (ısıtıcı) / turn on when falling (heater)
45bool hysteresis(bool state, float value, float onAt, float offAt) {
46 if (onAt > offAt) {
47 if (value >= onAt) return true;
48 if (value <= offAt) return false;
49 } else {
50 if (value <= onAt) return true;
51 if (value >= offAt) return false;
52 }
53 return state; // ölü bölgede durumu koru / keep state in the dead band
54}
55
56void setRelay(byte pin, bool on) {
57 digitalWrite(pin, on ? RELAY_ON : RELAY_OFF);
58}
59
60float readPercent(byte pin, int raw0, int raw100) {
61 long sum = 0;
62 for (byte i = 0; i < 10; i++) sum += analogRead(pin); // 10 ölçüm ortalaması / average of 10
63 long pct = map(sum / 10, raw0, raw100, 0, 100);
64 return constrain(pct, 0, 100);
65}
66
67void setup() {
68 Serial.begin(9600);
69 setRelay(PUMP_RELAY, false); pinMode(PUMP_RELAY, OUTPUT); // açılışta kapalı / off at boot
70 setRelay(FAN_RELAY, false); pinMode(FAN_RELAY, OUTPUT);
71 setRelay(HEATER_RELAY, false); pinMode(HEATER_RELAY, OUTPUT);
72 pinMode(LED_PIN, OUTPUT);
73 pinMode(FLOAT_PIN, INPUT_PULLUP);
74 dht.begin();
75 lcd.init();
76 lcd.backlight();
77 lcd.print(F("BlueGrays Sera"));
78 Serial.println(F("sn,sicaklik,nem,toprak,isik,fan,isitici,pompa,led")); // CSV başlığı / CSV header
79 delay(2000); // DHT22 açılış süresi / DHT22 start-up time
80 readSensors();
81 lastRead = millis();
82}
83
84void loop() {
85 unsigned long now = millis();
86 if (now - lastRead >= READ_MS) {
87 lastRead = now;
88 readSensors();
89 }
90 controlClimate();
91 controlLight(now);
92 controlPump(now);
93 updateLcd(now);
94 logCsv(now);
95}
96
97// 1) Ölç / Measure
98void readSensors() {
99 float t = dht.readTemperature();
100 float h = dht.readHumidity();
101 if (isnan(t) || isnan(h)) {
102 if (dhtErrors < 255) dhtErrors++; // okuma hatası / read error
103 } else {
104 tempC = t;
105 hum = h;
106 dhtErrors = 0;
107 }
108 soil = readPercent(SOIL_PIN, SOIL_DRY_RAW, SOIL_WET_RAW);
109 light = readPercent(LDR_PIN, LDR_DARK_RAW, LDR_BRIGHT_RAW);
110 tankOk = digitalRead(FLOAT_PIN) == TANK_OK;
111}
112
113// 2) Fan ve ısıtıcı / Fan and heater
114void controlClimate() {
115 if (dhtErrors >= 3) { // sensör yok: güvenli durum / no sensor: safe state
116 heaterOn = false;
117 fanByTemp = true;
118 } else {
119 fanByTemp = hysteresis(fanByTemp, tempC, FAN_ON_C, FAN_OFF_C);
120 fanByHum = hysteresis(fanByHum, hum, HUM_ON, HUM_OFF);
121 heaterOn = hysteresis(heaterOn, tempC, HEAT_ON_C, HEAT_OFF_C);
122 }
123 fanOn = fanByTemp || fanByHum;
124 setRelay(FAN_RELAY, fanOn);
125 setRelay(HEATER_RELAY, heaterOn);
126}
127
128// 3) LED aydınlatma / LED grow light
129void controlLight(unsigned long now) {
130 bool wasDark = isDark;
131 isDark = hysteresis(isDark, light, DARK_ON, DARK_OFF);
132 if (isDark && !wasDark) darkSince = now; // akşam oldu / dusk detected
133 ledOn = isDark && (now - darkSince < EXTRA_LIGHT_MS);
134 analogWrite(LED_PIN, ledOn ? LED_LEVEL : 0);
135}
136
137// 4) Sulama: darbe + bekleme / Watering: pulse + soak
138void controlPump(unsigned long now) {
139 needWater = hysteresis(needWater, soil, SOIL_DRY, SOIL_OK);
140 if (!needWater) {
141 pulses = 0;
142 pumpFault = false; // toprak ıslandı / soil is wet again
143 }
144 switch (pumpState) {
145 case IDLE:
146 if (needWater && tankOk && !pumpFault) {
147 if (pulses >= MAX_PULSES) {
148 pumpFault = true; // nem yükselmiyor / moisture is not rising
149 } else {
150 pumpState = PUMPING;
151 pumpAt = now;
152 pulses++;
153 }
154 }
155 break;
156 case PUMPING:
157 if (now - pumpAt >= PUMP_MS || !tankOk) {
158 pumpState = SOAKING;
159 pumpAt = now;
160 }
161 break;
162 case SOAKING:
163 if (now - pumpAt >= SOAK_MS) pumpState = IDLE;
164 break;
165 }
166 setRelay(PUMP_RELAY, pumpState == PUMPING);
167}
168
169// 5) LCD: üç sayfa / three pages
170void updateLcd(unsigned long now) {
171 if (now - lastLcd < 3000) return;
172 lastLcd = now;
173 page = (page + 1) % 3;
174 lcd.clear();
175 if (page == 0) {
176 lcd.print(F("Sicaklik: "));
177 if (isnan(tempC)) lcd.print(F("--")); else lcd.print(tempC, 1);
178 lcd.print('C');
179 lcd.setCursor(0, 1);
180 lcd.print(F("Hava nemi: %"));
181 if (isnan(hum)) lcd.print(F("--")); else lcd.print(hum, 0);
182 } else if (page == 1) {
183 lcd.print(F("Toprak: %"));
184 lcd.print(soil, 0);
185 lcd.setCursor(0, 1);
186 lcd.print(F("Isik: %"));
187 lcd.print(light, 0);
188 } else {
189 lcd.print(F("F:")); lcd.print(fanOn);
190 lcd.print(F(" I:")); lcd.print(heaterOn);
191 lcd.print(F(" P:")); lcd.print(pumpState == PUMPING);
192 lcd.print(F(" L:")); lcd.print(ledOn);
193 lcd.setCursor(0, 1);
194 if (dhtErrors >= 3) lcd.print(F("Sensor hatasi"));
195 else if (!tankOk) lcd.print(F("Depo bos!"));
196 else if (pumpFault) lcd.print(F("Sulama hatasi"));
197 else lcd.print(F("Sistem normal"));
198 }
199}
200
201// 6) Seri port CSV kaydı / Serial CSV log
202void logCsv(unsigned long now) {
203 if (now - lastLog < 10000) return;
204 lastLog = now;
205 Serial.print(now / 1000); Serial.print(',');
206 Serial.print(tempC, 1); Serial.print(',');
207 Serial.print(hum, 0); Serial.print(',');
208 Serial.print(soil, 0); Serial.print(',');
209 Serial.print(light, 0); Serial.print(',');
210 Serial.print(fanOn); Serial.print(',');
211 Serial.print(heaterOn); Serial.print(',');
212 Serial.print(pumpState == PUMPING); Serial.print(',');
213 Serial.println(ledOn);
214}| Functie | Taak | Hoe vaak? |
|---|---|---|
| readSensors() | Leest de DHT22, het bodemvocht, de LDR en de vlotterschakelaar uit; zet analoge waarden om naar 0–100% met het gemiddelde van 10 metingen | Elke 2,5 seconden |
| controlClimate() | Stuurt de ventilator aan met hysterese op temperatuur of luchtvochtigheid en de verwarming met hysterese op temperatuur; schakelt over naar een veilige toestand als de sensor uitvalt | Elke loop |
| controlLight() | Zet de leds met PWM aan als het donker wordt en schakelt ze na maximaal 4 uur uit | Elke loop |
| controlPump() | Toestandsmachine voor bewatering: 3 s water geven, 60 s wachten, opnieuw meten; met reservoir- en overloopbeveiliging | Elke loop |
| updateLcd() | Wisselt tussen drie pagina's: luchtmetingen, bodemvocht en licht, toestanden van de apparaten | Elke 3 seconden |
| logCsv() | Schrijft metingen en toestanden als CSV-regel naar de Serial Monitor | Elke 10 seconden |
De eerste LCD-pagina toont temperatuur en luchtvochtigheid, de tweede bodemvocht en lichtniveau en de derde de toestand van de apparaten: "F:1 I:0 P:0 L:1" betekent dat de ventilator draait, de verwarming (I = ısıtıcı) en pomp uit zijn en de leds aan. De onderste regel toont een van de meldingen "Sistem normal" (alles in orde), "Depo bos!" (reservoir leeg), "Sulama hatasi" (bewateringsfout) of "Sensor hatasi" (sensorfout); je kunt deze teksten in de code eenvoudig vertalen. Gecompileerd gebruikt deze code ongeveer 31% van het programmageheugen en 25% van het RAM van de Uno, dus er is ruim plek om een tweede bodemsensor, een buzzer of een RTC-klokmodule toe te voegen. Omdat de Uno geen echte klok heeft, werkt de ledregel als "maximaal 4 uur na zonsondergang", wat een goede manier is om korte winterdagen te verlengen. Wil je dat de leds elke dag op vaste tijden aangaan, voeg dan een RTC-module toe of stap over op de ESP32-versie hieronder.
Volgen en bewateren vanaf je telefoon met een ESP32

De Uno heeft geen Wi-Fi. Wil je de status van de kas op je telefoon zien en op afstand water geven, vervang de hersenen dan door een ESP32. De onderstaande code brengt dezelfde regellogica naar de ESP32 en start een kleine webserver. Met je telefoon op hetzelfde Wi-Fi-netwerk open je in je browser het IP-adres dat in de Serial Monitor staat en zie je de temperatuur, luchtvochtigheid, bodemvocht, licht, de status van het reservoir en of elk apparaat aan of uit staat; de pagina ververst zichzelf elke 10 seconden. De knop Nu water geven laat de pomp eenmalig 3 seconden draaien als er water in het reservoir zit. Bij het opstarten haalt de ESP32 de tijd van internet (NTP), zodat de leds alleen tussen 06:00 en 20:00 aangaan en alleen als het buiten donker is, en de planten 's nachts rusten.
1#include <WiFi.h>
2#include <WebServer.h>
3#include <DHT.h>
4#include <time.h>
5
6const char* ssid = "AgAdi"; // Wi-Fi adın / your Wi-Fi name
7const char* password = "Sifre123"; // Wi-Fi şifren / your Wi-Fi password
8
9// Pinler / Pins
10const int DHT_PIN = 4, FLOAT_PIN = 13, PUMP_RELAY = 25, FAN_RELAY = 26, HEATER_RELAY = 27;
11const int LED_PIN = 18; // MOSFET gate (PWM)
12const int SOIL_PIN = 34, LDR_PIN = 35; // ADC1: Wi-Fi açıkken çalışır / works with Wi-Fi on
13
14// Kalibrasyon (0-4095): kendin ölç / Calibration (0-4095): measure your own
15const int SOIL_DRY_RAW = 2800, SOIL_WET_RAW = 1200;
16const int LDR_DARK_RAW = 200, LDR_BRIGHT_RAW = 3800;
17
18// Eşikler (açma, kapama) / Thresholds (on, off)
19const float FAN_ON_C = 30, FAN_OFF_C = 27, HUM_ON = 85, HUM_OFF = 75;
20const float HEAT_ON_C = 16, HEAT_OFF_C = 19, SOIL_DRY = 35, SOIL_OK = 50;
21const float DARK_ON = 25, DARK_OFF = 35;
22const int LIGHT_FROM = 6, LIGHT_TO = 20; // LED yalnız 06:00-20:00 / LEDs only 06:00-20:00
23
24const unsigned long READ_MS = 2500, PUMP_MS = 3000, SOAK_MS = 60000;
25const unsigned long EXTRA_LIGHT_MS = 4UL * 3600000UL; // saat yoksa yedek kural / fallback without a clock
26const int MAX_PULSES = 6, LED_LEVEL = 200;
27const int RELAY_ON = LOW, RELAY_OFF = HIGH; // aktif LOW röle / active-LOW relay
28const int TANK_OK = LOW; // şamandıra suyla kapanır / float closes with water
29
30DHT dht(DHT_PIN, DHT22);
31WebServer server(80);
32
33float tempC = NAN, hum = NAN, soil = 0, light = 0;
34int dhtErrors = 0, pulses = 0;
35bool fanByTemp = false, fanByHum = false, fanOn = false, heaterOn = false;
36bool needWater = false, pumpFault = false, isDark = false, ledOn = false, tankOk = true;
37unsigned long lastRead = 0, pumpAt = 0, darkSince = 0;
38
39enum PumpState { IDLE, PUMPING, SOAKING };
40PumpState pumpState = IDLE;
41
42bool hysteresis(bool state, float value, float onAt, float offAt) {
43 if (onAt > offAt) { // yükselince aç / turn on when rising
44 if (value >= onAt) return true;
45 if (value <= offAt) return false;
46 } else { // düşünce aç / turn on when falling
47 if (value <= onAt) return true;
48 if (value >= offAt) return false;
49 }
50 return state;
51}
52
53void setRelay(int pin, bool on) {
54 digitalWrite(pin, on ? RELAY_ON : RELAY_OFF);
55}
56
57float readPercent(int pin, int raw0, int raw100) {
58 long sum = 0;
59 for (int i = 0; i < 16; i++) sum += analogRead(pin); // 16 ölçüm ortalaması / average of 16
60 long pct = map(sum / 16, raw0, raw100, 0, 100);
61 return constrain(pct, 0, 100);
62}
63
64int hourNow() {
65 struct tm t;
66 if (!getLocalTime(&t, 0)) return -1; // saat henüz yok / time not set yet
67 return t.tm_hour;
68}
69
70void readSensors() {
71 float t = dht.readTemperature();
72 float h = dht.readHumidity();
73 if (isnan(t) || isnan(h)) {
74 dhtErrors++;
75 } else {
76 tempC = t;
77 hum = h;
78 dhtErrors = 0;
79 }
80 soil = readPercent(SOIL_PIN, SOIL_DRY_RAW, SOIL_WET_RAW);
81 light = readPercent(LDR_PIN, LDR_DARK_RAW, LDR_BRIGHT_RAW);
82 tankOk = digitalRead(FLOAT_PIN) == TANK_OK;
83}
84
85void controlClimate() {
86 if (dhtErrors >= 3) { // sensör yok: güvenli durum / no sensor: safe state
87 heaterOn = false;
88 fanByTemp = true;
89 } else {
90 fanByTemp = hysteresis(fanByTemp, tempC, FAN_ON_C, FAN_OFF_C);
91 fanByHum = hysteresis(fanByHum, hum, HUM_ON, HUM_OFF);
92 heaterOn = hysteresis(heaterOn, tempC, HEAT_ON_C, HEAT_OFF_C);
93 }
94 fanOn = fanByTemp || fanByHum;
95 setRelay(FAN_RELAY, fanOn);
96 setRelay(HEATER_RELAY, heaterOn);
97}
98
99void controlLight(unsigned long now) {
100 bool wasDark = isDark;
101 isDark = hysteresis(isDark, light, DARK_ON, DARK_OFF);
102 if (isDark && !wasDark) darkSince = now;
103 int h = hourNow();
104 if (h >= 0) ledOn = isDark && h >= LIGHT_FROM && h < LIGHT_TO; // saat kuralı / clock rule
105 else ledOn = isDark && (now - darkSince < EXTRA_LIGHT_MS); // yedek kural / fallback rule
106 analogWrite(LED_PIN, ledOn ? LED_LEVEL : 0);
107}
108
109void controlPump(unsigned long now) {
110 needWater = hysteresis(needWater, soil, SOIL_DRY, SOIL_OK);
111 if (!needWater) {
112 pulses = 0;
113 pumpFault = false;
114 }
115 if (pumpState == IDLE && needWater && tankOk && !pumpFault) {
116 if (pulses >= MAX_PULSES) {
117 pumpFault = true; // nem yükselmiyor / moisture is not rising
118 } else {
119 pumpState = PUMPING;
120 pumpAt = now;
121 pulses++;
122 }
123 } else if (pumpState == PUMPING && (now - pumpAt >= PUMP_MS || !tankOk)) {
124 pumpState = SOAKING;
125 pumpAt = now;
126 } else if (pumpState == SOAKING && now - pumpAt >= SOAK_MS) {
127 pumpState = IDLE;
128 }
129 setRelay(PUMP_RELAY, pumpState == PUMPING);
130}
131
132String row(const char* name, const String& value) {
133 return String("<tr><td>") + name + "</td><td><b>" + value + "</b></td></tr>";
134}
135
136String onOff(bool on) {
137 return on ? "ON" : "OFF";
138}
139
140void handleRoot() {
141 String html = "<!DOCTYPE html><html><head><meta charset='utf-8'>"
142 "<meta name='viewport' content='width=device-width,initial-scale=1'>"
143 "<meta http-equiv='refresh' content='10'><title>BlueGrays Sera</title>"
144 "<style>body{font-family:sans-serif;max-width:420px;margin:auto;padding:12px}"
145 "td{padding:8px;border-bottom:1px solid #ddd}"
146 "a{display:block;margin-top:16px;padding:16px;border-radius:10px;background:#2e7d32;"
147 "color:#fff;text-align:center;text-decoration:none;font-size:18px}</style>"
148 "</head><body><h2>BlueGrays Sera</h2><table>";
149 html += row("Sıcaklık / Temperature", String(tempC, 1) + " °C");
150 html += row("Hava nemi / Humidity", "%" + String(hum, 0));
151 html += row("Toprak nemi / Soil", "%" + String(soil, 0));
152 html += row("Işık / Light", "%" + String(light, 0));
153 html += row("Fan", onOff(fanOn));
154 html += row("Isıtıcı / Heater", onOff(heaterOn));
155 html += row("Pompa / Pump", onOff(pumpState == PUMPING));
156 html += row("LED", onOff(ledOn));
157 html += row("Depo / Tank", tankOk ? "OK" : "BOŞ / EMPTY");
158 if (pumpFault) html += row("Uyarı / Warning", "Sulama hatası / Watering fault");
159 html += "</table><a href='/water'>Şimdi sula / Water now</a></body></html>";
160 server.send(200, "text/html", html);
161}
162
163void handleWater() { // elle tek darbe / one manual pulse
164 if (pumpState == IDLE && tankOk) {
165 pumpState = PUMPING;
166 pumpAt = millis();
167 }
168 server.sendHeader("Location", "/");
169 server.send(303);
170}
171
172void setup() {
173 Serial.begin(115200);
174 setRelay(PUMP_RELAY, false); pinMode(PUMP_RELAY, OUTPUT);
175 setRelay(FAN_RELAY, false); pinMode(FAN_RELAY, OUTPUT);
176 setRelay(HEATER_RELAY, false); pinMode(HEATER_RELAY, OUTPUT);
177 pinMode(LED_PIN, OUTPUT);
178 pinMode(FLOAT_PIN, INPUT_PULLUP);
179 dht.begin();
180 WiFi.begin(ssid, password);
181 while (WiFi.status() != WL_CONNECTED) {
182 delay(500);
183 Serial.print('.');
184 }
185 Serial.println();
186 Serial.println(WiFi.localIP()); // bu adresi telefonda aç / open this address on your phone
187 configTime(3 * 3600, 0, "pool.ntp.org"); // Türkiye UTC+3; kendi saat dilimini yaz / set your own time zone
188 server.on("/", handleRoot);
189 server.on("/water", handleWater);
190 server.begin();
191 readSensors();
192 lastRead = millis();
193}
194
195void loop() {
196 server.handleClient();
197 unsigned long now = millis();
198 if (now - lastRead >= READ_MS) {
199 lastRead = now;
200 readSensors();
201 }
202 controlClimate();
203 controlLight(now);
204 controlPump(now);
205}Dit verandert er ten opzichte van de Uno-code: de ADC van de ESP32 is 12-bits en geeft waarden van 0 tot 4095, dus je moet de kalibratie opnieuw doen; omdat je de sensoren vanaf 3V3 voedt, zijn de ruwe waarden ook anders. De tijdzone stel je in op de regel met configTime(); we hebben 3 × 3600 seconden geschreven voor Turkije (UTC+3). Vervang die regel voor je eigen zone met zomertijd door configTzTime() met een POSIX-tijdzonestring, bijvoorbeeld configTzTime("GMT0BST,M3.5.0/1,M10.5.0", "pool.ntp.org") voor het Verenigd Koninkrijk. Is er geen internet of is de tijd nog niet opgehaald, dan valt de ledregel terug op de regel "maximaal 4 uur" van de Uno. De pagina heeft geen wachtwoord, dus iedereen op je thuisnetwerk kan de pomp starten; een eenvoudig wachtwoord toevoegen met de functie authenticate() van de WebServer-bibliotheek is een goede gewoonte. Wil je ook op de ESP32 een LCD, dan kun je de functie updateLcd() uit de Uno-code ongewijzigd overnemen; SDA is GPIO 21 en SCL is GPIO 22.
| Methode | Toegang van buiten het huis | Moeilijkheid | Het beste voor |
|---|---|---|---|
| ESP32-webserver (de code in deze gids) | Nee, alleen hetzelfde netwerk | Gemiddeld | Presentaties op school, demo's zonder internet |
| Blynk IoT | Ja | Makkelijk | Kant-en-klare meters, grafieken en meldingen |
| Telegram-bot | Ja | Gemiddeld | Waarschuwingen "reservoir leeg" en "temperatuur te hoog" |
| Google Sheets | Ja | Gemiddeld | Wekenlange datalogging en grafieken |
| MQTT en Home Assistant | Ja, installatie nodig | Gevorderd | Echte huis- en tuinautomatisering |
Voor een schoolpresentatie is de ESP32-webserver de veiligste keuze: hij hangt niet af van een clouddienst en werkt op zijn eigen netwerk, ook als de zaal geen internet heeft. Wil je ook van buitenaf meekijken, dan is Blynk IoT met zijn kant-en-klare meters en grafieken de makkelijkste route. Wil je een bericht op je telefoon als het reservoir leeg raakt of de temperatuur gevaarlijk wordt, zie dan de gids ESP32-Telegram-bot; om wekenlang data voor je verslag te verzamelen, ESP32 met Google Sheets; en om de kas aan echte domotica te koppelen, MQTT en Home Assistant.
MicroPython-versie voor de Raspberry Pi Pico
Je kunt dezelfde kas ook laten draaien met een Raspberry Pi Pico in MicroPython. De MicroPython-firmware van de Pico heeft een DHT-driver ingebouwd, dus je hoeft geen extra bestanden te kopiëren. De analoge ingangen zijn alleen GP26, GP27 en GP28 en read_u16() geeft waarden van 0 tot 65535; meet je kalibratiegetallen dienovereenkomstig. Omdat de Pico op 3,3 V werkt, voed je de sensoren vanaf 3V3 en de relaismodule vanaf VBUS (de 5 V van USB) of de LM2596-rail. De onderstaande code bevat alle regels voor ventilator, verwarming, leds en bewatering en print de waarden in de shell van Thonny. Sla je het bestand op de Pico op als main.py, dan draait het board ook als het niet op een computer is aangesloten. Gebruik je de Pico W met Wi-Fi, dan kun je de methode uit het artikel Pico W-webserver toevoegen om de waarden vanaf je telefoon te volgen.
1from machine import Pin, ADC, PWM
2import dht
3import time
4
5sensor = dht.DHT22(Pin(15)) # GP15: DHT22 DATA
6soil_adc = ADC(26) # GP26: toprak nem AOUT / soil moisture AOUT
7ldr_adc = ADC(27) # GP27: LDR bölücü (3V3) / LDR divider (3V3)
8tank = Pin(14, Pin.IN, Pin.PULL_UP) # şamandıra: suyla 0 / float switch: 0 with water
9fan = Pin(16, Pin.OUT, value=1) # aktif LOW röleler kapalı başlar / active-LOW relays start off
10heater = Pin(17, Pin.OUT, value=1)
11pump = Pin(18, Pin.OUT, value=1)
12led = PWM(Pin(19)) # MOSFET gate
13led.freq(1000)
14
15SOIL_DRY_RAW, SOIL_WET_RAW = 50000, 22000 # kendin ölç / measure your own
16LDR_DARK_RAW, LDR_BRIGHT_RAW = 2000, 60000
17EXTRA_LIGHT_MS = 4 * 3600 * 1000 # günü 4 saat uzat / extend the day by 4 h
18
19
20def percent(adc, raw0, raw100):
21 raw = sum(adc.read_u16() for _ in range(10)) // 10
22 pct = (raw - raw0) * 100 // (raw100 - raw0)
23 return max(0, min(100, pct))
24
25
26def hysteresis(state, value, on_at, off_at):
27 if on_at > off_at: # yükselince aç / turn on when rising
28 if value >= on_at:
29 return True
30 if value <= off_at:
31 return False
32 else: # düşünce aç / turn on when falling
33 if value <= on_at:
34 return True
35 if value >= off_at:
36 return False
37 return state # ölü bölge / dead band
38
39
40def relay(pin, on):
41 pin.value(0 if on else 1)
42
43
44t = h = None
45errors = pulses = 0
46fan_t = fan_h = heat_on = need_water = dark = led_on = False
47pump_state, pump_at, dark_since = "idle", 0, 0
48soil = light = 0
49tank_ok = True
50time.sleep(2) # DHT22 açılış süresi / DHT22 start-up time
51last_read = time.ticks_add(time.ticks_ms(), -2500)
52
53while True:
54 now = time.ticks_ms()
55 if time.ticks_diff(now, last_read) >= 2500: # 2,5 sn'de bir ölç / measure every 2.5 s
56 last_read = now
57 try:
58 sensor.measure()
59 t, h = sensor.temperature(), sensor.humidity()
60 errors = 0
61 except OSError:
62 errors += 1 # okuma hatası / read error
63 soil = percent(soil_adc, SOIL_DRY_RAW, SOIL_WET_RAW)
64 light = percent(ldr_adc, LDR_DARK_RAW, LDR_BRIGHT_RAW)
65 tank_ok = tank.value() == 0
66
67 if errors >= 3 or t is None: # güvenli durum / safe state
68 heat_on, fan_t = False, True
69 else:
70 fan_t = hysteresis(fan_t, t, 30, 27)
71 fan_h = hysteresis(fan_h, h, 85, 75)
72 heat_on = hysteresis(heat_on, t, 16, 19)
73 relay(fan, fan_t or fan_h)
74 relay(heater, heat_on)
75
76 was_dark = dark
77 dark = hysteresis(dark, light, 25, 35)
78 if dark and not was_dark:
79 dark_since = now # akşam oldu / dusk detected
80 led_on = dark and time.ticks_diff(now, dark_since) < EXTRA_LIGHT_MS
81 led.duty_u16(50000 if led_on else 0)
82
83 need_water = hysteresis(need_water, soil, 35, 50)
84 if not need_water:
85 pulses = 0
86 print("T", t, "N", h, "Toprak", soil, "Isik", light, "Pompa", pump_state,
87 "Depo OK" if tank_ok else "Depo BOS", "HATA" if pulses >= 6 else "")
88
89 # Sulama: 3 sn darbe, 60 sn bekleme / Watering: 3 s pulse, 60 s soak
90 if pump_state == "idle" and need_water and tank_ok and pulses < 6:
91 pump_state, pump_at = "pump", now
92 pulses += 1
93 elif pump_state == "pump" and (time.ticks_diff(now, pump_at) >= 3000 or not tank_ok):
94 pump_state, pump_at = "soak", now
95 elif pump_state == "soak" and time.ticks_diff(now, pump_at) >= 60000:
96 pump_state = "idle"
97 relay(pump, pump_state == "pump")
98 time.sleep_ms(100)Tips voor presentaties op school en wetenschapsbeurzen
Slimme kassen zijn zo'n populair onderwerp dat juryleden tientallen vergelijkbare modellen zien. Wat jou laat opvallen is niet alleen laten zien dat het systeem werkt, maar een vraag beantwoorden met metingen. Bij een wetenschapsbeurs (zoals TÜBİTAK 4006 in Turkije) moeten je doel, methode en verwachte resultaat duidelijk zijn; onderzoekswedstrijden (zoals TÜBİTAK 2204) verwachten een vergelijkend experiment met data. Een goede onderzoeksvraag voor deze kas is: "Hoeveel water bespaart bewatering op basis van bodemvocht vergeleken met elke dag op hetzelfde tijdstip water geven, en hoe beïnvloedt het de groei van de planten?"
- Maak twee groepen: Verdeel zaailingen van dezelfde soort en dezelfde hoogte in twee groepen. Geef één groep water met het sensorsysteem en de andere elke dag met de hand een vaste hoeveelheid; houd licht en temperatuur voor beide groepen gelijk.
- Meten en vastleggen: Houd een tabel bij van de wekelijkse hoeveelheid water (door het reservoir te meten, in mL), de planthoogte (cm) en het aantal bladeren. De CSV-uitvoer van de code of een Google Sheets-log geeft je de grafiek van temperatuur en luchtvochtigheid gratis.
- Teken een blokschema: Sensoren links, de Arduino in het midden, actuatoren rechts; label de pijlen met regelzinnen ("bodem < 35% → pomp"). De jury leest je code niet, maar onthoudt dit schema wel.
- Leg hysterese uit: Twee grafieken die laten zien hoe vaak een ventilator met één drempel en een ventilator met hysterese per uur aan- en uitschakelen, zijn de beste manier om de jury de technische kant van je project te tonen.
- Schrijf een script voor de livedemo: Verwarm de DHT22 in je handpalm om de ventilator te starten, verplaats de bodemsensor naar een droge pot om de pomppulsen te laten zien, dek de LDR af met je hand om te laten zien dat de leds aangaan. Houd elke demo op 10–20 seconden.
- Koppel het aan het echte leven: Praat over echte problemen zoals water- en energieverbruik in kassen, schimmelziektes door te veel vocht en de werkdruk van telers; laat met cijfers zien welke daarvan jouw systeem aanpakt.
- Zorg voor een reserveplan: Film het werkende systeem; neem reservedraden, een reservepomp en een adapter mee; schrijf je kalibratiewaarden en Wi-Fi-instellingen op een papiertje.
- Bereid je voor op de vragen van de jury: Heb korte antwoorden klaar op "Wat gebeurt er als een sensor uitvalt?", "Wat gebeurt er met de planten bij stroomuitval?" en "Hoe zou je dit opschalen naar een echte kas?". De veilige toestand en de overloopbeveiliging in de code zijn de beste antwoorden op deze vragen.
Veelgemaakte fouten en hoe je ze oplost
| Symptoom | Waarschijnlijke oorzaak | Oplossing |
|---|---|---|
| De Arduino reset of het LCD toont rommel als de pomp draait | Pomp en relais gevoed vanaf de 5V-pin van de Arduino, motorruis | Voed de pomp en relaisspoelen vanaf de LM2596, verbind de GND's, voeg een diode in sperrichting en een condensator van 470 µF toe bij de pomp |
| De relais blijven klikken | Er wordt één drempel gebruikt of de metingen zijn ruisig | Gebruik aparte aan- en uitdrempels (hysterese) en neem het gemiddelde van de analoge metingen |
| Er blijft water stromen nadat de pomp stopt | Hevelwerking: het slanguiteinde ligt onder het waterniveau van het reservoir | Plaats het reservoir lager of maak een klein luchtgaatje bovenaan de slang |
| Bodemvocht is altijd 0% of altijd 100% | Verkeerde kalibratiewaarden, of AOUT op de verkeerde pin | Meet de ruwe waarde van de sensor in lucht en in water en schrijf ze in de constanten |
| De leds knipperen aan en uit | De LDR kan het licht van de leds zien | Verplaats de LDR naar buiten de kas, gericht op de lucht |
| De DHT22 geeft nan terug | Verkeerde pin, geen pull-upweerstand, of vaker dan elke 2 seconden uitgelezen | Controleer de pin, gebruik een module of voeg 10 kΩ toe tussen DATA en VCC |
| De temperatuur is hoger dan hij zou moeten zijn | Zon of ledlicht schijnt direct op de sensor | Schaduw hem met een wit kapje met gaatjes en verplaats hem weg van de verwarming |
| Waterdruppels en schimmel op de wanden | Luchtvochtigheid te hoog, ventilatie te zwak | Verlaag de vochtigheidsdrempel, vergroot de luchtinlaat, geef minder water |
| Op de ESP32 gaat de bodemmeting fout als Wi-Fi start | De sensor zit op een ADC2-pin | Verplaats hem naar een ADC1-pin tussen GPIO 32 en 39 |
| Bij een ESP32 laat het relais nooit los | Een HIGH van 3,3 V kan een active-LOW 5V-module niet uitschakelen | Scheid JD-VCC of gebruik een relaismodule met 3,3V-triggering |
Een project voor een slimme kas combineert sensoren uitlezen, kalibratie, beslissen met hysterese, relais en MOSFET's aansturen, voedingsplanning en draadloos volgen in één bouwproject, en uiteindelijk kweek je iets echt levends: een plant. Begin met bewatering en ventilatie, test elk onderdeel apart en voeg daarna de verwarming, de leds en de telefoon toe. In de BlueGrays-app vind je stap-voor-stapprojecten met schakelschema's en code voor het meten van temperatuur en luchtvochtigheid met een DHT11, het meten van licht met een LDR, een slim bewateringsstation en een temperatuurlogger met een DHT22.
Veelgestelde vragen
Wat heb ik nodig voor een project voor een slimme kas?
Voor een basale slimme kas zijn een Arduino Uno of ESP32, een DHT22-temperatuur- en vochtsensor, een capacitieve bodemvochtsensor, een LDR en een weerstand van 10 kΩ, een relaismodule, een mini-dompelpomp en een ventilator genoeg. De volledige versie voegt een 12 V PTC-verwarming toe, een ledstrip die door een MOSFET wordt aangestuurd, een I2C-LCD, een vlotterschakelaar, een 12 V 5 A-adapter en een LM2596. Voor de behuizing is een doorzichtige opbergbox met deksel de makkelijkste en goedkoopste oplossing.
Hoe werkt een slimme kas?
Een slimme kas werkt in een lus van meten, beslissen, handelen en tonen. Sensoren meten temperatuur, luchtvochtigheid, bodemvocht en licht; de Arduino vergelijkt deze waarden met drempels en schakelt de ventilator, verwarming, pomp en leds aan en uit via relais of een MOSFET. De resultaten worden getoond op een LCD en, met een ESP32, op je telefoon.
Moet ik in een kas een DHT11 of een DHT22 gebruiken?
Kies de DHT22. De DHT11 is tussen 0 en 50 °C slechts nauwkeurig tot ±2 °C en ziet geen vochtigheid boven 90%, terwijl een kas 's ochtends boven 90% vochtigheid kan komen en in de winter onder nul. De DHT22 meet van −40 tot 80 °C met ±0,5 °C en luchtvochtigheid tot op ongeveer ±2%, en zijn code is bijna identiek aan die van de DHT11.
Hoeveel kost een Arduino-project voor een kas?
Prijzen verschillen per verkoper, maar zonder het board kost de basisversie (DHT22, bodemvochtsensor, LDR, relais, pomp en ventilator) meestal ongeveer 25–40 dollar. De volledige versie met verwarming, ledstrip, LCD, 12V-adapter en behuizing komt uit op ongeveer 70–120 dollar. Heb je al een Arduino-starterset, dan dalen de kosten merkbaar.
Hoe kan ik mijn kas volgen vanaf mijn telefoon?
De makkelijkste manier is de hersenen te vervangen door een ESP32 en een webserver te draaien; je ziet dan de waarden en start de pomp vanuit de browser van je telefoon op hetzelfde Wi-Fi-netwerk. Voor toegang van buiten het huis kun je Blynk IoT gebruiken, voor waarschuwingsberichten een Telegram-bot en voor langetermijndatalogging Google Sheets.
Hoe presenteer ik een slimme kas op een wetenschapsbeurs?
Laat niet alleen een werkend model zien, maar stel een meetbare onderzoeksvraag; meet bijvoorbeeld gedurende meerdere weken met twee groepen planten hoeveel water bewatering op basis van sensoren bespaart vergeleken met bewatering op vaste tijden. Presenteer het waterverbruik, de planthoogte en de grafieken van temperatuur en luchtvochtigheid in tabellen en grafieken, leg het systeem uit met een blokschema en bereid een kort script voor de livedemo voor.
Projecten om hierna te bouwen
Alle projecten bekijken
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…

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.

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.

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

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.

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.

ESP32 slimme verlichting (PIR + LDR + relais + OLED)
Met een ESP32, een PIR-bewegingssensor, een LDR-lichtsensor en een relaismodule maak je van je gang, toilet of bijkeuken slimme verlichting. Is het al licht in de ruimte, dan blijft het licht uit, ook bij beweging, zodat overdag geen energie wordt verspild. Het licht blijft 30 seconden aan en de tijd verlengt automatisch zolang er beweging is.
Meer artikelen
BlueGrays-app
Bouw deze schakeling stap voor stap op je telefoon
Schakelschema, code en onderdelenlijst op één scherm. Meer dan 500 Arduino-, ESP32- en Pico-projecten om te bouwen.
Scan met je telefoon
Richt je camera op de code en de appstore van je telefoon opent.
of open de store

