Vraag over 3 knoppen en snelheid motor

Hoi,

Mijn engels is niet zo goed dus ik hoop in dit gedeelde van de site een antwoord te vinden op mijn vraag. Het klinkt heel simpel en ik denk dat ook voor de kenner het een simpel ding is maar ik kom er maar niet uit, wellicht zie ik het over het hoofd en ik hoop dat iemand mij dit werkend of voorbeeld wil geven en uitleg waar het volgende zit:

ik heb 3 knoppen, laten we zeggen:

Knop 1, als ik deze knop indruk dan kan ik daarna de snelheid van een motor regelen doormiddel van een potmeter, deze potmeter werkt dus alleen als ik eerst Knop 1 heb in gedrukt de motor word aangestuurd met een TIP120.
Knop 2, als ik deze knop indruk dan krijgt de TIP/Motor een vast snelheid (analogWrite Tip, 30), hiermee werkt de potmeter niet meer.

Knop 3 is de stop knop, als ik deze indruk dan werkt de alle 2 de opties niet meer, potmeter werkt niet en de vast aansturing naar de Tip (tip, 30) werkt ook niet, tot dat we een van die twee knoppen weer indrukken.

Dit is wat ik al heb, maar waar ik niet uit kom is het schakelen van de buttons, met name als ik eerste de stop knop in druk, hoe maak ik met knop 1 de potmeter actief?

Dit is de code van de potmeter

// read the potentiometer, convert it to 0 - 255:
potValue = analogRead(potPin) / 4;
// use that to control the transistor:
analogWrite(tip, potValue);

Neem aan de het principe van de drukknop ook als volgt werkt?

