Arduino & matrice 8x8

Version imprimable

1 pièce(s) jointe(s)

Bonjour ,

j'ai réalisé un projet de Pong avec 2 joueurs
à l'aide de Arduino Nano et une matrice 8x8
si le prg fonctionne de façon satisfaisante, je souhaite y rajouter les scores des 2 joueurs
sous cette forme Pièce jointe 582104

mais je n'y arrive pas
j'ai essayé de le faire sur croquis à part mais sans résultat

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
// Chiffres de 0 à 9 du score ***************************************** 
 
uint16_t Chiffre[10]= {111101101101111,010110010010111,111001111100111,111001011001111,
100101111001001,111100111001111,111100111101111,
111001001001001,111101111101111, 111101111001111};
 
byte rows[8] = {9, 14, 8, 12, 1, 7, 2, 5};
byte cols[8] = {13, 3, 4, 10, 6, 11, 15, 16};
byte pins[16] = {5, 4, 3, 2, 14, 15, 16, 17, 13, 12, 11, 10, 9, 8, 7, 6};
byte screen[8] = {0, 0, 0, 0, 0, 0, 0, 0};
 
int sG = 0; // score du joueur gauche
int sD = 0; // score du joueur droit
 
void setup() {
  Serial.begin(9600);
  for (int i = 0; i < 8; i++)  {
    screen[i] = B11111111;
    delay(25);
  }
  for (int i = 0; i < 8; i++)  {
    screen[i] = B00000000;
    delay(25);
  }
}
 
void loop() {
  int tempo = 250 ;
  score(Chiffre,1000);
  delay(tempo);
}
 
 
// Affichage du score
void score(uint16_t * image, unsigned long duree) {
unsigned long debut = millis();  
//Serial.println(Chiffre[sG]);
 
 
  for (int i = 0; i < 8; i++)  screen[i] = 0;
     for(int rows = 0; rows < 5; rows++){
         for(int cols = 0; cols < 3; cols++){
          boolean pixel = bitRead(image[0]*3,cols); 
          if (pixel == 1){
          on(rows,cols);
          }
        }
       }
}
 
 
 void on(byte row, byte column) {
   screen[column-1] |= (B1<<(row-1));
}

merci par avance si vous pouviez m'aider à finir ce projet

pascal

23/10/2020, 23h04
Jay M
On ne représente pas du binaire comme cela
Code:

1 2 3 uint16_t Chiffre[10]= {111101101101111,010110010010111,111001111100111,111001011001111, 100101111001001,111100111001111,111100111101111, 111001001001001,111101111101111, 111101111001111};
il faut mettre 0b devant les suites de 0 et 1 par exemple 0b111101101101111 (le compilateur doit vous mettre des messages, activez la version détaillée des warning dans les préférences)

merci pour la réponse Jay M
j'ai corrigé un peu le croquis mais sans résultat probant

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
// Chiffres de 0 à 9 du score ***************************************** 
 
uint16_t Chiffre[10]= {0b111101101101111,0b010110010010111,0b111001111100111,0b111001011001111,
0b100101111001001,0b111100111001111,0b111100111101111,
0b111001001001001,0b111101111101111, 0b111101111001111};
 
byte rows[8] = {9, 14, 8, 12, 1, 7, 2, 5};
byte cols[8] = {13, 3, 4, 10, 6, 11, 15, 16};
byte pins[16] = {5, 4, 3, 2, 14, 15, 16, 17, 13, 12, 11, 10, 9, 8, 7, 6};
byte screen[8] = {0, 0, 0, 0, 0, 0, 0, 0};
 
int sG = 0; // score du joueur gauche
int sD = 0; // score du joueur droit
 
void setup() {
  Serial.begin(9600);
  for (int i = 0; i < 8; i++)  {
    screen[i] = B11111111;
    delay(25);
  }
  for (int i = 0; i < 8; i++)  {
    screen[i] = B00000000;
    delay(25);
  }
}
 
 
void loop() {
  int tempo = 250 ;
  score(Chiffre[sG]);
  delay(tempo);
}
 
 
// Affichage du score
void score(uint16_t * Chiffre) {
unsigned long debut = millis();  
//Serial.println(Chiffre[sG]);
int x;
int y;
boolean v = 0;
 
  for(x = 0; x < 5; x++){
    for(y = 0; y < 3; y++){
         v = bitRead(Chiffre[sG],y*3+x) ;
         Serial.println(v);
         if (v=1) {
          on(x,y);
         }
     }
  }
}
 
 void on(byte row, byte column) {
   screen[column-1] |= (B1<<(row-1));
}

24/10/2020, 05h21
Jay M

Vous n’avez pas de hardware en fait?

A quoi servent les delay(25); des boucles for du setup et pourquoi faire deux boucles, la seconde efface le contenu du tableau de la première et il n’y a eu aucun "affichage" entre temps

Attention à ne pas confondre assignation (=) et test d’égalité (==) dans

Code:

if (v=1) {
24/10/2020, 08h51
cobra38

Citation:

Vous n’avez pas de hardware en fait?

Si, un Arduino Nano couplé à une matrice 8x8

Citation:

A quoi servent les delay(25); des boucles for du setup et pourquoi faire deux boucles, la seconde efface le contenu du tableau de la première et il n’y a eu aucun "affichage" entre temps

Vous avez certainement raison , je pensais à une méthode d'initialisation de la matrice

Citation:

Attention à ne pas confondre assignation (=) et test d’égalité (==) dans

J'ai corrigé mais au final il n'y toujours pas d'affichage

pascal
24/10/2020, 10h18
Jay M

Mais pourquoi y aurait il affichage?

Ou sont les ordres d’affichage? Vous ne déclarez aucune pin en sortie, vous ne pilotez rien du tout... remplir un tableau qui s’appelle screen display ou écran n’a aucun effet externe particulier

Quel est votre module 8x8? Y a t’il un driver? Utilisez éventuellement une bibliothèque existante

RE ...

Historique
N'ayant pas trop de connaissance dans ce domaine je me sui inspiré d'un exemple sur le net
pour m'aider à comprendre le principe après bien des soucis de câblage il fonctionne
Ce que j'essaie de faire maintenant c'est de reproduire la même chose dans mon projet
à partir de Chiffre[10]

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
/*
  Tutoriel : Matrice de LEDs 8x8
  Affichage d'une image personnalisée (clignotement du nombre 42)
*/
 
// Déclaration du tableau définissant l'image
// Un bit à '0' correspont à une LED éteinte, un bit à '1' à une LED allumée
byte fortyTwo[] =
{
  B00000000,
  B00100000,
  B01100111,
  B10100001,
  B11110111,
  B00100100,
  B00000111,
  B00000000,
};
 
// Déclaration des pins utilisées pour le branchement de la matrice
const int columnPins[] = {2, 3, 4, 5, 6, 7, 8, 9};
const int rowPins[] = {10, 11, 12, 15, 16, 17, 18, 19};
 
void setup()
{
  // Utilisation d'une boucle for pour optimiser l'initialisation
  for (int i = 0; i < 8; i++)
  {
    pinMode(rowPins[i], OUTPUT);        // lignes en sorties
    pinMode(columnPins[i], OUTPUT);     // colonnes en sorties
 
    /* Optionnel - permet d'éviter un "scintillement" au démarrage du programme
    digitalWrite(columnPins[i], HIGH);  // déconnexion des cathodes de la masse
    */
  }
}
 
void loop()
{
  // Délai entre deux affichages
  int tempo = 250 ;
  // Afficher le nombre pendant une seconde
  aff(fortyTwo, 1000);
  // ne rien afficher pendant la temporisation définie
  delay(tempo);
}
 
// Sous-routine pour la commande des LEDs à partir des données du tableau
// Elle s'affiche pendant la durée donnée en second paramètre
void aff(byte * image, unsigned long duree)
{
  // On note le moment où l'on commence
 unsigned long debut = millis();
 // On joue la boucle tant qu'on n'a pas atteint la durée souhaitée
 while (debut + duree > millis())
  {
    // Première itération (boucle for) sur les lignes
    for(int row = 0; row < 8; row++)
    {
      // Connexion de la ligne au +5V
      digitalWrite(rowPins[row], LOW);
      // Seconde itération sur les colonnes
      for(int col = 0; col < 8; col++)
      {
        // Miroir sur le poids du bit pour avoir le bon numéro de colonne
        int situ = 7 - col;
        // Lecture du bit concerné
        boolean pixel = bitRead(image[row],col);
        // S'il est à un...
        if(pixel == 1)
        {
          // ...on connecte la colonne concernée à la masse pour allumer la LED
          digitalWrite(columnPins[situ], HIGH);
        }
        // On attend un peu entre chaque LED (délai total ~20ms pour 64 LEDs)
        delayMicroseconds(300);
        // Et on déconnecte la colonne de la masse...
        digitalWrite(columnPins[situ], LOW);
      }
      // ...puis la ligne de l'alimentation
      digitalWrite(rowPins[row], HIGH);
    }
  }
}

Citation:

Ou sont les ordres d’affichage? Vous ne déclarez aucune pin en sortie,

J'ai effectivement oublié
et j'ai changé la méthode d'affichage

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
// Chiffres de 0 à 9 du score ***************************************** 
 
uint16_t Chiffre[10]= {0b111101101101111,0b010110010010111,0b111001111100111,0b111001011001111,
0b100101111001001,0b111100111001111,0b111100111101111,
0b111001001001001,0b111101111101111, 0b111101111001111};
 
byte rows[8] = {2, 3, 4, 5, 6, 7, 8, 9};
byte cols[8] = {10, 11, 12, 15, 16, 17, 18, 19};
byte pins[16] = {5, 4, 3, 2, 14, 15, 16, 17, 13, 12, 11, 10, 9, 8, 7, 6};
 
 
 
void setup() {
   Serial.begin(9600);
   for (int i = 0; i < 8; i++)
  {
    pinMode(rows[i], OUTPUT); // lignes en sorties
    pinMode(cols[i], OUTPUT); // colonnes en sorties
  }
    Serial.begin(9600);
}
 
void loop() {
  int tempo = 250 ;
  score();
  delay(tempo);
}
 
 
// Affichage du score
void score() {
unsigned long debut = millis();  
 
int x;
int y;
boolean v = 0;
 
  for(x = 0; x < 5; x++){
     digitalWrite(rows[x], LOW);
    for(y = 0; y < 3; y++)
    {
         int situ = 3 - y;
         v = bitRead(Chiffre[0],y) ;
         Serial.print("v=");
         Serial.println(v);
         if (v==1) {
          digitalWrite(cols[situ], HIGH);
          //delayMicroseconds(300);
          digitalWrite(cols[situ], LOW);
          Serial.print("x=");
          Serial.println(x);
          Serial.print("y=");
          Serial.println(y);
 
         }
      digitalWrite(rows[x], HIGH);   
     }
  }
}

Module : 1088AS

4 pièce(s) jointe(s)

vous avez compris que le code d'exemple (qui a quelques défauts et les commentaires ne sont pas corrects) que vous donnez fonctionne sur la notion de persistance rétinienne?

Pour peindre l'écran on procède ligne par ligne et colonne par colonne. Suivant comment est orienté le module, on met à 5V une ligne et à GND une colonne et ça crée un circuit qui allume la LED
Pièce jointe 582138
(ou si le module est tourné on met à GND une ligne et on met à 5V une colonne)
pour tous les circuits ainsi crées, la LED correspondante s'allume tour à tour en fonction de là où on met le GND

On attend un peu pour que l'oeil ait le temps de percevoir la luminosité puis on éteint cette LED et on passe à la suivante, puis on remet la ligne à GND (ou 5V si le circuit est tourné) et on passe à la ligne suivante et on recommence.

la fonction aff() prend en paramètre un tableau de 8 octets. Un bit à '0' correspont à une LED éteinte, un bit à '1' à une LED allumée.
Pièce jointe 582136

Dans son code, l'auteur met successivement les lignes à GND (contrairement à ce que dit le commentaire)
Code:

1 2 3 4 for(int row = 0; row < 8; row++) { // Connexion de la ligne au +5V GND digitalWrite(rowPins[row], LOW);
et on met à HIGH successivement les colonnes de cette lignes dont le pixel doit être allumé créant ainsi le circuit qui allume la LED à l'intersection de cette ligne et colonne puis l'éteint après une petite attente. C'est ce que fait cette boucle for (les commentaires sont erronés)
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 for (int col = 0; col < 8; col++) { // Miroir sur le poids du bit pour avoir le bon numéro de colonne int situ = 7 - col; // Lecture du bit concerné boolean pixel = bitRead(image[row], col); // S'il est à un... if (pixel == 1) { // ...on connecte la colonne concernée à la masse 5V pour allumer la LED digitalWrite(columnPins[situ], HIGH); } // On attend un peu entre chaque LED (délai total ~20ms pour 64 LEDs) delayMicroseconds(300); // Et on déconnecte la colonne de la masse... On remet à la masse digitalWrite(columnPins[situ], LOW); }
pour l'appliquer à votre cas, vous n'avez pas un bitmap avec tous les score possibles (il en faudrait 100 de 0-0 à 9-9 je suppose). Il vous faudrait définir sans doute dans une matrix 3x5 le bitmap pour les chiffres de 0 à 9, voici un exemple
Pièce jointe 582139

et vous voulez construire dynamiquement le score. Il faudra donc calculer un petit tableau de 8 octets dont vous aurez rempli les bits à partir des bitmaps des scores des 2 adversaires en positionnant les bit en haut à gauche pour le premier et en bas à droite pour le second
Pièce jointe 582145
donc un peu de maths à effectuer pour trouver les bons bits sur lesquels copier les bits du bitmap. Rien de compliqué puisque les tableau 3x5 va toujours au même endroit.

Ensuite vous appelez la fonction aff() qui existe dans le code d'exemple avec ce tableau et ça va fonctionner.

PS/ pour éviter des soucis de rollover si d'aventure le module devait tourner 50 jours au lieu de
Code:

1 2 3 4 // On note le moment où l'on commence unsigned long debut = millis(); // On joue la boucle tant qu'on n'a pas atteint la durée souhaitée while (debut + duree > millis())
il faut écrire
Code:

1 2 3 4 // On note le moment où l'on commence unsigned long debut = millis(); // On joue la boucle tant qu'on n'a pas atteint la durée souhaitée while (millis() - debut < duree)
Même si mathématiquement ça semble identique, ça trait le rollover correctement (quand millis() retombera à zéro dans une cinquantaine de jours)

j'ai donc refait le prg test suivant vos conseils

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
// Chiffres de 0 à 9 du score ***************************************** 
 
uint16_t Chiffre[10]= {0b111101101101111,0b010110010010111,0b111001111100111,0b111001011001111,
0b100101111001001,0b111100111001111,0b111100111101111,
0b111001001001001,0b111101111101111, 0b111101111001111};
 
byte rows[8] = {2, 3, 4, 5, 6, 7, 8, 9};
byte cols[8] = {10, 11, 12, 15, 16, 17, 18, 19};
//byte pins[16] = {5, 4, 3, 2, 14, 15, 16, 17, 13, 12, 11, 10, 9, 8, 7, 6};
 
 
 
void setup() {
   Serial.begin(9600);
   for (int i = 0; i < 8; i++)
  {
    pinMode(rows[i], OUTPUT); // lignes en sorties
    pinMode(cols[i], OUTPUT); // colonnes en sorties
  }
    Serial.begin(9600);
}
 
void loop() {
  //int tempo = 250 ;
  score(Chiffre[0],1000);
  //delay(tempo);
}
 
// Affichage du score
void score(uint16_t Chiffre[],unsigned long duree) {
  int x;
  int y;
  boolean v = 0;
  unsigned long debut = millis();
  while (millis() - debut < duree)
  {
     for(x = 0; x < 8; x++) 
     {
     digitalWrite(rows[x], LOW); // Connexion de la ligne à GND
       for(y = 0; y < 8; y++) // Colonne de 1 à 3 
       {
         int situ = 7-y;
         v = bitRead(Chiffre[0],y) ;
         Serial.print("v=");
         Serial.println(v);
         if (v==1) {
              digitalWrite(cols[situ], HIGH);  // on connecte la colonne au +5v pour allumer la LED
              delayMicroseconds(300);
              digitalWrite(cols[situ], LOW); // On remet à la masse
         }
       }
     digitalWrite(rows[x], HIGH); 
     }
  } 
}

le résultat se traduit par un "balayage" (?) de gauche à droite de toutes les Leds malgré
la validation de "v" qui change pourtant de la valeur suivant => Chiffre[0] = {0b111101101101111}

24/10/2020, 16h56
Jay M

Regardez ce que vous dit le compilateur (activez tous les warnings dans les préférences)

votre fonction score

Code:

void score(uint16_t Chiffre[],unsigned long duree) {

attend un tableau de uint16_t

vous l'appelez comme cela

Code:

score(Chiffre[0],1000);

avec un uint16_t et pas un tableau...

que représentent vos uint16_t ? 15 bits significatifs pour un tableau 5x3 ?
24/10/2020, 17h09
cobra38

Je dois donc mettre Chiffre[0] dans une variable ?
puis appeler cette variable byte dans ma sous-routine

si oui j'avoue que je ne sais pas faire
24/10/2020, 18h28
Jay M

Comme dit auparavant, Gardez la fonction d’origine qui affiche les bits d’un tableau de 8 octets et construisez ce tableau en copiant les bits du modèle de chiffre au bon endroit

Vous ne m’avez pas répondu sur cela: que représentent vos uint16_t ? 15 bits significatifs pour un tableau 5x3 ?
24/10/2020, 18h41
cobra38

Citation:

Vous ne m’avez pas répondu sur cela: que représentent vos uint16_t ? 15 bits significatifs pour un tableau 5x3 ?

oui , 15bits par chiffre de 0 à 9

dans la matrice je dois pour y incorporer mes 2 chiffres
l'un appelé sG composé de 5x3 bits en position 0,0
et l'autre sD en position 5,3
24/10/2020, 19h32
Jay M

J’ai pas regardé en détail ce que vous faites des bits mais en supposant que c’est correct déclarez la fonction comme ça

Code:

void score(uint16_t chiffre,unsigned long duree) {

et au lieu de faire

Code:

v = bitRead(Chiffre[0],y) ;

faites

Code:

v = bitRead(chiffre,y) ;

puisque vous passez déjà la valeur en paramètre de la fonction

Mais ça ne suffit pas pour afficher les 2 scores
24/10/2020, 23h28
cobra38

merci pour ces informations

mais çà ne fonctionne toujours pas
25/10/2020, 07h57
Jay M

Ma supposition n’était donc pas bonne :)

Ça ne marche pas ne veut pas dire grand chose. Que constatez vous? Avez vous essayé d’afficher les bits sur le moniteur série? etc...
25/10/2020, 07h58
Jay M

Je vous suggère de modifier votre code pour qu’il reprenne la fonction d’affichage de votre exemple sur un buffer de 8 octets.

Votre code doit appeler dans cesse cet affichage mais de temps en temps modifiez le buffer en copiant les bits des 10 chiffres aux bons endroit. Faites 2 fonctions scoreJoueurG(byte v) et une autre scoreJoueurD(byte v) qui prennent en paramètre une valeur entre 0 et 9 qui est le chiffre à afficher à Gauche ou à Droite. Ces fonctions devront aller lire les 15 bits de votre dessin dans Chiffre[v] et les mettre au bon endroit dans le buffer de 8 octets dédié à l’affichage.

Vous essayez et postez cela et on vous aidera à améliorer le tout

1 pièce(s) jointe(s)

Bonjour ,

Encore merci pour votre patience

j'ai refait le croquis comme suit :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
// Chiffres de 0 à 9 du score ***************************************** 
uint16_t Chiffre[1]= {010110010010111};
 
//uint16_t Chiffre[10]= {0b111101101101111,0b010110010010111,0b111001111100111,0b111001011001111,
//0b100101111001001,0b111100111001111,0b111100111101111,
//0b111001001001001,0b111101111101111, 0b111101111001111};
 
byte rows[8] = {2, 3, 4, 5, 6, 7, 8, 9};
byte cols[8] = {10, 11, 12, 15, 16, 17, 18, 19};
 
int sG; // score joueur gauche
 
void setup() {
   Serial.begin(9600);
   for (int i = 2; i <= 12; i++)  pinMode(i, OUTPUT);
   for (int i = 15; i <= 19; i++)  pinMode(i, OUTPUT);
 
   for (int i = 0; i < 8; i++)
  {
    pinMode(rows[i], OUTPUT); // lignes en sorties
    pinMode(cols[i], OUTPUT); // colonnes en sorties
  }
}
 
void loop() {
  int tempo = 250 ;
  sG = 1 ;
  scoreGauche(sG);
  delay(tempo);
}
 
// Affichage du score Gauche
void scoreGauche(int sG) {
  // Position du score en 0,0
  int x = 0;
  int y = 0 ;
  boolean v = 0;
    {
     for(x = 0; x < 5; x++) // Colonne de 1 à 5
     {
     digitalWrite(rows[x], LOW); // Connexion de la ligne à GND
       for(y = 0; y < 3; y++) // Colonne de 1 à 3 
       {
         int situ = 7-y;
        v = bitRead(Chiffre[sG],y) ;
        if (v==1) {
              digitalWrite(cols[situ], HIGH);  // on connecte la colonne au +5v pour allumer la LED
              delayMicroseconds(300);
              digitalWrite(cols[situ], LOW); // On remet à la masse
        }
       }
     digitalWrite(rows[x], HIGH); 
     }
  } 
}

avec sG ( score du joueur gauche) = 1
créé une fonction scoreGauche(int sG)
( le moniteur montre que la variable "v" suit les valeurs de Chiffre[sG] ( ici Chiffre[1] )

et le résultat est le suivant (?) :

Pièce jointe 582180

pascal

25/10/2020, 18h40
Jay M

Comme je vous l’ai proposé bâtissez la représentation dans un buffer de 8 octets. N’essayez pas d’afficher directement ça va vous compliquer la vie quand vous aurez l’autre score à gérer.

Voici un exemple de structure de code à explorer et compléter:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
// Déclaration du tableau définissant l'image
// Un bit à '0' correspont à une LED éteinte, un bit à '1' à une LED allumée
byte bitmapEcran[8]; // 8 octets, initialisé à zéro par défaut

// pour faire "lisible" on ne condense pas les 15 bits sur 2 octets, on va en utiliser 5. à optimiser plus tard
// les chiffres de 0 à 9 dans une matrice de 3x5
const byte lesChiffres[][5] =
{
  {0b111, 0b101, 0b101, 0b101, 0b111},    // 0
  {0b010, 0b110, 0b010, 0b010, 0b010},    // 1
  {0b111, 0b001, 0b010, 0b100, 0b111},    // 2
  {0b111, 0b001, 0b011, 0b001, 0b111},    // 3
  {0b101, 0b101, 0b111, 0b001, 0b001},    // 4
  {0b111, 0b100, 0b111, 0b001, 0b111},    // 5
  {0b100, 0b100, 0b111, 0b101, 0b111},    // 6
  {0b111, 0b001, 0b011, 0b001, 0b001},    // 7
  {0b111, 0b101, 0b111, 0b101, 0b111},    // 8
  {0b111, 0b101, 0b111, 0b001, 0b001},    // 9
};

// Déclaration des pins utilisées pour le branchement de la matrice
const int columnPins[] = {2, 3, 4, 5, 6, 7, 8, 9};
const int rowPins[] = {10, 11, 12, 15, 16, 17, 18, 19};

// on remplit les bit 7 6 5 des octets 0,1,2,3 et 4 de bitmapEcran  en fonction des bits 2 1 et 0 des octets lesChiffres[valeur][0->4]
void scoreJoueurGauche(byte valeur)
{
  for (int8_t ligne = 0; ligne < 5; ligne++) {
    for (int8_t bit = 7; bit > 4; --bit) {
      // à faire en utilisant bitRead, bitSet ou bitClear
    }
  }
}

// on remplit les bit 2 1 0 des octets 3,4,5,6 et 7 de bitmapEcran en fonction des bits 2 1 et 0 des octets lesChiffres[valeur][0->4]
void scoreJoueurDroite(byte valeur)
{
  for (int8_t ligne = 3; ligne < 8; ligne++) {
    for (int8_t bit = 2; bit >= 0; --bit) {
      // à faire en utilisant bitRead, bitSet ou bitClear
    }
  }
}

// Sous-routine pour la commande des LEDs à partir des données du tableau
void afficherEcran(byte * bitmap)
{
  for (byte row = 0; row < 8; row++) {                                              // Première itération (boucle for) sur les lignes
    digitalWrite(rowPins[row], LOW);                                                // Connexion de la ligne au GND
    for (byte col = 0; col < 8; col++) {                                            // Seconde itération sur les colonnes
      byte situ = 7 - col;                                                          // Miroir sur le poids du bit pour avoir le bon numéro de colonne
      if (bitRead(bitmap[row], col) == 1) digitalWrite(columnPins[situ], HIGH);     // si bit à 1 on allume cette LED
      delayMicroseconds(300);                                                       // On attend un peu entre chaque LED (délai total ~20ms pour 64 LEDs)
      digitalWrite(columnPins[situ], LOW);                                          // Et on reconnecte la colonne de la masse...
    }
    digitalWrite(rowPins[row], HIGH);                                               // et en fin,  la ligne de l'alimentation
  }
}

void setup()
{
  // On met toutes les pins en sortie
  for (byte i = 0; i < 8; i++)  {
    pinMode(rowPins[i], OUTPUT);        // lignes en sorties
    pinMode(columnPins[i], OUTPUT);     // colonnes en sorties
  }
  // par exemple mettre des scores
  scoreJoueurGauche(2);
  scoreJoueurDroite(5);
}

void loop()
{
  afficherEcran(bitmapEcran);  // à effectuer souvent, c'est la persistence rétinienne qui permet de voir les chiffres

  // vous pouvez coder autre chose ici mais il ne faut pas que ce soit bloquant
}

(en supposant que le code de l'exemple fonctionnait pour vous)

J'ai mis (je pense) dans le tableau lesChiffres[][5] les bits qui correspondent à ces dessins
https://www.developpez.net/forums/at...8/bitmaps.png/
ce n'est pas la représentation optimale vu qu'on prend 5 octets par chiffre alors que 2 pourraient suffire, mais c'est pour simplifier pour le moment. il sera toujours temps d'optimiser cela plus tard si vous manquez de RAM.

dans les fonctions en orange (qu'il vous faut finaliser) vous devez remplir la bonne zone de bit du tableau bitmapEcran, comme indiqué dans ma figure
https://www.developpez.net/forums/at...8x8/zones.png/

dans le setup j'appelle

Code:

1
2
  scoreJoueurGauche(2);
  scoreJoueurDroite(5);

donc on devrait voir à l'écran 2 à 5 comme score.

j'ai tapé cela rapidement ici sans tester, en me basant sur l'exemple que vous aviez dit être fonctionnel pour vous. il y peut-être des typos, l'important c'est de comprendre le principe de structuration du code.

Merci Jay M

Encore mille pardons pour le retard
des problèmes d'internet et autres en sont la cause

De mon côté, j'ai essayé un croquis en tenant compte des recommandations (je l'espère)

il fonctionne en voici le code
je serais content si vous pouviez me donner votre avis

attention : les chiffres de Gauche sont à Droite et inversement pour compenser l'effet "miroir" de la matrice (?)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
/**
 * Ping Pong with 8x8 Led Dot Matrix on Arduino
 V4 - 29-10-2020
 */
 
//***********************************************
//Pin conceptuelle   Pin Arduino   Pin physique
//   Colonne 1            9             13
//   Colonne 2            3             3
//   Colonne 3            2             4
//   Colonne 4            12            10
//   Colonne 5            A1            6
//   Colonne 6            11            11
//   Colonne 7            7             15
//   Colonne 8            6             16
//   Ligne 1              13            9
//   Ligne 2              8             14
//   Ligne 3              A3            8
//   Ligne 4              10            12
//   Ligne 5              5             1
//   Ligne 6              A2            7
//   Ligne 7              4             2
//   Ligne 8              A0            5 
//************************************************ 
 
#include "TimerOne.h"
#define PIN_LEFT 4  // A4 
#define PIN_RIGHT 5 // A5 
 
//******************************************************************************
byte Gauche [][10] {
     //Index0
     {
  B00000111,
  B00000101,
  B00000101,
  B00000101,
  B00000111,
  B00000000,
  B00000000,
  B00000000
},
    //Index1
{
  B00000010,
  B00000011,
  B00000010,
  B00000010,
  B00000111,
  B00000000,
  B00000000,
  B00000000
},
  //Index2
  {
  B00000111,
  B00000100,
  B00000111,
  B00000001,
  B00000111,
  B00000000,
  B00000000,
  B00000000
},
  //Index3
  {
  B00000111,
  B00000100,
  B00000110,
  B00000100,
  B00000111,
  B00000000,
  B00000000,
  B00000000
},
  //Index4
  {
  B00000001,
  B00000101,
  B00000111,
  B00000100,
  B00000100,
  B00000000,
  B00000000,
  B00000000
},
  //Index 5
{
  B00000111,
  B00000001,
  B00000111,
  B00000100,
  B00000111,
  B00000000,
  B00000000,
  B00000000
},
 //Index 6
{
  B00000111,
  B00000001,
  B00000111,
  B00000101,
  B00000111,
  B00000000,
  B00000000,
  B00000000
},
 //Index 7
{
  B00000111,
  B00000100,
  B00000100,
  B00000100,
  B00000100,
  B00000000,
  B00000000,
  B00000000
},
//Index 8
{
  B00000111,
  B00000101,
  B00000111,
  B00000101,
  B00000111,
  B00000000,
  B00000000,
  B00000000
},
 //Index 9
{
  B00000111,
  B00000101,
  B00000111,
  B00000100,
  B00000111,
  B00000000,
  B00000000,
  B00000000
}
 
};  
 
//** Chiffres Droite ********************* 
byte Droite [][10] {
 
 //Index0
{
  B00000000,
  B00000000,
  B00000000,
  B11100000,
  B10100000,
  B10100000,
  B10100000,
  B11100000
},
 
//Index1
{
  B00000000,
  B00000000,
  B00000000,
  B01000000,
  B01100000,
  B01000000,
  B01000000,
  B11100000
},
 
//Index2
{
  B00000000,
  B00000000,
  B00000000,
  B11100000,
  B10000000,
  B11100000,
  B00100000,
  B11100000
},
 
//Index3
{
  B00000000,
  B00000000,
  B00000000,
  B11100000,
  B10000000,
  B11000000,
  B10000000,
  B11100000
},
 
//Index4
{
  B00000000,
  B00000000,
  B00000000,
  B00100000,
  B10100000,
  B11100000,
  B10000000,
  B10000000
},
 
//Index5
{
  B00000000,
  B00000000,
  B00000000,
  B11100000,
  B00100000,
  B11100000,
  B10000000,
  B11100000
},
 
//Index6
{
  B00000000,
  B00000000,
  B00000000,
  B11100000,
  B00100000,
  B11100000,
  B10100000,
  B11100000
},
 
//Index7
{
  B00000000,
  B00000000,
  B00000000,
  B11100000,
  B10000000,
  B10000000,
  B10000000,
  B10000000
},
 
//Index8
{
  B00000000,
  B00000000,
  B00000000,
  B11100000,
  B10100000,
  B11100000,
  B10100000,
  B11100000
},
 
//Index9
{
  B00000000,
  B00000000,
  B00000000,
  B11100000,
  B10100000,
  B11100000,
  B10000000,
  B11100000
}
};
 
unsigned int left = 0;
unsigned int right = 0;
int angle = 0;
int radians;
byte rows[8] = {9, 14, 8, 12, 1, 7, 2, 5};
byte cols[8] = {13, 3, 4, 10, 6, 11, 15, 16};
byte pins[16] = {5, 4, 3, 2, 14, 15, 16, 17, 13, 12, 11, 10, 9, 8, 7, 6};
byte screen[8] = {0, 0, 0, 0, 0, 0, 0, 0};
volatile byte screenRow = 0;
volatile byte screenCol = 0;
int _angle;
int _px;
int _py;
int _w = 7;
int _h = 7;
int _wall[] = {3, 3};
int _count = 0;
int _speed = 3;
int _countPoints = 0;
 
int sG = 0; //score joueur gauche
int sD = 0; //score joueur droit
 
 
//**************************************************
// SETUP
//**************************************************
 
 
void setup() {
  Timer1.initialize(100);
  for (int i = 2; i <= 17; i++)  pinMode(i, OUTPUT);
  Timer1.attachInterrupt(doubleBuffer);
  Serial.begin(9600);
  face();
  reset();
}
 
//*****************************************
// Boucle LOOP 
//*****************************************
void loop() {
  calcWall();
  enterFrameHandler();
  delay(50);
}
 
//******************************************
void doubleBuffer() {
  digitalWrite(translatePin(rows[screenRow]), LOW);
  digitalWrite(translatePin(cols[screenCol]), HIGH);
  screenCol++;
  if (screenCol >= 8) {
    screenCol = 0;
    screenRow++;
    if (screenRow >= 8) {
      screenRow = 0;
    }
  }
  if ((screen[screenRow] >> screenCol) & B1 == B1) {
    digitalWrite(translatePin(rows[screenRow]), HIGH);
    digitalWrite(translatePin(cols[screenCol]), LOW);
  } else {
    digitalWrite(translatePin(rows[screenRow]), LOW);
    digitalWrite(translatePin(cols[screenCol]), HIGH);
  }
}
 
//*******************************************
 byte translatePin(byte original) {
 return pins[original- 1];
}
 
//********************************************
void allOFF() {
  for (int i = 0; i < 8; i++)  screen[i] = 0;
}
 
//********************************************
void on(byte row, byte column) {
   screen[column-1] |= (B1<<(row-1));
}
 
//********************************************
void off(byte row, byte column) {
  screen[column-1] &= (B1<<(row-1));
}
 
//**********************************************
void calcWall() {
  left = analogRead(PIN_LEFT);
  right = analogRead(PIN_RIGHT);
  left = constrain(map(left, 223, 800, 0, 6), 0, 6);
  right = constrain(map(right, 223, 800, 6, 0), 0, 6);
  clearWall();
  on(1, left + 1);
  on(1, left + 2);
  on(8, right + 1);
  on(8, right + 2);
  _wall[0] = left;
  _wall[1] = right;
  show();
}
 
//***************************************************
void clearWall() {
  for (int i = 0; i < 8; i++)  screen[i] &= B01111110;
}
 
//****************************************************
void clearGame() {
  for (int i = 0; i < 8; i++)  screen[i] &= B10000001;
}
 
//****************************************************
void enterFrameHandler() {
  if (_count++ < _speed)  return;
  _count = 0;
  checkCollision();
  calcAngleIncrement();
  show();
}
 
//****************************************************
void retorted(int angle) {
  Serial.println(angle);
  _angle = angle;
  if (++_countPoints % 5 == 0 && _speed > 1) _speed-- ;
}
 
//****************************************************
void resetAnim() {
 
  for (int i = 0; i < 8; i++)  {
    screen[i] = B11111111;
    delay(25);
  }
  for (int i = 0; i < 8; i++)  {
    screen[i] = B00000000;
    delay(25);
  }
 
   //****************************************
   // affichage du score pendant 1s (1000ms)
    for (byte i = 0; i < 8; i++){
    screen[i] = Gauche[sG][i] | Droite[sD][i] ;
    } 
    delay(1000);
	allOFF();
   //****************************************
 
 
 }
 
//******************************************************
void face() {
  on(1, 3);  on(1, 4);  on(1, 5);  on(1, 6);
  on(2, 2);  on(2, 7);
  on(3, 1);  on(3, 3); on(3, 5); on(3, 8);
  on(4, 1);  on(4, 5); on(4, 6); on(4, 8);
  on(5, 1);  on(5, 5); on(5, 6); on(5, 8);
  on(6, 1);  on(6, 3); on(6, 5); on(6, 8);
  on(7, 2);  on(7, 7);
  on(8, 3);  on(8, 4); on(8, 5); on(8, 6);
  delay(5000);
}
 
void faceG() {
  on(1, 1);  on(1, 2); on(1, 3);  on(1, 4); on(1, 5); on(1, 6); on(1, 7); on(1, 8);
  on(3, 2); on(3, 3);  on(3, 4); on(3, 5); on(3, 6); on(3, 7);
  on(4, 2); on(4, 7);
  on(5, 2); on(5, 5); on(5, 7);
  on(6, 2); on(6, 5); on(6, 6); on(6, 7);
  on(8, 1);  on(8, 2); on(8, 3);  on(8, 4); on(8, 5); on(8, 6); on(8, 7); on(8, 8);  
  delay(2000);
 
}
 
void faceD() {
  on(1, 1);  on(1, 2); on(1, 3); on(1, 4); on(1, 5); on(1, 6); on(1, 7); on(1, 8);
  on(3, 2); on(3, 3); on(3, 4); on(3, 5); on(3, 6); on(3, 7);
  on(4, 2); on(4, 7);
  on(5, 2); on(5, 7);
  on(6, 3); on(6, 4); on(6, 5); on(6, 6); 
  on(8, 1);  on(8, 2); on(8, 3); on(8, 4); on(8, 5); on(8, 6); on(8, 7); on(8, 8);  
  delay(2000);
}
//*******************************************************
void reset() {
  _px = random(3, 5);
  _py = random(3, 5);
  _angle = random(0, 2) == 0  ? 0  : 180;
  _speed = 5;
  _countPoints = 0;
 
  if ((sD == 9)|(sG ==9)) {
	 allOFF(); 
	 if (sD == 9) {
        faceD();
     } else{ 
        faceG();
     } 		
     sG = 0;
     sD = 0;
   }
 
  show();
  delay(500);
}
 
 
//*******************************************************
void show() {
  clearGame();
  on(_px + 1, _py + 1);
}
 
//*******************************************************
void checkCollision() {
    if (_px == _w-1) {
		if (_angle == 315 || _angle == 0 || _angle == 45)  {
			  if (_py == _wall[1] || _py == _wall[1] + 1)  {
				if (_angle == 0 && _py == _wall[1])  retorted(225);
					else if (_angle == 0 && _py == _wall[1] + 1)  retorted(135);
					else if (_angle == 45 && _py == _wall[1])  retorted(135);
					else if (_angle == 45 && _py == _wall[1] + 1)  retorted(180);
					else if (_angle == 315 && _py == _wall[1])  retorted(180);
					else if (_angle == 315 && _py == _wall[1] + 1)  retorted(225);
			  }
		}
   } else if (_px == 1)  {
     if (_angle == 225 || _angle == 180 || _angle == 135)  {
		  if (_py == _wall[0] || _py == _wall[0] + 1)  {
			if (_angle == 180 && _py == _wall[0])  retorted(315);
				else if (_angle == 180 && _py == _wall[0] + 1)  retorted(45);
				else if (_angle == 135 && _py == _wall[0])  retorted(45);
				else if (_angle == 135 && _py == _wall[0] + 1)  retorted(0);
				else if (_angle == 225 && _py == _wall[0])  retorted(0);
				else if (_angle == 225 && _py == _wall[0] + 1)  retorted(315);
		  }
     }
  }
  if (_px == _w)  {
	  sG = sG+1 ; 
    resetAnim();
    reset();
  }
  else if (_px == 0)  {
	 sD = sD+1;
	 resetAnim();
   reset();
 
  }
  else if (_py == _h)  {
    if (_angle == 45)  _angle = 315;
    else if (_angle == 135)  _angle = 225;
  }
  else if (_py == 0)  {
    if (_angle == 225)  _angle = 135;
    else if (_angle == 315)  _angle = 45;
  }
}
 
//******************************************************
void calcAngleIncrement() {
  if (_angle == 0 || _angle == 360)  {
    _px += 1;
  }
  else if (_angle == 45)  {
    _px += 1;
    _py += 1;
  }
  else if (_angle == 135)  {
    _px -= 1;
    _py += 1;
  }
  else if (_angle == 180)  {
    _px -= 1;
  }
  else if (_angle == 225)  {
    _px -= 1;
    _py -= 1;
  }
  else if (_angle == 315)  {
    _px += 1;
    _py -= 1;
  }
}
 
 
}

Cordialement
pascal

03/11/2020, 18h20
Jay M
salut

oui c'est une autre façon de faire, vous avez deux fois les représentations des chiffres, une fois à gauche et une fois à droite et comme ils ne se superposent pas
Pour construire un affichage vous faites
Code:

1 2 3 for (byte i = 0; i < 8; i++){ screen[i] = Gauche[sG][i] | Droite[sD][i] ; }
c'est à dire que vous mettez dans les 8 octets du buffer écran un OU logique des parties gauche et droite. Les 0 de l'un n'impactant pas les 1 de l'autre (1 OU 0 ça fait 1) ça va fonctionner (bien penser à effacer le buffer entre 2 affichages bien sûr).

ça se fait un peu au dépend de la mémoire, on duplique la représentation des chiffres, mais ça ne coûte "que 80 octets" de SRAM (10 chiffres, 8 octets) chacun et ça simplifie grandement la construction du bitmap final. Donc si vous pouvez vous permettre d'allouer ces 80 octets alors c'est très bien comme cela. (sinon il y aurait moyen de les mettre en mémoire flash avec PROGMEM).