Problema con programmazione

Salve a tutti, ho un problema riguardante la programmazione(premetto che sono i miei primi approcci con arduino UNO) Con l'utilizzo di 3 pulsanti devo comandare 2 led,con il primo pulsante i 2 led devono rimanere accesi per poi spegnersi una volta che viene ripremuto il pulsante, con il secondo pulsante i led devono lampeggiare ( si accende il primo led,si spegne il secondo per poi ripetersi il contrario) per poi spegnersi quando viene premuto il pulsante, mentre con il 3 pulsante i led devono lampeggiare insieme, per capirci devono accendersi e spegnere allo stesso tempo, per poi spegnersi ancora quando viene premuto il pulsante.

Grazie a tutti per l'eventuale attenzione e l'aiuto che fornirete. Mi scuso anche per la domanda banale ma non riesco a risolvere questo problema,ho letto anche su google varie guide ma nessuna di reale utilizzo per il mio problema.

#define analog0 A0
#define analog1 A1
#define analog2 A2

#define led0 12
#define led1 11


int statoLed0 = 0;
int statoLed1 = 0;
int Valore = 0; // per conservare lo stato del pin di input (pulsante)
int Stato = 0; // per conservare lo stato del led
int OldStato = 1;// per effettuare l’autoritenuta del pulsante salvando lo stato precedente



void setup()
{
    pinMode( analog0, INPUT );
    pinMode( analog1, INPUT );
    pinMode( analog2, INPUT );

    pinMode( led0, OUTPUT );
    pinMode( led1, OUTPUT );
   

    digitalWrite( led0, statoLed0 );
    digitalWrite( led1, statoLed1 );
    
}

void loop()
{

  if ( analogRead(analog0) > 1000 )
  {
    if ( statoLed0 == LOW  ) statoLed0 = HIGH;
    else                     statoLed0 = LOW;
    digitalWrite( led0, statoLed0 );
    digitalWrite( led1, statoLed1);
  }

  if ( analogRead(analog1) > 1000 )
  {
    if ( statoLed1 == LOW  ) statoLed1 = HIGH;
    else                     statoLed1 = LOW;
    digitalWrite( led0, HIGH );
    delay(200);
    digitalWrite( led0, LOW );
    delay(200);
    digitalWrite( led1,HIGH);
    delay(200);
    digitalWrite( led1,LOW);
    delay(200);
  }

  if ( analogRead(analog2) > 1000 )
  {
   if ((Valore == HIGH) && (Stato ==0) && (OldStato == 1) )   statoLed1 = HIGH; statoLed0 = HIGH;
    digitalWrite( led0, statoLed0 );
    delay(200);
    digitalWrite( led1,statoLed1 );
    delay(200);
  }
  if ((Valore == 0) && (Stato == 1) && (OldStato == 1)) { //  controlla che l’input sia 0 (pulsante NON premuto = LOW ) se lo Stato del led è spento ( 0 ) e lo stato prencedente del led era acceso (0)
OldStato = 0; }
if ((Valore == 0) && (Stato == 0) && (OldStato == 0)) { //  controlla che l’input sia 0 (pulsante NON premuto = LOW ) se lo Stato del led è spento ( 0 ) e lo stato prencedente del led era acceso (0)
OldStato = 1; } // => 0-1 modifica il OldState (il vecchio stato) su 1

}

Ciao, essendo il tuo primo post, ti chiederei cortesemente di presentarti QUI (spiegando bene quali conoscenze hai di elettronica e di programmazione ... possibilmente evitando di scrivere solo una riga di saluto) e di leggere con attenzione il REGOLAMENTO ... Grazie.

Guglielmo

... relativamente al tuo programma ... stai mischiando letture digitali ed analogiche ...

Se è vero che un qualsiasi pin analogico di Arduino può essere usato anche come pin digitale e quindi usato nella dichiarazione :

pinMode( analog0, INPUT );

... è anche vero che questo significa voler usare quel pin come DIGITALE (... altrimenti la pinMode() diventa inutile) e quindi successivamente leggerlo con:

digitalRead(analog0);

... e non con funzioni per la lettura analogica (analogRead()).