// Drukknop 2
buttonState2 = digitalRead(buttonPin2);
// Vergelijk hier de buttonstatus met zijn vorige stand
if (buttonState2 != lastButtonState2) {
  // Als de stand veranderd, verhoog de teller
  if (buttonState2 == HIGH) {
    // Als huidige status hoog is, dan verander in knop van uit naar aan:
    buttonPushCounter2++;
  }

En daar kom ik niet echt uit, hoe de potmeter te activeren.
Als iemand mij dit zou kunnen uitleggen dan ben ik je erg dankbaar, ben blond maar niet helemaal gek hoor hahah
alvast bedankt

Gr Natascha

Hoi Nataschabakker, welkom terug.

Wat je daar doet met die knop, is niet de waarde van uit naar aan zetten, maar een teller verhogen.
Zo kun je heel snel op een heel hoge waarde terecht komen en ik denk niet dat dat je bedoeling was.
Ik denk dat die knop 2 er dus voor is om de snelheid te beïnvloeden.
Maar je zegt zelf dat knop 2 er voor is om een vaste snelheid in te stellen.
Dus als je knop 2 gezien hebt, hoef je alleen maar de snelheid op die vaste waarde in te stellen.
Met knop 1 zou de potmeter de snelheid bepalen.
En met knop 3 zet je de snelheid weer op een andere vaste waarde, namelijk nul voor uit.

Zoals je onder elk van mijn berichten kunt zien, heb ik de blink without delay sketch hoog in het vaandel.
Want daarin word je een alternatief voor delay() geboden.
Maar die sketch leert je meer dan alleen een andere aanpak voor delay().
Je leert er ook dat je dingen moet bijhouden.
Dat is in het Engels, daar is helaas niet zoveel aan te doen.
Maar als je er specifieke vragen over hebt dan is er vast wel iemand die je wil helpen daarmee.

Goed, bij houden dus.
Je wil met de schakelaar dus verschillende modi van je regelaar instellen..
Wat zou je dan allemaal moeten gaan bijhouden..
En zijn er dan bepaalde voorwaarden die je in je sketch zou moeten gaan verwerken misschien, à la "als dit, dan dat.." ?

@MAS3
je doet wel je onderzoek naar mensen :wink:

@Natashabakker
Het is te adviseren om je volledige code te laten zien. Op die manier kunnen we zien hoe ver je bent en mogelijke problemen aanwijzen.

Het is mij ook niet helemaal duidelijk of de volgorde altijd 1/2/3 is of dat b.v. 1/3/1/3 of 2/3/2/1/2/3 ook mogelijkheden zijn?

Oke, dank jullie wel, ik zal het zo duidelijk mogelijk uitleggen:

De 3 push buttons zijn momentary buttons, dus een keer drukken, niet ingedrukt blijven houden.
Als button 1 word ingedrukt dan kan men met de potmeter de tip/motor snelheid regelen.
Als button 2 word ingedrukt dan krijgt de tip/motor een vaste, van te voren ingesteld waarde/snelheid mee maar werkt de potmeter niet meer.
Als button 3 word ingedrukt dan is de waarde 0, kortom de tip/motor is uit, ook het regelen van de potmeter werkt niet meer.

De potmeter mag pas werken als eerst button 1 ingedrukt is geweest. Daarna mag men button 2 direct indrukken om weer verder te gaan met een vaste waarde maar ook mag men de stop button indrukken.
Ook als men eerst button 2 heeft ingedrukt (vast waarde) mag men daarna button 1 weer indrukken om de snelheid met de potmeter weer verder te kunnen regelen. Kortom de volgorde van het indrukken van de buttons maakt niets uit, er is geen vaste volgorde.

Hieronder de code, hij geeft overigens geen foutmelding bij het checken ervan maar vraag is echter of het wel goed staat (nog niet geladen in de arduino dus in praktijk nog niet getest, ga ik vanavond even doen) of dat dit beter kan. Zit met namen ook met uitschakelen van de potmeter, dat vind ik erg lastig, als button 2 of button 3 ingedrukt is geweest dat de potmeter niet meer mag werken.

//Hier vermelden we welke pinnen gaan gebruiken en waarvoor.

const int buttonPin2 = 2;      // pushbutton pin om de potmeter te kunnen gebruiken
const int buttonPin3 = 3;       // pushbutton pin om een vast waarde mee te geven aan de TIP
const int buttonPin4 = 4;       // pushbutton pin om de vorige button, actie geactiveerd is, deze te stoppen
const int tip = 44;                // aansturing voor de tip120 

// Deze tel/counters denk ik te moeten gebruiken om de pushbuttons een waarde mee te geven, maar wellicht kan dat anders? 
// Het gaat om push buttons maar is niet de bedoeling dat men de button gedrukt moet blijven houden.


int buttonState2 = 0;         // current state of the button
int lastButtonState2 = 0;     // previous state of the button
int buttonPushCounter2 = 0;   // counter for the number of button presses
int buttonState3 = 0;         // current state of the button
int lastButtonState3 = 0;     // previous state of the button
int buttonPushCounter3 = 0;   // counter for the number of button presses
int buttonState4 = 0;         // current state of the button
int lastButtonState4 = 0;     // previous state of the button
int buttonPushCounter4 = 0;   // counter for the number of button presses
int potPin = A0;
int potValue = 0; 
int potValue1 = 0;
int potValue2 = 0; 
const int SPEED_THRESHOLD = 5;


//Hier vertellen we welke pin welke in/output hij heeft.

void setup() {

  pinMode(buttonPin2, OUTPUT);
  digitalWrite(2, LOW);
  pinMode(buttonPin3, OUTPUT);
  digitalWrite(3, LOW);
  pinMode(buttonPin4, OUTPUT);
  digitalWrite(4, LOW);
  pinMode(tip, OUTPUT);
}

void loop() {


  // Hier zou de activatie van de potmeter moeten komen, heb hier maar iets ingevuld omdat ik dit juist niet weet hoe het moet?
  buttonState2 = digitalRead(buttonPin2);
  if (buttonState2 != lastButtonState2) {
    if (buttonState2 == HIGH) {
    }
 // lees de potmeter en stuur de waarde door, convert it to 0 - 255:
  potValue = analogRead(potPin) / 4;
  // stuur door naar de TIP
  analogWrite(tip, potValue);   
  }


  // Als button 2 word ingedrukt, stuur vast waarde naar de TIP
  buttonState3 = digitalRead(buttonPin3);
  if (buttonState3 != lastButtonState3) {
    if (buttonState3 == HIGH) {
    }
 //  stuur vaste waarde door naar de TIP
  analogWrite(tip, 30);
  }

  // Als button 3 word ingedrukt, zet alles uit
  buttonState4 = digitalRead(buttonPin4);
  if (buttonState4 != lastButtonState4) {
    if (buttonState4 == HIGH) {
    }
 //  stuur vaste waarde door naar de TIP
  analogWrite(tip, 0);
  }

  
  
  
}

In feite heb je dus verschillende fasen in de loop.....
A)bepaal welke knop is ingedrukt en wacht tot deze is los gelaten. Je hebt nu een pramma status
B)kijk of dit een valide knop is ( dus jouw condities). Zo niet zet je de status op ongeldig
C) via een switchcase kun je nu de verschillende statussen verwerken.

