Amélioration de la réactivité de mes boutons.

Bonjour
Je suis débutant dans l'utilisation de C++, je l'utilise pour programmer ma carte arduino. Jusqu'à présent, je modifiais très légérement les scripts que je trouvais sur le net mais cette fois ci j'ai réalisé un script assez consequent.

Mon projet est de piloter 4 appareils numériques grace a des télécommandes filaires MCDC2 que j'ai démonté pour pouvoir gérer le tout avec arduino.

J'ai rajouté 2 modes de fonctionnement:

  • Mode manuel avec pour le déclenchement un bouton focus/shoot que l'utilisateur doit appuyer

  • Mode automatique ou la, la prise de photo se fait automatiquement avec un intervalle entre 2 photos que l'utilisateur peut modifier avec un bouton vitesse (4 vitesses possibles que l'utilisateur peut voir avec 4 leds)

//  Définition des constantes
 
const int boutonModeM = 2;      // crée un identifiant pour la broche utilisée avec le bouton mode manuel
const int boutonModeA = 3;      // crée un identifiant pour la broche utilisée avec le bouton mode auto
const int boutonShoot = 4;      // crée un identifiant pour la broche utilisée avec le bouton shoot
const int boutonVitesse = 5;    // crée un identifiant pour la broche utilisée avec le bouton vitesse
const int focus = 8;            // crée un identifiant pour la broche utilisée pour le focus
const int shoot = 9;            // crée un identifiant pour la broche utilisée pour le shoot
const int ledPin1 = 10;         // crée un identifiant pour la broche utilisée avec la LED
const int ledPin2 = 11;         // crée un identifiant pour la broche utilisée avec la LED
const int ledPin3 = 12;         // crée un identifiant pour la broche utilisée avec la LED
const int ledPin4 = 13;         // crée un identifiant pour la broche utilisée avec la LED
 
// Les variables sont modifiées au cours du programme
int boutonModeMState = 0;        //Variable pour l'état actuel du bouton Mode Manuel
int lastboutonModeMState = 0;    // Variable pour l'état précédent du bouton Mode Manuel
int boutonModeAState = 0;        //Variable pour l'état actuel du bouton Mode Auto
int lastboutonModeAState = 0;    // Variable pour l'état précédent du bouton Mode Auto
int boutonShootState = 0;        //Variable pour l'état actuel du bouton Shoot
int lastboutonShootState = 0;    // Variable pour l'état précédent du bouton Shoot
int boutonVitesseState = 0;      //Variable pour l'état actuel du bouton Vitesse
int lastboutonVitesseState = 0;  // Variable pour l'état précédent du bouton Vitesse
int boutonVitesseCounter = 0;    // variable pour le comptage du nombre d'appuis sur le bouton vitesse
int val = 1000;                  // temps entre 2 photos en mode Automatique soit 1s
 
