Idées pour améliorer un Dé électronique 4 joueurs

Bonjour à tous,

j'aurai besoin d'une idée pour faire avancer mon projet, svp.

Mon programme final fonctionne parfaitement: un dé électronique actionné par 4 boutons (4joueurs) à tour de rôle.
Je souhaite maintenant pouvoir choisir le nombre de joueur et pourvoir faire tourner ma boucle sur 1, 2, 3 ou 4 joueurs.
Pour la sélection du nombre de joueur, je verrai après (sélecteur, boutons, ...)

Ma question est celle-ci: que dois-je utiliser comme type de commande ou méthode pour faire ça dans mon programme.
Je pèche, j'aurai besoin que l'on m'aiguille un peu.

Merci d'avance
Ce post est mon premier de ma vie, je vais essayer de faire ça bien :slight_smile:

const int bouton1 = A0;
const int bouton2 = A1;
const int bouton3 = A2;
const int bouton4 = A3;
int nbreAleatoire;
const int nombreled = 7;
int ledPins2 = 2;
int ledPins3 = 3;
int ledPins4 = 4;
int ledPins5 = 5;
int ledPins6 = 6;
int ledPins7 = 7;
int ledPins8 = 8;
int bouton_seq = 1;
int etatDuBouton1 = 0;
int etatDuBouton2 = 0;
int etatDuBouton3 = 0;
int etatDuBouton4 = 0;
int ledBouton1 = 9;
int ledBouton2 = 10;
int ledBouton3 = 11;
int ledBouton4 = 12;
/*
  (6)     (2)
  (7) (5) (3)
  (8)     (4)
*/

void setup() {
  randomSeed(analogRead(A6));
  pinMode(bouton1, INPUT_PULLUP);
  pinMode(bouton2, INPUT_PULLUP);
  pinMode(bouton3, INPUT_PULLUP);
  pinMode(bouton4, INPUT_PULLUP);
  pinMode(ledPins2, OUTPUT);
  pinMode(ledPins3, OUTPUT);
  pinMode(ledPins4, OUTPUT);
  pinMode(ledPins5, OUTPUT);
  pinMode(ledPins6, OUTPUT);
  pinMode(ledPins7, OUTPUT);
  pinMode(ledPins8, OUTPUT);
  pinMode(ledBouton1, OUTPUT);
  pinMode(ledBouton2, OUTPUT);
  pinMode(ledBouton3, OUTPUT);
  pinMode(ledBouton4, OUTPUT);
}

