Programmering og koding

Automatisk vanning av potteplanter: bygg det selv med pumpe

Fotorealistisk illustrasjon av en potteplante som vannes gjennom en tynn slange fra en liten pumpe og en vanntank, styrt av en Arduino UNO R4 WiFi med relémodul

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.

Tegning av anlegget: pumpen suger vann fra en tank og sender det gjennom en slange til potta, mens en sonde i jorda måler fukten.
Slik kan anlegget se ut. Dette er en tegning. Pumpen står tørt mellom tanken og potta, og styringen er fuktmodulen på nivå 1 og en Arduino på nivå 2 og 3.
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
Kort forklartEn sonde i jorda måler fukten. Når jorda er tørr, slutter et relé en egen krets med 12 V, og pumpen sender vann fra tanken til potta. På nivå 1 gjør en ferdig fuktmodul alt dette alene. På nivå 2 og 3 lar du en Arduino UNO R4 WiFi gi én dose om gangen: pumpen går i tre sekunder, programmet venter en halv time mens vannet trekker inn, og så måler det på nytt. Flere sperrer hindrer at potta blir oversvømt.

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.

  • Fuktmodul med 12 V-relé, sonde og ledning
    Jordfuktighetssensor med 12 V-relé, MR-004041 stk. Modulen styrer nivå 1, sonden brukes på alle nivåene
    kr 229,00
    På lager
  • Væskepumpe for 12 V med to slangestusser
    Væskepumpe 12 V, 110 liter i timen1 stk, trekker rundt 0,3 A
    kr 339,00
    På lager
  • Strømadapter på 12 V med DC-plugg
    Strømadapter 12 V, 2,5 A1 stk, med plugg på 5,5 x 2,1 mm
    kr 239,00
    På lager
  • Liten modul med DC-kontakt og fire pinner
    DC-kontaktmodul til koblingsbrett1 stk, fører 12 V fra adapteren til brettet
    kr 79,00
    På lager
  • Ti likeretterdioder 1N4007 på tape
    Diode 1N4007, 10 stkÉn diode over pumpen
    kr 25,00
    På lager
  • Loddefritt koblingsbrett med 400 hull
    Koblingsbrett, 400 hull1 stk, holder til alle tre nivåene
    kr 75,00
    På lager
  • Krokodilleledninger i flere farger
    Krokodilleledninger, 10 stkTo ledninger til loddeflikene på pumpen
    kr 49,00
    På lager
  • Koblingsledninger hann til hunn i flere farger
    Koblingsledninger hann-hunn4 på nivå 1, 8 på nivå 3. Til pinnene på modulene
    kr 75,00
    På lager
  • Sett med koblingsledninger hann til hann
    Koblingsledninger hann-hann, 65 stk3 på nivå 1, rundt 15 på nivå 3
    kr 89,00
    På lager
  • Arduino UNO R4 WiFi sett på skrå
    Arduino UNO R4 WiFi1 stk, nivå 2 og 3
    kr 599,00
    På lager
  • Relémodul med ett relé og tre pinner
    Relémodul 5 V, 1 kanal1 stk, nivå 2 og 3
    kr 79,00
    På lager
  • Motstandssett med 16 verdier på papirremser
    Motstandssett, 16 verdierÉn på 10 kΩ og to på 1 kΩ
    kr 149,00
    På lager
  • Fem trykknapper med rød hette
    Trykknapp 12 x 12 mm, 5 stkÉn knapp, nivå 2 og 3
    kr 49,00
    På lager
  • Rød vannstandssensor med tre pinner
    kr 47,00
    På lager
  • Fem NPN-transistorer for hullmontering
    NPN-transistor BC337, 5 stkÉn transistor, nivå 3
    kr 39,00
    På lager

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.

Prinsipptegning: Arduino styrer spolen i reléet med 5 volt, og kontaktene COM og NO slutter en egen krets med 12 volt til pumpen.
Forenklet tegning. Styrekretsen og pumpekretsen har ingen felles ledning. Det eneste som går fra den ene til den andre, er magnetfeltet inne i reléet.

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åStyringNår går pumpen?Sperrer mot for mye vann
1Fuktmodul med relé, ingen kodeSå lenge sonden er tørrIngen. Sonden må stå tett ved utløpet
2Arduino og relémodulTre sekunder, så en halv times pauseMaks fire doser i døgnet og en teller for dosene i tanken
3Som nivå 2, med tankvaktSom nivå 2I 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é

