Hoe stop ik een loop totdat een bepaalde waarde bereikt is.

Ik ben bezig met een automatisch water systeem dmv. een Arduino MEGA 2560.
Het idee is om 1 pot per keer water te geven(10 in totaal). De pomp is niet sterk genoeg om er meerdere tegelijk te bedienen. Elke pot heeft zijn eigen Soil Moisure Sensor (Sparkfun), Als de thresholdDown <=300 een klep en 0.5 sec. later de pomp gaat open/run (via relay’s). Als de thresholdUp >= 700 is de pomp- en klep relay’s afschakelen.
Tot zover geen problemen. The sketch werkt prima. Het probleem is dat de loop blijft doorgaan en niet wacht tot de eerste pot klaar is.
Ik heb nog wat geprobeerd met [if … else] Controle Structures als ook met[Break] and [Continue], maar had hier geen succes mee.

Het idee is:
Meet pot 1, is deze droog (theresholdDown) → valve- and pump relay running
wacht tot deze nat is (thresholdUp) → pump- and valve relay closed, door naar pot 2
of
Meet pot 1, Als deze nat is (thresholdUp) → doe niet, door naar pot 2

Aan het eind van de loop, mag hij gerust doorlopen (Als dit lekker werkt, voeg ik nog een RTC toe, zodat hij tussen vaste tijden werkt).

Ik hoop dat iemand mij kan helpen.

Hier is een gedeelte van mijn code, de hele code zit in het:

