Skal du bort en uke, eller glemmer du rett og slett å vanne? Her bygger du automatisk vanning av potteplanter med en liten pumpe, en vanntank og en sonde i jorda. Først uten en eneste linje kode, deretter med en Arduino som gir små doser og venter, og til slutt med en tankvakt som stopper pumpen før tanken går tom. Du trenger ingen loddebolt.
- Nivå
- Nybegynner til avansert
- Tid
- Rundt 3,5 timer for alle tre nivåene
- Lodding
- Nei
- Spenning
- 12 V til pumpen, 5 V fra USB til Arduino
- Du lærer
- Relé, friløpsdiode, dosering, transistor som bryter og vakthund
Dette trenger du på bordet
Nivå 1 klarer seg med de ni første delene i listen. Arduinoen, relémodulen, knappen og motstandene kommer på nivå 2, og vannstandssensoren og transistoren på nivå 3. Fuktmodulen brukes bare på nivå 1, men sonden som følger med, er med hele veien.
Jordfuktighetssensor med 12 V-relé, MR-004041 stk. Modulen styrer nivå 1, sonden brukes på alle nivåeneFuktighetssensor med 12V rele, automatisk vanningsstyringPå lagerkr 229,00
Væskepumpe 12 V, 110 liter i timen1 stk, trekker rundt 0,3 AVæskepumpe - 12 V, 110 liter i timen - 7 mmPå lagerkr 339,00
Strømadapter 12 V, 2,5 A1 stk, med plugg på 5,5 x 2,1 mmStrømforsyning 12V 2,5A 30W med DC 5,5/2,1mm pluggPå lagerkr 239,00
DC-kontaktmodul til koblingsbrett1 stk, fører 12 V fra adapteren til brettetModul med DC-kontakt 5,5 x 2,1 mm og LEDPå lagerkr 79,00
Diode 1N4007, 10 stkÉn diode over pumpenLikeretterdiode 1N4007, 1A/1000V, 10-pakningPå lagerkr 25,00
Koblingsbrett, 400 hull1 stk, holder til alle tre nivåeneLoddefritt koblingsbrett med 400 hull og 2,54mm rasterPå lagerkr 75,00
Krokodilleledninger, 10 stkTo ledninger til loddeflikene på pumpenKrokodillekabler i mange farger - 50 cm, 10 stkPå lagerkr 49,00
Koblingsledninger hann-hunn4 på nivå 1, 8 på nivå 3. Til pinnene på moduleneSett med 40 koblingskabler, hann-til-hunn, 10 cm, fargerikePå lagerkr 75,00
Koblingsledninger hann-hann, 65 stk3 på nivå 1, rundt 15 på nivå 3Tilkoblingskabler hann-hann, forskjellige farger og lengder, sett 65 stk.På lagerkr 89,00
Arduino UNO R4 WiFi1 stk, nivå 2 og 3Utviklingskort Arduino Uno R4 WiFi med 12 x 8 LED-matrisePå lagerkr 599,00
Relémodul 5 V, 1 kanal1 stk, nivå 2 og 3Relémodul med 1 kanal, 5V spole og 10A/250V AC-kontakterPå lagerkr 79,00
Motstandssett, 16 verdierÉn på 10 kΩ og to på 1 kΩMotstandssett med 160 THT-motstander i 16 verdier, 0,25 WPå lagerkr 149,00
Trykknapp 12 x 12 mm, 5 stkÉn knapp, nivå 2 og 3Tact-bryter 12 x 12 mm med rød knapphette, 5 stk.På lagerkr 49,00
Vannstandssensor, analog1 stk, nivå 3Vannnivåsensor-modul, analogPå lagerkr 47,00
NPN-transistor BC337, 5 stkÉn transistor, nivå 3Bipolar NPN-transistor for hullmontering, 45V/0,8A, 5 stk.På lagerkr 39,00
I tillegg trenger du en USB-C-kabel, en vanntank (en bøtte, en mugge eller en matboks), et fat under potta og en slange. Slange har vi ikke i butikken, så den må du kjøpe et annet sted. Stussene på pumpen er 7 mm utvendig, så en myk slange med rundt 6 mm innvendig diameter sitter godt. Mål stussen eller ta med pumpen når du handler, og kjøp nok til både sugesiden og veien opp til potta. Andre koblingsbrett og ledninger finner du under koblingsplater og prototyping og koblingsledninger.
Slik virker automatisk vanning av potteplanter
Anlegget har fire deler: en tank med vann, en pumpe som flytter vannet, en slange som fører det til potta, og en styring som bestemmer når pumpen skal gå. Styringen vet det fordi en sonde står i jorda. Fuktig jord leder strøm bedre enn tørr jord, og det kan måles. Hvordan sonden virker, og hvordan du kalibrerer den, står i guiden om fuktighetsmåler for planter. Her bruker du den samme målingen til å styre en pumpe.
Pumpen går på 12 V og trekker rundt 0,3 A. En pinne på Arduino UNO R4 gir 5 V og tåler 8 mA, altså under en trettidel av det pumpen trenger, og med feil spenning. Derfor står det et relé mellom dem. Et relé er en bryter som styres av en elektromagnet: en liten strøm gjennom spolen trekker en kontakt, og kontakten slutter en helt annen krets.
Skrueklemmene på et relé heter COM, NO og NC. COM er felles. NO betyr «normally open»: kontakten er åpen når reléet hviler, og sluttes når spolen får strøm. NC er motsatt. Pumpen kobles til NO, slik at den står stille hvis styringen mister strømmen. Mer om relé, optokobler og de vanligste feilene finner du i guiden om relémodul med Arduino og ESP32.
| Nivå | Styring | Når går pumpen? | Sperrer mot for mye vann |
|---|---|---|---|
| 1 | Fuktmodul med relé, ingen kode | Så lenge sonden er tørr | Ingen. Sonden må stå tett ved utløpet |
| 2 | Arduino og relémodul | Tre sekunder, så en halv times pause | Maks fire doser i døgnet og en teller for dosene i tanken |
| 3 | Som nivå 2, med tankvakt | Som nivå 2 | I tillegg: stopp ved tom tank, stopp når dosene ikke virker, vakthund |
Test deg selv: hvorfor skal pumpen kobles til NO og ikke NC?
Fordi NO er åpen når reléet hviler. Hvis Arduinoen mister strømmen, programmet henger seg eller ledningen til reléet faller av, slipper reléet, og pumpen stopper. Med NC ville pumpen gått helt til noen oppdaget det.
Før du starter: 12 volt, vann og et fat under potta
12 V er ufarlig å ta på, men adapteren kan levere 2,5 A, og en kortslutning gjør ledninger og koblingsbrett varme. Vann og elektronikk hører dessuten ikke sammen. Fire regler holder prosjektet trygt:
- 12 V bor bare i de øvre skinnene. De to skinnene øverst på koblingsbrettet får 12 V fra adapteren. De to nederst får 5 V fra Arduinoen. De to parene kobles aldri sammen, og ingen ledning fra Arduinoen settes i de øvre skinnene.
- Koble alltid om uten strøm. Trekk ut både adapteren og USB-kabelen før du flytter en ledning.
- Elektronikken står tørt. Sett koblingsbrettet og Arduinoen ved siden av eller høyere enn tanken og potta, aldri under dem. Pumpen er ikke laget for å ligge i vannet. Den står ved siden av tanken og suger gjennom en slange.
- Potta står på et fat, og tanken er liten. Vannet i tanken er det meste som kan havne på feil sted. Start med én til to liter, og sett alt på et brett eller i en balje de første dagene.
Reléene i dette prosjektet tåler på papiret 230 V, men et koblingsbrett gjør det ikke. Bruk dem bare til 12 V her. Fast installasjon på 230 V er arbeid for en registrert installatør.
Nivå 1: vanning uten kode med fuktmodul og relé
Fuktmodulen er den ferdige delen av prosjektet. Den har en komparator som sammenligner fukten med en grense du stiller inn med en skrutrekker, og et relé som skifter når grensen passeres. Modulen og pumpen går begge på 12 V, så hele nivå 1 er én krets.