Comincia quindi a riscrivere il tuo codice in modo "congruo" e poi vediamo perché non va (... che, oltretutto, ti semplifichi anche la vita).

Guglielmo

P.S.: Ma con tanti pin SOLO digitali ... perché sprecare tre pin che possono funzionare in analogico per leggere dei bottoni che, tipicamente, si leggono come digitali ? ? ? :o

Ti ringrazio per la tua risposta tempestiva,provvederò a riscrivere il codice . Non ho capito cosa vuole intendere con il p.s.

Ti ringrazio per avermi inviato il link per presentarmi,non lo trovavo.

... intendo dire che, visto che devi leggere dei "bottoni" e che hai tanti pin che possono essere SOLO digitali, non capisco perché "sprecare" dei pin che possono essere anche "analogici" (... ed in futuro magari potrebbero servirti), quando, appunto, bastano i pin digitali (D2 ... D13) ;) |500x328 Guglielmo

Non solo, i pin analogici sono collegati internamente a convertitori ADC. Per usarli come pin digitali, nel codice vanno inserite istruzioni addizionali, che inserisce il compilatore per te in modo trasparente, ma fanno allungare il codice finale inutilmente e non è buona tecnica di programmazione.

E poi, come dice Guglielmo, un pulsante è per definizione digitale, può cioè essere solo premuto, o no, quindi assumere solo due stati. Un ingresso analogico, se a 10 bit, può assumere 2 elevato alla decima valori diversi. Usarlo come pin digitale è uno spreco.

Magari in futuro vorrai aggiungere anche la lettura di una tensione derivante da un partitore resistivo e quello lo farai realizzando un ADC discreto su un pin digitale, perché avrai già usato gli ingressi analogici per leggere i pulsanti... :)

Perché funzioni un pulsante su un pin digitale devi mttere una resistenza pulup o pulldown o devi attivare il pullup interno e collegare il pulsante tra entrata e massa.
Ciao Uwe

Questo è il codice che ho creato,ho inserito il Serial.print per verificare se i pulsanti quando vengono premuti valgono 1. Comunque dopo tutto ciò i led non rispondono ai ''comandi'' del pulsante,in poche parole se premo lo stato dei led non cambia. Chiedo quindi aiuto a voi che siete mooolto più esperti di me,quali sono gli errori nel codice? Oppure è un errore nel montaggio del circuito? Grazie.

const int pulsante0 = 3;
const int pulsante1 = 6;
const int pulsante2 =  5;

int led0 = 12;
int led1 = 11;
int val= 0 ;
int val1 = 0;
int val2 = 0;
int stato =0;
int stato1 =0;
int stato2=0;
int numpushbutton0=0;
int numpushbutton1=0;
int numpushbutton2=0;


void setup()
{
    pinMode( pulsante0, INPUT );
    pinMode( pulsante1, INPUT );
    pinMode( pulsante2, INPUT );

    pinMode( led0, OUTPUT );
    pinMode( led1, OUTPUT );
    Serial.begin(9600);
   
}

void loop()
{
  val = digitalRead (pulsante0);
  val1 = digitalRead (pulsante1);
  val2 = digitalRead (pulsante2);

  if(val==1){
    stato=1-stato;
    delay(300);
    
  }

if ( stato == 1 ){
   
    digitalWrite( led0, HIGH   );
    digitalWrite( led1, HIGH );
    numpushbutton0++;
    Serial.println("on");
    Serial.print("number of button pushes:  ");
    Serial.println(numpushbutton0, DEC);
  }


   if(val1==1){
    stato1=1-stato1;
    delay(300);
  }
  
  if ( stato1 == 1 )
  {
   
    digitalWrite( led0, HIGH );
    delay(200);
    digitalWrite( led0, LOW );
    delay(200);
    digitalWrite( led1,HIGH);
    delay(200);
    digitalWrite( led1,LOW);
    delay(200);
     numpushbutton1++;
    Serial.println("on");
    Serial.print("number of button pushes:  ");
    Serial.println(numpushbutton1, DEC);
  }


 if(val2=1){
    stato2=1-stato2;
    delay(300);
  }

  if ( stato2 == 1)
  {
   
    digitalWrite( led0, HIGH );
    delay(200);
    digitalWrite( led1,HIGH );
    delay(200);
     numpushbutton2++;
    Serial.println("on");
    Serial.print("number of button pushes:  ");
    Serial.println(numpushbutton2, DEC);
  }


   if(stato==0 && stato1==0 && stato2==0){
    digitalWrite(led0,LOW);
    digitalWrite(led1,LOW);
    Serial.println("off");
  }


  

}

