Gidsen · 25 min leestijd

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.

DHT22 (AM2302)
DHT22 (AM2302)
LDR
LDR
I2C LCD 16x2
I2C LCD 16x2
LM2596
LM2596
Arduino Uno
Arduino Uno

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?SensorActuatorRegel (voorbeeld)
LuchttemperatuurDHT22Ventilator en verwarmingVentilator start bij 30 °C, verwarming gaat aan bij 16 °C
Relatieve luchtvochtigheidDHT22FanVentilator start bij 85% en stopt bij 75%
BodemvochtCapacitieve bodemvochtsensorMini-dompelpompGeeft water in pulsen van 3 seconden onder 35%
LichtLDRLedstrip (MOSFET)Als het donker wordt, blijven de leds maximaal 4 uur aan
Water in het reservoirVlotterschakelaar voor waterniveauPompvergrendelingAls 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.

PlantDagNachtRelatieve luchtvochtigheidOpmerking
Tomaat21–27 °C15–18 °C60–75%Bloemen kunnen afvallen boven 32 °C
Paprika21–29 °C16–20 °C60–75%Gevoeliger voor kou dan tomaten
Sla en spinazie15–20 °C10–15 °C60–70%Schiet vroeg door bij hitte en lange dagen
Aardbei18–24 °C10–13 °C60–75%Risico op grauwe schimmel stijgt bij hoge luchtvochtigheid
Zaailingen en kieming20–25 °C18–20 °C70–85%Bodemtemperatuur is belangrijker dan luchttemperatuur
Als het lokaal op de demodag 22 °C is, gaat een ventilator die bij 30 °C start nooit draaien. Stel de drempels voor de presentatie 2–3 graden boven de kamertemperatuur in, zodat de jury de ventilator binnen enkele seconden ziet starten als je de DHT22 in je handpalm verwarmt. Ga voor echt gebruik terug naar de waarden in de tabel.

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.
Als het uiteinde van de slang lager ligt dan het waterniveau in het reservoir, blijft er water doorstromen nadat de pomp stopt door het hevelwerking, en loopt de pot over. Houd het reservoir lager dan de potten, of prik met een naald een klein luchtgaatje op het hoogste punt van de slang; als de pomp stopt, komt er lucht binnen door het gaatje en stopt de stroom meteen.

Onderdelenlijst en kosten

OnderdeelAantalFunctiePrijsniveau
Arduino Uno R3 of ESP32 DevKit1De hersenen van de kasGemiddeld
DHT22 (AM2302) temperatuur- en vochtigheidsmodule1Luchttemperatuur en luchtvochtigheidLaag
Capacitieve bodemvochtsensor (v1.2)1 (één per pot)BodemvochtLaag
LDR (GL5528) en weerstand van 10 kΩ1 + 1OmgevingslichtZeer laag
Vlotterschakelaar voor waterniveau1Vergrendelt de pomp als het reservoir leeg isLaag
4-kanaals 5V-relaismodule (optocoupler, met JD-VCC)1Ventilator, verwarming en pompLaag
Logic-level N-kanaals MOSFET (IRLZ44N), weerstanden van 220 Ω en 100 kΩ1 setHelderheid van de ledstrip (PWM)Zeer laag
3–6 V mini-dompelpomp en 1 m siliconenslang1BewateringLaag
12 V computerventilator van 80 mm1–2Ventilatie en vochtafvoerLaag
12 V PTC-verwarming (10–30 W) en thermische zekering1 + 1VerwarmingLaag
12 V ledstrip (kweeklamp of koudwit), ongeveer 1 m1BijbelichtingLaag
I2C 16x2 LCD1StatusdisplayLaag–gemiddeld
12 V 5 A voedingsadapter en LM2596 buck-converter1 + 1VoedingGemiddeld
1N5819- of 1N4007-diode, condensator van 470 µF, schroefklemmen, jumperdraden–Bescherming en aansluitingenZeer laag
Doorzichtige opbergbox met deksel of acrylplaat, potten, druipbakjes–KasbehuizingGemiddeld

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.

Bodemvochtsensormodule
Bodemvochtsensor: de in de wortelzone begraven sonde geeft als analoge spanning aan hoe nat de grond is; kies voor een lange levensduur in een kas het capacitieve model.

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.

Als de LDR het licht van de leds kan zien, raakt het systeem in een lus waarin het zichzelf aan- en uitzet: het wordt donker, de leds gaan aan, de LDR denkt dat het licht is en zet ze uit, ziet dan weer duisternis. Om dit te voorkomen plaats je de LDR buiten de kas, uit het zicht van de leds, en gebruik je in de code hysterese in plaats van één drempel. De elektronica bovenop een capacitieve bodemsensor is ook niet waterdicht; begraaf hem niet boven de erop aangegeven lijn en dicht de randen van het printje af met hotmelt of heldere nagellak.

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.