Hallo Nico, dank je wel voor je reactie, alhoewel ik hem niet helemaal begrijp. Is dat juist goed verschillende fasen in een loop? Of moet dit juist anders? Want dan begrijp ik hem niet erg goed. Dat is ook de reden waarom ik het op een support forum deel, dan graag willen weten wat beter of anders kan. Ben niet zo heel erg ervaren hoor met programmeren maar kleine basis lukt wel en dit soort uitdagingen kunnen we weer van leren.
Dank je wel

Ik zou beginnen om de knop pinnen logische namen te geven.

Bv btnSetspeed, btnFixedspeed en btnStop.

Vervolgens moet je consequent deze namen gebruiken. Dus niet eerst de pinMode zetten met een naam en vervolgens naar de pin schrijven (!!) met een nummer (digitalWrite(2, ...).

Het is maar goed dat js de code nog niet geladen hebt. De pinnen voor de knoppen moeten als ingang worden geconfigureerd niet als uitgang.

Super dank je wel, inderdaad, je heb gelijk om de namen meteen te hanteren en aan te leren, zo blijft overzichtelijk, thanks!

Dus als goed is komt het er zo uit te zien:

/*
  Hieronder probeer ik een code te maken voor 3 push buttons (dit zijn momentary buttons) een keer drukken, niet ingedrukt blijven houden.
  Als button 1 word ingedrukt dan kan men met de potmeter de tip/motor snelheid regelen.
  Als button 2 word ingedrukt dan krijgt de tip/motor een vaste, van te voren ingesteld waarde/snelheid mee.
  Als button 3 word ingedrukt dan is de waarde 0, kortom de tip/motor is uit, ook het regelen van de potmeter werkt niet meer.

  De potmeter mag pas werken als eerst button 1 ingedrukt is geweest.
  Daarna mag men button 2 direct indrukken om wer verder te gaan met een vaste waarde maar ook mag men de stop button indrukken.
  Ook als men eerst button 2 heeft ingedrukt (vast waare) mag men daarna button 1 weer indrukken om de snelheid met de potmeter weer verder te kunnen regelen.
  Kortom de volgorde van het indrukken van de buttons maakt niets uit, er is geen vaste volgorde.

*/

//Hier vermelden we welke pinnen gaan gebruiken en waarvoor.

const int btnSetspeed = 2;      // pushbutton pin om de potmeter te kunnen gebruiken
const int btnFixedspeed = 3;       // pushbutton pin om een vast waarde mee te geven aan de TIP
const int btnStop = 4;       // pushbutton pin om de vorige button, actie geactiveerd is, deze te stoppen
const int tip = 44;                // aansturing voor de tip120 

// Deze tel/counters denk ik te moeten gebruiken om de pushbuttons een waarde mee te geven, maar wellicht kan dat anders? 
// Het gaat om push buttons maar is niet de bedoeling dat men de button gedrukt moet blijven houden.


int buttonState2 = 0;         // current state of the button
int lastButtonState2 = 0;     // previous state of the button
int buttonPushCounter2 = 0;   // counter for the number of button presses
int buttonState3 = 0;         // current state of the button
int lastButtonState3 = 0;     // previous state of the button
int buttonPushCounter3 = 0;   // counter for the number of button presses
int buttonState4 = 0;         // current state of the button
int lastButtonState4 = 0;     // previous state of the button
int buttonPushCounter4 = 0;   // counter for the number of button presses
int potPin = A0;
int potValue = 0; 
int potValue1 = 0;
int potValue2 = 0; 
const int SPEED_THRESHOLD = 5;


//Hier vertellen we welke pin welke in/output hij heeft.

void setup() {

  pinMode(btnSetspeed, INPUT);
  pinMode(btnFixedspeed, INPUT);
  pinMode(btnStop, INPUT);
  pinMode(tip, OUTPUT);
}

void loop() {


  // Hier zou de activatie van de potmeter moeten komen, heb hier maar iets ingevuld omdat ik dit juist niet weet hoe het moet?
  buttonState2 = digitalRead(btnSetspeed);
  if (buttonState2 != lastButtonState2) {
    if (buttonState2 == HIGH) {
    }
 // lees de potmeter en stuur de waarde door, convert it to 0 - 255:
  potValue = analogRead(potPin) / 4;
  // stuur door naar de TIP
  analogWrite(tip, potValue);   
  }


  // Als button 2 word ingedrukt, stuur vast waarde naar de TIP
  buttonState3 = digitalRead(btnFixedspeed);
  if (buttonState3 != lastButtonState3) {
    if (buttonState3 == HIGH) {
    }
 //  stuur vaste waarde door naar de TIP
  analogWrite(tip, 30);
  }

  // Als button 3 word ingedrukt, zet alles uit
  buttonState4 = digitalRead(btnStop);
  if (buttonState4 != lastButtonState4) {
    if (buttonState4 == HIGH) {
    }
 //  stuur vaste waarde door naar de TIP
  analogWrite(tip, 0);
  }

  
  
  
}

De grootste fout die ik bij velen merk is dat ze moeite hebben om het probleem uit elkaar te trekken met als gevolg een zooitje.
Trek je het uit elkaar heb je vragen die je individueel kan behandelen.
A) is er een knop ingedrukt en zo ja welke
B) was die die ingedrukt was wel valide op dat moment?
C) als ik een valide knop heb verwerk deze.