En motor er en spole, og en spole liker ikke at strømmen brytes brått. Idet reléet åpner, lager motoren en kort spenningstopp som gir gnister på kontaktene. En diode koblet parallelt med pumpen gir strømmen en vei å gå i det øyeblikket. Den kalles friløpsdiode. Dioden har en ring i den ene enden, og ringen skal alltid peke mot pluss.
- La adapteren ligge. Den kobles til helt til slutt.
- DC-kontaktmodulen har fire pinner merket GND, GND, VCC og VCC. Koble en av VCC-pinnene til plusskinnen øverst på koblingsbrettet og en av GND-pinnene til minusskinnen øverst, med hann-hunn-ledninger.
- Koble VCC på fuktmodulen til plusskinnen øverst og GND til minusskinnen øverst, også med hann-hunn-ledninger.
- Koble sonden til de to andre pinnene på modulen med ledningen fra pakken. Det spiller ingen rolle hvilken vei.
- Sett dioden i øvre halvdel av brettet, fra kolonne 4 til kolonne 10. Ringen skal være i enden ved kolonne 10.
- Skru en hann-hann-ledning fast i COM, og sett den andre enden i plusskinnen øverst.
- Skru en hann-hann-ledning fast i NO, og sett den andre enden i kolonne 10, i øvre halvdel.
- Koble kolonne 4, i øvre halvdel, til minusskinnen øverst.
- Fest en krokodilleledning på hver loddeflik på pumpen. Den andre enden av den ene fester du på beinet til dioden ved kolonne 10, den andre på beinet ved kolonne 4. Er en av flikene merket med pluss eller en rød prikk, skal den til kolonne 10. La klemmene stå rett opp, slik at de ikke berører hverandre eller andre deler på brettet.
- Sett slangene på pumpen: den ene ned i tanken, den andre opp til potta. Hvilken stuss som suger, ser du på pilen på pumpehuset, eller du prøver deg fram.
Hold enden av slangen i et glass, og test før noe havner i potta:
- Sett pluggen fra adapteren i DC-kontaktmodulen. Lampen på modulen lyser.
- Hold sonden i lufta. Reléet klikker, og pumpen går. Første gang tar det noen sekunder før vannet kommer, fordi slangen er full av luft.
- Dypp beina på sonden i et glass vann. Reléet klikker igjen, og pumpen stopper.
- Går pumpen når sonden står i vann og stopper i luft, virker reléet på modulen din motsatt vei. Trekk ut adapteren og flytt ledningen fra NO til NC.
- Vri på potensiometeret (den lille skruen i den blå boksen) til reléet skifter ved den fukten du ønsker. Sett sonden i jord som er akkurat så tørr som du vil la den bli, og vri til pumpen så vidt starter.
Nå kan sonden og slangen flyttes til potta. Sett sonden helt inntil stedet der slangen slipper vannet, høyst to centimeter unna. Da merker modulen vannet raskt, og pumpen stopper før det renner over.
Nivå 2: Arduino gir små doser og venter
Vann bruker tid på å trekke gjennom jorda. En styring som pumper helt til sonden melder «vått», har allerede gitt for mye. Løsningen er å gi en liten, kjent dose, vente til vannet har fordelt seg, og måle på nytt. Er jorda fortsatt tørr, kommer én dose til.
Fuktmodulen byttes nå ut med relémodulen på 5 V, og sonden kobles rett til Arduinoen. Pumpekretsen fra nivå 1 blir stående: adapteren, dioden og krokodilleledningene rører du ikke. Relémodulen har tre pinner merket S, + og −. Spolen trekker rundt 70 mA fra 5V-pinnen på Arduinoen, mens S bare er et styresignal. Du setter en motstand på 1 kΩ i serie med S, slik at strømmen ut av D9 holder seg godt under 8 mA uansett hvordan inngangen på modulen er bygd.
- Trekk ut adapteren. USB-kabelen skal heller ikke være koblet til.
- Ta bort fuktmodulen: løsne ledningene i COM og NO, og ta de to ledningene til VCC og GND helt bort, også fra skinnene øverst. Sonden beholder ledningen sin.
- Skru ledningen fra plusskinnen øverst fast i COM på relémodulen (klemmen i midten) og ledningen fra kolonne 10 fast i NO.
- Koble 5V på UNO til plusskinnen nederst og GND ved siden av AREF til minusskinnen nederst.
- Koble + på relémodulen til plusskinnen nederst og − til minusskinnen nederst, med hann-hunn-ledninger.
- Koble S på relémodulen til kolonne 20, i øvre halvdel. Sett en motstand på 1 kΩ fra kolonne 20 til kolonne 24, og koble D9 til kolonne 24, også i øvre halvdel.
- Sett knappen over midtrennen, med beina i kolonne 15 og 17. Koble D8 til kolonne 15 og minusskinnen nederst til kolonne 17, begge i nedre halvdel. Knappen er bred og dekker også de innerste hullene i kolonnene ved siden av.
- Stikk en hann-hann-ledning inn i hver av de to kontaktene på sondeledningen. Sett den ene i kolonne 29 og den andre i kolonne 30, i øvre halvdel.
- Koble D7 til kolonne 29, i øvre halvdel.
- Sett motstanden på 10 kΩ fra kolonne 27 til kolonne 30, i øvre halvdel, og koble kolonne 27, også i øvre halvdel, til minusskinnen nederst.
- Koble A0 til kolonne 30, i øvre halvdel.
Motstanden på 10 kΩ har fargene brun, svart og oransje hvis den har fire ringer. Den på 1 kΩ har brun, svart og rød. Installer «Arduino UNO R4 Boards» i Boards Manager i Arduino IDE, velg «Arduino UNO R4 WiFi», og last opp programmet. Er dette ditt første Arduino-prosjekt, forklarer Arduino-guiden for nybegynnere hvordan du kommer i gang.
// Automatisk vanning av potteplanter, nivå 2: Arduino gir små doser
// Kort: Arduino UNO R4 WiFi. Pumpen går på 12 V gjennom relémodulen.
const int SONDE_STROM = 7; // D7 gir sonden 5 V bare mens den måler
const int SONDE_INN = A0; // punktet mellom sonden og 10 kΩ
const int RELE = 9; // S på relémodulen, gjennom 1 kΩ. HIGH trekker reléet.
const int KNAPP = 8; // knapp mot GND, intern pullup
// Dine egne tall fra kalibreringen
const int RAA_TORR = 40; // råverdi i tørr jord
const int RAA_VAT = 520; // råverdi i nyvannet jord
const int GRENSE_VANN = 35; // det vannes når fukten er under dette
const unsigned long DOSE_MS = 3000; // så lenge går pumpen per dose
const int MAKS_DOSER_DOGN = 4; // aldri flere doser enn dette på ett døgn
const int DOSER_I_TANKEN = 20; // tankens volum delt på volumet av én dose
// Testverdier. I daglig bruk: MALEPAUSE_MS 600000 (10 min) og TREKKETID_MS 1800000 (30 min).
const unsigned long MALEPAUSE_MS = 10000;
const unsigned long TREKKETID_MS = 30000;
const unsigned long DOGN_MS = 86400000UL;
bool forsteMaling = true;
bool harDosert = false;
int doserDogn = 0;
int doserBrukt = 0;
unsigned long dognStart = 0;
unsigned long sistMalt = 0;
unsigned long sistDose = 0;
int lesSonde() {
digitalWrite(SONDE_STROM, HIGH);
delay(100);
long sum = 0;
for (int i = 0; i < 8; i++) {
sum += analogRead(SONDE_INN);
delay(5);
}
digitalWrite(SONDE_STROM, LOW);
return sum / 8;
}
int tilProsent(int raa) {
long prosent = map(raa, RAA_TORR, RAA_VAT, 0, 100);
return constrain(prosent, 0, 100);
}
// Én dose: pumpen på, vent, pumpen av. Ingenting annet skjer imens.
void giDose() {
digitalWrite(RELE, HIGH);
delay(DOSE_MS);
digitalWrite(RELE, LOW);
doserDogn++;
doserBrukt++;
harDosert = true;
sistDose = millis();
Serial.print("Dose gitt. I dette døgnet: ");
Serial.print(doserDogn);
Serial.print(" Igjen i tanken: ");
Serial.println(DOSER_I_TANKEN - doserBrukt);
}
// Kort trykk gir én dose. Hold inne i tre sekunder når du har fylt tanken.
void sjekkKnapp() {
if (digitalRead(KNAPP) == HIGH) return;
unsigned long start = millis();
while (digitalRead(KNAPP) == LOW && millis() - start < 3000) {
delay(10);
}
if (millis() - start >= 3000) {
doserBrukt = 0;
Serial.println("Tanken er fylt. Telleren er nullstilt.");
while (digitalRead(KNAPP) == LOW) delay(10);
} else if (millis() - start > 50) {
if (doserBrukt < DOSER_I_TANKEN) {
giDose();
} else {
Serial.println("Tanken er tom ifølge regnestykket. Fyll tanken og hold knappen inne.");
}
}
}
void setup() {
pinMode(RELE, OUTPUT);
digitalWrite(RELE, LOW); // pumpen av med en gang
pinMode(SONDE_STROM, OUTPUT);
digitalWrite(SONDE_STROM, LOW);
pinMode(KNAPP, INPUT_PULLUP);
pinMode(LED_BUILTIN, OUTPUT);
Serial.begin(9600);
sistDose = millis(); // første automatiske dose kommer tidligst én ventetid etter oppstart
}
void loop() {
sjekkKnapp();
unsigned long na = millis();
// nytt døgn: tell dosene på nytt
if (na - dognStart >= DOGN_MS) {
dognStart = na;
doserDogn = 0;
}
// lampen på kortet lyser når tanken ifølge regnestykket er tom
bool tankTom = doserBrukt >= DOSER_I_TANKEN;
digitalWrite(LED_BUILTIN, tankTom ? HIGH : LOW);
if (forsteMaling || na - sistMalt >= MALEPAUSE_MS) {
sistMalt = na;
forsteMaling = false;
int raa = lesSonde();
int prosent = tilProsent(raa);
Serial.print("Råverdi: ");
Serial.print(raa);
Serial.print(" Fukt: ");
Serial.print(prosent);
Serial.println(" %");
bool torr = prosent < GRENSE_VANN;
bool ventetidOver = na - sistDose >= TREKKETID_MS;
if (torr && !ventetidOver) {
Serial.println(harDosert ? "Venter: vannet fra forrige dose trekker inn." : "Venter etter oppstart.");
} else if (torr && doserDogn >= MAKS_DOSER_DOGN) {
Serial.println("Stopp: maks antall doser i dette døgnet.");
} else if (torr && tankTom) {
Serial.println("Stopp: tanken er tom ifølge regnestykket. Fyll tanken og hold knappen inne.");
} else if (torr) {
giDose();
}
}
}
Test først uten 12 V. Åpne Serial Monitor på 9600 baud og trykk kort på knappen: reléet klikker, og tre sekunder senere klikker det igjen. Sett så i adapteren, hold slangen i et glass, la sonden henge i lufta, og trykk på reset-knappen på kortet. De første 30 sekundene gir programmet ingen dose. Deretter kommer fire doser med rundt 40 sekunders mellomrom, før døgnsperren stopper pumpen. Slik ser begynnelsen ut:
Råverdi: 0 Fukt: 0 % Venter etter oppstart. Råverdi: 0 Fukt: 0 % Venter etter oppstart. Råverdi: 0 Fukt: 0 % Venter etter oppstart. Råverdi: 0 Fukt: 0 % Dose gitt. I dette døgnet: 1 Igjen i tanken: 19 Råverdi: 0 Fukt: 0 % Venter: vannet fra forrige dose trekker inn.
Med sonden i jord får du andre tall enn 0, og dosene stopper så snart fukten er over grensen. Trykk på reset-knappen når du vil nullstille tellerne og prøve på nytt.
Programmet har fire tall du bør kjenne:
| Konstant | Verdi i koden | Hva den gjør |
|---|---|---|
GRENSE_VANN | 35 | Under denne prosenten gis det en dose |
DOSE_MS | 3000 | Hvor lenge pumpen går per dose, i millisekunder |
MAKS_DOSER_DOGN | 4 | Flere doser enn dette gis ikke i løpet av 24 timer, regnet fra oppstart, uansett hva sonden sier |
DOSER_I_TANKEN | 20 | Så mange doser rommer tanken. Etterpå stopper pumpen, og lampen merket L på kortet lyser |
Knappen har to oppgaver. Et kort trykk gir én dose for hånd. Holder du den inne i tre sekunder, forteller du programmet at tanken er fylt, og telleren starter på nytt. Tallene RAA_TORR og RAA_VAT er kalibreringen av sonden: les av råverdien i tørr og i nyvannet jord, og skriv inn dine egne tall. Mens du tester, måler programmet hvert tiende sekund og venter bare 30 sekunder etter en dose. Sett MALEPAUSE_MS til 600000 og TREKKETID_MS til 1800000 før anlegget skal stå alene. Tellerne ligger bare i minnet. Etter en omstart begynner de på null, og derfor venter programmet alltid en full ventetid før den første automatiske dosen.
Test deg selv: hva skjer hvis sonden faller ut av potta på nivå 2?
Sonden gir 0 %, og programmet tror jorda er knusktørr. Det gir én dose, venter en halv time og gir en ny, men stopper etter fire doser. Med en dose på 90 ml blir det 360 ml i løpet av 24 timer. Det er sperren som skiller nivå 2 fra nivå 1, der pumpen ville gått til tanken var tom.
Slik finner du riktig dose
Hvor mye vann tre sekunder gir, avhenger av slangen og av hvor høyt pumpen må løfte. Mål det i stedet for å gjette:
- Hold enden av slangen i et målebeger, i samme høyde som potta.
- Trykk kort på knappen to ganger, med noen sekunders mellomrom, slik at slangen blir fylt.
- Tøm begeret, trykk én gang til, og les av hvor mange milliliter én dose gir.
- Vil du ha mindre eller mer, endrer du
DOSE_MS. Halv tid gir omtrent halv dose. - Del volumet av tanken på dosen, trekk fra et par doser som margin, og skriv tallet inn i
DOSER_I_TANKEN. - Trykk på reset-knappen på kortet til slutt. Dosene du ga for hånd, teller ellers med i døgnsperren.
Tabellen gir et utgangspunkt. Planter og jord er forskjellige, så se på fatet under potta de første dagene: står det vann der en time etter en dose, er dosen for stor.
| Potte, diameter | Forslag til dose | Høyst per døgn med fire doser |
|---|---|---|
| 10 til 12 cm | 30 til 50 ml | 120 til 200 ml |
| 13 til 17 cm | 60 til 100 ml | 240 til 400 ml |
| 18 til 25 cm | 120 til 200 ml | 480 til 800 ml |
Regnestykket for tanken er enkelt: en tank på 2 liter og en dose på 90 ml gir 22 doser. Med margin skriver du 20. Gir anlegget i snitt én dose om dagen, varer tanken i snaut tre uker.
Nivå 3: tankvakt, symboler og vakthund
Nivå 2 regner seg fram til når tanken er tom. Nivå 3 måler det. En vannstandssensor står i tanken, og programmet spør den ved hver måling. Samtidig får anlegget tre sperrer til: det oppdager at dosene ikke virker, det viser tilstanden med symboler, og en vakthund starter kortet på nytt hvis programmet skulle henge seg.
Vannstandssensoren har blanke kobberbaner, og de tæres når de står under spenning i vann. Derfor skal den, akkurat som sonden, bare ha strøm mens den måler. Hvor mye strøm sensoren trekker, er ikke oppgitt på produktsiden. Derfor får den ikke strøm rett fra en pinne, men gjennom en transistor: D10 gir en liten strøm til basen på BC337 gjennom 1 kΩ, og transistoren kobler minus på sensoren til GND. Hvordan en transistor virker som bryter, forklarer guiden om transistorer.
- Trekk ut adapteren og USB-kabelen.
- Sett BC337 i nedre halvdel av brettet med den flate siden mot deg, med beina i kolonne 1, 2 og 3.
- Koble kolonne 3 til minusskinnen nederst.
- Sett en motstand på 1 kΩ fra kolonne 2 til kolonne 6, i nedre halvdel, og koble D10 til kolonne 6.
- Vannstandssensoren har tre pinner merket S, + og −. Koble − til kolonne 1, i nedre halvdel, og + til plusskinnen nederst, med hann-hunn-ledninger. Ledningene på 10 cm blir for korte når tanken står lavere enn brettet. Skjøt dem ved å stikke hann-enden på én ledning inn i hunn-enden på den neste.
- Koble S til A2 på UNO.
- Fest sensoren på innsiden av tanken, med kobberbanene ned i vannet og pinnene godt over kanten.
UNO R4 WiFi har en LED-matrise med 12 ganger 8 lysdioder midt på kortet. Programmet tegner fire symboler der, så du ser tilstanden uten å koble til en PC:
// Automatisk vanning av potteplanter, nivå 3: tankvakt, symboler og vakthund
// Kort: Arduino UNO R4 WiFi. Begge bibliotekene følger med kortpakken.
#include <WDT.h>
#include "Arduino_LED_Matrix.h"
ArduinoLEDMatrix matrise;
const int SONDE_STROM = 7; // D7 gir sonden 5 V bare mens den måler
const int SONDE_INN = A0;
const int TANK_STROM = 10; // D10 styrer BC337, som slår på vannstandssensoren
const int TANK_INN = A2; // S på vannstandssensoren
const int RELE = 9; // S på relémodulen, gjennom 1 kΩ. HIGH trekker reléet.
const int KNAPP = 8; // knapp mot GND, intern pullup
// Dine egne tall fra kalibreringen
const int RAA_TORR = 40;
const int RAA_VAT = 520;
const int TANK_GRENSE = 150; // under dette regnes tanken som tom
const int GRENSE_VANN = 35;
const unsigned long DOSE_MS = 3000;
const int MAKS_DOSER_DOGN = 4;
const int MIN_STIGNING = 5; // så mye skal fukten minst stige etter en dose
const int MAKS_UTEN_VIRKNING = 2; // så mange doser uten virkning før stopp
// Testverdier. I daglig bruk: MALEPAUSE_MS 600000 (10 min) og TREKKETID_MS 1800000 (30 min).
const unsigned long MALEPAUSE_MS = 10000;
const unsigned long TREKKETID_MS = 30000;
const unsigned long DOGN_MS = 86400000UL;
// Symbolene til LED-matrisen: 8 rader med 12 lysdioder. 1 er lys, 0 er mørk.
uint8_t BILDE_OK[8][12] = {
{0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,1,0},
{0,0,0,0,0,0,0,0,0,1,0,0},
{0,0,0,0,0,0,0,0,1,0,0,0},
{0,1,0,0,0,0,0,1,0,0,0,0},
{0,0,1,0,0,0,1,0,0,0,0,0},
{0,0,0,1,0,1,0,0,0,0,0,0},
{0,0,0,0,1,0,0,0,0,0,0,0}
};
uint8_t BILDE_DRAPE[8][12] = {
{0,0,0,0,0,0,1,0,0,0,0,0},
{0,0,0,0,0,1,1,1,0,0,0,0},
{0,0,0,0,0,1,1,1,0,0,0,0},
{0,0,0,0,1,1,1,1,1,0,0,0},
{0,0,0,1,1,1,1,1,1,1,0,0},
{0,0,0,1,1,1,1,1,1,1,0,0},
{0,0,0,0,1,1,1,1,1,0,0,0},
{0,0,0,0,0,1,1,1,0,0,0,0}
};
uint8_t BILDE_TOM[8][12] = {
{0,1,0,0,0,0,1,0,0,1,0,0},
{0,1,0,0,0,0,1,0,0,1,0,0},
{0,1,0,0,0,0,1,0,0,1,0,0},
{0,1,0,0,0,0,1,0,0,1,0,0},
{0,1,0,0,0,0,1,0,0,0,0,0},
{0,1,0,0,0,0,1,0,0,1,0,0},
{0,1,1,1,1,1,1,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0}
};
uint8_t BILDE_KRYSS[8][12] = {
{0,0,1,0,0,0,0,0,0,1,0,0},
{0,0,0,1,0,0,0,0,1,0,0,0},
{0,0,0,0,1,0,0,1,0,0,0,0},
{0,0,0,0,0,1,1,0,0,0,0,0},
{0,0,0,0,0,1,1,0,0,0,0,0},
{0,0,0,0,1,0,0,1,0,0,0,0},
{0,0,0,1,0,0,0,0,1,0,0,0},
{0,0,1,0,0,0,0,0,0,1,0,0}
};
uint8_t BILDE_MORK[8][12] = {};
const int VIS_OK = 0, VIS_DRAPE = 1, VIS_TOM = 2, VIS_KRYSS = 3, VIS_MORK = 4;
int vist = -1;
const int INGEN_FEIL = 0, TANK_TOM = 1, INGEN_VIRKNING = 2;
int feil = INGEN_FEIL;
bool forsteMaling = true;
bool venterPaVirkning = false;
int fuktForDose = 0;
int utenVirkning = 0;
int doserDogn = 0;
unsigned long dognStart = 0;
unsigned long sistMalt = 0;
unsigned long sistDose = 0;
// Tegner et symbol, men bare når det er et annet enn det som står der fra før.
void vis(int bilde) {
if (bilde == vist) return;
vist = bilde;
if (bilde == VIS_OK) matrise.renderBitmap(BILDE_OK, 8, 12);
if (bilde == VIS_DRAPE) matrise.renderBitmap(BILDE_DRAPE, 8, 12);
if (bilde == VIS_TOM) matrise.renderBitmap(BILDE_TOM, 8, 12);
if (bilde == VIS_KRYSS) matrise.renderBitmap(BILDE_KRYSS, 8, 12);
if (bilde == VIS_MORK) matrise.renderBitmap(BILDE_MORK, 8, 12);
}
// Venter og mater vakthunden imens. Bruk denne i stedet for delay().
void vent(unsigned long ms) {
unsigned long start = millis();
while (millis() - start < ms) {
WDT.refresh();
delay(10);
}
}
int lesSonde() {
digitalWrite(SONDE_STROM, HIGH);
vent(100);
long sum = 0;
for (int i = 0; i < 8; i++) {
sum += analogRead(SONDE_INN);
delay(5);
}
digitalWrite(SONDE_STROM, LOW);
return sum / 8;
}
int tilProsent(int raa) {
long prosent = map(raa, RAA_TORR, RAA_VAT, 0, 100);
return constrain(prosent, 0, 100);
}
// Vannstandssensoren får strøm gjennom transistoren bare mens vi leser.
bool tankHarVann() {
digitalWrite(TANK_STROM, HIGH);
vent(50);
int raa = analogRead(TANK_INN);
digitalWrite(TANK_STROM, LOW);
Serial.print("Tank: ");
Serial.println(raa);
return raa >= TANK_GRENSE;
}
void giDose(int prosentNa) {
fuktForDose = prosentNa;
venterPaVirkning = true;
vis(VIS_DRAPE);
digitalWrite(RELE, HIGH);
vent(DOSE_MS);
digitalWrite(RELE, LOW);
doserDogn++;
sistDose = millis();
Serial.print("Dose gitt. I dette døgnet: ");
Serial.println(doserDogn);
}
// Et trykk kvitterer en feil. Uten feil gir trykket én dose for hånd.
void sjekkKnapp() {
if (digitalRead(KNAPP) == HIGH) return;
vent(50);
if (digitalRead(KNAPP) == HIGH) return;
while (digitalRead(KNAPP) == LOW) vent(10);
if (feil != INGEN_FEIL) {
feil = INGEN_FEIL;
utenVirkning = 0;
venterPaVirkning = false;
Serial.println("Feil kvittert.");
} else if (tankHarVann()) {
giDose(tilProsent(lesSonde()));
venterPaVirkning = false; // en dose for hånd teller ikke i virkningssjekken
} else {
feil = TANK_TOM;
}
}
void setup() {
pinMode(RELE, OUTPUT);
digitalWrite(RELE, LOW); // pumpen av med en gang
pinMode(SONDE_STROM, OUTPUT);
digitalWrite(SONDE_STROM, LOW);
pinMode(TANK_STROM, OUTPUT);
digitalWrite(TANK_STROM, LOW);
pinMode(KNAPP, INPUT_PULLUP);
Serial.begin(9600);
matrise.begin();
vis(VIS_OK);
// Første automatiske dose kommer tidligst én ventetid etter oppstart.
sistDose = millis();
// Vakthunden starter kortet på nytt hvis koden henger i mer enn fem sekunder.
// Ved omstart slipper reléet, så pumpen kan ikke bli stående på.
WDT.begin(5000);
}
void loop() {
WDT.refresh();
sjekkKnapp();
unsigned long na = millis();
if (na - dognStart >= DOGN_MS) {
dognStart = na;
doserDogn = 0;
}
// Ved feil blinker symbolet. Ellers står haken der.
if (feil == INGEN_FEIL) {
vis(VIS_OK);
} else if ((na / 500) % 2 == 0) {
vis(feil == TANK_TOM ? VIS_TOM : VIS_KRYSS);
} else {
vis(VIS_MORK);
}
if (forsteMaling || na - sistMalt >= MALEPAUSE_MS) {
sistMalt = na;
forsteMaling = false;
int prosent = tilProsent(lesSonde());
Serial.print("Fukt: ");
Serial.print(prosent);
Serial.println(" %");
if (feil != INGEN_FEIL) {
Serial.println(feil == TANK_TOM ? "FEIL: tanken er tom." : "FEIL: dosene virker ikke.");
return;
}
// tanken leses ved hver måling, så du får beskjed før planten trenger vann
if (!tankHarVann()) {
feil = TANK_TOM;
return;
}
bool ventetidOver = na - sistDose >= TREKKETID_MS;
// fikk den forrige dosen fukten til å stige, eller kom den over grensen?
if (venterPaVirkning && ventetidOver) {
venterPaVirkning = false;
if (prosent < fuktForDose + MIN_STIGNING && prosent < GRENSE_VANN) {
utenVirkning++;
} else {
utenVirkning = 0;
}
if (utenVirkning >= MAKS_UTEN_VIRKNING) {
feil = INGEN_VIRKNING;
return;
}
}
if (prosent >= GRENSE_VANN || !ventetidOver) return;
if (doserDogn >= MAKS_DOSER_DOGN) {
Serial.println("Stopp: maks antall doser i dette døgnet.");
} else {
giDose(prosent);
}
}
}
Begge bibliotekene, WDT.h og Arduino_LED_Matrix.h, følger med kortpakken for UNO R4. Du trenger ikke installere noe. Åpne Serial Monitor, og les av tallet etter «Tank:» med sensoren i vann og i luft. Sett TANK_GRENSE omtrent midt mellom de to tallene. Husk å sette MALEPAUSE_MS og TREKKETID_MS til verdiene for daglig bruk også her. Med 30 sekunders ventetid rekker ikke vannet fram til sonden, og krysset vil blinke. Eksempel på utskrift med tørr jord og full tank, fra den første dosen:
Fukt: 22 % Tank: 412 Dose gitt. I dette døgnet: 1 Fukt: 24 % Tank: 405 Fukt: 27 % Tank: 404 Fukt: 30 % Tank: 405 Fukt: 31 % Tank: 403 Dose gitt. I dette døgnet: 2
Ved hver måling går programmet gjennom fem kontroller før pumpen får gå. Figuren viser dem i samme rekkefølge som i loop(), og listen under forklarer det som er nytt på nivå 3:
- Tom tank. Tanken leses ved hver måling, så du får beskjed før planten trenger vann. Leser A2 lavere enn
TANK_GRENSE, går ikke pumpen. Symbolet med tom tank og utropstegn blinker. Fyll tanken og trykk på knappen. - Dosene virker ikke. Etter hver dose husker programmet hva fukten var. Har den verken steget med minst fem prosentpoeng eller kommet over grensen når ventetiden er over, og det skjer to ganger på rad, blinker krysset. Da har slangen falt av, pumpen suger luft, eller sonden står et sted vannet ikke kommer til.
- Vakthund.
WDT.begin(5000)starter en teller i mikrokontrolleren, en såkalt watchdog. Programmet må nullstille den medWDT.refresh()minst hvert femte sekund. Henger koden seg, starter kortet på nytt, D9 blir lav, og reléet slipper. Funksjonenvent()erstatterdelay()nettopp for å mate vakthunden mens pumpen går. Etter en omstart venter programmet en full ventetid før neste dose. En feil som får kortet til å starte på nytt om og om igjen, kan derfor ikke tømme tanken.
Plassering av tank, slange og sonde
Elektronikken kan være feilfri, og anlegget kan likevel tømme tanken i potta. Årsaken er hevertvirkning: står vannflaten i tanken høyere enn enden av slangen, fortsetter vannet å renne av seg selv etter at pumpen har stoppet. Sett derfor alltid tanken lavere enn potta.