BelastingTypische waardeDriverWaarom?
12 V PTC-verwarming10–30 W, ongeveer 1–2,5 ARelais (IN2)Hoge stroom, alleen aan/uit nodig
12 V 80 mm fan0,1–0,2 ARelais (IN1) of MOSFETEen relais is simpel; een MOSFET maakt ook PWM-snelheidsregeling mogelijk
3–6 V mini-dompelpomp0,1–0,25 A, meer bij het opstartenRelais (IN3) of MOSFET met een diodeDraait in korte pulsen; motorruis moet worden onderdrukt
12 V ledstrip (5050, 60 leds/m)Ongeveer 1,2 A per meterLogic-level MOSFETPWM-helderheidsregeling en geruisloze werking
Mini-dompelpomp
3–6 V mini-dompelpomp: hij zit in het reservoir, trekt ongeveer 100–200 mA en duwt water via een slang naar de pot; laat hem nooit droog draaien.

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.

De verwarming is het enige echte brandrisico in de kas. Monteer hem op een metalen ondergrond waar hij de kunststof wanden niet kan raken, plaats een thermische zekering in serie met de verwarming op de 12V-lijn, tegen de plaat waarop hij is gemonteerd, en test het systeem urenlang voordat je het onbeheerd laat. De zekering moet iets boven de grenstemperatuur van de verwarming openen (bijvoorbeeld 92 °C voor een PTC van 80 °C); een lagere waarde springt zonder reden tijdens normaal bedrijf. Verwarmingsmatten voor zaailingen en grotere verwarmingen werken meestal op netspanning (230 V), en netspanning is levensgevaarlijk. Gebruik geen netspanning in een modelkas; een 12V-PTC-verwarming is genoeg. Heb je echt een apparaat op netspanning nodig, laat de bedrading dan door een elektricien of een bekwame volwassene doen en plaats het relaisboard in een gesloten, geïsoleerde doos. Veilige bedradingsregels vind je in het artikel Wat is een relaismodule?.

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.

BelastingRailOngeveer stroom
PTC-verwarming (24 W)12 V2 A (meer op het eerste moment als hij koud is)
Ledstrip (1 m)12 V1–1,2 A
Twee ventilatoren van 80 mm12 V0,2–0,4 A
Arduino Uno en sensoren (via de DC-jack)12 VOngeveer 0,06–0,08 A
Ingang van de LM2596 (terwijl de 5V-kant 1 A trekt)12 VOngeveer 0,5 A
Relaismodule (drie relais bekrachtigd)5 V0,2–0,25 A
Mini-dompelpomp5 V0,1–0,25 A (meer bij het opstarten)
I2C-LCD (achtergrondverlichting aan)5 V20–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.

AansluitingArduino UnoESP32Raspberry Pi Pico
DHT22 DATAD2GPIO 4GP15
Vlotterschakelaar (andere draad naar GND)D3GPIO 13GP14
Relais IN3: pompD4GPIO 25GP18
Relais IN1: ventilatorD7GPIO 26GP16
Relais IN2: verwarmingD8GPIO 27GP17
MOSFET-gate (via 220 Ω): ledD9GPIO 18GP19
Bodemvochtsensor AOUTA0GPIO 34GP26
Middelpunt van de LDR-delerA1GPIO 35 (deler vanaf 3V3)GP27 (deler vanaf 3V3)
I2C LCD SDA / SCLA4 / A5GPIO 21 / 22GP4 / GP5
Sensorvoeding5V3V33V3
De pins van de ESP32 en de Pico werken op 3,3 V en zijn niet 5V-tolerant. Voed op deze boards de DHT22, de bodemvochtsensor en de LDR-deler vanaf de 3V3-pin, zodat er niet meer dan 3,3 V op de analoge pin komt. Een active-LOW 5V-relaismodule laat soms niet volledig los bij een HIGH-signaal van 3,3 V; blijft een relais bekrachtigd, voed dan bij een module met JD-VCC de VCC vanaf 3,3 V en JD-VCC vanaf 5 V, of koop een module met 3,3V-triggering. Kies voor de ledstrip een MOSFET die volledig opent bij een gatespanning van 3,3 V (bijvoorbeeld de IRLB8721).

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.

RegelingSchakelt aanSchakelt uitDode zone
Ventilator (temperatuur)≥ 30 °C≤ 27 °C3 °C
Ventilator (luchtvochtigheid)≥ 85%≤ 75%10%
Verwarming≤ 16 °C≥ 19 °C3 °C
BewateringBodem ≤ 35%Bodem ≥ 50%15%
LedverlichtingLicht ≤ 25%Licht ≥ 35% of na 4 uur10%

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

  1. Bereid de behuizing voor: maak de gaten voor de ventilator, luchtinlaat, slang en kabels en plaats de elektronicadoos buiten de kas.
  2. 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.
  3. 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.
  4. 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.
  5. 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.
  6. Sluit de ledstrip aan via de MOSFET en verander de waarde van analogWrite() om de helderheid te zien veranderen.
  7. 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?