void setup() {
  // mettre les broches en entrée
  pinMode(boutonModeM, INPUT);
  pinMode(boutonModeA, INPUT);
  pinMode(boutonShoot, INPUT);
  pinMode(boutonVitesse, INPUT);
 // mettre les broches en sortie
  pinMode(ledPin1, OUTPUT);
  pinMode(ledPin2, OUTPUT);
  pinMode(ledPin3, OUTPUT);
  pinMode(ledPin4, OUTPUT);
  pinMode(focus, OUTPUT);  
  pinMode(shoot, OUTPUT);
  // initialise la communication série
  Serial.begin(9600);
}
 
 
void loop() {
  // lit l'état actuel des boutons et les mémorise dans une variable
  boutonModeMState = digitalRead(boutonModeM);
  boutonModeAState = digitalRead(boutonModeA);
  boutonShootState = digitalRead(boutonShoot);
  boutonVitesseState = digitalRead(boutonVitesse);
 
  // MODE MANUEL
  // compare l'état actuel du bouton poussoir à l'état précédent mémorisé
  if (boutonModeMState != lastboutonModeMState ) {
    // si l'état du bouton poussoir a changé et est HAUT, on incrémente la variable de comptage
    if (boutonModeMState == HIGH) {
      // si l'état actuel du bouton est HAUT
      // il est passé de BAS à HAUT
           Serial.println("Mode Manuel");
                                  }
 else {
      // si le bouton courant est BAS
      // il est passé de HAUT à BAS :
      Serial.println("Pas d'appui");
      }
  }
   // PRISE DE PHOTOS
    if (boutonShootState != lastboutonShootState) {
      if (boutonModeMState == HIGH && boutonShootState == HIGH) {
      Serial.println("Prise photo");
      digitalWrite(focus, HIGH);   // turn the LED on (HIGH is the voltage level)
      delay(500);                  // wait for a second
      digitalWrite(shoot, HIGH);   // turn the LED off by making the voltage LOW
      delay(100);                  // wait for a second
      digitalWrite(focus, LOW);    // turn the LED on (HIGH is the voltage level)
      digitalWrite(shoot, LOW);    // turn the LED off by making the voltage LOW
    }
}   
  // MODE AUTOMATIQUE
  // compare l'état actuel du bouton poussoir à l'état précédent mémorisé
  if (boutonModeAState != lastboutonModeAState) {
    // si l'état du bouton poussoir a changé et est HAUT, on incrémente la variable de comptage
    if (boutonModeAState == HIGH) {
      // si l'état actuel du bouton est HAUT
      // il est passé de BAS à HAUT
            Serial.print("Mode Auto");
}
 else {
      // si le bouton courant est BAS
      // il est passé de HAUT à BAS :
      Serial.println("Pas d'appui");
    }
}
  // REGLAGE VITESSE PHOTOS
  if (boutonVitesse != lastboutonVitesseState) {
   
      if (boutonModeAState == HIGH && boutonVitesseState == HIGH) {
      Serial.println("Reglage vitesse");
      boutonVitesseCounter++;
      Serial.println(boutonVitesseCounter, DEC);
    }
}
 
switch (boutonVitesseCounter) 
{
   case 1 :
    // traitement si 1 appui
    digitalWrite(ledPin1, HIGH); // allume la LED 1 
    Serial.println("LEd 1");
    Serial.println(val);
break ;

   case 2 :
    // traitement si 2 appuis
    digitalWrite(ledPin2, HIGH); // allume la LED 2 
    Serial.println("LEd 2");
    Serial.println(val);
break ;

   case 3 :
// traitement si 3 appuis
    digitalWrite(ledPin3, HIGH); // allume la LED 3 
    Serial.println("LEd 3");
    Serial.println(val);
break ;

   case 4 :
// traitement si 4 appuis
   digitalWrite(ledPin4, HIGH); // allume la LED 4 
   Serial.println("LEd 4");
   Serial.println(val);
break ;

  case 5 :
// traitement si 5 appuis
Serial.println("Remise à zéro");
digitalWrite(ledPin4, LOW); // eteint la LED 4
digitalWrite(ledPin3, LOW); // eteint la LED 3
digitalWrite(ledPin2, LOW); // eteint la LED 2
boutonVitesseCounter = 1;
break ;
      
default :
// traitement si aucun bouton n'a été utilisé
break ;
}
   
  // PRISE DE PHOTOS avec Val comme délai entre 2 photos
  val = boutonVitesseCounter * 1000;
  digitalWrite(focus, HIGH);   // turn the LED on (HIGH is the voltage level)
  delay(500);               // wait for a second
  digitalWrite(shoot, HIGH);    // turn the LED off by making the voltage LOW
  delay(100);               // wait for a second
  digitalWrite(focus, LOW);   // turn the LED on (HIGH is the voltage level)
  digitalWrite(shoot, LOW);    // turn the LED off by making the voltage LOW
  delay(val);
 
    //mémorise l'état courant du bouton poussoir
    //pour les prochains passages dans la boucle loop
    lastboutonModeMState = boutonModeMState;
    lastboutonModeAState = boutonModeAState;
    lastboutonShootState = boutonShootState;
    lastboutonVitesseState = boutonVitesseState;
     
  }

l'appui sur les boutons est parfois lent à être détecter. Dans mon cablage, j'ai pourtant utilisé un montage avec une résistance pull-down pour chaque bouton utilisé.

Est ce possible d'améliorer ce comportement de boutons? Ou de faire mieux et plus simple (enfin plus simple mais faut que j'arrive à le comprendre ensuite don c pas trop de contraction dans les formules?)

Merci beaucoup pour votre aide.

Un poussoir c'est mécanique, ça à des rebonds.
As tu un condensateur câblé en parallèle sur chaque contact de bouton ?

