allumer aléatoirement une leds sur 2 et l'éteindre avec un 1 bp précis sur 2

Bonjour je débute sur arduino est j'ai un projet de faire un programme sur un arduino uno avec une carte grove .
le programme doit consister a faire que une led s'allume au hasard on appuie, sans se tromper, sur le bouton associé à chaque led. Dès qu'une erreur est commise, le jeu s'arrête .

Du coup je suis a une ligne de programme de allumer une led aléatoirement mais rien de se que j'ai essayer ne marche quand je le compile .
Si quelqu’un pourrais m'aider

Mon début de programme :

#define BP1 2         // Le bouton poussoir est connecté sur l'entrée D2 : fil jaune
#define LED1 3       // La led est connectée sur l'entrée D3 : fil blanc 
#define BP2 4         // Le bouton poussoir est connecté sur l'entrée D4 : fil jaune
#define LED2 5        // La led est connectée sur l'entrée D5 : fil blanc 
// Déclaration des variables
byte Etat_BP1 = 1;          // Etat courant du bouton poussoir
byte Etat_BP2 = 2;          // Etat courant du bouton poussoir
byte Old_Etat_BP1 = 1;      // Etat précédent du bouton poussoir : permet de détecter une action sur l'appui du bouton
byte Old_Etat_BP2 = 2;      // Etat précédent du bouton poussoir : permet de détecter une action sur l'appui du bouton
boolean Etat_Led1 = false;
boolean Etat_Led2 = false;
boolean BP1_Appuye = false;  // Indication  si le BP a été appuyé
boolean BP2_Appuye = false;  // Indication  si le BP a été appuyé
int Duree = 0;             // Durée d'attente d'affichage LED aléatoire
int initLed = 0; 
int i; 
int randnumber ;