En in de loop zal dit zo'n 10000 x / sec worden uitgevoerd

Nu de volgende vraag. Kijkend naar je code lijken de knoppen te zijn aangesloten tussen pin en Vcc. Gebruik je pull-down weerstanden om te voorkomen dat de pinnen zweven? Indien niet, dan kan het makkelijker zijn om de knoppen aan te sluiten tussen pin en GND en de pinMode te veranderen van INPUT naar INPUT_PULLUP.

PS
Lijkt me ook logisch om de namen van je state variabelen te veranderen hoewel ik vermoed dat je deze niet nodig hebt.

Nico, ja inderdaad dat zijn van die dingen waar ik nog geen ervaring mee heb, daarvoor hier op zoek naar antwoorden.
Dank je wel sterretje, dat van de weerstanden is bekend, hier ben ik ooit mee begonnen om de arduino te leren kennen en beginsels om mee te spelen, een eerder printje heb ik inderdaad weerstanden gebruikt.
Zal hem vanavond eens inladen, kijken wat hij gaat doen.

dank jullie wel

Nou het schiet al aardig op.
Vanavond ben ik nog wat gaan google en deze forum goed doorgenomen met wat voorbeelden en inmiddels werkt het al bijna zoals ik het zou willen hebben, op 1 ding na, daar krijg ik inmiddels wel een beetje punthoofd van hoor haha. Button 1, button 2 en button 3 doen wat ze horen te doen, alleen bij button 1 gaat het nog niet goed, deze btnSetspeed stuurt de potValue door op moment als ik de button indruk, hij lees de waarde en stuurt deze door naar de TIP. Dat staat ook in de code, dat begrijp ik en zo lees ik het ook.