Non mais dans mon cablage, j'ai utilisé une résistance pull-down pour chaque bouton utilisé.

goodsayan:
...

l'appui sur les boutons est parfois lent à être détecter. Dans mon cablage, j'ai pourtant utilisé un montage avec une résistance pull-down pour chaque bouton utilisé.

Est ce possible d'améliorer ce comportement de boutons? Ou de faire mieux et plus simple (enfin plus simple mais faut que j'arrive à le comprendre ensuite don c pas trop de contraction dans les formules?)

Merci beaucoup pour votre aide.

bonjour
le delai de prise encompte des boutons est surement du à l'utilisation de delay() qui est une fonction bloquante

Si je prends uniquement la partie manuelle de mon programme

//  Définition des constantes

const int boutonModeM = 2;      // crée un identifiant pour la broche utilisée avec le bouton mode manuel
const int boutonShoot = 4;      // crée un identifiant pour la broche utilisée avec le bouton shoot
const int focus = 8;            // crée un identifiant pour la broche utilisée pour le focus
const int shoot = 9;            // crée un identifiant pour la broche utilisée pour le shoot

// Les variables sont modifiées au cours du programme
int boutonModeMState = 0;        //Variable pour l'état actuel du bouton Mode Manuel
int lastboutonModeMState = 0;    // Variable pour l'état précédent du bouton Mode Manuel
int boutonShootState = 0;        //Variable pour l'état actuel du bouton Shoot
int lastboutonShootState = 0;    // Variable pour l'état précédent du bouton Shoot

void setup() {
  // mettre les broches en entrée
  pinMode(boutonModeM, INPUT);
  pinMode(boutonShoot, INPUT);

 // mettre les broches en sortie
  pinMode(focus, OUTPUT);   
  pinMode(shoot, OUTPUT);
  // initialise la communication série
  Serial.begin(9600);
}


void loop() {
  // lit l'état actuel des boutons et les mémorise dans une variable
  boutonModeMState = digitalRead(boutonModeM);
  boutonShootState = digitalRead(boutonShoot);

  // MODE MANUEL
  // compare l'état actuel du bouton poussoir à l'état précédent mémorisé
  if (boutonModeMState != lastboutonModeMState ) {
    // si l'état du bouton poussoir a changé et est HAUT, on incrémente la variable de comptage
    if (boutonModeMState == HIGH) {
      // si l'état actuel du bouton est HAUT
      // il est passé de BAS à HAUT
           Serial.println("Mode Manuel");
                                  }
 else {
      // si le bouton courant est BAS
      // il est passé de HAUT à BAS :
      Serial.println("Pas d'appui");
      }
  }
   // PRISE DE PHOTOS
      if (boutonModeMState == HIGH && boutonShootState == HIGH) {
      Serial.println("Prise photo");
      void prisedephoto();
    } 
   }
   
void prisedephoto () {
digitalWrite(focus, HIGH);   // turn the LED on (HIGH is the voltage level)
delay(500);               // wait for a second
digitalWrite(shoot, HIGH);    // turn the LED off by making the voltage LOW
delay(100);               // wait for a second
digitalWrite(focus, LOW);   // turn the LED on (HIGH is the voltage level)
digitalWrite(shoot, LOW);    // turn the LED off by making the voltage LOW 
}

L'appui sur le bouton shoot est très réactif. C'est quand je rajoute la partie automatique que les appuis sont lents à être détecté. Ce que je ne comprends pas puisque la partie automatique ne devrait être lu par le programme que si le bouton mode est en automatique...
Je pense plutot a un probleme de construction dans mon script.
En mode manuel: surveillance du bouton shoot > si oui prendre photo
En mode auto: prise de photos toutes les X secondes mais avec une surveillance du bouton vitesse
Merci

goodsayan:
Non mais dans mon cablage, j'ai utilisé une résistance pull-down pour chaque bouton utilisé.

Oui mais :grin: si tu as des rebonds tu relances l'action du bouton autant de fois qu'il y a de rebonds
Même si les rebonds ne te paraissent pas être la cause principale, tu ne peux pas exclure que le fait de relancer l'action du bouton sous l'effet des rebonds relance les delay() bloquants autant de fois qu'il y a de rebonds.

Alors autant travailler avec un montage sain pour ne pas ajouter de la confusion à la confusion.

