[Non réglé] Jeu de réflexe (Problème de limite de score)

Bonjour à tous,

Le principe est simple, je dois réaliser un jeu de réflexe où deux joueurs ont en face d’eux, 2 leds colorées et deux boutons correspondant aux différentes leds (par joueur, donc 4 en tout !).
J’ai réussi toute la partie incrémentation des scores/allumages des leds aléatoirement.

Le score s’affiche sur un écran lcd 16 caractères sur deux lignes.

Et c’est justement là que commence mes ennuies !
En effet, j’ai réussi à faire mon incrémentation de score, jusque-là tout va bien. En fait, le problème vient du passage du score positif, vers le négatif: l’écran lcd va effectivement mettre un “-” devant le nombre. Par exemple de 0 à -1, au lieu de prendre un caractère, il va en prendre 2, le symbole négatif et le nombre en lui-même. Sauf que quand on repasse en positif, de -1 à 0, il va supprimer le symbole négatif, mais garder le chiffre 1, (ou des fois 0, je ne sais pas pourquoi…). Ce qui fait que parfois, on se retrouve avec un score où on a l’impression qui s’incrément de 10 en 10.
Alors je me suis dit qu’il fallait essayer de faire un score limite minimum.
Et c’est là que je bloque, j’ai essayé tout un tas de chose, sans succès.
Je vous propose mon code:

#include <LiquidCrystal.h>
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);
int LED1=13; // déclarations des variables LED sur les broches
int LED2=12;
int LED3=2;
int LED4=10;
int BUTTON_PIN1=1; //déclaration des variable bouttons (broche + permettre lecture de l'etat du boutton
int BUTTON_PIN2=3;
int BUTTON_PIN3=11;
int BUTTON_PIN4=0;
int scoreJ1=0;            //les scores des joueurs 1 et 2
int scoreJ2=0;
int previousButton1State=LOW;
int previousButton2State=LOW;
int previousButton3State=LOW;      // l'état des boutons avant qu'ils ne soient pressés
int previousButton4State=LOW;
boolean isIniti=false;             //variable de type booléan en "faux", permettra de rentrer qu'une seule fois à l'initialisation
int ledId = LED1;
int ledId3= LED3;                   // les ledsId vont permettre de d'allumer une des deux leds de chaque joueur
int buttonState=0;
int buttonBase=buttonState;          //l'état du bouton de base, est égal à l'état du bouton, utile pour gérer le rebond du bouton poussoir.

void setup ()
{
  pinMode(LED1, OUTPUT); //leds en sorties
  pinMode (LED2, OUTPUT);
  pinMode (LED3, OUTPUT);
  pinMode (LED4, OUTPUT);
  pinMode (BUTTON_PIN1, INPUT);  //boutons en entrées
  pinMode (BUTTON_PIN2, INPUT);
  pinMode (BUTTON_PIN3, INPUT);
  pinMode (BUTTON_PIN4, INPUT);
  lcd.begin(16,2);         // on initialise un écran de 16 caractères sur 2 lignes
  lcd.write("Joueur 1:");     
  lcd.setCursor (0,1);    //on place le curseur sur la ligne d'en dessous pour écrire Joueur 2
  lcd.write ("Joueur 2:");
  
}

// Initialise l'allumage d'une led.
void initi()
{
  // On initialise si besoin
  if(!isIniti) // On ne doit entrer qu'une seule fois à chaque partie. (grâce au "!")
  {
     // On peut ajouter un delay ici (mais les pressions bouton ne seront pas détectées)
     pickLed(); // choix d'une led.
     digitalWrite (ledId, HIGH); // allumage de la led du joueur 1.
     digitalWrite (ledId3, HIGH); // et celle du joueur 2
     isIniti = true; // On marque que le programme est initialisé pour ne pas refaire la fonction.
  }
}

// Permet de choisir la Led1 et la Led 3 ou la Led2 et la Led 4 aléatoirement.
void pickLed()
{
   if(random(2) == 1) {
      ledId = LED2;
      ledId3 = LED4;
   } else {
      ledId = LED1;
      ledId3 = LED3; 
   }
}

// Vérifie la pression des boutons et met à jour le score
void checkButtons()
{
   // On determine le bouton qui marque des points.
   
   
   int increasingPin = BUTTON_PIN1; // pas besoin de If, puisque de base il est sur le bouton 1, si jamais la ledid change,
   if(ledId == LED2) {              //alors on peut utiliser le if qui permettra de controler ce changement.
      increasingPin = BUTTON_PIN2;
   }
   
    int increasingPin3 = BUTTON_PIN3; // de même
   
   if (ledId3 == LED4)
   {
    increasingPin3= BUTTON_PIN4; 
   }

   
   // On vérifie le bouton 1
   checkButton1(increasingPin);
   // On vérifie le bouton 2
   checkButton2(increasingPin);    //appelle des différentes fonction vu plus bas
   //on vérifie le bouton 3
   checkButton3(increasingPin3);
   //on vérifie le bouton 4
   checkButton4 (increasingPin3);
}

void checkButton1(int increasingPin)
{
    // On détermine le nombre de point marqué par le J1 si le bouton1 est pressé.
    int points = 1; // de base, point est à un
    if(BUTTON_PIN1 != increasingPin) // si le bouton 1 est pressé alors que sa led correspondante n'est pas activé,
    {
        
        points = -1;    // on lui affecte la valeur -1
        
    }
    
    // On vérifie que le bouton est pressé.
    buttonState=digitalRead(BUTTON_PIN1);
    if (buttonState==HIGH && buttonState!=previousButton1State) { // Si il est pressé 
        
        // Mise a jour du score
        scoreJ1=scoreJ1+points;
        // affichage du score du J1
        lcd.setCursor (9,0);
        lcd.print(scoreJ1);
        // Est-ce le bon bouton ?
        if(increasingPin == BUTTON_PIN1) // si oui
        {
            digitalWrite (ledId, LOW);
            digitalWrite (ledId3, LOW); // On éteint la led.
            isIniti=false; // On marque que le programme doit etre initialisé, au prochain passage dans init.
        }
    }
    previousButton1State=buttonState; // On stocke l'état du bouton pour vérifier si il y a un changement d'état
    
}