void loop()
{
  nbreAleatoire = random(1, 7);

  if (bouton_seq == 1)
  {
    digitalWrite(ledBouton1, HIGH);
    delay(50);
    digitalWrite(ledBouton1, LOW);
    delay(50);

    int etatDuBouton1 = digitalRead(bouton1);
    if (etatDuBouton1 == LOW)
    {
      digitalWrite(ledPins2, LOW);
      digitalWrite(ledPins3, LOW);
      digitalWrite(ledPins4, LOW);
      digitalWrite(ledPins5, LOW);
      digitalWrite(ledPins6, LOW);
      digitalWrite(ledPins7, LOW);
      digitalWrite(ledPins8, LOW);
    }
    while (etatDuBouton1 == LOW)
    {
      etatDuBouton1 = digitalRead(bouton1);
      affichage();
      bouton_seq = 2;
      digitalWrite(ledBouton4, LOW);
      digitalWrite(ledBouton1, HIGH);
    }
  }
  if (bouton_seq == 2)
  {
    digitalWrite(ledBouton2, HIGH);
    delay(50);
    digitalWrite(ledBouton2, LOW);
    delay(50);

    int etatDuBouton2 = digitalRead(bouton2);
    if (etatDuBouton2 == LOW)
    {
      digitalWrite(ledPins2, LOW);
      digitalWrite(ledPins3, LOW);
      digitalWrite(ledPins4, LOW);
      digitalWrite(ledPins5, LOW);
      digitalWrite(ledPins6, LOW);
      digitalWrite(ledPins7, LOW);
      digitalWrite(ledPins8, LOW);
    }
    while (etatDuBouton2 == LOW)
    {
      etatDuBouton2 = digitalRead(bouton2);
      affichage();
      bouton_seq = 3;
      digitalWrite(ledBouton1, LOW);
      digitalWrite(ledBouton2, HIGH);
    }
  }
  if (bouton_seq == 3)
  {
    digitalWrite(ledBouton3, HIGH);
    delay(50);
    digitalWrite(ledBouton3, LOW);
    delay(50);

    int etatDuBouton3 = digitalRead(bouton3);
    if (etatDuBouton3 == LOW)
    {
      digitalWrite(ledPins2, LOW);
      digitalWrite(ledPins3, LOW);
      digitalWrite(ledPins4, LOW);
      digitalWrite(ledPins5, LOW);
      digitalWrite(ledPins6, LOW);
      digitalWrite(ledPins7, LOW);
      digitalWrite(ledPins8, LOW);
    }
    while (etatDuBouton3 == LOW)
    {
      etatDuBouton3 = digitalRead(bouton3);
      affichage();
      bouton_seq = 4;
      digitalWrite(ledBouton2, LOW);
      digitalWrite(ledBouton3, HIGH);
    }
  }
  if (bouton_seq == 4)
  {
    digitalWrite(ledBouton4, HIGH);
    delay(50);
    digitalWrite(ledBouton4, LOW);
    delay(50);

    int etatDuBouton4 = digitalRead(bouton4);
    if (etatDuBouton4 == LOW)
    {
      digitalWrite(ledPins2, LOW);
      digitalWrite(ledPins3, LOW);
      digitalWrite(ledPins4, LOW);
      digitalWrite(ledPins5, LOW);
      digitalWrite(ledPins6, LOW);
      digitalWrite(ledPins7, LOW);
      digitalWrite(ledPins8, LOW);
    }
    while (etatDuBouton4 == LOW)
    {
      etatDuBouton4 = digitalRead(bouton4);
      affichage();
      bouton_seq = 1;
      digitalWrite(ledBouton3, LOW);
      digitalWrite(ledBouton4, HIGH);
    }
  }
}
int affichage()
{
  digitalWrite(ledPins2, HIGH);
  delay(50);
  digitalWrite(ledPins3, HIGH);
  delay(50);
  digitalWrite(ledPins4, HIGH);
  delay(50);
  digitalWrite(ledPins5, HIGH);
  delay(50);
  digitalWrite(ledPins6, HIGH);
  delay(50);
  digitalWrite(ledPins7, HIGH);
  delay(50);
  digitalWrite(ledPins8, HIGH);
  delay(50);
  digitalWrite(ledPins8, LOW);
  delay(50);
  digitalWrite(ledPins7, LOW);
  delay(50);
  digitalWrite(ledPins6, LOW);
  delay(50);
  digitalWrite(ledPins5, LOW);
  delay(50);
  digitalWrite(ledPins4, LOW);
  delay(50);
  digitalWrite(ledPins3, LOW);
  delay(50);
  digitalWrite(ledPins2, LOW);
  delay(50);

  if (nbreAleatoire == 1) {
    digitalWrite(ledPins5, HIGH);
  }
  if (nbreAleatoire == 2) {
    digitalWrite(ledPins2, HIGH);
    digitalWrite(ledPins8, HIGH);
  }
  if (nbreAleatoire == 3) {
    digitalWrite(ledPins2, HIGH);
    digitalWrite(ledPins8, HIGH);
    digitalWrite(ledPins5, HIGH);
  }
  if (nbreAleatoire == 4) {
    digitalWrite(ledPins2, HIGH);
    digitalWrite(ledPins4, HIGH);
    digitalWrite(ledPins6, HIGH);
    digitalWrite(ledPins8, HIGH);
  }
  if (nbreAleatoire == 5) {
    digitalWrite(ledPins2, HIGH);
    digitalWrite(ledPins4, HIGH);
    digitalWrite(ledPins5, HIGH);
    digitalWrite(ledPins6, HIGH);
    digitalWrite(ledPins8, HIGH);
  }
  if (nbreAleatoire == 6) {
    digitalWrite(ledPins2, HIGH);
    digitalWrite(ledPins3, HIGH);
    digitalWrite(ledPins4, HIGH);
    digitalWrite(ledPins6, HIGH);
    digitalWrite(ledPins7, HIGH);
    digitalWrite(ledPins8, HIGH);
  }
}