Maar wat pas ik nu aan dat hij voortdurend de waardes door stuurt naar de TIP? Nadat ik de button heb indrukt? Denk dat dit met de press1 te maken heb maar snap het niet helemaal nog, graag tips of suggesties, hier de nieuwe code:

int btnSetspeed = 2; //button om potmeter te gebruiken
int press1 = 0;
int btnFixedspeed = 3; //button vast waarde mee te geven
int press2 = 0;
int btnStop = 4; //button om alles op 0 te zetten
int press3 = 0;
const int tip = 44;  // aansturing voor de tip120 
int potPin = A0;
int potValue = 0; 
const int SPEED_THRESHOLD = 5;



void setup()
{
  pinMode(btnSetspeed, INPUT);
  pinMode(btnFixedspeed, INPUT);
  pinMode(btnStop, INPUT);
}

void loop()

{
  press1 = digitalRead(btnSetspeed);
  if (press1 == LOW)
  {
  potValue = analogRead(potPin) / 4;
  // stuur door naar de TIP
  analogWrite(tip, potValue);
  }    

  press2 = digitalRead(btnFixedspeed);
  if (press2 == LOW)
  {
        analogWrite(tip, 100);
  }
  
  press3 = digitalRead(btnStop);
  if (press3 == LOW)
  {
        analogWrite(tip, 0);
  }

}

Hoi.

Inderdaad, zo staat het in de code.
Die code is kort.
Je kijkt of er op een knop gedrukt word, en als dat zo is dan ga je de waarde van de potmeter lezen en verwerken.
Daarna kijk je ook nog even of er op de andere knoppen gedrukt word, en dan komt de loop ten einde.
Ten einde betekent hier dat ie weer van voor af aan begint.
Omdat je dan als eerste weer opnieuw naar die knop kijkt, vergeet je dan dus hoe het daarnet met de knop stond.
Je moet onthouden of er eerder al op die knop werd gedrukt, dan kun je met dat onthouden gegeven verder werken.

Daarom moet je een extra variabele gaan gebruiken, en een extra stap in je code.
Die variabele mag klein zijn (1 bit), en kan daarom als boolean worden aangemaakt, ik noem hem voor dit voorbeeld even pressed1:

bool pressed1 = false;

Dat zet je gewoon waar je de andere variabelen ook hebt klaargezet, dan geldt ie overal in je sketch.

Daarna kun je pressed1 gaan aansturen met het resultaat van de knopdrukken.
Als knop 1 werd ingedrukt, en pressed1 is niet true, dan moet ie nu wel true worden.
Als er een andere knop werd ingedrukt, dan moet pressed1 dus false gezet worden.
Daarna kun je gaan kijken hoe het met pressed1 staat, en afhankelijk van pressed1 de potmeter inlezen en verwerken.
Nu werkt het nog steeds als je knop 1 hebt ingedrukt en weer hebt losgelaten, maar verder nog geen andere knop hebt ingedrukt.

Dit voorbeeld laat zien dat je best veel moet onthouden in je code.
Als mens doe je dat ook, maar dan onbewust (hoewel, soms vergeet je vast ook even waar je ook weer mee bezig was).
Dit is iets wat je leert als je de blink without delay sketch goed bestudeert en begrijpt (jahaa, daar heb je MAS3 weer...).

Beste MAS3,

Dank je wel voor je uitleg, ik begrijp hem een klein beetje. Wat ik denk hoe het werkt.

Doordat we als eerste het volgende mee geven:

bool press1 = false;

Dan geven we in de loop iets van het volgende mee:

Als press1 false is dan.....neem button1 niet meer me in de loop?
Of sla ik de plank nu volledig mis? Dat concreet invullen is lastig voor me, sorry.

Is hier een mooi voorbeeld van een sketch waarin bool goed uitgelegd word?
Meestal door zien snap ik deze wat beter.

Dank je wel

Ik zou het een klein beetje anders aanpakken. Gebruik een variabele die kan bijhouden welke knop is ingedrukt; deze moet globaal zijn of static zijn in loop().
Als je de eerste knop indrukt zet je de variabele op 1, voor de tweede knop op 2 etc.

