Réaction game- le temps ne se calcul pas

Bonjour,

je suis totalement debutant en programmation arduino;
je travaille sur un projet perso.

OBJECTIF:
je souhaiterais faire un jeu de reaction arduino.
Lorsque la LED verte s'allume on appuie sur un bouton et PAF! le temps de reaction s'affiche sur un LCD 16x2 ET ça ainsi de suite pendant 1min ou plusieurs cycle. puis affichage de la moyenne des temps.

PROBLEME:
Le programme de compile bien, mon cablage m'a l'air logique,
mais le l'ecran affiche toute les millisecondes jusqu'a ce que j'appui sur le bouton ( là le chrono s'arrete puis repart de zero, la Led s'eteint)
et avant cela, il affiche directement 0.00 sur la première boucle avant que j'appuie :o

je souhaite seulement affiché: "reaction time" puis " XXX.XX sec"

quelqu'un aurait la solution svp? un indice ? :confused:

ci joint mon programme et une image du cablage (proteus 8, Arduino UNO)

```
**// OBJECTIF ALLUMER 1 LED EN DELAY ALEATOIRE;
// AFFICHER LE TEMPS DE REACTION "BOUTON PRESSE/LED ALLUME" (SUR 1MIN OU 20 CYCLES).

//PARAMETRAGE LED
#define led1 10

//PARAMETRAGE ECRAN LCD 16X2
#include <LiquidCrystal.h>      // inclusion de la bibliothèque
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);  // Initialisation de la bibliothèque par rapport au cablage

//PARAMETRAGE DU BOUTON
int boutontouch =  8;    // Bouton pour reaction

void setup() {

// EXPLICATION TEXTE DU PROGRAMME ................................................

lcd.begin(16, 2);              // réglage du nombre de ligne et de colonne
 lcd.print("SPEED TEST"); // Affiche un message
 delay(1000);
 lcd.clear();
 lcd.print("SI LED ALLUME");
 lcd.setCursor(0, 1);
 lcd.print("APPUYEZ");
 delay(1000);
 lcd.clear();

}
void loop() {

//LED1 comme OUTPUT
 pinMode(led1, OUTPUT);

//Boutontouch comme INPUT
 pinMode(boutontouch, INPUT);

//nombre aléatoire generator
 randomSeed(millis());

//Attendre un temps aléatoire entre 1 et 3 secondes
 delay(random(100, 1000));

//Allumer la led1
 digitalWrite(led1, HIGH);

//Enregistrer le temps de depart ( allumage led1)
 long start = millis();

//attendre tant le bouton ( boutontouch pin8) n'est pas fermé
 while (digitalRead(8))

//Afficher le temps
   // lcd.print("Reaction time");
   // lcd.setCursor(0, 1);
   lcd.print((millis() - start) / 1000.0);
 delay(1000);
 lcd.clear();
 digitalWrite(led1, LOW);
 delay(100);
}**
```

y'a un smiley à lunette dans votre code, faut s'en méfier, il a dû manger un point virgule à la fin de la ligne....


blague à part (enfin pas une blague car c'est votre bug) corrigez votre post ci dessus et rajoutez les code tags autour du code:
[code]`` [color=blue]// votre code ici[/color] ``[/code].

ça doit ressembler à cela:// votre code ici
(faites aussi ctrl-T (PC) or cmd-T (Mac) dans l'IDE avant de copier le code pour qu'il soit indenté correctement --> ça vous aurait donné une petit indication sur votre souci)

PS: vous feriez mieux de capturer le temps juste après appui du bouton, là vous mesurez après avoir demandé

  lcd.print("Reaction time");
  lcd.setCursor(0, 1);

ce qui prend un peu de temps

Bonjour JML,

merci des conseils, en effet c'est mieux, je connaissais pas ^^
message modifié, ci dessus :slight_smile:

mais je vois toujours la ligne

  //attendre tant le bouton ( boutontouch pin8) n'est pas fermé
  while (digitalRead(8))

qui semble pas bien terminée...

À ok, j'ai compris ce que vous voulez dire.
Faut que je reecrive à partir de while (digitalRead(8)) je pense

Je ferais sa demain.
Mais mon problème sera toujours d'actu ^^

Bonne soirée

Non ... il manque juste un point virgule à la fin de cette ligne...

C’est pour faire une attente active sur cette condition: tant que la pin 8 est HIGH, on ne fait rien et on attend -> il faut une instruction vide après le while sinon c’est l’instruction suivante qui est prise et ici c’est le lcd.print((millis() - start) / 1000.0);

Bonjour,

Du coup j'ai corrigé comme vous m'avez dit,
et après le test sur proteus tout fonctionne correctement !

mon probleme venait juste du point virgule ?! :o

Merci du coup!

// OBJECTIF ALLUMER 1 LED EN DELAY ALEATOIRE;
// AFFICHER LE TEMPS DE REACTION "BOUTON PRESSE/LED ALLUME" (SUR 1MIN OU 20 CYCLES).

//PARAMETRAGE LED
#define led1 10

//PARAMETRAGE ECRAN LCD 16X2
#include <LiquidCrystal.h>      // inclusion de la bibliothèque
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);  // Initialisation de la bibliothèque par rapport au cablage

