[Arduino] compter combien de fois on a appuyé sur une suite boutons

[Yvan_Delaserge]

Voilà le code de la machine à états. Il reste à faire le debouncing .

const byte boutonUn = 2 ;
const byte boutonDeux = 3 ;
int compteur = 0 ;
int etat = 0 ;

void setup (){
    
    pinMode(boutonUn,INPUT_PULLUP);
    pinMode(boutonDeux,INPUT_PULLUP);

    }
void loop(){
  switch (etat) {
    case 0:
      if (digitalRead(boutonUn) == LOW)
      {
       etat=1;
      }
      else if (digitalRead(boutonDeux) == LOW)
      {
       etat=3;
      }
      break;
    case 1:
      if (digitalRead(boutonDeux) == LOW)
      {
       etat=2;
      }
      break;
    case 2:
      compteur++;
      etat=0;
      break;
    case 3:
      if (digitalRead(boutonUn) == LOW)
      {
       etat=4;
      }
      break;
    case 4:
      compteur--;
      etat=0;
      break;
    }
}

-----

[mag1]

@ mag1: Comment coderais-tu ça avec un picaxe et des boucles?

Même question pour les combinaisons 1-2-1 ou 1-2-2-1?

Je pense que 1-2-2-1 :On incrémente et on décrément

Pour 1-2-1 : Normalement on incrémente, et on attend un 2

Dans l'organigramme d'état, soit on boucle sur E3, soit on retourne à E0 pour retrouver le choix de la séquence (à définir)
Les problème de rebonds étant considérés comme résolus.

Un select case probablement

MM

[mag1]

Un select case probablement
MM

C'est à dire la traduction de #31

On pourrait aussi attendre le relâchement du poussoir

MM

[invitec8cd64cb]

Voilà le code de la machine à états. Il reste à faire le debouncing .

const byte boutonUn = 2 ;
const byte boutonDeux = 3 ;
int compteur = 0 ;
int etat = 0 ;

void setup (){
    
    pinMode(boutonUn,INPUT_PULLUP);
    pinMode(boutonDeux,INPUT_PULLUP);

    }
void loop(){
  switch (etat) {
    case 0:
      if (digitalRead(boutonUn) == LOW)
      {
       etat=1;
      }
      else if (digitalRead(boutonDeux) == LOW)
      {
       etat=3;
      }
      break;
    case 1:
      if (digitalRead(boutonDeux) == LOW)
      {
       etat=2;
      }
      break;
    case 2:
      compteur++;
      etat=0;
      break;
    case 3:
      if (digitalRead(boutonUn) == LOW)
      {
       etat=4;
      }
      break;
    case 4:
      compteur--;
      etat=0;
      break;
    }
}

J'ai branché sur les broches 2 et 3, rajouté Serial.Begin(9600) et serial.print(compteur), mais ce code ne fonctionne pas,du moins,je n'arrive pas a l'utiliser.
J'ai cherché le problème ,mais la je suis perdu.

[Yvan_Delaserge]

Il reste à faire le debouncing

[Yvan_Delaserge]

En fait, je me rends compte qu'il y a un autre problème: Lorsque l'on appuie sur le second bouton, le uC passe instantanément (une boucle = quelques us) à l'état 0. Mais à ce moment-là, l'utilisateur (humain) a toujours son doigt sur le deuxième bouton.
Et donc, le uC va partir dans la boucle du côté opposé.

Pour éviter cela, il faut créer un état supplémentaire de chaque côté, dans lequel le uC va attendre que l'opérateur ait relâché le second bouton.



Voici l'organigramme. J'ai renuméroté les états pour plus de clarté.

[Yvan_Delaserge]

Et voici le soft. ça devrait aller mieux comme ça. Mais il reste toujours à faire le debouncing.

const byte boutonUn = 2 ;
const byte boutonDeux = 3 ;
int compteur = 0 ;
int etat = 0 ;

void setup (){
    
    pinMode(boutonUn,INPUT_PULLUP);
    pinMode(boutonDeux,INPUT_PULLUP);

    }
void loop(){
  switch (etat) {
    case 0:
      if (digitalRead(boutonUn) == LOW)
      {etat=1;}
      else if (digitalRead(boutonDeux) == LOW)
      {etat=4;}
    break;
    
    case 1:
      if (digitalRead(boutonDeux) == LOW)
      {etat=2;}
    break;
    
    case 2:
      if (digitalRead(boutonDeux) == HIGH)
      {etat=3;}
    break;
    
    case 3:
      compteur++;
      etat=0;
    break;
    
    case 4:
      if (digitalRead(boutonUn) == LOW)
      {etat=5;}
    break;
    
    case 5:
      if (digitalRead(boutonUn) == HIGH)
      {etat=6;}
    break;
    
    case 6:
      compteur--;
      etat=0;
    break;
    }
}