Vervolgens kun je in de code deze variabele gebruiken om te bepalen wat er moet gebeuren (en niet de knop).

Dank je maar ik begrijp niet wat je daar mee bedoel

void loop()
{
  // remember the last button pressed
  static byte action = 0;

  // check the buttons
  if(digitalRead(btnSetspeed) == LOW)
  {
    action = 1;
  }
  if(digitalRead(btnFixedspeed) == LOW)
  {
    action = 2;
  }
  if(digitalRead(btnStop) == LOW)
  {
    action = 0;
  }

  // execute the action
  if(action == 1)
  {
    potValue = analogRead(potPin) / 4;
    // stuur door naar de TIP
    analogWrite(tip, potValue);
  }   

  if (action == 2)
  {
        analogWrite(tip, 100);
  }
 
  if (action == 0)
  {
        analogWrite(tip, 0);
  }
}

Voor betere leesbaarheid van de code kun je een paar #defines gebruiken

#define SETSPEED 1
#define FIXEDSPEED 2
#define STOP 0

En dan kan de code er zo uitzien

#define SETSPEED 1
#define FIXEDSPEED 2
#define STOP 0

...
...

void setup()
{
  ...
  ...
}

void loop()
{
  // remember the last button pressed
  static byte action = STOP;

  // check the buttons
  if(digitalRead(btnSetspeed) == LOW)
  {
    action = SETSPEED;
  }
  if(digitalRead(btnFixedspeed) == LOW)
  {
    action = FIXEDSPEED;
  }
  if(digitalRead(btnStop) == LOW)
  {
    action = STOP;
  }

  // execute the action
  if(action == SETSPEED)
  {
    potValue = analogRead(potPin) / 4;
    // stuur door naar de TIP
    analogWrite(tip, potValue);
  }   
  else if (action == FIXEDSPEED)
  {
        analogWrite(tip, 100);
  }
  else if (action == STOP)
  {
        analogWrite(tip, 0);
  }
}

Maakt nu ook gebruik van if / else if in plaats van wat losse 'if's. Een een switch/case is misschien nog wel mooier.

Nataschabakker:
..ik begrijp hem een klein beetje. Wat ik denk hoe het werkt...

Doordat we als eerste het volgende mee geven:

bool press1 = false;

Dan geven we in de loop iets van het volgende mee:

Als press1 false is dan.....neem button1 niet meer me in de loop?
Of sla ik de plank nu volledig mis? Dat concreet invullen is lastig voor me, sorry.

Is hier een mooi voorbeeld van een sketch waarin bool goed uitgelegd word?
Meestal door zien snap ik deze wat beter.

Hoi.

Het is altijd belangrijk om heel goed te lezen.
Dat is natuurlijk voor mij gemakkelijk gezegd, want mij gaat dat redelijk af.
Maar ik heb geen idee hoe dat voor anderen gaat.

Wat je in bovenstaande stukje verwoordt, is niet wat ik bedoelde.
Jij verandert namelijk ineens een waarde waar je al mee aan de gang was, naar een boolean.
Maar ik maakte er een extra waarde bij die een boolean is, en das wezenlijk anders.
Een boolean, ook wel bool (mag je allebei gebruiken), kan alleen waar of niet waar zijn, en is daarom maar 1 bit groot.
Dat kan je werkruimte schelen, maar dat terzijde.

Inmiddels heeft sterretje je al een stuk code toegeworpen dat ongetwijfeld zal werken op de manier hoe hij het bedacht heeft.
Wat ik bedoelde is dat je moet onthouden of er in het verleden op knop 1 werd gedrukt, want dat deed je niet en is ook het probleem dat je beschreef.
Daarvoor is het wel van belang dat je nog steeds kijkt of er op de 3 knoppen word gedrukt.
Maar als je eenmaal hebt gezien dat er op de knop 1 werd gedrukt, dan moet je telkens iets anders gaan bijhouden, je bent dan dynamisch bezig.
Daarom kijk je dus elke keer als de loop word doorlopen of er op knop 1 word gedrukt.
Als dat zo is, dan maak je de boolean waar.
En als de boolean waar is, dan ga je de potmeter lezen en de daaraan verbonden waarde naar de transistor sturen.
Als die boolean niet waar is, dan sla je dat over.