//PARAMETRAGE DU BOUTON
int boutontouch =  8;    // Bouton pour reaction


void setup() {

  // EXPLICATION TEXTE DU PROGRAMME ................................................

  lcd.begin(16, 2);              // réglage du nombre de ligne et de colonne
  lcd.print("SPEED TEST"); // Affiche un message
  delay(1000);
  lcd.clear();
  lcd.print("SI LED ALLUME");
  lcd.setCursor(0, 1);
  lcd.print("APPUYEZ");
  delay(1000);
  lcd.clear();

}
void loop() {


  //LED1 comme OUTPUT
  pinMode(led1, OUTPUT);

  //Boutontouch comme INPUT
  pinMode(boutontouch, INPUT);

  //nombre aléatoire generator
  randomSeed(millis());

  //Attendre un temps aléatoire entre 1 et 3 secondes
  delay(random(100, 1000));

  //Allumer la led1
  digitalWrite(led1, HIGH);

  //Enregistrer le temps de depart ( allumage led1)
  long start = millis();


  //attendre tant le bouton ( boutontouch pin8) n'est pas fermé
  while (digitalRead(8));

  //Afficher le temps
  lcd.print("Reaction time");
  lcd.setCursor(0, 1);
  lcd.print((millis() - start) / 1000.0);
  delay(1000);
  lcd.clear();
  digitalWrite(led1, LOW);
  delay(100);
}

BigReinhardt:
mon probleme venait juste du point virgule ?! :o

oui... comme quoi la syntaxe est importante...

vous auriez pu vous en rendre compte en regardant l'indentation du programme (appuyez sur ctrl-T)

sinon il est généralement bien vu de mettre des commentaires en rapport avec le code :slight_smile:

  //Attendre un temps aléatoire entre 1 et 3 secondes
  delay(random(100, 1000));

millis() retourne un unsigned long. si vous stockez cela dans un long (signé), dans 25 jours environ vous allez vous retrouver avec un nombre négatif... (si vous laissez l'arduino branché)

   //Enregistrer le temps de depart ( allumage led1)
  long start = millis();

comme dit plus haut, vous pénalisez le joueur car vous insérez des instructions avant de mesurer le temps

//Afficher le temps
  lcd.print("Reaction time");
  lcd.setCursor(0, 1);
  lcd.print((millis() - start) / 1000.0);

faites plutôt

//Afficher le temps
  unsigned long tempsFinal = millis() - start;
  lcd.print("Reaction time");
  lcd.setCursor(0, 1);
  lcd.print(tempsFinal / 1000.0, 3); // le ,3 pour trois chiffres après la virgule si vous voulez

Bonjour,

OK j'ai corrigé en suivant vos conseils et tout fonctionne.
il me reste plusieurs chose à ajouter avant de finaliser mon petit jeu.

J'ai une dernière question: j'ai arreté la boucle après 1min ecoulé,
et j'aimerais afficher la moyenne des temps (à la fin de la minute ecoulé)
il y a un moyen d'enregistrer les temps pour en faire la moyenne ?

PS: Oui j'ecris pleins de commentaires parce que j'apprends en autodidacte et ça me permet de me servir de mes programmes précédemment ecrit comme cours/ressources ^^

merci pour le detail de vos reponses, c'est très clair.

  //Enregistrer le temps de depart ( allumage led1)
  unsigned long start = millis();

  //attendre tant le bouton ( boutontouch pin8) n'est pas fermé
  while (digitalRead(8));

  //Afficher le temps
  unsigned long tempsFinal = millis() - start;
  lcd.print("Reaction time");
  lcd.setCursor(0, 1);
  lcd.print(tempsFinal / 1000.0, 3); // le ,3 pour trois chiffres après la virgule si vous voulez
  delay(1000);
  lcd.clear();
  digitalWrite(led1, LOW);
  delay(100);

  if (millis() > 1 * 60000UL)
    while (1);          // le programme est arrêté

}