void setup() 
{
 // Initialisation du port USB du PC à 9600 bauds
 Serial.begin(9600);                     // Définition vitesse de  sur port USB
 // Définition des connexions
 pinMode(BP1,INPUT_PULLUP);   // Le bouton est connecté en entrée avec résisance de PullUp de l'Arduino
 pinMode(BP2,INPUT_PULLUP);
 pinMode(LED1,OUTPUT);        // La Led est connectée en sortie de l'Arduino
 pinMode(LED2,OUTPUT);
 digitalWrite(LED1,HIGH);     // Par sécurité on éteint la Led ??
 digitalWrite(LED2,HIGH);
 Serial.println("Jeu avec des nombres aléatoires");
 Serial.println("Dès que la Led s'allume : appuyer sur le BP pour l'éteindre");

 delay(5000);
}
// Fin setup
void loop() 
{
 // Génération d'un nombre aléatoire ici compris entre 0 et 99
 // ==========================================================
 //Serial.print("Nombre aléatoire = ");
 //Serial.println(nbAleatoire);   // Affichage du nombre aléatoire
 Serial.print("Attente = ");      // Pour débug
 Serial.print(Duree);             // Pour debug
 Serial.println(" milli secondes");  
 delay(Duree);                    // Attente aléatoire
 randnumber=random(0,2);          //Déclaration d'un premier nombre aléatoire de 0 à 1
 digitalWrite(led[randnumber],LOW);   //ne veut pas se compiler

Tout d'abord, lire les instructions de la liste

digitalWrite(led[randnumber],LOW); //ne veut pas se compiler

randnumber est un int qui contient 0 ou 1.
led[randnumber] c'est soit led[0] ou led[1]. Le compilateur cherche un tableau led qui doit contenir au moins 2 valeurs...

Ce que tu veux c'est soit led1 soit led2.

Led1 est une valeur numérique qui vaut 3. Écrire led1 ou 3, c'est pareil

Ce que tu veux c'est soit 3 soit 5.

On peut créer un tableau contentant ces valeurs, ou bien calculer 3 ou 5 à partir de 0 ou 1 par exemple digitalWrite(randnumber*2+3,LOW);

Merci j’ai pris en compte se que vous m’avez dit j’ai avancer dans mon programme hélas j’ai eu se message si:
Arduino : 1.8.12 (Windows Store 1.8.33.0) (Windows 10), Carte : “Arduino Uno”

C:\Users\s\OneDrive\Bureau\Led_Aleatoire_D2_et_D4\Led_Aleatoire_D2_et_D4.ino: In function ‘void loop()’:

Led_Aleatoire_D2_et_D4:59:14: error: invalid operands of types ‘’ and ‘int’ to binary ‘operator==’

if (random == 3){


Led_Aleatoire_D2_et_D4:60:20: error: 'led2' was not declared in this scope

digitalWrite (led2, LOW);

^~~~

C:\Users\s\OneDrive\Bureau\Led_Aleatoire_D2_et_D4\Led_Aleatoire_D2_et_D4.ino: At global scope:

Led_Aleatoire_D2_et_D4:74:6: error: expected unqualified-id before 'else'

else { if ( digitalRead(BP2(randnumber*2+3)==HIGH

^~~~

Led_Aleatoire_D2_et_D4:78:6: error: expected unqualified-id before 'if'

if (random == 5){

^~

Led_Aleatoire_D2_et_D4:89:6: error: 'Etat_BP2' does not name a type

Etat_BP2 = digitalRead(BP2); // Lecture état du BP

^~~~~~~~

Led_Aleatoire_D2_et_D4:90:11: error: expected constructor, destructor, or type conversion before '(' token

delay(1000);

^

Led_Aleatoire_D2_et_D4:91:6: error: 'ranim' does not name a type

ranim = random(3, 5); // on effectue un random pour chaque affichage

^~~~~

Led_Aleatoire_D2_et_D4:92:5: error: expected declaration before '}' token

}

^

exit status 1
invalid operands of types '<unresolved overloaded function type>' and 'int' to binary 'operator=='

Ce rapport pourrait être plus détaillé avec
l'option "Afficher les résultats détaillés de la compilation"
activée dans Fichier -> Préférences.

```
#define BP1 2         // Le bouton poussoir est connecté sur l'entrée D2 : fil jaune
#define LED1 3       // La led est connectée sur l'entrée D3 : fil blanc 
#define BP2 4         // Le bouton poussoir est connecté sur l'entrée D4 : fil jaune
#define LED2 5        // La led est connectée sur l'entrée D5 : fil blanc 
// Déclaration des variables
byte Etat_BP1 = 1;          // Etat courant du bouton poussoir
byte Etat_BP2 = 2;          // Etat courant du bouton poussoir
byte Old_Etat_BP1 = 1;      // Etat précédent du bouton poussoir : permet de détecter une action sur l'appui du bouton
byte Old_Etat_BP2 = 2;      // Etat précédent du bouton poussoir : permet de détecter une action sur l'appui du bouton
boolean Etat_Led1 = false;
boolean Etat_Led2 = false;
boolean BP1_Appuye = false;  // Indication  si le BP a été appuyé
boolean BP2_Appuye = false;  // Indication  si le BP a été appuyé
int Duree = 0;             // Durée d'attente d'affichage LED aléatoire
int initLed = 0;
int randnumber ;
long ranim;
long ran;



void setup() 
{
  // Initialisation du port USB du PC à 9600 bauds
  Serial.begin(9600);                     // Définition vitesse de  sur port USB
  // Définition des connexions
  pinMode(BP1,INPUT_PULLUP);   // Le bouton est connecté en entrée avec résisance de PullUp de l'Arduino
  pinMode(BP2,INPUT_PULLUP);
  pinMode(LED1,OUTPUT);        // La Led est connectée en sortie de l'Arduino
  pinMode(LED2,OUTPUT);
  digitalWrite(LED1,HIGH);     // Par sécurité on éteint la Led ??
  digitalWrite(LED2,HIGH);
  Serial.println("Jeu avec des nombres aléatoires");
  Serial.println("Dès que la Led s'allume : appuyer sur le BP pour l'éteindre");
  randomSeed(analogRead(0));

  delay(5000);
 }
// Fin setup
void loop() 
{
  // Génération d'un nombre aléatoire ici compris entre 0 et 99
  // ==========================================================
  //Serial.print("Nombre aléatoire = ");
  //Serial.println(nbAleatoire);   // Affichage du nombre aléatoire
  Serial.print("Attente = ");      // Pour débug
  Serial.print(Duree);             // Pour debug
  Serial.println(" milli secondes");  
  delay(Duree);                    // Attente aléatoire
  delay(50); // pause de 50 ms
  digitalWrite(randnumber*2+3,LOW);  // Allumer soit la led 3 ou 5
  Serial.println("Led allumée !!");
  // Attente appui sur bouton poussoir
  while (BP1_Appuye == false)
  
  random(3,5);
  
  if (random == 3){
     digitalWrite (led2, LOW);
     Etat_BP1 = digitalRead(BP1);   // Lecture état du BP
     if ((Etat_BP1 == 0)&&(Etat_BP1 != Old_Etat_BP1))
      {
      Serial.println("BP Appuyé !!");
      BP1_Appuye = true;      // Le bouton a été appuyé
      }
    Old_Etat_BP1=Etat_BP1;
    delay(1000);
    }
     Etat_BP1 = digitalRead(BP1);   // Lecture état du BP
     delay(1000);
     ranim = random(3, 5); // on effectue un random pour chaque affichage
    }
     else { if ( digitalRead(BP2(randnumber*2+3)==HIGH
     }


     if (random == 5){
     digitalWrite (led2, LOW);
     Etat_BP2 = digitalRead(BP2);   // Lecture état du BP
     if ((Etat_BP2 == 0)&&(Etat_BP2 != Old_Etat_BP2))
      {
      Serial.println("BP Appuyé !!");
      BP2_Appuye = true;      // Le bouton a été appuyé
      }
    Old_Etat_BP2=Etat_BP2;
    delay(1000);
    }
     Etat_BP2 = digitalRead(BP2);   // Lecture état du BP
     delay(1000);
     ranim = random(3, 5); // on effectue un random pour chaque affichage
    }
     else { if ( digitalRead(BP1[randnumber*1+2])==HIGH
  }
```

randnumber=random(0,2); //Déclaration d’un premier nombre aléatoire de 0 à 1

C’est bien à garder. randnumber est bien un nombre aléatoire entre 0 et 1. J’aurais écris par paresse
randnumber=random(2);
Utilises randnumber partout comme avant sauf quand tu avais led[randnumber] que tu remplaces par randnumber*2+3. Le reste ne doit pas changer.

ligne 55 à 57:

  // Attente appui sur bouton poussoir
  while (BP1_Appuye == false)
 
  random(3,5);

Ce que comprend le compilateur:
si BP1_Appuye vaut false alors j’appelle la fonction random, mais je me moque de ce qu’elle retourne. Du coup l’appel ne sert à rien
sinon, je ne fais rien.
Au final → soit je ne fais rien, soit je ne fais rien

ligne 59
if (random == 3){
random n’est pas une variable. Elle ne vaut pas 3 (il y a des histoires de pointeurs derrière cette écriture, mais ce n’est pas cela que tu cherches). Je pense que tu voulais quelque chose comme:

// Attente appui sur bouton poussoir 
while (BP1_Appuye == false) Etat_BP1 = digitalRead(BP1);
 
randnumber=random(2);
 
if (random == 0){
....
     else { if ( digitalRead(BP2(randnumber*2+3)==HIGH <--- non!
     else { if ( digitalRead(randnumber*2+3)==HIGH) <-- oui
.....

Alors j'ai fais une boucle qui marche que quand la led s'allume on appuie elle s’éteint aléatoirement

Mais des que je rajoute un "else if" avec le code approprier pour y rajouter une erreur si le bouton poussoir est pas le bon je obtient se message si en compilant :
exit status 1
'Aleatoire' was not declared in this scope

Voici le code que j'ai mis

#define BP1 2         // Le bouton poussoir est connecté sur l'entrée D2 : fil jaune
#define LED1 3       // La led est connectée sur l'entrée D3 : fil blanc 
#define BP2 4         // Le bouton poussoir est connecté sur l'entrée D4 : fil jaune
#define LED2 5        // La led est connectée sur l'entrée D5 : fil blanc 
//
// Déclaration des variables
byte Etat_BP1 = 1;          // Etat courant du bouton poussoir
byte Etat_BP2 = 2;          // Etat courant du bouton poussoir
byte Old_Etat_BP1 = 1;      // Etat précédent du bouton poussoir : permet de détecter une action sur l'appui du bouton
byte Old_Etat_BP2 = 2;      // Etat précédent du bouton poussoir : permet de détecter une action sur l'appui du bouton
boolean Etat_Led1 = false;
boolean Etat_Led2 = false;
boolean BP1_Appuye = false;  // Indication  si le BP a été appuyé
boolean BP2_Appuye = false;  // Indication  si le BP a été appuyé
int nbAleatoireDuree = 0;    // Nombre aléatoire d'attente avant l'éclairement d'une Led
int ValeurMaxDuree = 100;    // Ici le nombre aléatoire d'attente sera compris entre 0 et 99
int Duree = 0;               // Durée d'attente d'affichage LED aléatoire
int nbAleatoireLed = 0;      // Nombre aléatoire de choix de la Led Allumée
int ValeurMaxLed = 2;        // Ici le nombre aléatoire de la LED (1 ou 2)


// Programme d'initalisation
void setup() 
{
  // Initialisation du port USB du PC à 9600 bauds
  Serial.begin(9600);          // Définition vitesse de  sur port USB
  // Définition des connexions
  pinMode(BP1,INPUT_PULLUP);   // Le bouton est connecté en entrée avec résisance de PullUp de l'Arduino
  pinMode(BP2,INPUT_PULLUP);   // La Led est connectée en sortie de l'Arduino
  pinMode(LED1,OUTPUT);        // La Led est connectée en sortie de l'Arduino
  pinMode(LED2,OUTPUT);        // La Led est connectée en sortie de l'Arduino
  digitalWrite(LED1,HIGH);     // Par sécurité on éteint la Led ??
  digitalWrite(LED2,HIGH);     // Par sécurité on éteint la Led ??
  Serial.println("Jeu aléatoire 2 Leds et 2 BP");
  Serial.println("Dès qu'une Led s'allume: appuyer sur le BP correspondant pour l'éteindre");
  delay(5000);
 }
// Fin du setup
//
// Boucle programme
void loop() 
  {
  // Génération aléatoire de la Led qui sera allumée
  // ===============================================
  nbAleatoireLed = Aleatoire(ValeurMaxLed);  // Appel de la fonction génération nombre aléatoire
  Serial.print("Nombre aléatoire (choix Led1 ou Led2) avant éclairement Led = "); 
  Serial.println(nbAleatoireLed);          // Affichage du nombre aléatoire
  //  
  // Génération d'un nombre aléatoire pour l'attente
  // ===============================================
  nbAleatoireDuree = Aleatoire(ValeurMaxDuree);       // Appel de la fonction génération nombre aléatoire
  Serial.print("Nombre aléatoire (entre 0 et 99) avant éclairement Led = "); 
  Serial.println(nbAleatoireDuree);     // Affichage du nombre aléatoire
  Duree = nbAleatoireDuree * 50 ;       // Durée entre 0 et 5000 secondes
  Serial.print("Attente aléatoire = ");           // Pour débug
  Serial.print(Duree);                  // Pour debug
  Serial.println(" milli secondes");  
  delay(Duree);                         // Attente aléatoire
  // Choix aléatoire de l'allumage de la LED1
  if (nbAleatoireLed == 0)   // led 1
    {
    // On allume la Led 1
    digitalWrite(LED1,LOW);               // Allumage LED
    Serial.println("Led 1 allumée !!");
    // Attente appui sur bouton poussoir
    while (BP1_Appuye == false)
      {
      Etat_BP1 = digitalRead(BP1);        // Lecture état du BP
      if ((Etat_BP1 == 0)&&(Etat_BP1 != Old_Etat_BP1))
        {
        Serial.println("BP Appuyé !!");
        BP1_Appuye = true;      // Le bouton a été appuyé
        }
      Old_Etat_BP1=Etat_BP1;
      }
      BP1_Appuye = false;       // On a fini l'attente
      digitalWrite(LED1,HIGH);        // Extinction LED
      Serial.println("Led 1 éteinte !!");
      { else if // si joueur a appuyer sur le mauvais bp 
      { Etat_BP2 = digitalRead(BP2);        // Lecture état du BP
      if ((Etat_BP2 == 0)&&(Etat_BP2 != Old_Etat_BP2))
      {
        Serial.println("BP2 Appuyé !!");
        BP2_Appuye = true;      // Le bouton a été appuyé
        }
       Old_Etat_BP2=Etat_BP2; 
        }
        BP2_Appuye = false;       // On a fini l'attente
        // On allume led 1 et 2
    digitalWrite(LED2,LOW); // Allumage LED
    delay(1000)              
    digitalWrite(LED1,LOW); // Allumage LED
    delay(1000)
    digitalWrite(LED2,LOW); // Allumage LED
    delay(1000)              
    digitalWrite(LED1,LOW); // Allumage LED
    }
  // Choix aléatoire de l'allumage de la LED2
  if (nbAleatoireLed == 1)   // led 2
    {
    // On allume la Led 2
    digitalWrite(LED2,LOW);               // Allumage LED
    Serial.println("Led 2 allumée !!");
    // Attente appui sur bouton poussoir
    while (BP2_Appuye == false)
      {
      Etat_BP2 = digitalRead(BP2);        // Lecture état du BP
      if ((Etat_BP2 == 0)&&(Etat_BP2 != Old_Etat_BP2))
        {
        Serial.println("BP2 Appuyé !!");
        BP2_Appuye = true;      // Le bouton a été appuyé
        }
      Old_Etat_BP2=Etat_BP2;
      }
      BP2_Appuye = false;       // On a fini l'attente
      digitalWrite(LED2,HIGH);        // Extinction LED
      Serial.println("Led 2 éteinte !!");
     { else if // si joueur a appuyer sur le mauvais bp 
      { Etat_BP1 = digitalRead(BP1);        // Lecture état du BP
      if ((Etat_BP1 == 0)&&(Etat_BP1 != Old_Etat_BP1))
      {
        Serial.println("BP1 Appuyé !!");
        BP1_Appuye = true;      // Le bouton a été appuyé
        }
       Old_Etat_BP1=Etat_BP1; 
        }
        BP1_Appuye = false;       // On a fini l'attente
        // On allume led 1 et 2
    digitalWrite(LED2,LOW); // Allumage LED
    delay(1000)              
    digitalWrite(LED1,LOW); // Allumage LED
    delay(1000)
    digitalWrite(LED2,LOW); // Allumage LED
    delay(1000)              
    digitalWrite(LED1,LOW); // Allumage LED
    }
  }
// Fin boucle loop

// Fonction de génération du nombre aléatoire
// ==========================================
int Aleatoire(int duree)
  {
   return (random(duree));      //construit le nombre aléatoire compris entre 0 et 99
  }

Bonjour,

Il manque des accolades fermantes à la fin de la loop. Fais ctrl T pour formater ton code et tu t'en apercevras.

'Aleatoire' was not declared in this scope

En fait il faut comprendre:
'Aleatoire' n'a pas encore été déclaré. la déclaration intervient après. Si on veut pouvoir utiliser un nom, il faut le déclarer AVANT.

Quelqu’un ne voudrais pas me faire la ligne de programme qui consiste a verifer si le mauvais bp est appuyer que celui allume les 2 led pendant 4 seconde voici le code qui marche

#define BP1 2         // Le bouton poussoir est connecté sur l'entrée D2 : fil jaune
#define LED1 3       // La led est connectée sur l'entrée D3 : fil blanc 
#define BP2 4         // Le bouton poussoir est connecté sur l'entrée D4 : fil jaune
#define LED2 5        // La led est connectée sur l'entrée D5 : fil blanc 
//
// Déclaration des variables
byte Etat_BP1 = 1;          // Etat courant du bouton poussoir
byte Etat_BP2 = 2;          // Etat courant du bouton poussoir
byte Old_Etat_BP1 = 1;      // Etat précédent du bouton poussoir : permet de détecter une action sur l'appui du bouton
byte Old_Etat_BP2 = 2;      // Etat précédent du bouton poussoir : permet de détecter une action sur l'appui du bouton
boolean Etat_Led1 = false;
boolean Etat_Led2 = false;
boolean BP1_Appuye = false;  // Indication  si le BP a été appuyé
boolean BP2_Appuye = false;  // Indication  si le BP a été appuyé
int nbAleatoireDuree = 0;    // Nombre aléatoire d'attente avant l'éclairement d'une Led
int ValeurMaxDuree = 100;    // Ici le nombre aléatoire d'attente sera compris entre 0 et 99
int Duree = 0;               // Durée d'attente d'affichage LED aléatoire
int nbAleatoireLed = 0;      // Nombre aléatoire de choix de la Led Allumée
int ValeurMaxLed = 2;        // Ici le nombre aléatoire de la LED (1 ou 2)


// Programme d'initalisation
void setup() 
{
  // Initialisation du port USB du PC à 9600 bauds
  Serial.begin(9600);          // Définition vitesse de  sur port USB
  // Définition des connexions
  pinMode(BP1,INPUT_PULLUP);   // Le bouton est connecté en entrée avec résisance de PullUp de l'Arduino
  pinMode(BP2,INPUT_PULLUP);   // La Led est connectée en sortie de l'Arduino
  pinMode(LED1,OUTPUT);        // La Led est connectée en sortie de l'Arduino
  pinMode(LED2,OUTPUT);        // La Led est connectée en sortie de l'Arduino
  digitalWrite(LED1,HIGH);     // Par sécurité on éteint la Led ??
  digitalWrite(LED2,HIGH);     // Par sécurité on éteint la Led ??
  Serial.println("Jeu aléatoire 2 Leds et 2 BP");
  Serial.println("Dès qu'une Led s'allume: appuyer sur le BP correspondant pour l'éteindre");
  delay(5000);
 }
// Fin du setup
//
// Boucle programme
void loop() 
  {
  // Génération aléatoire de la Led qui sera allumée
  // ===============================================
  nbAleatoireLed = Aleatoire(ValeurMaxLed);  // Appel de la fonction génération nombre aléatoire
  Serial.print("Nombre aléatoire (choix Led1 ou Led2) avant éclairement Led = "); 
  Serial.println(nbAleatoireLed);          // Affichage du nombre aléatoire
  //  
  // Génération d'un nombre aléatoire pour l'attente
  // ===============================================
  nbAleatoireDuree = Aleatoire(ValeurMaxDuree);       // Appel de la fonction génération nombre aléatoire
  Serial.print("Nombre aléatoire (entre 0 et 99) avant éclairement Led = "); 
  Serial.println(nbAleatoireDuree);     // Affichage du nombre aléatoire
  Duree = nbAleatoireDuree * 50 ;       // Durée entre 0 et 5000 secondes
  Serial.print("Attente aléatoire = ");           // Pour débug
  Serial.print(Duree);                  // Pour debug
  Serial.println(" milli secondes");  
  delay(Duree);                         // Attente aléatoire
  // Choix aléatoire de l'allumage de la LED1
  if (nbAleatoireLed == 0)   // led 1
    {
    // On allume la Led 1
    digitalWrite(LED1,LOW);               // Allumage LED
    Serial.println("Led 1 allumée !!");
    // Attente appui sur bouton poussoir
    while (BP1_Appuye == false)
      {
      Etat_BP1 = digitalRead(BP1);        // Lecture état du BP
      if ((Etat_BP1 == 0)&&(Etat_BP1 != Old_Etat_BP1))
        {
        Serial.println("BP Appuyé !!");
        BP1_Appuye = true;      // Le bouton a été appuyé
        }
      Old_Etat_BP1=Etat_BP1;
      }
      BP1_Appuye = false;       // On a fini l'attente
      digitalWrite(LED1,HIGH);        // Extinction LED
      Serial.println("Led 1 éteinte !!");
    }
  // Choix aléatoire de l'allumage de la LED2
  if (nbAleatoireLed == 1)   // led 2
    {
    // On allume la Led 2
    digitalWrite(LED2,LOW);               // Allumage LED
    Serial.println("Led 2 allumée !!");
    // Attente appui sur bouton poussoir
    while (BP2_Appuye == false)
      {
      Etat_BP2 = digitalRead(BP2);        // Lecture état du BP
      if ((Etat_BP2 == 0)&&(Etat_BP2 != Old_Etat_BP2))
        {
        Serial.println("BP2 Appuyé !!");
        BP2_Appuye = true;      // Le bouton a été appuyé
        }
      Old_Etat_BP2=Etat_BP2;
      }
      BP2_Appuye = false;       // On a fini l'attente
      digitalWrite(LED2,HIGH);        // Extinction LED
      Serial.println("Led 2 éteinte !!");
    }
  }
// Fin boucle loop

// Fonction de génération du nombre aléatoire
// ==========================================
int Aleatoire(int duree)
  {
   return (random(duree));      //construit le nombre aléatoire compris entre 0 et 99
  }