Nivå 1: nybegynner. Tid: rundt 45 minutter. Du trenger fuktmodulen med 12 V-relé, pumpen, strømadapteren på 12 V, DC-kontaktmodulen, én diode 1N4007, koblingsbrett, to krokodilleledninger og koblingsledninger. Du lærer hvordan et relé og en friløpsdiode virker.

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.

Produktbilde av fuktmodulen MR-00404 med gaffelformet sonde, ledning med to kontakter og modul med blått relé og skrueklemmer.
Produktbildet av MR-00404. Modulen har to pinner til sonden, to pinner merket VCC og GND og tre skrueklemmer. Klemmene er merket med kinesiske tegn: den i midten er COM, og sett fra klemmesiden er NO til venstre og NC til høyre.

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.

Koblingstegning for nivå 1: 12 volt på de øvre skinnene, fuktmodulen får strøm derfra, og reléet kobler 12 volt til pumpen.
Forenklet tegning. Modulen er tegnet med skrueklemmene bort fra deg, og da står NC til venstre og NO til høyre. Følg alltid merkingen på din egen modul. Dioden står mellom kolonne 4 og 10, med ringen mot kolonne 10.
  1. La adapteren ligge. Den kobles til helt til slutt.
  2. 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.
  3. Koble VCC på fuktmodulen til plusskinnen øverst og GND til minusskinnen øverst, også med hann-hunn-ledninger.
  4. Koble sonden til de to andre pinnene på modulen med ledningen fra pakken. Det spiller ingen rolle hvilken vei.
  5. Sett dioden i øvre halvdel av brettet, fra kolonne 4 til kolonne 10. Ringen skal være i enden ved kolonne 10.
  6. Skru en hann-hann-ledning fast i COM, og sett den andre enden i plusskinnen øverst.
  7. Skru en hann-hann-ledning fast i NO, og sett den andre enden i kolonne 10, i øvre halvdel.
  8. Koble kolonne 4, i øvre halvdel, til minusskinnen øverst.
  9. 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.
  10. 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:

  1. Sett pluggen fra adapteren i DC-kontaktmodulen. Lampen på modulen lyser.
  2. 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.
  3. Dypp beina på sonden i et glass vann. Reléet klikker igjen, og pumpen stopper.
  4. 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.
  5. 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

Nivå 2: viderekommen. Tid: rundt 1,5 timer. I tillegg til nivå 1 trenger du Arduino UNO R4 WiFi, relémodulen på 5 V, én trykknapp, én motstand på 10 kΩ og én på 1 kΩ fra motstandssettet og flere koblingsledninger. Du lærer dosering, ventetid og sperrer i kode.

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.

Eksempelkurve: jorda er tørr, pumpen gir en dose, programmet venter en halv time og måler igjen, og etter tre doser er fukten over grensen.
Beregning, ikke måling. Kurven viser tankegangen med tallene fra koden: grense på 35 %, en halv time mellom dosene og stopp så snart målingen er over grensen. Hvor mye hver dose øker fukten, avhenger av potta.

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.

Koblingstegning for nivå 2: relémodulen på D9 gjennom 1 kiloohm, knapp på D8, sonden på D7 og A0, og 12 volt bare på de øvre skinnene.
UNO R4 sett ovenfra med USB-C til venstre. De øvre skinnene og kolonne 4 og 10 i øvre halvdel fører 12 V. Alt som går til Arduinoen, bruker de nedre skinnene og står minst fem kolonner unna. Relémodulen er tegnet med skrueklemmene vendt bort fra deg.
  1. Trekk ut adapteren. USB-kabelen skal heller ikke være koblet til.
  2. 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.
  3. Skru ledningen fra plusskinnen øverst fast i COM på relémodulen (klemmen i midten) og ledningen fra kolonne 10 fast i NO.
  4. Koble 5V på UNO til plusskinnen nederst og GND ved siden av AREF til minusskinnen nederst.
  5. Koble + på relémodulen til plusskinnen nederst og − til minusskinnen nederst, med hann-hunn-ledninger.
  6. 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.
  7. 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.
  8. 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.
  9. Koble D7 til kolonne 29, i øvre halvdel.
  10. 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.
  11. 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:

KonstantVerdi i kodenHva den gjør
GRENSE_VANN35Under denne prosenten gis det en dose
DOSE_MS3000Hvor lenge pumpen går per dose, i millisekunder
MAKS_DOSER_DOGN4Flere doser enn dette gis ikke i løpet av 24 timer, regnet fra oppstart, uansett hva sonden sier
DOSER_I_TANKEN20Så 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:

  1. Hold enden av slangen i et målebeger, i samme høyde som potta.
  2. Trykk kort på knappen to ganger, med noen sekunders mellomrom, slik at slangen blir fylt.
  3. Tøm begeret, trykk én gang til, og les av hvor mange milliliter én dose gir.
  4. Vil du ha mindre eller mer, endrer du DOSE_MS. Halv tid gir omtrent halv dose.
  5. Del volumet av tanken på dosen, trekk fra et par doser som margin, og skriv tallet inn i DOSER_I_TANKEN.
  6. 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, diameterForslag til doseHøyst per døgn med fire doser
10 til 12 cm30 til 50 ml120 til 200 ml
13 til 17 cm60 til 100 ml240 til 400 ml
18 til 25 cm120 til 200 ml480 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å 3: avansert. Tid: rundt 1 time. I tillegg til nivå 2 trenger du vannstandssensoren, én NPN-transistor BC337, én motstand til på 1 kΩ og fem koblingsledninger. Du lærer å bruke en transistor som bryter, LED-matrisen på UNO R4 WiFi og en 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.

Koblingstegning for nivå 3: som nivå 2, pluss vannstandssensor i tanken med BC337 på D10 som bryter og signalet S på A2.
UNO R4 sett ovenfra med USB-C til venstre. Alt fra nivå 2 står som før. Transistoren står i nedre halvdel med den flate siden mot deg, og da er beina kollektor, base og emitter fra venstre. Følg merkingen på vannstandssensoren når du kobler S, + og −.
  1. Trekk ut adapteren og USB-kabelen.
  2. Sett BC337 i nedre halvdel av brettet med den flate siden mot deg, med beina i kolonne 1, 2 og 3.
  3. Koble kolonne 3 til minusskinnen nederst.
  4. Sett en motstand på 1 kΩ fra kolonne 2 til kolonne 6, i nedre halvdel, og koble D10 til kolonne 6.
  5. 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.
  6. Koble S til A2 på UNO.
  7. 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:

Fire bilder tegnet fra tabellene i koden: hake når alt er i orden, dråpe mens pumpen går, tom tank med utropstegn og kryss ved feil.
Slik kan symbolene se ut. Dette er en tegning, laget ut fra de samme tabellene med enere og nuller som står i koden. De to feilsymbolene blinker.
// 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:

Flytskjema for nivå 3 med fem kontroller før pumpen får gå: vann i tanken, ventetid, virkning av forrige dose, tørr jord og døgnets doser.
Forenklet tegning. Tallene 35 %, fire doser og tre sekunder er konstantene i koden. En feil blir stående til du trykker på knappen.
  • 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 med WDT.refresh() minst hvert femte sekund. Henger koden seg, starter kortet på nytt, D9 blir lav, og reléet slipper. Funksjonen vent() erstatter delay() 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.

To oppsett side om side: tank under potta stopper vannet når pumpen stopper, mens tank over potta kan tømme seg som en hevert.
Forenklet tegning. Til venstre må pumpen løfte vannet, og når den stopper, stopper vannet. Til høyre drar vannet i slangen resten av tanken med seg.
Fotorealistisk illustrasjon av en potte der vanningsslangen er bundet til en blomsterpinne, og sonden står i jorda noen centimeter fra utløpet.
Illustrasjon. Slangen er bundet til en blomsterpinne og slipper vannet rett ned, og sonden står i kanten av det våte feltet.
  • 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:

Fuktmodulen alene

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.

kr 229,00
På lager
For M5Stack

Vanningsenheten med fuktsensor og minipumpe har sensor og pumpe i samme enhet og kobles til med én Grove-kabel. Koden skriver du selv.

kr 389,00
På lager
For micro:bit

Sensorsettet for smart jordbruk har pumpe, fuktsensor og flere andre deler for prosjekter med planter. Selve micro:bit-kortet følger ikke med.

kr 979,00
På lager

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.

Alle guider

Produkter omtalt i denne guiden

Produktene som brukes og sammenlignes i guiden, med pris og lagerstatus.