void checkButton2(int increasingPin)
{
    // On détermine le nombre de point marqué par le J2 si le bouton2 est pressé.
    int points = 1;
    if(BUTTON_PIN2 != increasingPin)
    {
        points = -1;
    }
    
    // On vérifie que le bouton est pressé.
    buttonState=digitalRead(BUTTON_PIN2);
    if (buttonState==HIGH && buttonState!=previousButton2State) { // Si il est pressé 
        // Mise a jour du score
        scoreJ1=scoreJ1+points;
        lcd.setCursor (9,0);
        // affichage du score du J1
        lcd.print(scoreJ1);
        // Est-ce le bon bouton ?
        if(increasingPin == BUTTON_PIN2)// oui
        {
            digitalWrite (ledId, LOW);
            digitalWrite (ledId3, LOW); // On éteint la led.
            isIniti=false; // On marque que le programme doit etre initialisé, au prochain passage dans init.
        }
    }
    previousButton2State=buttonState; // On stocke l'état du bouton pour vérifier si il y a un changement d'état
     
}
void checkButton3 (int increasingPin3)
{
  int points = 1;
  if (BUTTON_PIN3 != increasingPin3)
  {
    points = -1;
  }
  buttonState=digitalRead(BUTTON_PIN3);
  if (buttonState==HIGH && buttonState!=previousButton3State) { // Si il est pressé 
        // Mise a jour du score
        scoreJ2=scoreJ2+points;
        lcd.setCursor (9,1);
        // affichage du score du J3
        lcd.print(scoreJ2);
        // Est-ce le bon bouton ?
        if(increasingPin3 == BUTTON_PIN3)// oui
        {
            digitalWrite (ledId, LOW);
            digitalWrite (ledId3, LOW); // On éteint les leds.
            isIniti=false;
        }
  }
   previousButton3State=buttonState;
}
void checkButton4 (int increasingPin)
{
  int points = 1;
  if (BUTTON_PIN4 != increasingPin)
  {
    points = -1;
  }
  buttonState=digitalRead(BUTTON_PIN4);
  if (buttonState==HIGH && buttonState!=previousButton4State) { // Si il est pressé 
        // Mise a jour du score
        scoreJ2=scoreJ2+points;
        lcd.setCursor (9,1);
        // affichage du score du J4
        lcd.print(scoreJ2);
        // Est-ce le bon bouton ?
        if(increasingPin == BUTTON_PIN4)// oui
        {
            digitalWrite (ledId, LOW);
            digitalWrite (ledId3, LOW); // On éteint les leds.
            isIniti=false;
        }
  }
   previousButton4State=buttonState;
   
}

// Et on exécute le programme en boucle.
void loop ()
{
    initi();
    checkButtons();
    
}

J’ai d’abord eu l’idée d’agir directement sur la valeur des points en utilisant une boucle do/tant que score J1>=0
Il ne récupère jamais la valeur du score du joueur 1
Dans tous les cas, il faut aussi que j’arrive à faire une limite de score maximum, afin d’afficher le vainqueur de la partie, mais encore une fois, je ne sais vraiment pas comment faire.
J’ai d’abord essayé de créer une nouvelle fonction en testant le score du joueur 1 (if (scoreJ1==9), alors on efface l’'écran lcd, puis on affiche “victoire de J1 !”).
Peu importe où je positionnais cette fonction (que ce soit dans les checkbutton1 et 2 ou le loop), il n’y rentrait jamais.
Dernier problème, les deux joueurs commencent avec un score à -1
Merci à vous pour votre lecture, et à bientôt

Il est aussi important de préciser que je suis élève de terminale SI option ISN, et je fais ceci dans le cadre de mon projet personnel. Donc voilà, si vous avez des idées et des pistes à éclairer, n'hésiter pas à me les faire parvenir.

tu semble avoir des "reste d'affichage de scores qui trainent sur l'écran essayes en effaçant le vieux score avant d'écrire le nouveau ' à chacun des endroits ou tu affiches tes scores

lcd.setCursor (9, 0);
 // affichage du score du J1
 lcd.print("   "); // (trois espaces)
lcd.setCursor (9, 0);
 // affichage du score du J1
 lcd.print(scoreJ1);

Merci pour ta réponse,
effectivement, c’est ce que je pense, il y a des “restes” comme tu dis de score qui reste à l’écran.
J’avais déjà essayé d’utiliser cette astuce, mais à moins que je n’ai pas su bien la placé, cela ne fonctionne pas.
J’ai réessayé selon la syntaxe que tu as donné, pareil, rien n’y fait !

ton code avec les modifs d’effacement

#include <LiquidCrystal.h>
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);
int LED1 = 13; // déclarations des variables LED sur les broches
int LED2 = 12;
int LED3 = 2;
int LED4 = 10;
int BUTTON_PIN1=1; //déclaration des variable bouttons (broche + permettre lecture de l'etat du boutton
int BUTTON_PIN2=3;
int BUTTON_PIN3=11;
int BUTTON_PIN4=0;
int scoreJ1 = 0;          //les scores des joueurs 1 et 2
int scoreJ2 = 0;
int previousButton1State = LOW;
int previousButton2State = LOW;
int previousButton3State = LOW;    // l'état des boutons avant qu'ils ne soient pressés
int previousButton4State = LOW;
boolean isIniti = false;           //variable de type booléan en "faux", permettra de rentrer qu'une seule fois à l'initialisation
int ledId = LED1;
int ledId3 = LED3;                  // les ledsId vont permettre de d'allumer une des deux leds de chaque joueur
int buttonState = 0;
int buttonBase = buttonState;        //l'état du bouton de base, est égal à l'état du bouton, utile pour gérer le rebond du bouton poussoir.

