Actie eenmalig uitvoeren in een for loop.

Beste mensen,

Ik heb een programmaatje geschreven waarbij ik de waarde van mijn potentiometer kan opslaan. Omdat ik 10 verschillende waardes wil kunnen opslaan heb ik hier een array voor gebruikt.
De bedoeling is om een motertje eenmalig te laten trillen wanneer de potentiometer weer deze waarde bereikt. Om te checken of hij al 1 keer heeft getrilt heb ik motorRun gemaakt die na 1 keer trillen op 1 wordt gezet.

Dat doe ik met deze code:

  for (i = 0; i < 10; i = i + 1) {
    int difVal = abs(Coordinates[i] - potValue);
     potValue = analogRead(A0);
     if (difVal <=tolerance && motorRun == 0 )  {     
     digitalWrite(vibPin, HIGH);
    delay(100); 
     digitalWrite(vibPin, LOW);
       Serial.println("In range");
    motorRun= 1; 
    } 
    else {
     
      Serial.println("Out of range");
      motorRun= 0;
    }

Alleen is mijn probleem nu dat motorRun weer continu op 0 gezet wordt, en het motortje dus blijft trillen wanneer je in de range zit, en niet eenmalig zoals de bedoeling is.
Nu is mijn vraag of jullie advies hebben hoe ik er voor kan zorgen dat mijn motortje maar 1 keer trilt als hij in de range zit. Alvast bedankt.

Mijn hele code :

 int Coordinates[10] = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
int tolerance = 50;
const int buttonPin = 4;
const int vibPin = 7; 
int buttonState = 0;
int potValue = 9999;
int i;
int led = 3;
int motorRun= 0;


void setup() {
  // initialize serial communication at 9600 bits per second:
  Serial.begin(9600);
   pinMode(buttonPin, INPUT);
   pinMode(vibPin, OUTPUT);
}

// the loop routine runs over and over again forever:
void loop() {
 
  potValue = analogRead(A0);
  Serial.println(potValue);
  
   buttonState = digitalRead(buttonPin);
 if (buttonState == HIGH) {     
    // print out the value you read:   
    Serial.println("ingedrukt");
  
  for (i = 0; i < 10; i = i + 1) {
    if(Coordinates[i]==-1) {
        Coordinates[i]=potValue;
        Serial.println(i);
        
         
         digitalWrite(led, HIGH);   // turn the LED on (HIGH is the voltage level)
          delay(1000);               // wait for a second
          digitalWrite(led, LOW);    // turn the LED off by making the voltage LOW
        delay(500);   
        break;
        }
      }
 }
 
  for (i = 0; i < 10; i = i + 1) {
    int difVal = abs(Coordinates[i] - potValue);
     potValue = analogRead(A0);
     if (difVal <=tolerance && motorRun == 0 )  {     
     digitalWrite(vibPin, HIGH);
    delay(100); 
     digitalWrite(vibPin, LOW);
       Serial.println("In range");
    motorRun= 1; 
    
    } 
    else {
      motorRun= 0;
      Serial.println("Out of range");
     
    }
 

 }
 
 
  delay(200);
}

Hoi Jelmer93.

Dit komt natuurlijk omdat jij 'm elke keer weer terug zet.
Dus dat moet je anders doen.
Wat je doet is dit:

Moet de wel motor draaien ? > Laat de motor draaien > en maak je hulpje 1.
Moet de motor niet draaien ? > maak het hulpje 0.
Deze twee hangen aan elkaar en een van de twee wordt altijd uitgevoerd.

Dus de eerste keer nadat je motor gedraaid heeft, word er niet gedraaid.
Maar daarna mogelijk wel, want je hulpje werd zojuist (onterecht) terug gezet.

Uiteraard moet ie wel worden terug gezet, maar dan ergens buiten de for.. loop waarin je m maar 1 keer wil laten draaien.

Mag niet al te moeilijk zijn om op te lossen.

Hoi MAS3,

Bedankt voor je antwoord!

Ik heb nu de motorRun (het zogenaamde hulpje) laten reseten direct boven in de void loop.
Alleen dit zorgt ervoor dat mijn motortje nog steeds blijft trillen wanneer ik met de Potentiometer nog binnen mijn opgeslagen values zit. Waarschijnlijk komt dit omdat wanneer de for loop is afgelopen hij weer motorRun reset en de potentiometer nog steeds binnen de opgeslagen waardes zit hij weer opnieuw gaat trillen.
Ik kom dus nog steeds niet echt uit hoe en wanneer ik motorRun moet resetten om ervoor te zorgen dat mijn motortje maar 1 keer trilt als de potentiemeter binnen de opgeslagen waardes zit :S

Mijn code nu:

 int Coordinates[10] = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
int tolerance = 50;
const int buttonPin = 4;
const int vibPin = 7; 
int buttonState = 0;
int potValue = 9999;
int i;
int led = 3;
int motorRun= 0;


void setup() {
  // initialize serial communication at 9600 bits per second:
  Serial.begin(9600);
   pinMode(buttonPin, INPUT);
   pinMode(vibPin, OUTPUT);
}

// the loop routine runs over and over again forever:
void loop() {
  motorRun= 0;
  potValue = analogRead(A0);
  Serial.println(potValue);
  
   buttonState = digitalRead(buttonPin);
 if (buttonState == HIGH) {     
    // print out the value you read:   
    Serial.println("ingedrukt");
  
  for (i = 0; i < 10; i = i + 1) {
    if(Coordinates[i]==-1) {
        Coordinates[i]=potValue;
        Serial.println(i);
        
         
         digitalWrite(led, HIGH);   // turn the LED on (HIGH is the voltage level)
          delay(1000);               // wait for a second
          digitalWrite(led, LOW);    // turn the LED off by making the voltage LOW
        delay(500);   
        break;
        }
      }
 }
 
 
  for (i = 0; i < 10; i = i + 1) {
    int difVal = abs(Coordinates[i] - potValue);
     potValue = analogRead(A0);
     if (difVal <=tolerance && motorRun == 0 )  {     
     digitalWrite(vibPin, HIGH);
    delay(100); 
     digitalWrite(vibPin, LOW);
       Serial.println("In range");
    motorRun= 1; 
    
    } 
   

 }
 
 
  delay(200);
 
 
}

Zo had ik je vraag niet begrepen.
Wanneer je de motor maar 1 keer ooit wil laten trillen, moet je je hulpje dus ook nooit resetten.
Dus 1 keer definiëren voor void.loop en dan gelijk de waarde 0 toewijzen, zoals je nu ook al doet.
Dan als ie eenmaal naar 1 gezet word, kan ie niet meer terug naar nul.

Ik betwijfel of dit echt is wat je wil.
Als dat niet zo is, dan moet je aangeven wanneer het hulpje weer van 1 af moet komen.

Ik bedoel dus dat wanneer je aan de potmeter gaat draaien en je komt bij de opgeslagen waarde dat het motortje maar 1 keer trilt. Wanneer je weer aan de pot meter gaat draaien en je komt bij een andere waarde moet het motortje weer maar 1 keer trillen. Ik denk dat je me de eerste keer wel goed had begrepen, het is dus niet de bedoeling dat het motortje maar 1 malig trilt. Ik wil meerdere waarde's kunnen opslaan en hem laten trillen als ik weer bij die waarde kom.

Ik zit nu een beetje te proberen wanneer ik de Motorrun weer 0 kan laten worden, maar kom er nog niet echt uit om het voor elkaar te krijgen wat ik wil.
Heb jij misschien een suggestie hoe ik kan weten dat ik weer uit mijn opgeslagen waarde ben en dus mijn Motorrun weer op 0 kan zetten ?

Groeten,

Jelmer

je hebt dus 10 verschillende waardes in een array staan bijv, 100,200,300......
potmeter=200
we testen i=0 dus we testen op 100 dus dif is groot en motorrun=0 eerste regel in loop weghalen.
dus vib gaat aan.
motorrun wordt 1
nu testen op 200 dif is goed en motorrun staat op 1 dus overslaan.
nu testen op 300 dif is fout en motorrun is 1 dus hup hij gaat weer tekeer.
dat is niet wat je wilt.

eerst testen of de potmeter binnen een bereik is(for loop), zo ja dan kijken of dit een ander is als vorige keer(is teller gelijk aan vorige keer), zo ja dan trillen, en teller opslaan in een var, anders niets doen.

Als ik het goed begrijp, wil je verschillende keren draaien aan de potmeter registreren.
Dus iemand gaat een beetje zitten pieren aan die potmeter en dan komt er op een gegeven moment een tril.
Daarna niet meer dus deze persoon geeft het op.
Een tijdje later komt er iemand anders (of dezelfde persoon komt terug) en die gaat dan aan de potmeter zitten.

In het bovenstaande is het deel “een tijdje later” het belangrijkste punt.
Want ik heb je dat niet zien zeggen, maar meen het zelf uit je beschrijvingen te kunnen filteren.
Als dat klopt, moet je dus gaan registreren dat er een bepaalde periode niet meer aan de potmeter gedraaid word.
Niet draaien betekent dat de waarde uit de potmeter niet meer verandert,
Dat kun je registreren, en je kunt ook bijhouden hoe lang dat duurt.
Je kunt dan vergelijken of dat overeen komt met “een tijdje”.

Die 10 keer uitlezen van de potmeter, verlopen ontzettend snel.
Je hebt er een vertraging in zitten van een tiende seconden, dus iemand moet binnen 1 seconde die heen en weer draaien naar dezelfde waarde.
Kan een leuk spelletje zijn (ik kan er zo een aantal varianten op verzinnen), maar dit moet je je wel realiseren.