Tu as 4 boutons : le plus simple pour sélectionner le nombre de joueurs est d'utiliser ces boutons : bouton1 = 1 joueur, bouton2 = 2 joueurs, etc.
C'est a priori dans le setup que tu feras cette sélection.

Ensuite, je te conseille d'utiliser des tableaux afin de simplifier ton code en y mettant des boucles. Par exemple :

Ceci peut être remplacé par un truc du genre

byte mesBoutons[4] = {A0, A1, A2, A3};
for (byte i=0; i<4; ++i) pinMode(mesBoutons[i], INPUT_PULLUP);

La première ligne va dans l'entête du code, avant le setup. La seconde remplace les 4 lignes de pinMode.
Si tu fais ça à tous les endroits où tu peux remplacer des lignes par une boucle, tu pourras facilement ensuite paramétrer le nombre de joueurs selon le choix fait au début, sans modifier énormément le code.
Mais il faut faire cet effort auparavant.

Ah mais tout à fait, je comptais bien réduire tout ce code en faisant des tableaux.
Je me disais que c'était plus simple pour travailler dessus au début.

Et pareil pour l'idée du choix du nombre de joueur en utilisant leur propre bouton, genre chaque joueur valide son bouton puis un 5eme bouton pour valider et démarrer la partie...

Merci pour les conseils, je continu de travailler dessus.

J'ai un peu de mal à suivre ce que tu veux faire notamment dans le code suivant.
Pourquoi avoir une boucle avec des trucs qui ne change pas et ne pas le sortir de ta boucle?
de même dans affichage tu semble faire une animation, mais avec 50ms entre chaque changement, je me dis que non, aucune animation, mais plutôt affichage du nouveau nombre.

Pour répondre à ta question initiale, j'ai l'impression qu'il faut que tu rationnalise ton code en fonction de ce que tu veux faire.

Merci pour vos réponses rapides et intérêt que vous porter à mon projet.

Alors effectivement le bout de code pour mettre les LEDs à LOW ne sert strictement à RIEN! :neutral_face:

Pour l'animation j'ai fait une vidéo:
Dé eléctronique 4 joueurs

Je commence à compacter mon code (je me plonge dans les tableaux :face_with_spiral_eyes:)

Ne sert à rien ça dépend de l'animation que tu veux produire dans la fonction affichage.
pourquoi tu rallume, puis éteint les LED de ton dé avec un écart de 50ms, puis affiche le résultat.
Autant si c'est l'animation que tu veux, mais comme affichage est dans un "while", qui appel entre autre la fonction tant que le bouton n'est pas relâché.
C'est à dire si le bouton est pressé pendant 5s, affichage sera appelé un certain nombre de fois et à chaque fois la nouvelle valeur sera affichée pendant le temps que le µC repasse sur les 7 HIGH.
En fait je ne suis pas sûre que c'est vraiment ce que tu peux faire.

Peut être qu'avant de passer par la phase tableau, tu devrais rationnaliser ton code et passer par une machine à état.
Ou au moins faire un petit diagramme de ton algorithme.

Une petite idée pour les animations : tu peux les "encoder" dans un tableau de int comme ceci :
{1,2,3,4,-1,-2,-3,-4,5,6,7,8,-8,-7,-6,-5}
Tu envoies ce tableau à une fonction animation qui va le décoder : une valeur positive allume la led, une valeur négative l'éteint

void animation (tab, n) {
for (int i=0; i<n; ++i) {
  digitalWrite (led[tab[i]], sgn(tab[i]));
  delay (50);
  }
}

n est le nombre de cases du tableau envoyé, et la fonction sgn est à définir quelque part (renvoie 1 si positif, et 0 si négatif) :

int sgn(int v) {
  return (v < 0) ? 0 : 1);
}

Le problème : il ne faut pas de led numéro 0... :wink:

Haha!! j'adore, ça fuse d'idées et ça m'en met plein la tête, j'adore... :crazy_face: et merci !

terwal > tu as raison, si je laisse le bouton appuyé: l’animation tourne en boucle. Bien vu.
En revanche, vu que l'animation tourne avant l'affichage du dé, elle permet d'éteindre toutes les LEDs.
Pour la machine à état j'ai regardé et c'est du level au dessus... :upside_down_face:

lesept > ok je vais partir sur : séparer en 2 fonctions: anime et affichage. Ça va faire K2000. lol

En plus de vos idées je dois réfléchir pour mon choix de nb de joueur...
D’ailleurs, c'est possible de mettre une boucle dans le void setup() pour configurer le nombre de joueurs?

Bien sûr : tu peux mettre un while qui scanne les boutons et attend que l'un d'eux soit enfoncé

Oui, mais mon questionnement était plus sur le fait de vouloir vraiment affiché la valeur de ton dé pendant que l'utilisateur appuis sur le bouton.
Comme je suppose que non, je pense qu'il serait bon d'au moins faire un diagramme de ce que tu veux faire, pour le comparer à ce que fait vraiment ton programme.

Pour la machine à état, non ce n'est pas spécialement d'un niveau au dessus, mais par contre cela te force à structure ta pensé :slight_smile:
Quitte a ne pas faire une vrai machine à état dans les règles de l'art

Il peut être aussi intéressant d'utiliser des "else" lorsque tu enchaine des "if" exclusif

Salut les gens

Alors j'ai bien réussi mon truc: je fais ma sélection du nombre de joueur et ça fonctionne niquel. :slightly_smiling_face:
J'ai ajouté un bouton pour valider la sélection.
J'ai essayé de commenter un peu pour faire comprendre ce que je fais.
Pas encore de tableaux, je patauge mais ce n'est pas ma priorité.
J'attends des boitiers pour fabriquer mon prototype, je referai une vidéo
Je remets mon code et je vais peut-être faire un schéma de câblage.
Je vois bien que mon code est à rallonge mais je le maitrise bien.
La bizarrerie c'est l'animation qui joue 2 fois.

const int bouton1 = A0;
const int bouton2 = A1;
const int bouton3 = A2;
const int bouton4 = A3;
const int bouton5 = A4;
int nbre_aleatoire;
int led_de2 = 2;
int led_de3 = 3;
int led_de4 = 4;
int led_de5 = 5;
int led_de6 = 6;
int led_de7 = 7;
int led_de8 = 8;
int bouton_seq = 1;
int etat_bouton1 = 0;       //bouton du joueur 1
int etat_bouton2 = 0;       //bouton du joueur 2
int etat_bouton3 = 0;       //bouton du joueur 3
int etat_bouton4 = 0;       //bouton du joueur 4
int etat_bouton5 = 0;       //bouton de validation
int led_bouton1 = 9;
int led_bouton2 = 10;
int led_bouton3 = 11;
int led_bouton4 = 12;
int led_bouton5 = 13;
int etat_bouton_selec_v = 0;
int etat_bouton_selec1 = 0;
int etat_bouton_selec2 = 0;
int etat_bouton_selec3 = 0;
int etat_bouton_selec4 = 0;
int joueur1 = 0;
int joueur2 = 0;
int joueur3 = 0;
int joueur4 = 0;
int joueur_total = 0;
/* Schéma d'implantation des LEDs du dé (numéro de sortie)
  (6)     (2)
  (7) (5) (3)
  (8)     (4)
*/