void setup ()
{
  pinMode(LED1, OUTPUT); //leds en sorties
  pinMode (LED2, OUTPUT);
  pinMode (LED3, OUTPUT);
  pinMode (LED4, OUTPUT);
  pinMode (BUTTON_PIN1, INPUT);  //boutons en entrées
  pinMode (BUTTON_PIN2, INPUT);
  pinMode (BUTTON_PIN3, INPUT);
  pinMode (BUTTON_PIN4, INPUT);
  lcd.begin(16, 2);        // on initialise un écran de 16 caractères sur 2 lignes
  lcd.write("Joueur 1:");
  lcd.setCursor (0, 1);   //on place le curseur sur la ligne d'en dessous pour écrire Joueur 2
  lcd.write ("Joueur 2:");
}

// Initialise l'allumage d'une led.
void initi()
{
  // On initialise si besoin
  if (!isIniti) // On ne doit entrer qu'une seule fois à chaque partie. (grâce au "!")
  {
    // On peut ajouter un delay ici (mais les pressions bouton ne seront pas détectées)
    pickLed(); // choix d'une led.
    digitalWrite (ledId, HIGH); // allumage de la led du joueur 1.
    digitalWrite (ledId3, HIGH); // et celle du joueur 2
    isIniti = true; // On marque que le programme est initialisé pour ne pas refaire la fonction.
  }
}

// Permet de choisir la Led1 et la Led 3 ou la Led2 et la Led 4 aléatoirement.
void pickLed()
{
  if (random(2) == 1) {
    ledId = LED2;
    ledId3 = LED4;
  } else {
    ledId = LED1;
    ledId3 = LED3;
  }
}

// Vérifie la pression des boutons et met à jour le score
void checkButtons()
{
  // On determine le bouton qui marque des points.


  int increasingPin = BUTTON_PIN1; // pas besoin de If, puisque de base il est sur le bouton 1, si jamais la ledid change,
  if (ledId == LED2) {             //alors on peut utiliser le if qui permettra de controler ce changement.
    increasingPin = BUTTON_PIN2;
  }

  int increasingPin3 = BUTTON_PIN3; // de même

  if (ledId3 == LED4)
  {
    increasingPin3 = BUTTON_PIN4;
  }


  // On vérifie le bouton 1
  checkButton1(increasingPin);
  // On vérifie le bouton 2
  checkButton2(increasingPin);    //appelle des différentes fonction vu plus bas
  //on vérifie le bouton 3
  checkButton3(increasingPin3);
  //on vérifie le bouton 4
  checkButton4 (increasingPin3);
}

void checkButton1(int increasingPin)
{
  // On détermine le nombre de point marqué par le J1 si le bouton1 est pressé.
  int points = 1; // de base, point est à un
  if (BUTTON_PIN1 != increasingPin) // si le bouton 1 est pressé alors que sa led correspondante n'est pas activé,
  {

    points = -1;    // on lui affecte la valeur -1

  }

  // On vérifie que le bouton est pressé.
  buttonState = digitalRead(BUTTON_PIN1);
  if (buttonState == HIGH && buttonState != previousButton1State) { // Si il est pressé

    // Mise a jour du score
    scoreJ1 = scoreJ1 + points;
    // affichage du score du J1
    
lcd.setCursor (9, 0);
 // affichage du score du J1
 lcd.print("     "); // (cinq espaces)
lcd.setCursor (9, 0);
 // affichage du score du J1
 lcd.print(scoreJ1);

    // Est-ce le bon bouton ?
    if (increasingPin == BUTTON_PIN1) // si oui
    {
      digitalWrite (ledId, LOW);
      digitalWrite (ledId3, LOW); // On éteint la led.
      isIniti = false; // On marque que le programme doit etre initialisé, au prochain passage dans init.
    }
  }
  previousButton1State = buttonState; // On stocke l'état du bouton pour vérifier si il y a un changement d'état

}

void checkButton2(int increasingPin)
{
  // On détermine le nombre de point marqué par le J2 si le bouton2 est pressé.
  int points = 1;
  if (BUTTON_PIN2 != increasingPin)
  {
    points = -1;
  }

  // On vérifie que le bouton est pressé.
  buttonState = digitalRead(BUTTON_PIN2);
  if (buttonState == HIGH && buttonState != previousButton2State) { // Si il est pressé
    // Mise a jour du score
    scoreJ1 = scoreJ1 + points;
    
lcd.setCursor (9, 0);
 // affichage du score du J1
 lcd.print("     "); // (cinq espaces)
lcd.setCursor (9, 0);
 // affichage du score du J1
 lcd.print(scoreJ1);

    // Est-ce le bon bouton ?
    if (increasingPin == BUTTON_PIN2) // oui
    {
      digitalWrite (ledId, LOW);
      digitalWrite (ledId3, LOW); // On éteint la led.
      isIniti = false; // On marque que le programme doit etre initialisé, au prochain passage dans init.
    }
  }
  previousButton2State = buttonState; // On stocke l'état du bouton pour vérifier si il y a un changement d'état

}
void checkButton3 (int increasingPin3)
{
  int points = 1;
  if (BUTTON_PIN3 != increasingPin3)
  {
    points = -1;
  }
  buttonState = digitalRead(BUTTON_PIN3);
  if (buttonState == HIGH && buttonState != previousButton3State) { // Si il est pressé
    // Mise a jour du score
    scoreJ2 = scoreJ2 + points;
    lcd.setCursor (9, 1);
 // affichage du score du J2
 lcd.print("      "); // (cinq espaces)
lcd.setCursor (9, 1);
 // affichage du score du J2
 lcd.print(scoreJ2);
    // Est-ce le bon bouton ?
    if (increasingPin3 == BUTTON_PIN3) // oui
    {
      digitalWrite (ledId, LOW);
      digitalWrite (ledId3, LOW); // On éteint les leds.
      isIniti = false;
    }
  }
  previousButton3State = buttonState;
}
void checkButton4 (int increasingPin)
{
  int points = 1;
  if (BUTTON_PIN4 != increasingPin)
  {
    points = -1;
  }
  buttonState = digitalRead(BUTTON_PIN4);
  if (buttonState == HIGH && buttonState != previousButton4State) { // Si il est pressé
    // Mise a jour du score
    scoreJ2 = scoreJ2 + points;
    
lcd.setCursor (9, 1);
 // affichage du score du J2
 lcd.print("     "); // (cinq espaces)
lcd.setCursor (9, 1);
 // affichage du score du J2
 lcd.print(scoreJ2);

    // Est-ce le bon bouton ?
    if (increasingPin == BUTTON_PIN4) // oui
    {
      digitalWrite (ledId, LOW);
      digitalWrite (ledId3, LOW); // On éteint les leds.
      isIniti = false;
    }
  }
  previousButton4State = buttonState;

}