void loop(){ 
                  
                    // set the relay's
                    //1st set Soil moisture sensors + relay's
                                      
  int sensorValue1;
    sensorValue1 = analogRead(sensorPin1);    //Reads SMSP value.
    if (sensorValue1 <= thresholdDown){
    digitalWrite(relayPin1, HIGH);            //solenoid valve1 open
    delay(500);                               //0.5 sec. delay between valve and pump
    digitalWrite(relayPin0, HIGH);            //solenoid Pump running
    }
    //sensorValue1 = analogRead(sensorPin1);    //Not necessary
    else if (sensorValue1 >= thresholdUp){         
    digitalWrite(relayPin0, LOW);             //solenoid Pump stopped
    delay(500);                               //0.5 sec. delay between valve and pump
    digitalWrite(relayPin1, LOW);             //solenoid valve1 closed
    //digitalWrite(sensorPin1, LOW);  //Actief maken natest met aansturing via NPN transistor
    }
    delay(500);                               //print value's every 0.5 sec.
    sensorValue1 = analogRead(sensorPin1);
    Serial.print("sensor1 = " );
    Serial.println(sensorValue1);

                    // end sensor 1

                    // 2nd set Soil moisture sensors

  int sensorValue2;
    sensorValue2 = analogRead(sensorPin2);  //Reads SMSP value.
    if (sensorValue2 <= thresholdDown){
    digitalWrite(relayPin2, HIGH);          //solenoid valve2 open
    delay(500);                             //0.5 sec. delay between valve and pump                         
    digitalWrite(relayPin0, HIGH);          //solenoid Pump running
    }
    //sensorValue2 = analogRead(sensorPin2);  //Not necessary
    else if (sensorValue2 >= thresholdUp){         
    digitalWrite(relayPin0, LOW);           //solenoid Pump stopped
    delay(500);                             //0.5 sec. delay between valve and pump
    digitalWrite(relayPin2, LOW);           //solenoid valve2 closed
    }
    delay(500);                             //print value's every 0.5 sec.
    sensorValue2 = analogRead(sensorPin2);
    Serial.print("sensor2 = " );
    Serial.println(sensorValue2);
              
                    // end sensor 2

Begin__code_sprinkler_mar10b.ino (6.22 KB)

Als jij meerdere potten hebt die op dezelfde wijze verwerkt worden dan zou ik een array maken die elke pot verwerkt. Is deze klaar dan mag de volgende. En daarna begin je weer bij de eerste

Dat kun je zo doen als Nico voorstelt.
Je zegt dat je pomp maar 1 afnemer per keer aan kan.
Dan moet je dus maar 1 pot aansturen.
Maar verder kun je gewoon alle andere handelingen uitvoeren hoor.

Ik type dit bericht, zodat je ook mijn handtekening hier onder de streep kunt zien.
Ik noem daarin de sketch 'blink without delay' en dat doe ik zo niet voor niets in elke post die ik maak.
Via die sketch kun je leren hoe je dingen min of meer op de achtergrond kunt laten verlopen, maar toch andere dingen doet.
Je moet daarvoor bijhouden wat je aan het doen was.
Je gebruikt delay in je sketch, en dat is onnodig en ontzettend zonde van de tijd.
Ik zie in die snippet anderhalve seconde niets doen staan.
Je doet daar telkens een halve seconde niets.
Het leger kaboutertjes in je Arduino laat dan alles vallen, en gaan allemaal een halve seconde op de horloge staan kijken.
Een halve seconde zijn dan acht miljoen handelingen die niet verricht worden.

Dus,
Je kunt ook kijken (en bijhouden in statistieken als je dat zou willen) welke pot het hardste uitdroogt.
Die pot die waarschijnlijk de grootste plant heeft, kun je dan vaker water geven.
Je kunt dan ook gaan kijken of je die pot misschien wel vaker, maar dan minder per keer water moet gaan geven, zodat de andere planten niets te kort gaan komen.
Dat kan allemaal, maar dan moet je wel op een veel efficiëntere wijze gaan werken.
Je hoeft de voorbeelden die ik noemde natuurlijk niet te gaan uitvoeren, het is alleen bedoeld om je erop te wijzen dat er heel veel mogelijk is.
Als je je sketch eerst laat doen wat je nu bedacht hebt maar dan op de wijze die ik bedoel, dan kun je later nog gaan werken aan een versie deluxe.

nicoverduin:
Als jij meerdere potten hebt die op dezelfde wijze verwerkt worden dan zou ik een array maken die elke pot verwerkt. Is deze klaar dan mag de volgende. En daarna begin je weer bij de eerste

Okay, ik zal mij hierin verdiepen. Ik ben veel van dit soort systemen tegengekomen, maar dan is er maar 1 relay of zit er zoveel meer bij, (draadloos besturen, uitgebreid LCD schermen, etc), waardoor de code's ook veel ingewikkelder zijn, en kan ik er de, voor mij interresante, stukken niet meer uitvissen kan.
Bedankt nogmaals voor de tip.

Zelf ontwerpen is meestal de beste oplossing ipv kopieren van iets wat er op lijkt. Dat wordt elke keer opnieuw hier bewezen

MAS3:
Je gebruikt delay in je sketch, en dat is onnodig en ontzettend zonde van de tijd.
Ik zie in die snippet anderhalve seconde niets doen staan.
Je doet daar telkens een halve seconde niets.
Het leger kaboutertjes in je Arduino laat dan alles vallen, en gaan allemaal een halve seconde op de horloge staan kijken.
Een halve seconde zijn dan acht miljoen handelingen die niet verricht worden.

De 0.5 sec. pauze bedoeld om eerst de klep van pot1 te openen alvorens de pomp te starten, misschien een beetje overdreven, maar dat wat het idee erachter.

MAS3:
Je kunt ook kijken (en bijhouden in statistieken als je dat zou willen) welke pot het hardste uitdroogt.
Die pot die waarschijnlijk de grootste plant heeft, kun je dan vaker water geven.
Je kunt dan ook gaan kijken of je die pot misschien wel vaker, maar dan minder per keer water moet gaan geven, zodat de andere planten niets te kort gaan komen.
Dat kan allemaal, maar dan moet je wel op een veel efficiëntere wijze gaan werken.
Je hoeft de voorbeelden die ik noemde natuurlijk niet te gaan uitvoeren, het is alleen bedoeld om je erop te wijzen dat er heel veel mogelijk is.
Als je je sketch eerst laat doen wat je nu bedacht hebt maar dan op de wijze die ik bedoel, dan kun je later nog gaan werken aan een versie deluxe.

Ik ga in eerste instantie met Nico zijn idee aan de gang. Als dat werkt, voeg ik de RTC er aan toe, zodat er b.v. vanaf 19:00 tot 21:00 naar de potten 'gekeken' wordt en indien nodig water wordt gegeven. In dit tijdsbestek, zal de grond het water opnemen/verdelen, waardoor meerdere keren watergeven noodzakelijk is. Dit zal dan 's morgens b.v. tussen 6:00 en 9:00 herhaald worden.
Zoals gezegd, eerst alles werkende krijgen, daarna werken aan de 'DeLuxe' versie.
Bedankt voor je input.

Uiteraard nicos idee met een array is erg slim.
dus de sensorpinnen, de kleppinnen, de meting komen in 3 losse arrays.
loop{
for int teller..... {
je meet een pot, als te laag dan klep open en pomp aan, ander niks doen
2 seconden wachten
klep weer dicht, pomp uit
}
}

Ik ben mij op het moment aan het 'inlezen' in het array verhaal, hoe dit precies in elkaar steekt.
Dit helpt mij weer eens stapje verder.
Nog een vraagje, ik wil de pomp en klep pas laten stoppen op het moment dat de sensor de Max. waarde bereikt, dit i.v.m. verschillende grootte van de potten. Dus inplaats van de [delay] functie. Op deze manier krijgt de pot de ideale hoeveelheid water.
Kan jij daar een voorbeeld voor geven?
Alvast bedankt.

Lees meetpot
While (meetpot< max waarde){
Klepopen
Lees meetpot
}
Klep dicht

Nico en Paul,
Ik kom er nog niet helemaal uit. Ik snap het array verhaal zoals het op verschillende site’s wordt uitgelegd. Helaas gaan alle voorbeelden die ik tegenkom over ‘getallen’, de array begint met ‘int’, of over karakters (letters en woorden), de array begint met ‘char’.

Dit is wat ik tot nu toe heb. Onderin de ‘void setup’ heb ik de voorgestelde 3 array gemaakt, maar weet niet hoe er invulling aan te geven, en om ze daarna op te roepen.
De code bevat op dit moment geen fouten (errors), maar werkt niet zoals ik wil.

//Define solenoids and pomp #define pRelayPin 30 //Pump #define vRelayPin1 31 //Solenoid valve 1 #define vRelayPin2 32 //Solenoid valve 2 #define vRelayPin3 33 //Solenoid valve 3 #define vRelayPin4 34 //Solenoid valve 4 #define vRelayPin5 35 //Solenoid valve 5 #define vRelayPin6 36 //Solenoid valve 6 #define vRelayPin7 37 //Solenoid valve 7 #define vRelayPin8 38 //Solenoid valve 8

//if more valve’s needed, make more pins

//8 Soil Moister Sensors

int sensorValue1 = A1; //Begin with # A1, for easy connecting.
int value1 = 0;
int sensorValue2 = A2;
int value2 = 0;
int sensorValue3 = A3;
int value3 = 0;
int sensorValue4 = A4;
int value4 = 0;
int sensorValue5 = A5;
int value5 = 0;
int sensorValue6 = A6;
int value6 = 0;
int sensorValue7 = A7;
int value7 = 0;
int sensorValue8 = A8;
int value8 = 0;

//value’s,will need to change to needs
int valueMax = 600;
int valueMin = 300;

void setup() {
Serial.begin(9600);
pinMode (pRelayPin, OUTPUT);
pinMode (vRelayPin1, OUTPUT);
pinMode (vRelayPin2, OUTPUT);
pinMode (vRelayPin3, OUTPUT);
pinMode (vRelayPin4, OUTPUT);
pinMode (vRelayPin5, OUTPUT);
pinMode (vRelayPin6, OUTPUT);
pinMode (vRelayPin7, OUTPUT);
pinMode (vRelayPin8, OUTPUT);

int sensorPin[8]; //fill in # of sensors???

int relay[9]; //fill in # of relays (1pump, 8 valves)???

int sensorValue[8]; //fill in # of measurepoints???
}

void loop() {

//for (int sensorValue1; sensorValue1 < valueMin;) {
if (analogRead(A1) <= valueMin)
{
digitalWrite(vRelayPin1, HIGH);
digitalWrite(pRelayPin, HIGH);

delay(500);
Serial.print ("sensor 1 = ");
Serial.println (sensorValue1 = analogRead(A1));
}
else
{
digitalWrite(pRelayPin, LOW);
digitalWrite(vRelayPin1, LOW);

delay(500);
Serial.print ("sensor 1 = ");
Serial.println (sensorValue1 = analogRead(A1));
}

if (analogRead(A2) <= valueMin)
{
digitalWrite(vRelayPin2, HIGH);
digitalWrite(pRelayPin, HIGH);

delay(500);
Serial.print ("sensor 2 = ");
Serial.println (sensorValue2 = analogRead(A2));
}
else
{
digitalWrite(pRelayPin, LOW);
digitalWrite(vRelayPin2, LOW);

delay(500);
Serial.print ("sensor 1 = ");
Serial.println (sensorValue1 = analogRead(A1));
}
}

Ik heb wel weer de ‘void loop’ toegepast, maar dat was meer om de boel aan de gang te krijgen. Volgens mij moet de ‘void loop’ leeg blijven, maar dan gebeurt er niet veel, of zelf ‘error-meldingen’, welke ik niet opgelost krijg.

Graag zou ik nog een zetje in de goede richting krijgen.

Bijna goed met de code tags :wink:

[code] en [/code]

Verder moet je je arrays niet in setup() declareren; als je dat doet kun je ze niet in loop() gebruiken.

Verder zou ik het pomp relay niet in het array plaatsen, dat gaat verwarring geven.

goed op weg, doe zoals sterretje zei, en zet de pinnen ook in een array, en ook de ingangen.
en ik bedoelde inderdaad maar heel even aanzetten, en meerdere keer door de routine, dan heeft het water de tijd om te zakken. dan krijg je dus een soort druppelaar.
zoals je al gemerkt hebt, wordt het een heel lange loop, met heel vaak hetzelfde, een array (of meerdere) dan wordt het een stuk eenvoudiger.
probeer de loop op 1 pagina te houden en roep een functie aan om water te geven aan een plant, verhoog dan een teller om in diezelfde functie plant 2 te doen.

Het array verhaal begreep ik wel, wist alleen niet hoe ik het moest implementeren, m.a.w. de nummers tussen de {} kunnen dus ook verwijzen naar de pinnen… op de arduino. Die mogelijkheid had ik nergens terug kunnen vinden.

Ik kreeg een PM van ‘bartlagaisse’, met de hele sketch, waarvoor dank. Ik begrijp nu helemaal wat deze sketch doet.

@ shooter (paul), ik denk dat de teller zoals jij bedoeld hier dus in verwerkt zit, na pot 1, door naar pot 2 etc., etc.
@ sterretje, de code invoeren moest ik even bedenken, was de balk bovenin kwijt. De array’s staan voor de setup() en het pomprelay is apart genomen.

Allen hartelijk dank voor de hulp.

int valueMin = 300;
int pomppin = 30;

// dit is een array met 8 waarden, die waarden zijn de pinnen van je relays
int relaypinnen[8] = {31, 32, 33, 34, 35, 36, 37, 38};   

// hetzelfde voor de pinnen van je sensors
int sensorpinnen[8] = {A1, A2, A3, A4, A5, A6, A7, A8}; 

// hetzelfde voor de waarden die je sensors gaan geven
int waardes[8] ={0, 0, 0, 0, 0, 0, 0, 0};

void setup()
{
  Serial.begin(9600);

  pinMode (pomppin, OUTPUT);

  // hier doen we: begin bij 0, doe het zolang i kleiner is dan 8, tel dan 1 bij i
  for (int i = 0 ; i < 8 ; i++) 
  {
    // dit gedeelte zal 8 keer gebeuren
    pinMode (relaypinnen[i], OUTPUT);
    pinMode (sensorpinnen[i], INPUT);
  }  

}
 
void loop() 
{
  for (int i = 0 ; i < 8 ; i++) 
  {
     waardes[i] = analogRead(sensorpinnen[i]);
     Serial.print ("sensor ");
     Serial.print (i);
     Serial.print (" = ");
     Serial.println (waardes[i]);

     while (waardes[i] <= valueMin) 
     {
       // dit gedeelte gaat ie blijven doen zolang de waarde kleiner of gelijk aan de minimumwaarde is

       digitalWrite(relaypinnen[i], HIGH);               // klep open
       digitalWrite(pomppin, HIGH);                      // pomp aan 
     
       delay(500);                                            // wacht even
       waardes[i] = analogRead(sensorpinnen[i]);   // meet opnieuw
       
     }
     if (waardes[i] > valueMin)                           // de gemeten waarde is voldoende voor deze pot, pomp uit, klep dicht
     {
       
       digitalWrite(pomppin, LOW);          // pomp uit
       digitalWrite(relaypinnen[i], LOW);   // klep[i] dicht
  
     }

    }
}

Je hebt geen array nodig voor de 'waardes'. Een enkele variabele zal het dit keer ook doen.

Deze test is niet nodig

    if (waardes[i] > valueMin)                           // de gemeten waarde is voldoende voor deze pot, pomp uit, klep dicht

Omdat de enige manier om bij die if te komen is als je uit de while komt en dus zal de bovenstaande test altijd waar zijn.

sterretje:
Je hebt geen array nodig voor de 'waardes'. Een enkele variabele zal het dit keer ook doen.

Deze test is niet nodig

    if (waardes[i] > valueMin)                           // de gemeten waarde is voldoende voor deze pot, pomp uit, klep dicht

Omdat de enige manier om bij die if te komen is als je uit de while komt en dus zal de bovenstaande test altijd waar zijn.

Ik laat hem toch maar even staan zo. Ik wil op een later tijdstip nog even kijken of, als er eenmaal water gegeven moet worden aan een pot, om door te gaan naar een maximale waarde.
Alsnog bedankt voor je input.