[invitec8cd64cb]

Je me disais bien aussi qu'il y avait un problème dans le code.
Sinon, que signifie debouncing?

Merci

[invite1d577638]

La gestion de l'anti-rebond !

[Yvan_Delaserge]

Et voilà avec le debouncing. Ce n'est pas une mince affaire. C'est ce qui prend le plus de lignes de code!
Il y a moyen de faire plus court, mais c'est moins didactique.

#define boutonUnOn (digitalRead (boutonUn)==0) //  actif à 0V
#define boutonUnOff (digitalRead (boutonUn)==1) //  actif à 5V
#define boutonDeuxOn (digitalRead (boutonDeux)==0) //  actif à 0V
#define boutonDeuxOff (digitalRead (boutonDeux)==1) //  actif à 5V

const byte boutonUn = 2 ;
const byte boutonDeux = 3 ;
int compteur = 0 ;
int etat = 0 ;
int PremLectBoutUn=LOW;
int PremLectBoutDeux=LOW;
int SecLectBoutUn=LOW;
int SecLectBoutDeux=LOW;
int BoutUnStable=LOW;
int BoutDeuxStable=LOW;

void setup (){
    
    pinMode(boutonUn,INPUT_PULLUP);
    pinMode(boutonDeux,INPUT_PULLUP);

    }
void loop(){
  //pour gérer les rebonds des contacts (debouncing)
  //on va lire les deux boutons deux fois à un
  //intervalle de 1 ms. Si la valeur est la même les deux fois
  //on en conclut qu'il ne s'agit pas d'un rebond
  //donc le bouton est dans un état stable
 if (boutonUnOn)
      {PremLectBoutUn = HIGH;}
      else
      {PremLectBoutUn = LOW;}
 if (boutonDeuxOn) 
      {PremLectBoutDeux = HIGH;}
      else
      {PremLectBoutDeux = LOW;}
      
      delay(1);
 //seconde lecture, une milliseconde plus tard     
 if (boutonUnOn)
      {SecLectBoutUn = HIGH;}
      else
      {SecLectBoutUn = LOW;}
 if (boutonDeuxOn) 
      {SecLectBoutDeux = HIGH;}
      else
      {SecLectBoutDeux = LOW;}  
  
  //on compare les deux lectures    

 if (PremLectBoutUn == HIGH && SecLectBoutUn == HIGH) 
      {BoutUnStable = HIGH;}
 if (PremLectBoutUn == LOW && SecLectBoutUn == LOW) 
      {BoutUnStable = LOW;}
      
 if (PremLectBoutDeux == HIGH && SecLectBoutDeux == HIGH) 
      {BoutDeuxStable = HIGH;}
 if (PremLectBoutDeux == LOW && SecLectBoutDeux == LOW) 
      {BoutDeuxStable = LOW;}     
  
  
  switch (etat) {
    case 0:
      if (BoutUnStable == HIGH)
      {etat=1;}
      else if (BoutDeuxStable == HIGH)
      {etat=4;}
    break;
    
    case 1:
      if (BoutDeuxStable == HIGH)
      {etat=2;}
    break;
    
    case 2:
      if (BoutDeuxStable == LOW)
      {etat=3;}
    break;
    
    case 3:
      compteur++;
      etat=0;
    break;
    
    case 4:
      if (BoutUnStable == HIGH)
      {etat=5;}
    break;
    
    case 5:
      if (BoutUnStable == LOW)
      {etat=6;}
    break;
    
    case 6:
      compteur--;
      etat=0;
    break;
    }
}

[mag1]

Bonjour,

Avec ce code et un picaxe, il ne devrait pas y avoir de problème de rebonds (à vérifier...)

symbol pous1	=pinC.3
symbol pous2	=pinC.4
symbol etat		=b1
symbol compte	=b2
	etat=0
	pullup %11000
	Do
			select etat
		case 0
			if pous1=0 then
				do loop while pous1=0
				etat=1
			elseif pous2=0 then
				do loop while pous2=0
				etat=2
			endif
		case 1
			if pous2=0 then
				do loop while pous2=0
				inc compte
				etat=0
			elseif pous1=0 then
				etat=0
			endif
		case 2
			if pous1=0 then
				do loop while pous1=0
				dec compte
				etat=0
			elseif pous2=0 then
				etat=0
			endif
		end select
		if compte >254 then
			 compte=0 ;pour ne pas passer en négatif
		endif
		serout C.0,N2400,(254,1,254,128,"compte= ",#compte)
	loop

MM