// Et on exécute le programme en boucle.
void loop ()
{
  initi();
  checkButtons();

}

Non non, rien y fait, c'est exactement ce que j'avais fait (hormis que à la base j'avais juste mit 3 espaces comme tu avais conseillé au début), et là je réessaye pareil, mais avec 5 espace, ça ne fonctionne pas.

un schéma de ton montage, je fais le même et on regarde ensuite

Je préviens, c'est la première fois que j'utilise ce logiciel (Fritzing), donc c'est peut-être pas forcément tout à fait clair.. en tout cas, j'ai essayé de l'être le plus possible malgré tout !

|500x378

Petite remarque: chez moi, j'ai une carte Arduino UNO avec un "prototyping shield" qui se fixe par dessus la carte UNO, ça m'a permit d'avoir suffisement de broche pour le 5V et les GND. Donc, je n'ai pas trouvé le moyen sur le logiciel de reproduire le même principe, donc du coup j'ai tout connecté sur le prototyping shield, sans que lui même soit connecté à la carte Arduino (alors qu'en réalité il l'est ..)

Si ce n'est pas clair, fais moi le savoir !

Merci encore une fois pour ta patience.

il manque des raccordements sur le LCD, c'est voulu ?

Oui, j'ai sélectionné les seuls broches dont j'avais besoin, les autre gèrent d'autres paramètres que nous n'avons pas besoin ici il me semble (nous n'avons besoin que de l'affichage ^^ Les broches sont déclarées en début de programme "liquidCrystal"). Je peux peut-être me tromper, mais j'avais fait des recherches là dessus justement.

tu as tout faux, voici un copié/collé de ce que j'ai répondu à un autre gars lcd: 1= masse 2=+5V 3= retour potar 4= >patte micro c'est RS 5= 0V c'est R/W on force en W 6= >patte micro c'est Enable 7=0V car bus reduit à 4 fils 8=0V car bus reduit à 4 fils 9=0V car bus reduit à 4 fils 10=0V car bus reduit à 4 fils 11 = >patte micro c'est D4 12 = >patte micro c'est D5 13 = >patte micro c'est D6 14 = >patte micro c'est D7 15 = > +5V c'est l'anode de la led back light 16 = >0V c'est la cathode de la led back light

j'ai fais ton montage, je regarde ton code

ton code fonctionne et l'affichage aussi le voici à nouveau tu verras que j'ai modifié ton câblage cela à l'avantage de libérer les pinoches 0 et 1 et donc de te rendre la liaison USB accessible et vive le moniteur pour débuger. j'ai également rajouté une fonction de test des BP et une autre de test des leds ATTENTION aux commentaires, ils ne sont pas à jour. mais je te laisse le plaisir de le faire, cela te permettra de fouiller ton code pour le comprendre au mieux. le fonctionnement est je pense à modifier, car on ne voit pas qu'une saisie est terminée, il faudrait je pense ajouter une led qui s'allume 1/2 seconde pour signaler aux joueurs que c'est un nouveau coup. ...............................et non, j'ai toujours le même message de dépassement je vais être obligé de le couper en deux

j'insiste, il faut fixer le potentiel sur les pinoches inutilisées du LCD à 0v sans parler de la R/W qu'il faut fixer à 0V pour forcer le LCD en écriture.

bon j'ai essayé de te mettre le code, mais j'ai un message pour me dire que je dépasse les 9000 caractères. je fais un nouveau post ci dessous

la premiere moitié

#include <LiquidCrystal.h>
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);
int LED1 = 13; // déclarations des variables LED sur les broches
int LED2 = 12;
int LED3 = 11;//2;
int LED4 = A5;
int BP1 = A1; //1; //déclaration des variable bouttons (broche + permettre lecture de l'etat du boutton
int BP2 = A2; //3;
int BP3 = A3; //11;
int BP4 = A4; //0;
int scoreJ1 = 0;          //les scores des joueurs 1 et 2
int scoreJ2 = 0;
int previousButton1State = LOW;
int previousButton2State = LOW;
int previousButton3State = LOW;    // l'état des boutons avant qu'ils ne soient pressés
int previousButton4State = LOW;
boolean isIniti = false;           //variable de type booléan en "faux", permettra de rentrer qu'une seule fois à l'initialisation
int leds_J1 = LED1;
int leds_J2 = LED3;                  // les ledsId vont permettre de d'allumer une des deux leds de chaque joueur
int buttonState = 0;
int buttonBase = buttonState;        //l'état du bouton de base, est égal à l'état du bouton, utile pour gérer le rebond du bouton poussoir.
int val_BP1 = LOW;
int val_BP2 = LOW;
int val_BP3 = LOW;
int val_BP4 = LOW;