Wanneer er op knop 2 of 3 werd gedrukt, dan stel je een vaste waarde in.
Die waarde is 100 (ongeveer 40 %), of nul voor stoppen, aan de hand van jouw eigen code.
Als die eenmaal gezet is, dan hoef je die niet telkens opnieuw te zetten of bij te houden, en das dus anders dan wanneer je de analoge uitgang wil laten afhangen van waar de potmeter staat.
Dat is per definitie dus niet dynamisch.

Daarom had ik dus pressed1 bedacht, pressed1 is niet hetzelfde als press1 maar is er wel van afhankelijk.
Press is tegenwoordige tijd, pressed is verleden tijd.
Het maakt geen zier uit hoe je het noemt, als je er maar voor zorgt dat de namen niet hetzelfde zijn.
Dus als jij liever druk1 en gedrukt1 gebruikt, dan is dat geen enkel probleem.
Wanneer je nu ziet dat press1 is ingedrukt, dan maak je pressed1 dus true.
Zie je dat press2 of press3 is ingedrukt, dan maak je pressed1 false, en stel je de bij de ingedrukte knop behorende waarde in (100 of nul dus).

Daarna ga je, als pressed1 true blijkt te zijn, de potmeter uitlezen en verwerken.
De volgende keer als je door de loop heen gaat en knop 1 hebt losgelaten, dan is press1 dus niet meer actief, maar pressed1 is nog steeds actief.
Daarom zal dan nog een keer de nieuwe waarde van de potmeter worden opgehaald en verwerkt.
Tot dat er op een andere knop word gedrukt, want dan is pressed1 ineens niet meer true (en dus false).
Ik weet niet hoe ik dat beter zou kunnen uitleggen.

In het voorbeeld van sterretje (volgens zijn beschrijving), onthoud je ook of je op 1 van die andere 2 knoppen hebt gedrukt.
Daarmee kun je je code een beetje efficiënter maken, das zeker waar.
Maar dat kun je niet in een boolean stoppen, want je hebt er met 3 knoppen minimaal 2 bits voor nodig.
Dat laatste is verder niet zo heel interessant hoor.
Tijdens het typen van dit bericht meen ik me te herinneren dat je ook wilde dat je niet van stilstand naar vaste waarde kon.
Dus dan moet je wel degelijk ook bijhouden of je wel in het verleden op knop 3 hebt gedrukt.

Je vroeg ook naar een voorbeeld sketch met een boolean waarde.
Helaas kan ik je daar geen voorbeeld van aandragen, ik ken er geen die alleen dat doen.

MAS3:
Inmiddels heeft sterretje je al een stuk code toegeworpen dat ongetwijfeld zal werken op de manier hoe hij het bedacht heeft.

Uiteraard werkt dat zoals ik het bedacht heb :smiley: Maar ik heb het niet getest :wink:

MAS3:
Tijdens het typen van dit bericht meen ik me te herinneren dat je ook wilde dat je niet van stilstand naar vaste waarde kon.
Dus dan moet je wel degelijk ook bijhouden of je wel in het verleden op knop 3 hebt gedrukt.

Dat is niet hoe ik het begreep; maar dat maakt niet uit :wink: @Nataschabakker kan gemakkelijk een stukje code inbouwen om ongeldige overgangen in the 'action' te voorkomen.

Je hebt gelijk, in de 1e post staat dat de volgorde niet uit maakt.
Ik wist het niet meer zeker, maar dacht ergens gezien te hebben dat je alleen naar een vaste waarde mocht kunnen als eerst de potmeter aan de beurt was geweest.
In dat geval hoef je dus voor een correcte werking alleen bij te houden of knop 1 als laatste ingedrukt is geweest.