BigReinhardt:
PS: Oui j'ecris pleins de commentaires parce que j'apprends en autodidacte et ça me permet de me servir de mes programmes précédemment ecrit comme cours/ressources ^^

les commentaires c'est bien mais c'est encore mieux quand ils décrivent vraiment ce que fait le code. c'était mon point ci dessus car la commande

delay(random(100, 1000));

n'attends pas "un temps aléatoire entre 1 et 3 secondes"... donc si vous mettez des commentaires, assurez vous de leur justesse, sinon ils ne servent à rien.

j'ai arreté la boucle après 1min ecoulé,
et j'aimerais afficher la moyenne des temps (à la fin de la minute ecoulé)
il y a un moyen d'enregistrer les temps pour en faire la moyenne ?

oui bien sûr. dans la pratique vous pourriez avoir envie de rejouer, non ? --> donc au lieu d'arrêter la loop laissez la recommencer après un appui sur le bouton par exemple

const byte led1 = 10;
const byte pinBouton = 8;
const unsigned long dureeDuJeu = 60000UL; // 60 secondes

#include <LiquidCrystal.h>      // inclusion de la bibliothèque
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);  // Initialisation de la bibliothèque par rapport au cablage


void setup()
{
  lcd.begin(16, 2);
  ...
}

void loop()
{
  //Enregistrer le temps de depart ( allumage led1)
  unsigned long tempsDebut;
  unsigned long cumulDesTemps = 0;
  unsigned long nombreDeTentatives = 0;

  randomSeed(millis());

  while (digitalRead(pinBouton) == HIGH);  //attendre tant le bouton n'est pas appuyé
  tempsDebut = millis();

  while (millis() - tempsDebut <= dureeDuJeu) {
    // ici faire un jeu de plus
    delay(random(100, 1000));    //Attendre un temps aléatoire entre 100ms et 1 secondes
    digitalWrite(led1, HIGH);  //Allumer la led1
    unsigned long startLed = millis();    //Enregistrer le temps de depart ( allumage led1)
    while (digitalRead(pinBouton) == HIGH);  //attendre tant le bouton n'est pas appuyé
    //Afficher le temps
    unsigned long tempsCourant = millis() - startLed;
    digitalWrite(led1, LOW);
    cumulDesTemps += tempsCourant;
    nombreDeTentatives++;
    lcd.clear();
    lcd.print("Temps : ");
    lcd.print(tempsCourant / 1000.0);
    lcd.print(" s  "); // pour effacer s'il y a des caractères en trop
  }

  //Afficher le temps moyen
  lcd.clear();
  lcd.print("Temps Moyen :");
  lcd.setCursor(0, 1);
  if (nombreDeTentatives == 0) {
    // je vous laisse trouver ce qu'on affiche :)
  } else {
    // je vous laisse trouver ce qu'on affiche :)
  }

  // ici on remonte au début de la loop et donc on va attendre pour recommencer le jeu
}

j'ai tapé ça ici, donc peut être des bugs et il manque du code, je vous laisse compléter :slight_smile:

re,bonjour.

du coup, j'ai ajouté ce que vous m'avez dit plus haut,
tout fonctionne très bien !!

c'est pas finalisé mais les principales difficultées sont passées je pense,
merci à vous! je reviendrais^^

PS:pour le moment j'ai pas mis de bouton pour relancer le loop, je ferais sa dans la finalisation. :slight_smile:

code fonctionnel ci dessous:

// OBJECTIF ALLUMER 1 LED EN DELAY ALEATOIRE;
// AFFICHER LE TEMPS DE REACTION "BOUTON PRESSE/LED ALLUME" 

//PARAMETRAGE LED/BOUTON & DUREE
const byte led1 = 10;
const byte pinBouton = 8;
const unsigned long dureeDuJeu = 10000UL; // 60 secondes