Probeer niet alles in één keer te bedraden en meteen werkend te krijgen. Als zes modules niet samenwerken, kan het uren duren om de fout te vinden; modules die je een voor een hebt getest, werken na het samenvoegen meestal in één keer.

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.

C++ (Arduino IDE)
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}
FunctieTaakHoe 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 metingenElke 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 uitvaltElke loop
controlLight()Zet de leds met PWM aan als het donker wordt en schakelt ze na maximaal 4 uur uitElke loop
controlPump()Toestandsmachine voor bewatering: 3 s water geven, 60 s wachten, opnieuw meten; met reservoir- en overloopbeveiligingElke loop
updateLcd()Wisselt tussen drie pagina's: luchtmetingen, bodemvocht en licht, toestanden van de apparatenElke 3 seconden
logCsv()Schrijft metingen en toestanden als CSV-regel naar de Serial MonitorElke 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

ESP32-ontwikkelboard
ESP32: dankzij Wi-Fi volg je de kas op je telefoon en met de tijd van internet laat hij de leds op de echte klok draaien.

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.

C++ (Arduino IDE)
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.

Is er op school geen Wi-Fi, vervang dan de regel WiFi.begin() en de wachtlus erna door WiFi.softAP("BlueGrays-Sera", "12345678"), zodat de ESP32 zijn eigen netwerk maakt; je telefoon maakt verbinding met dat netwerk en opent 192.168.4.1. In dat geval is er geen internet, dus kan de tijd niet worden opgehaald en gebruiken de leds de terugvalregel.
MethodeToegang van buiten het huisMoeilijkheidHet beste voor
ESP32-webserver (de code in deze gids)Nee, alleen hetzelfde netwerkGemiddeldPresentaties op school, demo's zonder internet
Blynk IoTJaMakkelijkKant-en-klare meters, grafieken en meldingen
Telegram-botJaGemiddeldWaarschuwingen "reservoir leeg" en "temperatuur te hoog"
Google SheetsJaGemiddeldWekenlange datalogging en grafieken
MQTT en Home AssistantJa, installatie nodigGevorderdEchte 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.

MicroPython
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.
Doe je mee aan een wedstrijd met thema's, dan past landbouw en voedseltechnologie het natuurlijkst bij dit project (bij TÜBİTAK 4006 is dat het thema Landbouw- en veeteelttechnologieën). Voor meer ideeën, kostentabellen en beoordelingscriteria zie je het artikel Arduino-projectideeën voor wetenschapsbeurzen.

Veelgemaakte fouten en hoe je ze oplost

SymptoomWaarschijnlijke oorzaakOplossing
De Arduino reset of het LCD toont rommel als de pomp draaitPomp en relais gevoed vanaf de 5V-pin van de Arduino, motorruisVoed 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 klikkenEr wordt één drempel gebruikt of de metingen zijn ruisigGebruik aparte aan- en uitdrempels (hysterese) en neem het gemiddelde van de analoge metingen
Er blijft water stromen nadat de pomp stoptHevelwerking: het slanguiteinde ligt onder het waterniveau van het reservoirPlaats 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 pinMeet de ruwe waarde van de sensor in lucht en in water en schrijf ze in de constanten
De leds knipperen aan en uitDe LDR kan het licht van de leds zienVerplaats de LDR naar buiten de kas, gericht op de lucht
De DHT22 geeft nan terugVerkeerde pin, geen pull-upweerstand, of vaker dan elke 2 seconden uitgelezenControleer de pin, gebruik een module of voeg 10 kΩ toe tussen DATA en VCC
De temperatuur is hoger dan hij zou moeten zijnZon of ledlicht schijnt direct op de sensorSchaduw hem met een wit kapje met gaatjes en verplaats hem weg van de verwarming
Waterdruppels en schimmel op de wandenLuchtvochtigheid te hoog, ventilatie te zwakVerlaag de vochtigheidsdrempel, vergroot de luchtinlaat, geef minder water
Op de ESP32 gaat de bodemmeting fout als Wi-Fi startDe sensor zit op een ADC2-pinVerplaats hem naar een ADC1-pin tussen GPIO 32 en 39
Bij een ESP32 laat het relais nooit losEen HIGH van 3,3 V kan een active-LOW 5V-module niet uitschakelenScheid 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.

Alle projecten bekijken
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
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
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 slimme verlichting (PIR + LDR + relais + OLED)
ES-37Gevorderd
Premium

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.

4.3(6)
11