void setup() {
  randomSeed(analogRead(A6));
  pinMode(bouton1, INPUT_PULLUP);
  pinMode(bouton2, INPUT_PULLUP);
  pinMode(bouton3, INPUT_PULLUP);
  pinMode(bouton4, INPUT_PULLUP);
  pinMode(bouton5, INPUT_PULLUP);
  pinMode(led_de2, OUTPUT);
  pinMode(led_de3, OUTPUT);
  pinMode(led_de4, OUTPUT);
  pinMode(led_de5, OUTPUT);
  pinMode(led_de6, OUTPUT);
  pinMode(led_de7, OUTPUT);
  pinMode(led_de8, OUTPUT);
  pinMode(led_bouton1, OUTPUT);
  pinMode(led_bouton2, OUTPUT);
  pinMode(led_bouton3, OUTPUT);
  pinMode(led_bouton4, OUTPUT);

  int etat_bouton_selec_v = digitalRead(bouton5);
  while (etat_bouton_selec_v == HIGH)                   // On attend la validation du nombre de joueur avec le bouton de validation
  {
    digitalWrite(led_bouton5, HIGH);                      //le bouton de validation clignote
    delay(50);
    digitalWrite(led_bouton5, LOW);
    delay(50);
    etat_bouton_selec_v = digitalRead(bouton5);
    etat_bouton_selec1 = digitalRead(bouton1);          //on li les 4 boutons
    etat_bouton_selec2 = digitalRead(bouton2);
    etat_bouton_selec3 = digitalRead(bouton3);
    etat_bouton_selec4 = digitalRead(bouton4);

    if (etat_bouton_selec1 == 0)                        // si on appui sur le bouton du joueur 1
    {
      joueur1 = 1;                                      // on met la variable "joueur1" à 1
      digitalWrite(led_bouton1, HIGH);                  // on allume la LED du bouton du joueur 1
    }
    if (etat_bouton_selec2 == 0)
    {
      joueur2 = 1;
      digitalWrite(led_bouton2, HIGH);
    }
    if (etat_bouton_selec3 == 0)
    {
      joueur3 = 1;
      digitalWrite(led_bouton3, HIGH);
    }
    if (etat_bouton_selec4 == 0)
    {
      joueur4 = 1;
      digitalWrite(led_bouton4, HIGH);
    }
    joueur_total = joueur1 + joueur2 + joueur3 + joueur4;  // on additionne le nombre de bouton (joueur)

  }
  digitalWrite(led_bouton1, LOW);
  digitalWrite(led_bouton2, LOW);
  digitalWrite(led_bouton3, LOW);
  digitalWrite(led_bouton4, LOW);
}