//PARAMETRAGE ECRAN LCD 16X2
#include <LiquidCrystal.h>      // inclusion de la bibliothèque
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);  // Initialisation de la bibliothèque par rapport au cablage

void setup() {

  // EXPLICATION .............................................

  lcd.begin(16, 2);              // réglage du nombre de ligne et de colonne
  lcd.print("SPEED TEST"); // Affiche un message
  delay(1000);
  lcd.clear();
}

void loop() {

  pinMode(led1, OUTPUT);

  pinMode(pinBouton, INPUT);

  //Enregistrer le temps de depart ( allumage led1)
  unsigned long tempsDebut;
  unsigned long cumulDesTemps = 0;
  unsigned long nombreDeTentatives = 0;

  randomSeed(millis());

  //attendre tant le bouton (pin8) n'est pas fermé
  while (digitalRead(pinBouton) == HIGH);
  tempsDebut = millis();

  while (millis() - tempsDebut <= dureeDuJeu) {
    // ici faire un jeu de plus
    delay(random(100, 1500));    //Attendre un temps aléatoire entre 100ms et 1.5 secondes
    digitalWrite(led1, HIGH);  //Allumer la led1
    unsigned long startLed = millis();    //Enregistrer le temps de depart ( allumage led1)
    while (digitalRead(pinBouton) == HIGH);  //attendre tant le bouton n'est pas appuyé

    //Afficher le temps
    unsigned long tempsCourant = millis() - startLed;
    digitalWrite(led1, LOW);
    cumulDesTemps += tempsCourant;
    nombreDeTentatives++;
    lcd.clear();
    lcd.print("Temps : ");
    lcd.print(tempsCourant / 1000.0);
    lcd.print(" s  "); // pour effacer s'il y a des caractères en trop
  }

  //Afficher le temps moyen
  digitalWrite(led1, LOW);
  lcd.clear();
  lcd.print("Temps Moyen :");
  lcd.setCursor(0, 1);
  if (nombreDeTentatives == 0) {
    lcd.print("Echec");
  }
  if (millis() > 1 * dureeDuJeu) {
    digitalWrite(led1, LOW);
    lcd.clear();
    lcd.print("FIN!");
    delay(1000);
    lcd.print("Temps Moyen :");
    lcd.setCursor(0, 1);
    lcd.print((cumulDesTemps / (nombreDeTentatives)) / 1000.0 );
    delay(2000);
  }

  // ici on remonte au début de la loop et donc on va attendre pour recommencer le jeu
  lcd.clear();
  lcd.print("Recommencer ?");
  delay(1000);

}

J'ai deux petites remarques.

1 : pourquoi mettre les pinMode dans la loop ? En général, c'est plutôt dans le setup qu'on les met.

2 : si je comprends bien l'objectif du jeu, c'est de mesurer un temps de réaction. Or j'ai l'impression que tu mesures le temps total, c'est à dire celui d'attente plus de réaction. Par exemple, si la durée aléatoire est de 1000 ms et que le temps avant appui sur le bouton est de 1100 ms, c'est 1100 qui sera comptabilisé. Or la durée de réaction serait ici de 100 ms, et c'est ça qui est intéressant je pense.

Je peux me tromper ou avoir mal lu le programme, bien sûr

lesept:
j'ai l'impression que tu mesures le temps total, c'est à dire celui d'attente plus de réaction. Par exemple, si la durée aléatoire est de 1000 ms et que le temps avant appui sur le bouton est de 1100 ms, c'est 1100 qui sera comptabilisé. Or la durée de réaction serait ici de 100 ms, et c'est ça qui est intéressant je pense.

il y a une durée totale pour une séquence de jeu, qui inclut le temps aléatoire, mais ensuite le temps de réponse de l'utilisateur est bien cumulé par rapport à la durée active de la LED (tempsCourant et cumulDesTemps)

    digitalWrite(led1, HIGH);  //Allumer la led1
    unsigned long startLed = millis();    //Enregistrer le temps de depart ( allumage led1)
    while (digitalRead(pinBouton) == HIGH);  //attendre tant le bouton n'est pas appuyé

    //Afficher le temps
    unsigned long tempsCourant = millis() - startLed;
    digitalWrite(led1, LOW);
    cumulDesTemps += tempsCourant;