En survolant le code comme ça on se rend déjà compte qu'il manque des choses. Un bouton typiquement et basiquement se gère comme ça (en supposant une résistance de pull-up et bouton au GND) :

if(digitalRed(MonBouton)==LOW) {

// code

while(digitalRed(MonBouton)==LOW); // on boucle tant que le bouton n'est pas relâché
delay(50); // on attend que les perturbations (rebonds) passent et que la situation soit stable
}

goodsayan:
L'appui sur le bouton shoot est très réactif. C'est quand je rajoute la partie automatique que les appuis sont lents à être détecté. Ce que je ne comprends pas puisque la partie automatique ne devrait être lu par le programme que si le bouton mode est en automatique...
Je pense plutot a un probleme de construction dans mon script.
En mode manuel: surveillance du bouton shoot > si oui prendre photo
En mode auto: prise de photos toutes les X secondes mais avec une surveillance du bouton vitesse
Merci

rapidement reagrdé ton code
mais ça c'est il me semble effectué à chaque tour de boucle loop
tu a donc un delai mini bloquant de 500+100+ n*1000 ms

 // PRISE DE PHOTOS avec Val comme délai entre 2 photos
  val = boutonVitesseCounter * 1000;
  digitalWrite(focus, HIGH);   // turn the LED on (HIGH is the voltage level)
  delay(500);               // wait for a second
  digitalWrite(shoot, HIGH);    // turn the LED off by making the voltage LOW
  delay(100);               // wait for a second
  digitalWrite(focus, LOW);   // turn the LED on (HIGH is the voltage level)
  digitalWrite(shoot, LOW);    // turn the LED off by making the voltage LOW
  delay(val);

68tjs:

goodsayan:
Non mais dans mon cablage, j'ai utilisé une résistance pull-down pour chaque bouton utilisé.

Oui mais :grin: si tu as des rebonds tu relances l'action du bouton autant de fois qu'il y a de rebonds
Même si les rebonds ne te paraissent pas être la cause principale, tu ne peux pas exclure que le fait de relancer l'action du bouton sous l'effet des rebonds relance les delay() bloquants autant de fois qu'il y a de rebonds.

Alors autant travailler avec un montage sain pour ne pas ajouter de la confusion à la confusion.

Je comprends. Peux tu me dire comment cabler le condensateur et quelle valeur prendre?

@B@tto et Artouste. Merci pour vos conseils.
Je vais essayer de modifier tout ca. Comme j'utilise un bouton (mode A ou M dans mon script) à 3 positions. Je vais faire le reglage de la vitesse lorsque ni le mode A ou M n'est enclenché. Ca permettra en automatique de ne pas etre ralenti par les délais si on veut changer la vitesse.

Valeur 100nF. Avec des poules-machins de 10 kohms le couple est gagnant .
Emplacement :
Je te joins un schéma (réalisé avec gschem de la suite open source Geda).

C'est une version "ceinture + bretelles" dans le sens où la résistance R2 de 100 ohms n'est généralement pas câblée.
Elle n'est là que pour mémoire et pour les cas difficiles.
Elle a deux rôles : protection et amortissement du circuit dans le cas de fils très longs entre le contact et le micro.

Anti_rebond.png

Super merci!
Chez moi, le fil avec R2 de 100 ohms sera connecté sur une entrée digitale de l'arduino pour détecter l'appui sur l'interupteur.

ok j'ai rajouté des condensateurs.

Par contre, au niveau du programme je me rend chèvre!!! J'ai décidé de simplifier pour pouvoir mieux comprendre les problèmes.
J'ai donc fait 3 parties, manuel/automatique/reglage vitesse.

1ere partie: MANUEL Cette partie fonctionne comme je veux.

//  Définition des constantes

const int boutonModeM = 2;      // Pin pour le bouton mode manuel
const int boutonShoot = 4;      // Pin pour le bouton shoot
const int focus = 8;            // Pin pour le focus
const int shoot = 9;            // Pin pour le shoot

// Les variables sont modifiées au cours du programme
int boutonModeMState = 0;        // Variable pour l'état actuel du bouton Mode Manuel
int lastboutonModeMState = 0;    // Variable pour l'état précédent du bouton Mode Manuel
int boutonShootState = 0;        // Variable pour l'état actuel du bouton Shoot
int lastboutonShootState = 0;    // Variable pour l'état précédent du bouton Shoot