Vi allego anche il monitor seriale

on
number of button pushes:  1
off
on
number of button pushes:  2
off
on
number of button pushes:  3
off
on
number of button pushes:  4
off
on
number of button pushes:  5
off
on
number of button pushes:  6
off
on
number of button pushes:  7
off
on
number of button pushes:  8
off
on
number of button pushes:  9
off
on
number of button pushes:  10
off
on
number of button pushes:  11
off
on
number of button pushes:  12
off
on
number of button pushes:  13
off
on
number of button pushes:  14
off
on
number of button pushes:  15
off
on
number of button pushes:  16
off
on
number of button pushes:  17
off
on
number of button pushes:  18
off
on
number of button pushes:  19
off
on
number of button pushes:  20
off
on
number of button pushes:  21
off
on
number of button pushes:  22
off
on
number of button pushes:  23
off

Clicco il pulsante una volta e mi fa un on/off all'infinito.

Devi suddividere i problemi, per far ciò ti conviene creare delle funzioni.

#define LED0_P 12
#define LED1_P 11
#define BUTTON0_P 3
#define BUTTON1_P 6
#define BUTTON2_P 5

//invertire a LOW se il pulsante quando premuto va a massa.
#define BUTTON_LOGIC HIGH
#define DEBOUNCE_TIME 80


#define TIME_BLINK 500

uint8_t buttonPress(uint8_t pin)
{
    if ( digitalRead(pin) != BUTTON_LOGIC ) return 0;
    delay(DEBOUNCE_TIME);
    if ( digitalRead(pin) != BUTTON_LOGIC ) return 0;
    while( digitalRead(pin) == BUTTON_LOGIC);
    return 1;
}

void led0Blink(void)
{
    while( buttonPress(BUTTON0_P) == 0 )
    {
        digitalWrite(LED0_P,HIGH);
        delay(TIME_BLINK);
        digitalWrite(LED0_P,LOW);
        delay(TIME_BLINK);
    }
}

void ledSwap(void)
{
    while( buttonPress(BUTTON1_P) == 0 )
    {
        digitalWrite(LED0_P,HIGH);
        digitalWrite(LED1_P,LOW);
        delay(TIME_BLINK);
        digitalWrite(LED0_P,LOW);
        digitalWrite(LED1_P,HIGH);
        delay(TIME_BLINK);
    }
    digitalWrite(LED1_P,LOW);
}

void allLedBlink(void)
{
    while( buttonPress(BUTTON2_P) == 0 )
    {
        digitalWrite(LED0_P,HIGH);
        digitalWrite(LED1_P,HIGH);
        delay(TIME_BLINK);
        digitalWrite(LED0_P,LOW);
        digitalWrite(LED1_P,LOW);
        delay(TIME_BLINK);
    }
}

void setup(void)
{
    pinMode(LED0_P,OUTPUT);
    pinMode(LED1_P,OUTPUT);
    pinMode(BUTTON0_P,INPUT);
    pinMode(BUTTON1_P,INPUT);
    pinMode(BUTTON2_P,INPUT);
}

void loop(void)
{
    if( buttonPress(BUTTON0_P) == 1 )
    {
        led0Blink();
    }
    if ( buttonPress(BUTTON1_P) == 1 )
    {
        ledSwap();
    }
    if ( buttonPress(BUTTON2_P) == 1 )
    {
        allLedBlink();
    }
}

il codice proposto è stato scritto dal cellulare senza un reale controllo e vuole essere solo un esempio su come si dovrebbe strutturare il codice al fine di semplificarne la stesura.

uwefed: Perché funzioni un pulsante su un pin digitale devi mettere una resistenza pulup o pulldown o devi attivare il pullup interno e collegare il pulsante tra entrata e massa. Ciao Uwe