@BigReinhardt - pour ce genre de jeu il fait prendre des boutons bien solides car les joueurs vont y aller fort... si vous voulez que ça dure un peu va falloir soigner les soudures aussi :slight_smile:

Ok, j'avais mal lu... Merci

Re, bonjour,

je reviens sur le même sujet,
j'ai besoin d'aide svp car j'ai ajouté 3 leds ( 4 au total) qui s'allume en aleatoire.
mais depuis, le temps ne se calcul plus :frowning:

sa affiche tout le temps : (Temps : 0.00s)
même pour le calcul du temps moyen à la fin

j'ai du loupé quelque chose, quelqu'un à une idée svp ? :slight_smile:

// OBJECTIF ALLUMER 4 LED EN DELAY ALEATOIRE;
// AFFICHER LE TEMPS DE REACTION "BOUTON PRESSE/LED ALLUME" (SUR 1MIN OU 20 CYCLES).

//PARAMETRAGE LED/BOUTON & DUREE
const byte led1 = 10;
const byte led3 = 7;
const byte led2 = 6;
const byte led4 = 9;
const byte pinBouton = 8;
const unsigned long dureeDuJeu = 60000UL; // 60 secondes

//PARAMETRAGE ECRAN LCD 16X2
#include <LiquidCrystal.h>      // inclusion de la bibliothèque
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);  // Initialisation de la bibliothèque par rapport au cablage

void setup() {

  // EXPLICATION TEXTE DU PROGRAMME ................................................

  lcd.begin(16, 2);              // réglage du nombre de ligne et de colonne
  lcd.print("SPEED TEST"); // Affiche un message
  delay(1000);
  lcd.clear();
}

void loop() {
  int lamp_aleatoire;

  //LEDs comme OUTPUT
  pinMode(led1, OUTPUT);
  pinMode(led2, OUTPUT);
  pinMode(led3, OUTPUT);
  pinMode(led4, OUTPUT);

  //Boutontouch comme INPUT
  pinMode(pinBouton, INPUT);

  //Enregistrer le temps de depart ( allumage led1)
  unsigned long tempsDebut;
  unsigned long cumulDesTemps = 0;
  unsigned long nombreDeTentatives = 0;

  randomSeed(millis());

  //OK OK

  //attendre tant le bouton ( boutontouch pin8) n'est pas fermé
  while (digitalRead(pinBouton) == HIGH);
  tempsDebut = millis();

  //OK OK
  while (millis() - tempsDebut <= dureeDuJeu) {
    unsigned long startLed = millis();    //Enregistrer le temps de depart ( allumage led1)
    unsigned long tempsCourant = millis() - startLed;
    lamp_aleatoire = rand() % 3; // un nombre aleatoire entre 0 et 3
    switch (lamp_aleatoire) {

      case 0 :
        // ici faire un jeu de plus
        delay(random(100, 1500));    //Attendre un temps aléatoire entre 100ms et 1.5 secondes
        digitalWrite(led1, HIGH);  //Allumer la led1
        while (digitalRead(pinBouton) == HIGH);  //attendre tant le bouton n'est pas appuyé
        digitalWrite(led1, LOW);

      case 1 :
        // ici faire un jeu de plus
        delay(random(100, 1500));    //Attendre un temps aléatoire entre 100ms et 1.5 secondes
        digitalWrite(led2, HIGH);  //Allumer la led1
        while (digitalRead(pinBouton) == HIGH);  //attendre tant le bouton n'est pas appuyé
        digitalWrite(led2, LOW);

      case 2 :
        // ici faire un jeu de plus
        delay(random(100, 1500));    //Attendre un temps aléatoire entre 100ms et 1.5 secondes
        digitalWrite(led3, HIGH);  //Allumer la led1
        while (digitalRead(pinBouton) == HIGH);  //attendre tant le bouton n'est pas appuyé
        digitalWrite(led3, LOW);

      case 3 :
        // ici faire un jeu de plus
        delay(random(100, 1500));    //Attendre un temps aléatoire entre 100ms et 1.5 secondes
        digitalWrite(led4, HIGH);  //Allumer la led1
        while (digitalRead(pinBouton) == HIGH);  //attendre tant le bouton n'est pas appuyé
        digitalWrite(led4, LOW);

    }

    //Afficher le temps
    cumulDesTemps += tempsCourant;
    nombreDeTentatives++;
    lcd.clear();
    lcd.print("Temps : ");
    lcd.print(tempsCourant / 1000.0);
    lcd.print(" s  "); // pour effacer s'il y a des caractères en trop
  }
  //Afficher le temps moyen
  lcd.clear();
  lcd.print("Temps Moyen :");
  lcd.setCursor(0, 1);
  if (nombreDeTentatives == 0) {
    lcd.print("Echec");
  }
  if (millis() > 1 * dureeDuJeu) {
    digitalWrite(led1, LOW);
    lcd.clear();
    lcd.print("FIN DU JEU");
    delay(1000);
    lcd.print("Temps Moyen :");
    lcd.setCursor(0, 1);
    lcd.print((cumulDesTemps / (nombreDeTentatives)) / 1000.0 );
    delay(1000);
  }

  // ici on remonte au début de la loop et donc on va attendre pour recommencer le jeu
  lcd.clear();
  lcd.print("Recommencer ?");
  delay(1000);

}
[code]
lamp_aleatoire = rand() % 3;