void setup() {
  // mettre les broches en entrée
  pinMode(boutonModeM, INPUT);
  pinMode(boutonShoot, INPUT);

  // mettre les broches en sortie
  pinMode(focus, OUTPUT);   
  pinMode(shoot, OUTPUT);

  // initialise la communication série
  Serial.begin(9600);
}

void loop() {
  // lit l'état actuel des boutons et les mémorise dans une variable
  boutonModeMState = digitalRead(boutonModeM);
  boutonShootState = digitalRead(boutonShoot);

  // MODE MANUEL
  // compare l'état actuel du bouton mode à l'état précédent mémorisé
  if (boutonModeMState != lastboutonModeMState ) {     // si l'état du bouton poussoir a changé
    if (boutonModeMState == HIGH) {       // si l'état actuel du bouton est HAUT
           Serial.println("Mode Manuel");
                                  }
 	  }

   // PRISE DE PHOTOS
    if (boutonShootState != lastboutonShootState) {
      if (boutonModeMState == HIGH && boutonShootState == HIGH) {
      Serial.println("Prise photo");
      digitalWrite(focus, HIGH);   // Met la broche focus a HIGH
      delay(500);                  // wait for a second
      digitalWrite(shoot, HIGH);   // Met la broche shoot a HIGH
      delay(100);                  // wait for a second
      digitalWrite(focus, LOW);    // Met la broche focus a LOW
      digitalWrite(shoot, LOW);    // Met la broche shoot a LOW
    } 
}    
      //mémorise l'état courant du bouton poussoir pour les prochains passages dans la boucle loop
    lastboutonModeMState = boutonModeMState;
    lastboutonShootState = boutonShootState;  
    
  }

2eme partie: Automatique. Cette partie fonctionne comme je veux.

//  Définition des constantes

const int boutonModeA = 3;      // Pin pour le bouton mode auto
const int focus = 8;            // Pin pour le focus
const int shoot = 9;            // Pin pour le shoot

// Les variables sont modifiées au cours du programme

int boutonModeAState = 0;        // Variable pour l'état actuel du bouton Mode Auto
int lastboutonModeAState = 0;    // Variable pour l'état précédent du bouton Mode Auto
int val = 1000;                  // temps entre 2 photos en mode Automatique soit 1s

void setup() {
  // mettre les broches en entrée
  pinMode(boutonModeA, INPUT);

 // mettre les broches en sortie
  pinMode(focus, OUTPUT);   
  pinMode(shoot, OUTPUT);

  // initialise la communication série
  Serial.begin(9600);
}

void loop() {
  // lit l'état actuel des boutons et les mémorise dans une variable
  boutonModeAState = digitalRead(boutonModeA);
  
  // MODE AUTOMATIQUE
  // compare l'état actuel du bouton mode à l'état précédent mémorisé
  if (boutonModeAState != lastboutonModeAState) {     // si l'état du bouton poussoir a changé 
    while (boutonModeAState == HIGH) {       // si l'état actuel du bouton est HAUT          
           Serial.println("Mode Auto");
           Serial.println("Prise de photo");
           digitalWrite(focus, HIGH);   // Met la broche focus a HIGH
           delay(500);                  // wait for a second
           digitalWrite(shoot, HIGH);   // Met la broche shoot a HIGH
           delay(100);                  // wait for a second
           digitalWrite(focus, LOW);    // Met la broche focus a LOW
           digitalWrite(shoot, LOW);    // Met la broche shoot a LOW
           delay(val); //Val délai entre 2 photos
           digitalRead(boutonModeA);
                                     }
  }
  
   //mémorise l'état courant des boutons pour les prochains passages dans la boucle loop
    lastboutonModeAState = boutonModeAState;
  }

3eme partie: Vitesse
Il reste la partie reglage de la vitesse mais la je sais pas si c'est la fatigue mais ca ne fonctionne pas du tout comme je veux.
Mon interrupteur a 3 positions je vais donc m'en servir comme cela Auto/Vitesse/Manuel.

Voici mon dernier essai

//  Définition des constantes