Ripeto il mio suggerimento. Ciao Uwe

DigitalRead() da come risultato LOW o HIGH, non un valore numerico.

Inoltre stai usando variabili a 16 bit (32 su alcuni Arduino) per leggere byte. Hanno inventato il tipo dati "byte" apposta.

#define BUTTON 3                                    // pin di input a cui è collegato il pulsante  
#define LED1 12                                     // LED collegato al pin digitale 13  
#define LED2 11                                     // LED collegato al pin digitale 12  
#define LED3 10                                     // LED collegato al pin digitale 11  
#define BUTTON1 6 
#define BUTTON2 5                                       
  
// Variabili  
int ContatorePulsantePremuto = 0;                   // conta il numero di volte che il pulsante è premuto buttonPushCounter   
int StatoPulsante = 0;                              // stato corrente del pulsante  
int StatoPulsantePrecedente = 0;                    // stato precedente del pulsante  
int ContatorePulsantePremuto1 = 0;                   // conta il numero di volte che il pulsante è premuto buttonPushCounter   
int StatoPulsante1 = 0;                              // stato corrente del pulsante  
int StatoPulsantePrecedente1 = 0;                    // stato precedente del pulsante
int ContatorePulsantePremuto2 = 0;                   // conta il numero di volte che il pulsante è premuto buttonPushCounter   
int StatoPulsante2 = 0;                              // stato corrente del pulsante  
int StatoPulsantePrecedente2 = 0;                    // stato precedente del pulsante
void setup() {  
  pinMode(BUTTON, INPUT);                           // imposta il pin digitale come input  
  pinMode(LED1, OUTPUT);                            // imposta il pin digitale come output  
  pinMode(LED2, OUTPUT);                            // imposta il pin digitale come output  
  pinMode(LED3, OUTPUT);                            // imposta il pin digitale come output  
  pinMode(BUTTON1, INPUT);
  pinMode(BUTTON2, INPUT);                              
  Serial.begin(9600);                               // apre la porta seriale e la inizzializza a 9600 bps  
}  
  