Un nombre modulo 3 vaut 0, 1 ou 2, jamais 3.

Pour obtenir un nombre aléatoire entre 0 et 3 inclus, tu peux faire

lamp_aleatoire = random(4);

Je pense qu'il faut déplacer les lignes de pinMode dans le setup.

Pour initialiser le générateur aléatoire, on utilise plutôt

randomSeed(analogRead(0));

il manque des break à votre switch/case et vous n'avez plus le calcul du temps lorsqu'on appuie sur le bouton

    unsigned long tempsCourant = millis() - startLed;
    digitalWrite(led1, LOW);
    cumulDesTemps += tempsCourant;

--> juste après l'appui du bouton il faut capturer ce temps.

bonjour JMP,

( merci pour tes reponses lesept aussi)

j'ai fait comme vous m'avez dit mais la vérif ne fonctionne pasdans IDE.
il m'affiche :

"exit status 1
crosses initialization of 'long unsigned int tempsCourant' "
en surlignant la ligne dans le case :" unsigned long tempsCourant = millis() - startLed; "

voir image ci joint et code ci dessous:

 //attendre tant le bouton ( boutontouch pin8) n'est pas fermé
  while (digitalRead(pinBouton) == HIGH);
  tempsDebut = millis();

  while (millis() - tempsDebut <= dureeDuJeu) {
    unsigned long startLed = millis();    //Enregistrer le temps de depart ( allumage led1)
    lamp_aleatoire = random(4);
    switch (lamp_aleatoire) {

      case 0 :

        delay(random(100, 1500));    //Attendre un temps aléatoire entre 100ms et 1.5 secondes
        digitalWrite(led1, HIGH);  //Allumer la led1
        while (digitalRead(pinBouton) == HIGH);  //attendre tant le bouton n'est pas appuyé
        unsigned long tempsCourant = millis() - startLed;
        digitalWrite(led1, LOW);
        cumulDesTemps += tempsCourant;
        break;
      case 1 :
 
        delay(random(100, 1500));    //Attendre un temps aléatoire entre 100ms et 1.5 secondes
        digitalWrite(led2, HIGH);  //Allumer la led1
        while (digitalRead(pinBouton) == HIGH);  //attendre tant le bouton n'est pas appuyé
        unsigned long tempsCourant = millis() - startLed;
        digitalWrite(led2, LOW);
        cumulDesTemps += tempsCourant;
        break; 

[code]

[/code]

Sans titre.png

Définissez la variable tempsCourant en dehors du switch case

    unsigned long tempsCourant;
    unsigned long startLed;
    lamp_aleatoire = random(4);
    switch (lamp_aleatoire) {

      case 0 :

        delay(random(100, 1500));    //Attendre un temps aléatoire entre 100ms et 1.5 secondes
        startLed = millis();    //Enregistrer le temps de depart ( allumage led1)
        digitalWrite(led1, HIGH);  //Allumer la led1
        while (digitalRead(pinBouton) == HIGH);  //attendre tant le bouton n'est pas appuyé
        tempsCourant = millis() - startLed;
        digitalWrite(led1, LOW);
        cumulDesTemps += tempsCourant;
        break;

...

bonjour,

merci pour vos conseils tout fonctionne :slight_smile:

Bonne continuation!