void setup ()
{
  Serial.begin(57600);
  pinMode(LED1, OUTPUT); //leds en sorties
  pinMode (LED2, OUTPUT);
  pinMode (LED3, OUTPUT);
  pinMode (LED4, OUTPUT);
  pinMode (BP1, INPUT);  //boutons en entrées
  pinMode (BP2, INPUT);
  pinMode (BP3, INPUT);
  pinMode (BP4, INPUT);
  lcd.begin(16, 2);        // on initialise un écran de 16 caractères sur 2 lignes
  lcd.write("Joueur 1:");
  lcd.setCursor (0, 1);   //on place le curseur sur la ligne d'en dessous pour écrire Joueur 2
  lcd.write ("Joueur 2:");
  test_leds();
  test_BP();
}

// Initialise l'allumage d'une led.
void initi()
{
  // On initialise si besoin
  if (!isIniti) // On ne doit entrer qu'une seule fois à chaque partie. (grâce au "!")
  {
    // On peut ajouter un delay ici (mais les pressions bouton ne seront pas détectées)
    pickLed(); // choix d'une led.
    digitalWrite (leds_J1, HIGH); // allumage de la led du joueur 1.
    digitalWrite (leds_J2, HIGH); // et celle du joueur 2
    isIniti = true; // On marque que le programme est initialisé pour ne pas refaire la fonction.
    Serial.print("les leds choisies sont allumees : joueur 1 = "); Serial.print(leds_J1); Serial.print(" et Joueur 2 = "); Serial.println(leds_J2);

  }
}

// Permet de choisir la Led1 et la Led 3 ou la Led2 et la Led 4 aléatoirement.
void pickLed()
{
  if (random(2) == 1) {
    leds_J1 = LED2;
    leds_J2 = LED4;
  } else {
    leds_J1 = LED1;
    leds_J2 = LED3;
  }
  Serial.print("leds choisies : Joueur 1= "); Serial.print(leds_J1); Serial.print(" et Joueur 2 = "); Serial.println(leds_J2);
}

// Vérifie la pression des boutons et met à jour le score
void checkButtons()
{
  // On determine le bouton qui marque des points.


  int BP_enfonce_J1 = BP1; // pas besoin de If, puisque de base il est sur le bouton 1, si jamais la leds_J1 change,
  if (leds_J1 == LED2) {             //alors on peut utiliser le if qui permettra de controler ce changement.
    BP_enfonce_J1 = BP2;
  }

  int BP_enfonce_J2 = BP3; // de même

  if (leds_J2 == LED4)
  {
    BP_enfonce_J2 = BP4;
  }


  // On vérifie le bouton 1
  checkButton1(BP_enfonce_J1);
  // On vérifie le bouton 2
  checkButton2(BP_enfonce_J1);    //appelle des différentes fonction vu plus bas
  //on vérifie le bouton 3
  checkButton3(BP_enfonce_J2);
  //on vérifie le bouton 4
  checkButton4 (BP_enfonce_J2);
}

void checkButton1(int BP_enfonce_J1)
{
  // On détermine le nombre de point marqué par le J1 si le bouton1 est pressé.
  int points = 1; // de base, point est à un
  if (BP1 != BP_enfonce_J1) // si le bouton 1 est pressé alors que sa led correspondante n'est pas activé,
  {

    points = -1;    // on lui affecte la valeur -1

  }

  // On vérifie que le bouton est pressé.
  buttonState = digitalRead(BP1);
  if (buttonState == HIGH && buttonState != previousButton1State) { // Si il est pressé

    // Mise a jour du score
    scoreJ1 = scoreJ1 + points;
    // affichage du score du J1

    lcd.setCursor (9, 0);
    // affichage du score du J1
    lcd.print("     "); // (cinq espaces)
    lcd.setCursor (9, 0);
    // affichage du score du J1
    lcd.print(scoreJ1);

    // Est-ce le bon bouton ?
    if (BP_enfonce_J1 == BP1) // si oui
    {
      digitalWrite (leds_J1, LOW);
      digitalWrite (leds_J2, LOW); // On éteint la led.
      isIniti = false; // On marque que le programme doit etre initialisé, au prochain passage dans init.
    }
  }
  previousButton1State = buttonState; // On stocke l'état du bouton pour vérifier si il y a un changement d'état

}

void checkButton2(int BP_enfonce_J1)
{
  // On détermine le nombre de point marqué par le J2 si le bouton2 est pressé.
  int points = 1;
  if (BP2 != BP_enfonce_J1)
  {
    points = -1;
  }

la suite

la suite

// On vérifie que le bouton est pressé.
  buttonState = digitalRead(BP2);
  if (buttonState == HIGH && buttonState != previousButton2State) { // Si il est pressé
    // Mise a jour du score
    scoreJ1 = scoreJ1 + points;

    lcd.setCursor (9, 0);
    // affichage du score du J1
    lcd.print("     "); // (cinq espaces)
    lcd.setCursor (9, 0);
    // affichage du score du J1
    lcd.print(scoreJ1);

    // Est-ce le bon bouton ?
    if (BP_enfonce_J1 == BP2) // oui
    {
      digitalWrite (leds_J1, LOW);
      digitalWrite (leds_J2, LOW); // On éteint la led.
      isIniti = false; // On marque que le programme doit etre initialisé, au prochain passage dans init.
    }
  }
  previousButton2State = buttonState; // On stocke l'état du bouton pour vérifier si il y a un changement d'état

}
void checkButton3 (int BP_enfonce_J2)
{
  int points = 1;
  if (BP3 != BP_enfonce_J2)
  {
    points = -1;
  }
  buttonState = digitalRead(BP3);
  if (buttonState == HIGH && buttonState != previousButton3State) { // Si il est pressé
    // Mise a jour du score
    scoreJ2 = scoreJ2 + points;
    lcd.setCursor (9, 1);
    // affichage du score du J2
    lcd.print("      "); // (cinq espaces)
    lcd.setCursor (9, 1);
    // affichage du score du J2
    lcd.print(scoreJ2);
    // Est-ce le bon bouton ?
    if (BP_enfonce_J2 == BP3) // oui
    {
      digitalWrite (leds_J1, LOW);
      digitalWrite (leds_J2, LOW); // On éteint les leds.
      isIniti = false;
    }
  }
  previousButton3State = buttonState;
}