const int boutonModeM = 2;      // Pin pour le bouton mode manuel
const int boutonModeA = 3;      // Pin pour le bouton mode auto
const int boutonVitesse = 5;    // Pin pour le bouton vitesse
const int ledPin1 = 10;         // Pin pour la LED
const int ledPin2 = 11;         // Pin pour la LED
const int ledPin3 = 12;         // Pin pour la LED
const int ledPin4 = 13;         // Pin pour la LED

// Les variables sont modifiées au cours du programme
int boutonModeMState = 0;        // Variable pour l'état actuel du bouton Mode Manuel
int lastboutonModeMState = 0;    // Variable pour l'état précédent du bouton Mode Manuel
int boutonModeAState = 0;        // Variable pour l'état actuel du bouton Mode Auto
int lastboutonModeAState = 0;    // Variable pour l'état précédent du bouton Mode Auto
int boutonVitesseState = 0;      // Variable pour l'état actuel du bouton Vitesse
int lastboutonVitesseState = 0;  // Variable pour l'état précédent du bouton Vitesse
int boutonVitesseCounter = 0;    // variable pour le comptage du nombre d'appuis sur le bouton vitesse
int val = 1000;                  // temps entre 2 photos en mode Automatique soit 1s

void setup() {
  // mettre les broches en entrée
  pinMode(boutonModeM, INPUT);
  pinMode(boutonModeA, INPUT);
  pinMode(boutonVitesse, INPUT);

 // mettre les broches en sortie
  pinMode(ledPin1, OUTPUT);
  pinMode(ledPin2, OUTPUT);
  pinMode(ledPin3, OUTPUT);
  pinMode(ledPin4, OUTPUT);

  // initialise la communication série
  Serial.begin(9600);
}

void loop() {
  // lit l'état actuel des boutons et les mémorise dans une variable
  boutonModeMState = digitalRead(boutonModeM);
  boutonModeAState = digitalRead(boutonModeA);
  boutonVitesseState = digitalRead(boutonVitesse);
   
 // MODE REGLAGE VITESSE
  // compare l'état actuel du bouton poussoir à l'état précédent mémorisé
  if (boutonModeAState == LOW && boutonModeMState == LOW) {
        Serial.println("Mode reglage");
                if (boutonVitesseState != lastboutonVitesseState) {
                  if (boutonVitesse == HIGH) {
                           Serial.print("Changement de vitesse");
            boutonVitesseCounter++;
	    vitesse (val);
            Serial.println(boutonVitesseCounter, DEC);
                }
                } 
}
    //mémorise l'état courant des bouton pour les prochains passages dans la boucle loop
    lastboutonModeMState = boutonModeMState;
    lastboutonModeAState = boutonModeAState;
    lastboutonVitesseState = boutonVitesseState;  
  
}

// Definition de la fontion vitesse qui allume des leds en fonction du nombre d'appui
int vitesse (int val) {
switch (boutonVitesseCounter) {
   case 1 :
    // traitement si 1 appui
    digitalWrite(ledPin1, HIGH); // allume la LED 1 
    Serial.println("LEd 1");
    val = 1000;
    Serial.println(val);
break ;
   case 2 :
    // traitement si 2 appuis
    digitalWrite(ledPin2, HIGH); // allume la LED 2 
    Serial.println("LEd 2");
    val = 2000;
    Serial.println(val);
break ;
   case 3 :
// traitement si 3 appuis
    digitalWrite(ledPin3, HIGH); // allume la LED 3 
    Serial.println("LEd 3");
    val = 3000;
    Serial.println(val);
break ;
   case 4 :
// traitement si 4 appuis
   digitalWrite(ledPin4, HIGH); // allume la LED 4 
   Serial.println("LEd 4");
   val = 4000;
   Serial.println(val);
break ;
  case 5 :
// traitement si 5 appuis
Serial.println("Remise à zéro");
digitalWrite(ledPin4, LOW); // eteint la LED 4
digitalWrite(ledPin3, LOW); // eteint la LED 3
digitalWrite(ledPin2, LOW); // eteint la LED 2
boutonVitesseCounter = 1;
val = 1000;
break ;
  default :
// traitement si aucun appui n'a été fait
break ; 
return val;} 
}

La l'appui sur le bouton vitesse ne fonctionne pas. Je rentre juste en mode reglage vitesse. J'ai du faire une betise mais je la vois.
Si quelqu'un veut bien jeter un oeil sur cette dernière partie? SInon je reprendrais tout ca demain.