- Slangen festes til en blomsterpinne eller til kanten av potta, slik at enden peker ned mot jorda og ikke kan gli ut. La den slippe vannet midt mellom stammen og kanten.
- Sonden står to til fire centimeter fra utløpet på nivå 2 og 3, og helt inntil på nivå 1. Står den på motsatt side av potta, kommer vannet sent fram, og dosene blir for mange.
- Pumpen står ved siden av tanken, omtrent i høyde med vannflaten. Jo kortere sugeslange, desto raskere kommer vannet.
- Fatet under potta skal romme minst to doser.
- Elektronikken står tørt, høyere enn tanken og så nær potta at ledningen til sonden rekker. Blir en ledning for kort, skjøter du den med en hann-hunn-ledning.
La anlegget gå i minst en uke mens du er hjemme, før du stoler på det når du reiser bort. Se etter vann i fatet, følg med på symbolet, og kjenn på jorda med en finger. Når alt virker, kan Arduinoen få strøm fra en USB-lader i stedet for fra PC-en.
Vanlige feil og løsninger
Reléet klikker, men pumpen går ikke
Feilen ligger i 12 V-kretsen. Lyser lampen på DC-kontaktmodulen? Sitter ledningene i COM og NO godt fast under skruene? Har krokodilleklemmene tak i selve metallet på loddeflikene og på beina til dioden? Lyser lampen svakt eller slukner den når reléet trekker, står dioden feil vei.
Pumpen går, men det kommer ikke vann
Pumpen suger luft. Sjekk at sugeslangen når ned i vannet og sitter tett på stussen, og at du ikke har byttet om de to stussene. Er pumpen ny og tørr, hjelper det å fylle sugeslangen med vann eller å senke pumpen til den står lavere enn vannflaten den første gangen.
Pumpen går hele tiden på nivå 1
Sonden står for langt fra utløpet, eller grensen er skrudd for høyt. Flytt sonden inntil utløpet, og skru potensiometeret tilbake. Går pumpen når sonden er våt og stopper når den er tørr, flytter du ledningen fra NO til NC.
Reléet klikker ikke på nivå 2
Sjekk at + og − på relémodulen går til de nedre skinnene, og at de nedre skinnene har 5 V og GND fra Arduinoen. Sjekk så at motstanden på 1 kΩ og ledningen fra S står i samme kolonne, og at D9 går til den andre enden av motstanden. Klikker reléet fortsatt ikke, bytter du motstanden på 1 kΩ med en på 470 Ω fra det samme settet. Da får inngangen omtrent dobbelt så mye strøm. Gå ikke lavere enn 470 Ω.
Arduinoen starter på nytt når pumpen stopper
Det tyder på at dioden mangler, eller at en ledning er satt feil og forbinder de to kretsene. Sjekk at ingen ledning fra Arduinoen står i de øvre skinnene eller i kolonne 4 og 10, og at dioden står med ringen mot kolonne 10.
Krysset blinker selv om det kommer vann
Vannet når ikke fram til sonden før ventetiden er over, eller dosen er for liten til å øke fukten med fem prosentpoeng. Flytt sonden nærmere utløpet, øk DOSE_MS litt, eller senk MIN_STIGNING til 3.
Symbolet for tom tank blinker med full tank
TANK_GRENSE er satt høyere enn det sensoren din gir i vann. Les av tallet etter «Tank:» i Serial Monitor, og juster. Sjekk også at transistoren står riktig vei, med den flate siden mot deg.
Vil du heller ha noe ferdig?
Ikke alt må bygges fra løse deler. Dette er alternativene i butikken:
Jordfuktighetssensoren med 12 V-relé fra nivå 1 er en ferdig styring. Den kan også åpne en magnetventil eller tenne en varsellampe i stedet for å starte en pumpe.
Vanningsenheten med fuktsensor og minipumpe har sensor og pumpe i samme enhet og kobles til med én Grove-kabel. Koden skriver du selv.
Sensorsettet for smart jordbruk har pumpe, fuktsensor og flere andre deler for prosjekter med planter. Selve micro:bit-kortet følger ikke med.
Vanlige spørsmål
Hvor lenge kan automatisk vanning av potteplanter stå alene?
Det er tanken som bestemmer. Del volumet på det planten bruker i døgnet. En middels stor grønn plante innendørs bruker ofte rundt én desiliter om dagen, og da varer to liter i snaut tre uker. Mål forbruket til din egen plante i en uke før du reiser.
Kan én pumpe vanne flere potter?
Ja, med et T-stykke på slangen, men vannet fordeler seg sjelden likt, og det er bare potta med sonden som styrer. Det fungerer for like potter med like planter. Skal pottene styres hver for seg, trenger hver av dem sin egen sonde, pumpe og relémodul.
Kan jeg bruke en annen pumpe?
Ja. Reléet bryr seg ikke om hva det slår av og på, så lenge strømforsyningen passer til pumpen. En nedsenkbar pumpe på 5 V kobles på samme måte, med en strømforsyning på 5 V i stedet for 12 V. Behold dioden, og mål dosen på nytt.
Kan Arduinoen og pumpen dele én strømforsyning?
Ja. UNO R4 WiFi tåler 6 til 24 V på VIN, så du kan koble VIN til plusskinnen øverst og GND til minusskinnen øverst. Da er de to kretsene ikke lenger atskilt, og en koblingsfeil kan sende 12 V inn på en pinne. Vent med dette til alt virker med USB.
Hvorfor ikke bare la pumpen gå til jorda er våt?
Fordi sonden merker vannet for sent. Vannet bruker flere minutter på å trekke fra utløpet til sonden, og i mellomtiden renner det over. Små doser med pause gir samme mengde vann, men aldri mer enn potta rekker å ta imot.
Er det trygt å la anlegget stå på mens jeg er på ferie?
Sperrene på nivå 3 begrenser skaden, men ingen hjemmebygd løsning er uten risiko. Bruk en tank som ikke er større enn nødvendig, la alt stå på et brett som tåler vann, og kjør anlegget i minst en uke hjemme først. Koden er kompilert, men ikke prøvd på fysisk maskinvare hos oss, så din egen test er den som teller.
Veien videre
Nå vanner planten seg selv. Vil du se fukten på telefonen og få varsel når tanken er tom, er neste steg guiden om jordfuktighetssensor i Home Assistant, som gjør det samme med ESP32 og ESPHome. Har du ikke bygd måleren med skjerm ennå, viser guiden om fuktighetsmåler for planter hvordan sonden kalibreres, og hvordan fukten vises på en OLED-skjerm. Og vil du styre større motorer med variabel fart, er guiden om motorstyring med L298N og MOSFET en fin fortsettelse.
Fakta her er hentet fra databladet til UNO R4 WiFi (8 mA per pinne, 6 til 24 V på VIN), Arduinos veiledning for LED-matrisen, WDT-biblioteket i kortpakken for UNO R4, databladet til 1N4007, databladet til BC337 og produktsidene. Koden er kompilert for UNO R4 WiFi, men ikke kjørt på fysisk maskinvare. Hvilken vei reléet på fuktmodulen skifter, er ikke oppgitt på produktsiden, og derfor tester du det i et glass vann på nivå 1.