void checkButton4 (int BP_enfonce_J2)
{
  int points = 1;
  if (BP4 != BP_enfonce_J2)
  {
    points = -1;
  }
  buttonState = digitalRead(BP4);
  if (buttonState == HIGH && buttonState != previousButton4State) { // Si il est pressé
    // Mise a jour du score
    scoreJ2 = scoreJ2 + points;

    lcd.setCursor (9, 1);
    // affichage du score du J2
    lcd.print("     "); // (cinq espaces)
    lcd.setCursor (9, 1);
    // affichage du score du J2
    lcd.print(scoreJ2);

    // Est-ce le bon bouton ?
    if (BP_enfonce_J2 == BP4) // oui
    {
      digitalWrite (leds_J1, LOW);
      digitalWrite (leds_J2, LOW); // On éteint les leds.
      isIniti = false;
    }
  }
  previousButton4State = buttonState;

}
void test_leds()
{
  Serial.println("test des leds en cours");
  for (int f = 0; f < 4; f++) {
    digitalWrite (LED1, HIGH); // allumage de la led du joueur 1.
    digitalWrite (LED2, HIGH); // et celle du joueur 2
    digitalWrite (LED3, HIGH); // allumage de la led du joueur 1.
    digitalWrite (LED4, HIGH); // et celle du joueur 2
    delay(200);
    digitalWrite (LED1, LOW); // allumage de la led du joueur 1.
    digitalWrite (LED2, LOW); // et celle du joueur 2
    digitalWrite (LED3, LOW); // allumage de la led du joueur 1.
    digitalWrite (LED4, LOW); // et celle du joueur 2
    delay(200);
  }
  digitalWrite (LED1, LOW); // allumage de la led du joueur 1.
  digitalWrite (LED2, LOW); // et celle du joueur 2
  digitalWrite (LED3, LOW); // allumage de la led du joueur 1.
  digitalWrite (LED4, LOW); // et celle du joueur 2
}
void test_BP()
{
  Serial.println("test des BP en cours, appuez sur les BP un par un");
  int tampon = 0;
  static boolean flag_BP1 = false;
  static boolean flag_BP2 = false;
  static boolean flag_BP3 = false;
  static boolean flag_BP4 = false;
  while (tampon != 15)
  {
    val_BP1 = digitalRead (BP1);
    if (val_BP1 == HIGH)
    {
      digitalWrite (LED1, HIGH);
      {
        if (flag_BP1 == false)
        {
          tampon = tampon + 1;
          flag_BP1 = true;
          Serial.println("BP1 = ok");
        }
      }
    }

    val_BP2 = digitalRead (BP2);
    if (val_BP2 == HIGH)
    {
      digitalWrite (LED2, HIGH);
      {
        if (flag_BP2 == false)
        {
          tampon = tampon + 2;
          flag_BP2 = true;
          Serial.println("BP2 = ok");
        }
      }
    }
    val_BP3 = digitalRead (BP3);
    if (val_BP3 == HIGH)
    {
      digitalWrite (LED3, HIGH);
      {
        if (flag_BP3 == false)
        {
          tampon = tampon + 4;
          flag_BP3 = true;
          Serial.println("BP3 = ok");
        }
      }
    }
    val_BP4 = digitalRead (BP4);
    if (val_BP4 == HIGH)
    {
      digitalWrite (LED4, HIGH);
      {
        if (flag_BP4 == false)
        {
          tampon = tampon + 8;
          flag_BP4 = true;
          Serial.println("BP4 = ok");
        }
      }
    }
  }
  digitalWrite (LED1, LOW); // allumage de la led du joueur 1.
  digitalWrite (LED2, LOW); // et celle du joueur 2
  digitalWrite (LED3, LOW); // allumage de la led du joueur 1.
  digitalWrite (LED4, LOW); // et celle du joueur 2
}
  // Et on exécute le programme en boucle.
  void loop ()
  {
    initi();
    checkButtons();

  }

Que dire .. vraiment merci pour ton aide très précieuse ! En revanche, je n'aurai pas le temps de tester le programme ce soir avec les nouveaux branchements (je passe des oraux de langue demain matin ^^'), mais je regarde ça dès que possible pour tout comprendre ! Par la même occasion, j'essayerai de trouver un moyen pour fixer la limite de score, afin de déterminer un vainqueur pour une partie !

Je te tiens au courant, merci encore !

une suggestion pour signifier aux joueurs qu'un nouveau coup commence remplace cette fonction

void pickLed()
{
    digitalWrite (LED1, LOW); // allumage de la led du joueur 1.
    digitalWrite (LED2, LOW); // et celle du joueur 2
    digitalWrite (LED3, LOW); // allumage de la led du joueur 1.
    digitalWrite (LED4, LOW); // et celle du joueur 2
  
    digitalWrite (LED1, HIGH); // allumage de la led du joueur 1.
   delay(200);
    digitalWrite (LED2, HIGH); // et celle du joueur 2
  delay(200);  
    digitalWrite (LED3, HIGH); // allumage de la led du joueur 1.
  delay(200);  
    digitalWrite (LED4, HIGH); // et celle du joueur 2
    
    delay(500);
   
    digitalWrite (LED4, LOW); // allumage de la led du joueur 1.
   delay(200); 
    digitalWrite (LED3, LOW); // et celle du joueur 2
   delay(200); 
    digitalWrite (LED2, LOW); // allumage de la led du joueur 1.
   delay(200); 
    digitalWrite (LED1, LOW); // et celle du joueur 2
    
    delay(500);
    
  if (random(2) == 1) {
    leds_J1 = LED2;
    leds_J2 = LED4;
  } else {
    leds_J1 = LED1;
    leds_J2 = LED3;
  }
  Serial.print("leds choisies : Joueur 1= "); Serial.print(leds_J1); Serial.print(" et Joueur 2 = "); Serial.println(leds_J2);
}