void loop() {  
  StatoPulsante = digitalRead(BUTTON);              // legge il valore dell'input e lo conserva  
  StatoPulsante1 = digitalRead(BUTTON1);
  StatoPulsante2 = digitalRead(BUTTON2);
  if (StatoPulsante != StatoPulsantePrecedente) {   // compara lo stato del pulsante attuale con il precedente  
    if (StatoPulsante == HIGH) {                    // se lo stato è cambiato incrementa il contatore  
      // se lo stato corrente è alto, il pulsante è passato da off a on  
      ContatorePulsantePremuto++;  
       if (StatoPulsante1 != StatoPulsantePrecedente1) {   // compara lo stato del pulsante attuale con il precedente  
    if (StatoPulsante1 == HIGH) {                    // se lo stato è cambiato incrementa il contatore  
      // se lo stato corrente è alto, il pulsante è passato da off a on  
      ContatorePulsantePremuto1++; 
       if (StatoPulsante2 != StatoPulsantePrecedente2) {   // compara lo stato del pulsante attuale con il precedente  
    if (StatoPulsante2 == HIGH) {                    // se lo stato è cambiato incrementa il contatore  
      // se lo stato corrente è alto, il pulsante è passato da off a on  
      ContatorePulsantePremuto2++; 
  
      switch ((ContatorePulsantePremuto) && (ContatorePulsantePremuto1) && (ContatorePulsantePremuto2)) {  
      case 1:  // controlla se il pulsante è stato premuto una volta  
        Serial.println("on");                                // stampa sulla console "on"  
        Serial.print("numero di volte tasto premuto:  ");    // stampa sulla console "numero di volte tasto premuto:"  
        Serial.println(ContatorePulsantePremuto, DEC);       // stampa il numero di volte che il pulsante è stato premuto  
        digitalWrite(LED1, HIGH);                            // accende il LED1    
        digitalWrite(LED2, HIGH);
        Serial.println("off");                               // stampa sulla console "off"  
        break;  
      case 2:  // controlla se il pulsante è stato premuto due volte  
        Serial.println("on");                                // stampa sulla console "on"  
        Serial.print("numero di volte tasto premuto:  ");    // stampa sulla console "numero di volte tasto premuto:"  
        Serial.println(ContatorePulsantePremuto1, DEC);       // stampa il numero di volte che il pulsante è stato premuto  
         digitalWrite( LED1, HIGH );
         delay(200);
         digitalWrite( LED1, LOW );
         delay(200);
         digitalWrite( LED2,HIGH);
         delay(200);
         digitalWrite( LED2,LOW);
         delay(200);                            
                                       
        Serial.println("off");                               // stampa sulla console "off"  
        break;  
      case 3:  // controlla se il pulsante è stato premuto tre volte  
        Serial.println("on");                                // stampa sulla console "on"  
        Serial.print("numero di volte tasto premuto:  ");    // stampa sulla console "numero di volte tasto premuto:"  
        Serial.println(ContatorePulsantePremuto2, DEC);       // stampa il numero di volte che il pulsante è stato premuto  
        digitalWrite( LED1, HIGH );
        delay(200);
        digitalWrite( LED2,HIGH );
        delay(200);                                
        Serial.println("off");                               // stampa sulla console "off"  
        break;  
      case 4:  // controlla se il pulsante è stato premuto quattro volte  
        Serial.println("on");                                // stampa sulla console "on"  
        Serial.print("numero di volte tasto premuto:  ");    // stampa sulla console "numero di volte tasto premuto:"  
        Serial.println(ContatorePulsantePremuto, DEC);       // stampa il numero di volte che il pulsante è stato premuto  
        digitalWrite(LED1, LOW);                             // spegne il LED1  
        digitalWrite(LED2, LOW);                             // spegne il LED 2
        digitalWrite(LED3, HIGH);                             // accende il LED3  
        Serial.println("off");                               // stampa sulla console "off"  
        break;  
      }  
    }   
  } 
    }
       }
    }
  }
  
  // salva lo stato corrente nella variabile che indica lo stato precedente per il loop successivo   
  StatoPulsantePrecedente = StatoPulsante;  
   StatoPulsantePrecedente1 = StatoPulsante1;
    StatoPulsantePrecedente2 = StatoPulsante2;
  
  // controlla se il pulsante è stato premuto quattro volte se vero indica che è finito il ciclo  
  // il led lampeggia 2 volte per 50 millisecondi  
  // vengono inizializzate nuovamente le variabili  
  // si riavvia il ciclo  
  
  if (ContatorePulsantePremuto > 4) {  
    Serial.println("fine ciclo");                            // stampa sulla console "fine ciclo"  
    digitalWrite(LED3, LOW);                                 // spegne il LED3     
    for (int x=0; x<5; x++) {                                // ciclo di accensione e spegnimento led  
      for (int n=10; n<14; n++) {                            // ciclo sui diodi da accendere e spegnere  
        digitalWrite(n, HIGH);                               // accende il LED    
        delay(50);                                           // aspetta 50 millisecondi    
        digitalWrite(n, LOW);                                // spegne il LED    
        delay(50);                                           // aspetta 50 millisecondi  
      }  
    }  
    // inizializzazione delle variabili  
    ContatorePulsantePremuto = 0;  
    StatoPulsante = 0;  
    StatoPulsantePrecedente = 0;  
    ContatorePulsantePremuto1 = 0;  
    StatoPulsante1 = 0;  
    StatoPulsantePrecedente1 = 0;
    ContatorePulsantePremuto2 = 0;  
    StatoPulsante2 = 0;  
    StatoPulsantePrecedente2 = 0;
    Serial.println("mi riavvio");                            // stampa sulla console "mi riavvio"  
  }  
 
}

Ma mi da come errore questo

warning: case label value exceeds maximum value for type [enabled by default]

       case 4:  // controlla se il pulsante è stato premuto quattro volte  

            ^

Lo stesso per il caso 2 e 3
Se levo lo statoPulsantePrecendente2/1 e tutto ciò che riguarda gli altri due pulsanti il programma funziona perfettamente,solo ché , nel caso 2 ad esempio, clicco il pulsante ed i led lampeggiano solo una volta, riclicco e passano al caso 3, se volessi far durare il lampeggiamento all’infinito finchè non riclicco il pulsante come dovrei fare?Spero di essermi spiegato bene :confused:

e-person: DigitalRead() da come risultato LOW o HIGH, non un valore numerico.

Quindi dovrei usare analogRead() ? Mentre sapete dirmi a cosa è dovuto quell'errore?

l'errore te lo da perché la condizione che hai messo nello switch da un risultato booleano, quindi o vero (TRUE - 1) o false (FALSE - 0). i valori 2, 3 e 4 non rientrano nella casistica possibile.

l'operatore && è l'and logico e restituisce vero se entrambi gli operandi sono veri, falso altrimenti.

Come potrei risolvere questo problema?

porta pazienza ma non ho ben capito cosa vuoi fare... hai 3 bottoni e 3 led. poi?

Hai ragione mi sono spiegato anche male io.
Allora ho 3 bottoni e 2 LED (il 3 posso anche non metterlo volendo)

-Il primo bottone alla sua pressione deve tenermi accesi 2 LED,quando viene ricliccato devono spegnersi.
-Il secondo bottone alla sua pressione deve farmi lampeggiare i 2 LED,quando viene ricliccato devono spegnersi.

-Il terzo bottone alla sua pressione deve farmi accendere e spegnere in modo contemporaneo i 2 LED , in poche parole si accendono insieme e si spengono insieme,quando viene ricliccato il pulsante devono spegnersi

Poichè con i 3 bottoni non riuscivo a comandare i led ho provato con un bottone solo, il risultato è stato che tutto funzionava solo che quando premevo il pulsante e doveva farmi lampeggiare i LED,lo faceva ma solo per una volta,poi passava al caso 3 ed al caso 4

Ti riporto il secondo codice con cui ho provato questo che ti ho appena spiegato

#define BUTTON 3                                    // pin di input a cui è collegato il pulsante  
#define LED1 12                                     // LED collegato al pin digitale 13  
#define LED2 11                                     // LED collegato al pin digitale 12  
#define LED3 10                                     // LED collegato al pin digitale 11  
                                     // LED collegato al pin digitale 10  
  
// Variabili  
int ContatorePulsantePremuto = 0;                   // conta il numero di volte che il pulsante è premuto buttonPushCounter   
int StatoPulsante = 0;                              // stato corrente del pulsante  
int StatoPulsantePrecedente = 0;                    // stato precedente del pulsante  
  
void setup() {  
  pinMode(BUTTON, INPUT);                           // imposta il pin digitale come input  
  pinMode(LED1, OUTPUT);                            // imposta il pin digitale come output  
  pinMode(LED2, OUTPUT);                            // imposta il pin digitale come output  
  pinMode(LED3, OUTPUT);                            // imposta il pin digitale come output  
                              // imposta il pin digitale come output  
  Serial.begin(9600);                               // apre la porta seriale e la inizzializza a 9600 bps  
}  
  