void loop()
{
  nbre_aleatoire = random(1, 7);                //Générer un nombre aléatoire entre 1 et 7

  if (bouton_seq == 1 && joueur_total >= 1)        //Joueur 1 commence
  {
    digitalWrite(led_bouton1, HIGH);                //La LED du bouton du joueur 1 clignotte
    delay(50);
    digitalWrite(led_bouton1, LOW);
    delay(50);

    int etat_bouton1 = digitalRead(bouton1);

    while (etat_bouton1 == LOW)                   //Le joueur 1 appui sur son bouton
    {
      etat_bouton1 = digitalRead(bouton1);
      affichage();                               //Allumage du dé
      if (joueur_total <= 1)
      { // selon le nombre de joueur on repart au joueur 1
        bouton_seq = 1;
        digitalWrite(led_bouton1, HIGH);
      }
      else                                       // sinon on continu le tour
        bouton_seq = 2;                            //Incrémentation pour phase suivante
      digitalWrite(led_bouton2, LOW);            //On éteind la Led du bouton du joueur 2, 3 et 4
      digitalWrite(led_bouton3, LOW);
      digitalWrite(led_bouton4, LOW);
      digitalWrite(led_bouton1, HIGH);           //On allume constant la LED du joueur 1
    }
  }
  if (bouton_seq == 2 && joueur_total >= 2)
  {
    digitalWrite(led_bouton2, HIGH);
    delay(50);
    digitalWrite(led_bouton2, LOW);
    delay(50);

    int etat_bouton2 = digitalRead(bouton2);

    while (etat_bouton2 == LOW)
    {
      etat_bouton2 = digitalRead(bouton2);
      affichage();
      if (joueur_total <= 2)
      {
        bouton_seq = 1;
        digitalWrite(led_bouton1, LOW);
        digitalWrite(led_bouton2, HIGH);
      }
      else
        bouton_seq = 3;
      digitalWrite(led_bouton1, LOW);
      digitalWrite(led_bouton2, HIGH);
    }
  }
  if (bouton_seq == 3 && joueur_total >= 3)
  {
    digitalWrite(led_bouton3, HIGH);
    delay(50);
    digitalWrite(led_bouton3, LOW);
    delay(50);

    int etat_bouton3 = digitalRead(bouton3);

    while (etat_bouton3 == LOW)
    {
      etat_bouton3 = digitalRead(bouton3);
      affichage();
      if (joueur_total <= 3)
      {
        bouton_seq = 1;
        digitalWrite(led_bouton2, LOW);
        digitalWrite(led_bouton3, HIGH);
      }
      else
        bouton_seq = 4;
      digitalWrite(led_bouton2, LOW);
      digitalWrite(led_bouton3, HIGH);
    }
  }
  if (bouton_seq == 4 && joueur_total >= 4)
  {
    digitalWrite(led_bouton4, HIGH);
    delay(50);
    digitalWrite(led_bouton4, LOW);
    delay(50);

    int etat_bouton4 = digitalRead(bouton4);

    while (etat_bouton4 == LOW)
    {
      etat_bouton4 = digitalRead(bouton4);
      affichage();
      if (joueur_total <= 4)
      {
        bouton_seq = 1;
        digitalWrite(led_bouton3, LOW);
        digitalWrite(led_bouton4, HIGH);
      }
      else
        bouton_seq = 1;
      digitalWrite(led_bouton3, LOW);
      digitalWrite(led_bouton4, HIGH);
    }
  }
}
int affichage()
{
  digitalWrite(led_de2, HIGH);        //animation avant affichage du dé
  delay(50);
  digitalWrite(led_de3, HIGH);
  delay(50);
  digitalWrite(led_de4, HIGH);
  delay(50);
  digitalWrite(led_de5, HIGH);
  delay(50);
  digitalWrite(led_de6, HIGH);
  delay(50);
  digitalWrite(led_de7, HIGH);
  delay(50);
  digitalWrite(led_de8, HIGH);
  delay(50);
  digitalWrite(led_de8, LOW);
  delay(50);
  digitalWrite(led_de7, LOW);
  delay(50);
  digitalWrite(led_de6, LOW);
  delay(50);
  digitalWrite(led_de5, LOW);
  delay(50);
  digitalWrite(led_de4, LOW);
  delay(50);
  digitalWrite(led_de3, LOW);
  delay(50);
  digitalWrite(led_de2, LOW);
  delay(50);

  if (nbre_aleatoire == 1) {        //affichage du chiffre 1 sur le dé
    digitalWrite(led_de5, HIGH);
  }
  if (nbre_aleatoire == 2) {
    digitalWrite(led_de2, HIGH);
    digitalWrite(led_de8, HIGH);
  }
  if (nbre_aleatoire == 3) {
    digitalWrite(led_de2, HIGH);
    digitalWrite(led_de8, HIGH);
    digitalWrite(led_de5, HIGH);
  }
  if (nbre_aleatoire == 4) {
    digitalWrite(led_de2, HIGH);
    digitalWrite(led_de4, HIGH);
    digitalWrite(led_de6, HIGH);
    digitalWrite(led_de8, HIGH);
  }
  if (nbre_aleatoire == 5) {
    digitalWrite(led_de2, HIGH);
    digitalWrite(led_de4, HIGH);
    digitalWrite(led_de5, HIGH);
    digitalWrite(led_de6, HIGH);
    digitalWrite(led_de8, HIGH);
  }
  if (nbre_aleatoire == 6) {
    digitalWrite(led_de2, HIGH);
    digitalWrite(led_de3, HIGH);
    digitalWrite(led_de4, HIGH);
    digitalWrite(led_de6, HIGH);
    digitalWrite(led_de7, HIGH);
    digitalWrite(led_de8, HIGH);
  }
}

Salut les gens.
Juste pour donner des nouvelles de l'avancement.
J'ai fini le boitier principal et j'attaque les boitiers boutons de joueurs.
Un jour je ferai un proto sans fil mais cela signifie de mettre un arduino dans chaque boitier avec un NRF24L01 et une batterie.
@+



Qu'est-ce que tu appelles "l'animation" ?

juste avant que les leds affichent le score, il y a une animation: les leds s'allument dans un sens puis s’éteignent dans l'autre sens. c'est le début de la fonction "affichage()". voir la vidéo.

C'est peut-être dû au rebond des boutons dans les boucles while ?

C'est un mystère, l'animation a toujours joué 2 fois même au tout début lorsque j'ai créé mon programme simple sans while.
Mais ça ne me dérange pas, ça fait une anime plus longue et plus visuel. :star_struck:

Si ça te convient, tu peux en rester là.
Sinon, tu peux ajouter un delay(50); à la fin de la fonction et voir si ça le fait encore.

This topic was automatically closed 180 days after the last reply. New replies are no longer allowed.