Je suis en train d'effectuer le montage et je test actuellement le programme. Seulement, je dois me tromper sur les câblages de l'écran lcd. Quand tu dis qu'on doit forcer le R/W en W et donc mettre le pin à 0V (ainsi que les autres pins inutilisés), comment procède-t-on ? Je ne comprends pas, je dois les relier à la masse ? Ou est-ce que je dois écrire une ligne de code ?

oui, c’est bien les cabler à la masse

je me suis amusé à faire ton code
il vient tout juste d’etre termine
il semble bien fonctionner
par contre il faudra virer les commentaires actuels qui sont des restes des anciens commentaires et les remplacer par les tiens.
mefies toi, les cablage des leds et des BP est peu etre légèrement different
à toi de chercher
demain, je ne suis pas là de toute la journée

#include <LiquidCrystal.h>
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);

#define LEDS 4
int PIN_LED [LEDS] = {13, 12, 11, A5};
#define BPS 4
int PIN_BP [BPS] = {A1, A2, A3, A4};
boolean FLAG_SAISIE_J1 = false;
boolean FLAG_SAISIE_J2 = false;
boolean isInitialisation = false;
int BP_enfonce_J1 = 0;
int BP_enfonce_J2 = 0;
int BP_enfonce=0;
int tampon = 0;
int leds_J1 = 0;
int leds_J2 = 0;
int flag_led_J1 = 0;
int flag_led_J2 = 0;
int score_J1 = 0;
int score_J2 = 0;
int C=0;
int L=0;
int score = 0;
int score_maxi=0;
int score_max=0;
int tempo = 100;
void setup() {
Serial.begin(57600);
lcd.begin(16, 2); // on initialise un écran de 16 caractères sur 2 lignes

// affichage du score du J1
//lcd.print(" "); // (cinq espaces)
//lcd.setCursor (9, 0);
// affichage du score du J1
//lcd.print(scoreJ1);

//on place le curseur sur la ligne d’en dessous pour écrire Joueur 2

for (int i = 0; i < LEDS; i++) {
pinMode(PIN_LED*, OUTPUT);*

  • }*
  • for (int i = 0; i < BPS; i++) {*
    pinMode(PIN_BP*, INPUT);
    _
    }*_

* test_leds(tempo);
reglage_score_maxi();
//test_BP();
init_affichage_jeu();
//Initialisation_scores();
_
}_
void loop()
_
{_
_
Serial.println("");_
_
Serial.println(“boucle loop”);_
_
Initialisation();_
Serial.print("bcl loop flag_led : Joueur 1= "); Serial.println(flag_led_J1);
Serial.print(“bcl loop flag_led : Joueur 2= “); Serial.println(flag_led_J2);
scrutation_des_BP();
controle_reponses();
controle_partie_finie();
_
isInitialisation = false;_
_
}_
void scrutation_des_BP()// scrutation de BP
_
{_
_
Serial.println(””);_
_
Serial.println(“fonction scrutation BP”);_
//while ((FLAG_SAISIE_J1 != true) || (FLAG_SAISIE_J2 != true))
while ((FLAG_SAISIE_J1 != true) && (FLAG_SAISIE_J2 != true))
_
{_
_
for (int i = 0; i < BPS; i++)_
_
{_
_
if (i < 2)_
_
{_
if (FLAG_SAISIE_J1 == false)
_
{_
BP_enfonce_J1 = digitalRead(PIN_BP);
if (BP_enfonce_J1 != 0)
_ {_
BP_enfonce_J1 = (i + 1);
FLAG_SAISIE_J1 = true;
Serial.print("BP enfonce Joueur 1 = "); Serial.println(BP_enfonce_J1);
_ }
}
}
else*
* {_
if (FLAG_SAISIE_J2 == false)
_ {_
BP_enfonce_J2 = digitalRead(PIN_BP);
if (BP_enfonce_J2 != 0)
_ {_
BP_enfonce_J2 = (i + 1);
FLAG_SAISIE_J2 = true;
Serial.print("BP enfonce Joueur 2 = "); Serial.println(BP_enfonce_J2);
_ }
}
}
}_

} Serial.print("scr bp flag_led : Joueur 1= "); Serial.println(flag_led_J1);
Serial.print("scr bp flag_led : Joueur 2= "); Serial.println(flag_led_J2);
//Serial.print(“BP Joueur 1= “); Serial.print(BP_enfonce_J1); Serial.print(” et BP Joueur 2 = “); Serial.println(BP_enfonce_J2);
_ delay(1000);
}
void Initialisation()
{
Serial.println(””);
Serial.println(“fonction initialisation”);
// On initialise si besoin*

* if (!isInitialisation) // On ne doit entrer qu’une seule fois à chaque partie. (grâce au “!”)
{
// On peut ajouter un delay ici (mais les pressions bouton ne seront pas détectées)_

init_nouveau_coup();
choix_Led(); // choix d’une led.
digitalWrite (leds_J1, HIGH); // allumage de la led du joueur 1.
digitalWrite (leds_J2, HIGH); // et celle du joueur 2*

* isInitialisation = true; // On marque que le programme est initialisé pour ne pas refaire la fonction.*
* // Serial.print("les leds choisies sont allumees : joueur 1 = “); Serial.print(leds_J1); Serial.print(” et Joueur 2 = "); Serial.println(leds_J2);
Serial.print("init flag_led : Joueur 1= "); Serial.println(flag_led_J1);
Serial.print(“init flag_led : Joueur 2= “); Serial.println(flag_led_J2);
_ }
}
// Permet de choisir la Led1 et la Led 3 ou la Led2 et la Led 4 aléatoirement.
void choix_Led()
{
Serial.println(””);
Serial.println(“fonction picked”);
//randomSeed(analogRead(0));
tampon = 5;
while (tampon > 1)
{
tampon = ((random(400)) / 100);
// Serial.print("tampon Joueur 1= "); Serial.println(tampon);
if (tampon < 2)
{_

leds_J1 = PIN_LED [tampon];
flag_led_J1 = tampon + 1 ;
Serial.print("leds choisies Joueur 1= "); Serial.println(leds_J1);
Serial.print("flag_led : Joueur 1= “); Serial.println(flag_led_J1);
_ }
// Serial.println(” ");
}
tampon = 0;
while (tampon < 2)
{
tampon = ((random(400)) / 100);
//Serial.print("tampon Joueur 2= "); Serial.println(tampon);
if (tampon > 1)
{_

leds_J2 = PIN_LED [tampon];
flag_led_J2 = tampon + 1 ;
Serial.print("leds choisies : Joueur 2= "); Serial.println(leds_J2);
Serial.print(“flag_led : Joueur 2= “); Serial.println(flag_led_J2);
_ }
} Serial.println(” “);
}
void init_nouveau_coup()
{
Serial.println(””);
Serial.println(“fonction nouveau coup”);_

FLAG_SAISIE_J1 = false;
FLAG_SAISIE_J2 = false;
BP_enfonce_J1 = 0;
BP_enfonce_J2 = 0;
leds_J1 = 0;
leds_J2 = 0;
_ for (int i = 0; i < LEDS; i++) {
digitalWrite(PIN_LED , LOW);
}
}_

void controle_reponses()
{ Serial.print("ctrl rep bp flag_led : Joueur 1= “); Serial.println(flag_led_J1);
Serial.print(“ctrl rep bp flag_led : Joueur 2= “); Serial.println(flag_led_J2);
_ Serial.println(””);
Serial.println(“controle reponses”);_

if (FLAG_SAISIE_J1 == true)
_ {_
Serial.print(“BP_enfonce_J1”); Serial.println(BP_enfonce_J1); Serial.print(“led_allumee_J1”); Serial.println(flag_led_J1);
if (BP_enfonce_J1 == flag_led_J1)
{ score_J1++;
_ Serial.println(“J1 +1”);
}
else*

* {_
score_J1–; Serial.println(“J1 -1”);
_ }_
C=9;L=0;score=score_J1;affichage_des_scores(C,L,score);
_ }_
if (FLAG_SAISIE_J2 == true)
_ {_
Serial.print(“BP_enfonce_J2”); Serial.println(BP_enfonce_J2); Serial.print(“led_allumee_J2”); Serial.println(flag_led_J2);
if (BP_enfonce_J2 == flag_led_J2) {
score_J2++;
_ Serial.println(“J2 +1”);
} else {_

score_J2–;
_ Serial.println(“J2 -1”);
}_

C=9;L=1;score=score_J2;affichage_des_scores(C,L,score);
_ }
}
void affichage_des_scores(int C,int L, int score)
{
lcd.setCursor (C, L); lcd.print(” ");
lcd.setCursor (C, L); lcd.print(score);
}
void controle_partie_finie()
{_

if ((score_J1==score_maxi)or(score_J1>score_maxi))
_ {_
for (int i = 0; i < 10; i++){test_leds(tempo=10); }
score_J1=0;score_J2=0;score=0;
C=9;L=0;affichage_des_scores(C,L,score);
C=9;L=1;affichage_des_scores(C,L,score);
_ }*_

* if ((score_J2==score_maxi)or(score_J2>score_maxi))
_ {_
for (int i = 0; i < 10; i++){test_leds(tempo=20); }
score_J1=0;score_J2=0;score=0;
C=9;L=0;affichage_des_scores(C,L,score);
C=9;L=1;affichage_des_scores(C,L,score);
_ }
}
void test_leds(int tempo)
{
for (int i = 0; i < LEDS; i++) {
digitalWrite(PIN_LED , HIGH);
delay(tempo);
}
for (int i = 0; i < LEDS; i++) {
digitalWrite(PIN_LED , LOW);
delay(tempo);
}
}
void init_affichage_jeu()
{
lcd.clear();
C = 0; L = 0; lcd.setCursor (C, L); lcd.write(“Joueur 1:”);
C = 0; L = 1; lcd.setCursor (C, L); lcd.write(“Joueur 2:”);_

C=9;L=0;affichage_des_scores(C,L,score);
C=9;L=1;affichage_des_scores(C,L,score);
_}
void init_affichage_score_maxi(int score_max)
{
C = 0; L = 0; lcd.setCursor (C, L); lcd.write(“reglage du score maxi”);_

C = 7; L = 1; lcd.setCursor (C, L); lcd.print(score_max);
Serial.print("score_max = "); Serial.println(score_max);
_}
void reglage_score_maxi()
{*_

* init_affichage_score_maxi(score_maxi);
_ Serial.println(“reglage du score maxi”);_
while (BP_enfonce != 3) // touche 2 du J2 attribuee pour select score maxi*

* {*
* for (int i = 0; i < BPS; i++)*
* {Serial.print("i = "); Serial.println(i);*
BP_enfonce = digitalRead(PIN_BP*);
if (BP_enfonce != 0)
_ {_
BP_enfonce = i;
if (BP_enfonce == 1){score_maxi ++;}
if (BP_enfonce == 2){score_maxi --;}
Serial.print("BP enfonce pour score_maxi = "); Serial.println(BP_enfonce);
Serial.print("score_maxi = "); Serial.println(score_maxi);*

* init_affichage_score_maxi(score_maxi);
_ }
}
delay(1000);
}*_

}
[/quote]

bon, un petit mot vite fait dans le prg, il manque une fonction pour tester le bon fonctionnement des BP il faut supprimer les commentaires et en remettre qui correspondent au code. au lancement du prg, une fonction de reglage du score maxi les BP centraux servent à incrémenter/décrémenter le score maxi le BP de droite sert à valider le score maxi initialisé pour les autres fonctions, tu verras en testant le prg nota, afin d'éviter des saisies multiples, il y a des delay(1000) que tu pourras ajuster à ton gout il existe une methode qui consiste à empecher tout nouvelle saisie tant que la touche n'a pas été relachée.

et tu peux aussi garder ta première version

bon courage