void loop() {  
  StatoPulsante = digitalRead(BUTTON);              // legge il valore dell'input e lo conserva  
  
  if (StatoPulsante != StatoPulsantePrecedente) {   // compara lo stato del pulsante attuale con il precedente  
    if (StatoPulsante == HIGH) {                    // se lo stato è cambiato incrementa il contatore  
      // se lo stato corrente è alto, il pulsante è passato da off a on  
      ContatorePulsantePremuto++;  
  
      switch (ContatorePulsantePremuto) {  
      case 1:  // controlla se il pulsante è stato premuto una volta  
        Serial.println("on");                                // stampa sulla console "on"  
        Serial.print("numero di volte tasto premuto:  ");    // stampa sulla console "numero di volte tasto premuto:"  
        Serial.println(ContatorePulsantePremuto, DEC);       // stampa il numero di volte che il pulsante è stato premuto  
        digitalWrite(LED1, HIGH);                            // accende il LED1    
        digitalWrite(LED2, HIGH);
        Serial.println("off");                               // stampa sulla console "off"  
        break;  
      case 2:  // controlla se il pulsante è stato premuto due volte  
        Serial.println("on");                                // stampa sulla console "on"  
        Serial.print("numero di volte tasto premuto:  ");    // stampa sulla console "numero di volte tasto premuto:"  
        Serial.println(ContatorePulsantePremuto, DEC);       // stampa il numero di volte che il pulsante è stato premuto  
         digitalWrite( LED1, HIGH );
         delay(200);
         digitalWrite( LED1, LOW );
         delay(200);
         digitalWrite( LED2,HIGH);
         delay(200);
         digitalWrite( LED2,LOW);
         delay(200);                            
                                       
        Serial.println("off");                               // stampa sulla console "off"  
        break;  
      case 3:  // controlla se il pulsante è stato premuto tre volte  
        Serial.println("on");                                // stampa sulla console "on"  
        Serial.print("numero di volte tasto premuto:  ");    // stampa sulla console "numero di volte tasto premuto:"  
        Serial.println(ContatorePulsantePremuto, DEC);       // stampa il numero di volte che il pulsante è stato premuto  
        digitalWrite( LED1, HIGH );
        delay(200);
        digitalWrite( LED2,HIGH );
        delay(200);                                
        Serial.println("off");                               // stampa sulla console "off"  
        break;  
      case 4:  // controlla se il pulsante è stato premuto quattro volte  
        Serial.println("on");                                // stampa sulla console "on"  
        Serial.print("numero di volte tasto premuto:  ");    // stampa sulla console "numero di volte tasto premuto:"  
        Serial.println(ContatorePulsantePremuto, DEC);       // stampa il numero di volte che il pulsante è stato premuto  
        digitalWrite(LED1, LOW);                             // spegne il LED1  
        digitalWrite(LED2, LOW);                             // spegne il LED 2
        digitalWrite(LED3, HIGH);                             // accende il LED3  
        Serial.println("off");                               // stampa sulla console "off"  
        break;  
      }  
    }   
  }  
  
  // salva lo stato corrente nella variabile che indica lo stato precedente per il loop successivo   
  StatoPulsantePrecedente = StatoPulsante;  
  
  // controlla se il pulsante è stato premuto quattro volte se vero indica che è finito il ciclo  
  // il led lampeggia 2 volte per 50 millisecondi  
  // vengono inizializzate nuovamente le variabili  
  // si riavvia il ciclo  
  
  if (ContatorePulsantePremuto > 4) {  
    Serial.println("fine ciclo");                            // stampa sulla console "fine ciclo"  
    digitalWrite(LED3, LOW);                                 // spegne il LED3     
    for (int x=0; x<5; x++) {                                // ciclo di accensione e spegnimento led  
      for (int n=10; n<14; n++) {                            // ciclo sui diodi da accendere e spegnere  
        digitalWrite(n, HIGH);                               // accende il LED    
        delay(50);                                           // aspetta 50 millisecondi    
        digitalWrite(n, LOW);                                // spegne il LED    
        delay(50);                                           // aspetta 50 millisecondi  
      }  
    }  
    // inizializzazione delle variabili  
    ContatorePulsantePremuto = 0;  
    StatoPulsante = 0;  
    StatoPulsantePrecedente = 0;  
    Serial.println("mi riavvio");                            // stampa sulla console "mi riavvio"  
  }  
}

void loop() { boolean bottone1=false, bottone2=false, bottone3=false;

[... omissis (che non è una istruzione) ...]

if (DigitalRead(xyz1)==HIGH) bottone1=true; else if (DigitalRead(xyz2)==HIGH) bottone2=true; else if [... omissis ...]

[... omissis ...]

if (bottone1) { fai quello che devi fare; bottone1=false; }

[omissis]

}

sono esterefatto...... nel linguaggio C/C++, ma spesso non solo qui, il tipo booleano può assumere due valori, false e true, false vale 0 e true vale !false indipercui tutto ciò che non è zero è vero. Secondo digitalRead ritorna 0 o 1 a seconda se il livello logico è 0v o 5v, per semplificare il core Arduino espone due macro istruzioni chiamate HIGH e LOW che valgono rispettivamente 0 e 1. Detto questo 1==HIGH==TRUE , 0==LOW==FALSE.

Ora ti invito a rispondere alla domanda di uwefed e magari potresti ispirarti al codice che ti ho proposto.