Merci

bonjour à tous,

J'ai trouvé un exemple "interagir avec les leds" sur openclasroom qui ressemble à ce que je veux faire. J'ai donc adapté le code que voici:

/* déclaration des constantes pour les nom des broches ; ceci selon le schéma*/
const int boutonModeM = 2;
const int boutonModeA = 3;
const int boutonVitesse = 7;
const int ledPin1 = 10;
const int ledPin2 = 11;
const int ledPin3 = 12;
const int ledPin4 = 13;

/* déclaration des variables utilisées pour le comptage et le décomptage */
int boutonVitesseCounter = 1; //le nombre qui sera incrémenté
int boutonModeMState; //lecture de l'état du bouton mode
int lastboutonModeMState; 
int boutonModeAState; //lecture de l'état du bouton mode
int lastboutonModeAState;
int boutonVitesseState = LOW; //état LOW par défaut
int lastboutonVitesseState = LOW;

/* initilisation des broches en entrée/sortie */
void setup()
{
  // mettre les broches en entrée
  pinMode(boutonModeM, INPUT);
  pinMode(boutonModeA, INPUT);
  pinMode(boutonVitesse, INPUT);

 // mettre les broches en sortie
  pinMode(ledPin1, OUTPUT);
  pinMode(ledPin2, OUTPUT);
  pinMode(ledPin3, OUTPUT);
  pinMode(ledPin4, OUTPUT);

  // initialise la communication série
  Serial.begin(9600);
}

void loop()
{
   //lecture de l'état du bouton mode
   boutonModeMState = digitalRead(boutonModeM);
   boutonModeAState = digitalRead(boutonModeA);	
   boutonVitesseState = digitalRead(boutonVitesse);
   
   //Si le bouton mode n'est ni en mode manuel ni en mode auto et bouton vitesse appuyé
   if ((boutonModeMState == LOW) && (boutonModeAState == LOW) && (boutonVitesseState != lastboutonVitesseState))
   {
	Serial.println("Mode reglage");
	boutonVitesseCounter++;
   }
 
   //mémorise l'état courant des boutons pour les prochains passages dans la boucle loop
    lastboutonModeMState = boutonModeMState;
    lastboutonModeAState = boutonModeAState;
    lastboutonVitesseState = boutonVitesseState; 

   //on applique une limite au nombre pour ne pas dépasser 4
   if (boutonVitesseCounter > 4)
   {
      boutonVitesseCounter = 1;
   }
  
   //appel de la fonction affiche() que l'on aura créée. On lui passe en paramètre la valeur du nombre de LED à éclairer
   affiche(boutonVitesseCounter); 
}

void affiche(int valeur_recue)
{
    //on éteint toutes les leds sauf la 1
    digitalWrite(ledPin2, LOW);
    digitalWrite(ledPin3, LOW);
    digitalWrite(ledPin4, LOW);
    //Puis on les allume une à une
    if(valeur_recue >= 1)
    {
        digitalWrite(ledPin1, HIGH);
    }
    if(valeur_recue >= 2)
    {
        digitalWrite(ledPin2, HIGH);
    }
    if(valeur_recue >= 3)
    {
        digitalWrite(ledPin3, HIGH);
    }
    if(valeur_recue >= 4)
    {
        digitalWrite(ledPin4, HIGH);
    }
}

Cela fonctionne presque... Par rapport à l'exemple, la led 1 est toujours allumée chez moi, c'est voulu. Cela signifie que la vitesse est de 1.
Lorsque j'appuie une fois sur le bouton, la led 2 et très rapidement la 3 s'allume...
Si j'appuie une seconde fois, la led 4 s'allume puis s'éteint quasiment tout de suite et seul la led 1 reste allumée...
On dirait que la carte recoit deux appuis chaque fois.
Je ne comprends pas pourquoi car j'ai mis un condensateur de 100nF, une resistance pull-down de 10ko entre l'interrupteur est la masse ainsi qu'une resistance de 100 ohms sur le pin de l'arduino ou est branché l'interrupteur. J'ai essayé avec un autre interrupteur c'est la même chose.
Comment regler cela?
Merci

C'est normal ... Regarde mon précédent post

De tous les exemples que j'ai vu, et sur celui "interagir avec les leds" aucun n'utilise cette manière de faire...
Je vais tester cependant.