Chainer trois matrices led avec un MAX 7219

[neteraser]

Bonjour à tous,
j'utilise des matrices de 8X8 led avec le MAX 7219 ... j'ai un montage perso avec une "barre" bleue et un barre rouge ... je voudrais en connecter une troisième mais appremment la limite est de deux seulement ... j'utilise la library "LedControl.h" qui ne permet que 2 matrices

 /* We keep track of the led-status for all 8 devices in this array */
        byte status[64];

existe t'il un fichier "LedControl.h" qui me permettrait de chainer trois matrices ?...
j'ai cherché sur la toile mais rien trouvé qui fonctionne ...
à vous lire
bonne soirée..

[UKHeliBob]

Post mis dans la mauvaise section, on parle anglais dans les forums généraux. déplacé vers le forum francophone.

Merci de prendre en compte les recommandations listées dans Les bonnes pratiques du Forum Francophone

[J-M-L]

l'image des matrices que vous montrez sont en 32 x 8 = 256 pixels

il y a 4 blocs de 8x8 pixels juxtaposés et de mémoire il y a un MAX7219 dessous pour chaque module

et on chaîne simplement les MAX7219

Si vous voulez chaîner 3 matrices comme cela — Comme le MAX7219 peut contrôler un maximum de 64 LED, la taille maximale de l'affichage matriciel qu'il peut gérer est de 8×8 pixels. Cependant, il est possible de chaîner plusieurs pilotes et matrices ensemble et de contrôler facilement des affichages beaucoup plus grands comme 8×32, 8×64 ou dans votre cas 8 x 96. Malgré tout, vous n'avez besoin que de trois fils pour contrôler tous les circuits intégrés.

(il faut juste assez de RAM pour représenter tous les pixels)

[neteraser]

Bonjour du dimanche,

je me suis mal exprimé ... ... ce sont effectivement des 8X32 en utilisation ( 2 fois 4 matrices ) ... ma "barre bleue" ( et la "barre rouge" aussi ) est bien le module en image... j'ai chainé les deux en reliant l'IN de la seconde barre sur le OUT de la première ... ça marche super en activant bien les 8 matrices et en "nommant" la matrice voulue dans le sketch ... mais j'aurais souhaité en raccorder une troisème en queue de la seconde ... mais comme dit, LedControl.h ne sait gérer que 8 matrices ... d'ou ma question ... est ce faisable ?
à vous lire

[J-M-L]

postez votre code avec les balises de code et un dessin de votre circuit, ce sera plus simple à comprendre...

sinon utilisez la bibliothèque MD_Parola

voici un exemple de code avec 11 modules connectés

Parola_Scrolling.ino - Wokwi ESP32, STM32, Arduino Simulator

si vous voulez en mettre 12 au lieu de 11 (pour correspondre à vos 3 x 4 modules) changez le code ligne 44

#define MAX_DEVICES 12

et allez dans l'onglet diagram.json et modifiez la ligne 12 pour dire qu'il y a 12 modules 8x8 qui sont chaînés

      "attrs": { "chain": "12" }

[neteraser]

Bonsoir,

merci pour le tuyau ... mais je vais surement réécrire mon sketch en prenant sur l'exemple que vous m'avez envoyé .... celui que j'ai actuellement est trop loin et ne pourra pas se "croiser" avec ... donc plutôt que bricoler ... je refais de zéro ...
merci encore de votre suivi
bonne soirée ...

[Patriboom]

Est-ce que Parola ne considérera pas les 3 x 4 comme un seul panneau 24x32 ou 8x96?
Si neteraser utiliser trois couleurs, je soupçonne que ce soit pour afficher trois textes différentes.
Qu'en est-il, neteraser ?

[J-M-L]

Quelle que soit la taille de la matrice on contrôle les pixels individuellement. Quel est le souci ?

[neteraser]

exactement ça ... le projet est simple et c'est pour un stand de tir sportif...
première barre de 8X32 ( BLEUE ) : matrice 3 = symbole croix signifiant "attention" , matrices 1, 2, 3 éteintes... puis compte à rebours de 9 à 0, les matrices 0, 1, 2, s'allument graduellement à chaque tiers du compte à rebours... quand compte à rebours arrivé à 0 la première barre ( BLEUE ) s'éteint et ...
seconde barre de 8X32 ( ROUGE ) : les 4 matrices 0, 1, 2, 3 s'allument en "PLEIN" ... temporisation de 10 secondes ( séquence de tir sur cible ) ... >>> fin de tempo = extinction de la seconde barre ( ROUGE ) signifiant "fin de tir" .... avec >>> ...
première barre ( BLEUE )= allumage des matrices avec symbole croix pour signifier fin de cycle et affichage " R.A.Z " avec effet de balayage des matrices en extinction...
ce que je voulais et en réponse à la demande des tireurs : troisième barre ( VERTE ) allumée pendant le compte à rebours et éteinte dès que la seconde barre ( ROUGE ) s'allument ...
j'ai écris le sketch en utilisant un fichier symbole qui me permet d'e créer tous les symboles et chifres ou lettres souhaités .. il suffit de les nommer dans le sketch pour les utiliser...
je vous donne le code et le fichier symbole ...
si vous voulez tester, - IL FAUT DECONNECTER LA BROCHE "RESET" ( 12 ) POUR CHARGER LE LOGICIEL, SINON ERREUR D'ECRITURE sur ARDUINO UNO ou NANO

// ========================
// #include et #define du  programme
// ========================
// Inclusion de la librairie LedControl
#include "LedControl.h"
#include "chiffres_et_symboles.h"

// Définition des broches de raccordement Arduino UNO ou Nano → Matrice LED pilotée par MAX7219
#define brochePourLhorloge              13         // Sortie 13 de l'Arduino vers la broche CLK de la matrice LED
#define brocheDeSelection               10         // Sortie 10 de l'Arduino vers la broche CS  de la matrice LED
#define brochePourLesDonnees            11         // Sortie 11 de l'Arduino vers la broche DIN de la matrice LED

// Définition des autres "constantes"

int resetPin = 12;                               // Sortie de la RAZ de la BOUCLE secondaire

#define nombreDeMatricesLedRaccordees   8         // Nombre pouvant aller de 1 à 12 (nombre maxi de matrice led pilotable ici)

// sélection de la matrice d'affichage A...
#define adresseDeLaMatrice              3        // Pour les 4 matrices max évoquées ci-dessus, leurs index respectifs (adresses) vont de 0 à 3
#define adresseDeLaMatrice2             2        // Pour les 4 matrices max évoquées ci-dessus, leurs index respectifs (adresses) vont de 0 à 3
#define adresseDeLaMatrice1             1        // Pour les 4 matrices max évoquées ci-dessus, leurs index respectifs (adresses) vont de 0 à 3
#define adresseDeLaMatrice3             0        // Pour les 4 matrices max évoquées ci-dessus, leurs index respectifs (adresses) vont de 0 à 3
// 0 pres du connecteur ... 3 au bout de la matrice de 4 ...

// sélection de la matrice d'affichage B...
#define adresseDeLaMatrice7             7        // Pour les 4 matrices max évoquées ci-dessus, leurs index respectifs (adresses) vont de 4 à 7
#define adresseDeLaMatrice6             6        // Pour les 4 matrices max évoquées ci-dessus, leurs index respectifs (adresses) vont de 4 à 7
#define adresseDeLaMatrice5             5        // Pour les 4 matrices max évoquées ci-dessus, leurs index respectifs (adresses) vont de 4 à 7
#define adresseDeLaMatrice4             4        // Pour les 4 matrices max évoquées ci-dessus, leurs index respectifs (adresses) vont de 4 à 7

#define delaiEntreChaqueChangementAffichage  1000       // Délai d'attente entre chaque changement d'affichage (chiffres et symboles successifs )
#define delaiEntreChaqueChangementAffichage2  10000       // Délai d'utorisation action 
#define delaiEntreChaqueChangementAffichage3  100       // Délai d'attente changement FLASH
#define delaiAllumageLed                20       // Temps de maintien d'allumage LED, en millisecondes
#define DENIED_DELAYTON 300
#define DENIED_DELAYTON2 500
#define DENIED_DELAY1 500
#define DENIED_DELAY 2000
#define DENIED_DELAY2 3000
#define BOUTON1 7
#define RELAIS 5
// Buzzer
#define BUZZER 3 //buzzer pin
int relay_pin = 5;
// Display parameters
// const uint8_t TEXT_ZONE = 0;    // just change this to adjust display

// Define other dependent zone constants
// const uint8_t GRAPHIC_ZONE = (TEXT_ZONE == 1 ? 1 : 0);

// Instanciation de la matrice de leds
LedControl matriceLed = LedControl(brochePourLesDonnees, brochePourLhorloge, brocheDeSelection, nombreDeMatricesLedRaccordees);
// ========================

// ========================
// Initialisation programme
// ========================
void setup() {
// ===================================
  // RESET du démarrage du logiciel
// ===================================
  pinMode(RELAIS, OUTPUT);
 
 digitalWrite(resetPin, HIGH);
  delay(200);
  
// ===================================  
  // initialiser la broche numérique en tant que sortie.
  pinMode(resetPin, OUTPUT);   
// ===================================

 // ============= Initialisation matrice 8X32  référencée A ======================

// ===================================
  // Initialisation de la matrice LED 0
// ===================================  
  matriceLed.shutdown(adresseDeLaMatrice, false);       // shutdown     : "true" active le mode "sommeil", tandis que "false" active le mode "normal"
  matriceLed.setIntensity(adresseDeLaMatrice, 10);       // setIntensity : valeur pouvant aller de 0 à 15 (pour 16 niveaux de luminosité )
  matriceLed.clearDisplay(adresseDeLaMatrice);          // clearDisplay : éteint toutes les LEDs de la matrice
// ===================================
  // Initialisation de la matrice LED 1
// ===================================  
  matriceLed.shutdown(adresseDeLaMatrice1, false);       // shutdown     : "true" active le mode "sommeil", tandis que "false" active le mode "normal"
  matriceLed.setIntensity(adresseDeLaMatrice1, 10);       // setIntensity : valeur pouvant aller de 0 à 15 (pour 16 niveaux de luminosité )
  matriceLed.clearDisplay(adresseDeLaMatrice1);          // clearDisplay : éteint toutes les LEDs de la matrice
// ===================================
  // Initialisation de la matrice LED 2
// ===================================  
  matriceLed.shutdown(adresseDeLaMatrice2, false);       // shutdown     : "true" active le mode "sommeil", tandis que "false" active le mode "normal"
  matriceLed.setIntensity(adresseDeLaMatrice2, 10);       // setIntensity : valeur pouvant aller de 0 à 15 (pour 16 niveaux de luminosité )
  matriceLed.clearDisplay(adresseDeLaMatrice2);          // clearDisplay : éteint toutes les LEDs de la matrice
// ===================================
  // Initialisation de la matrice LED 3
// ===================================  
  matriceLed.shutdown(adresseDeLaMatrice3, false);       // shutdown     : "true" active le mode "sommeil", tandis que "false" active le mode "normal"
  matriceLed.setIntensity(adresseDeLaMatrice3, 10);       // setIntensity : valeur pouvant aller de 0 à 15 (pour 16 niveaux de luminosité )
  matriceLed.clearDisplay(adresseDeLaMatrice3);          // clearDisplay : éteint toutes les LEDs de la matrice  
 // ===================================

 // ============= Initialisation matrice 8X32  référencée B ======================
 
// ===================================
  // Initialisation de la matrice LED 7
// ===================================  
  matriceLed.shutdown(adresseDeLaMatrice7, false);       // shutdown     : "true" active le mode "sommeil", tandis que "false" active le mode "normal"
  matriceLed.setIntensity(adresseDeLaMatrice7, 10);       // setIntensity : valeur pouvant aller de 0 à 15 (pour 16 niveaux de luminosité )
  matriceLed.clearDisplay(adresseDeLaMatrice7);          // clearDisplay : éteint toutes les LEDs de la matrice
// ===================================
  // Initialisation de la matrice LED 6
// ===================================  
  matriceLed.shutdown(adresseDeLaMatrice6, false);       // shutdown     : "true" active le mode "sommeil", tandis que "false" active le mode "normal"
  matriceLed.setIntensity(adresseDeLaMatrice6, 10);       // setIntensity : valeur pouvant aller de 0 à 15 (pour 16 niveaux de luminosité )
  matriceLed.clearDisplay(adresseDeLaMatrice6);          // clearDisplay : éteint toutes les LEDs de la matrice
// ===================================
  // Initialisation de la matrice LED 5
// ===================================  
  matriceLed.shutdown(adresseDeLaMatrice5, false);       // shutdown     : "true" active le mode "sommeil", tandis que "false" active le mode "normal"
  matriceLed.setIntensity(adresseDeLaMatrice5, 10);       // setIntensity : valeur pouvant aller de 0 à 15 (pour 16 niveaux de luminosité )
  matriceLed.clearDisplay(adresseDeLaMatrice5);          // clearDisplay : éteint toutes les LEDs de la matrice
// ===================================
  // Initialisation de la matrice LED 4
// ===================================  
  matriceLed.shutdown(adresseDeLaMatrice4, false);       // shutdown     : "true" active le mode "sommeil", tandis que "false" active le mode "normal"
  matriceLed.setIntensity(adresseDeLaMatrice4, 10);       // setIntensity : valeur pouvant aller de 0 à 15 (pour 16 niveaux de luminosité )
  matriceLed.clearDisplay(adresseDeLaMatrice4);          // clearDisplay : éteint toutes les LEDs de la matrice  
  
  
  // Initialisation du programme mis en pause
// ===================================  
  pinMode(BUZZER, OUTPUT);
  noTone(BUZZER);
  pinMode (BOUTON1, INPUT_PULLUP);
  while (digitalRead(BOUTON1)) ;
}

// ===================================
// Fonction : afficherChiffreOuSymbole
// ===================================
// version originelle
// void afficherChiffreOuSymbole(byte pointeurVersChiffreOuSymbole[]) {
// fin de V.O
// version modifiée
void afficherChiffreOuSymbole(byte pointeurVersChiffreOuSymbole[], int quellematrice) {
//fin de V.modifiée
 // seconde modification - version originelle
  // Parcours des 8 lignes
//  for (int ligne = 0; ligne < 8; ligne++){
    // Et affichage des 8 colonnes pour chacune de ces lignes, avec fonction :
    // setRow(numero_de_matrice, numero_de_ligne, valeur_pour_cette_ligne)
 //   matriceLed.setRow(adresseDeLaMatrice, ligne, pgm_read_byte_near(pointeurVersChiffreOuSymbole + ligne));
//  }
 // fin de seconde modification version originelle
// modif ajoutée
 // Parcours des 8 lignes
  for (int ligne = 0; ligne < 8; ligne++){
    // Et affichage des 8 colonnes pour chacune de ces lignes, avec fonction :
    // setRow(numero_de_matrice, numero_de_ligne, valeur_pour_cette_ligne)
    matriceLed.setRow(quellematrice, ligne, pgm_read_byte_near(pointeurVersChiffreOuSymbole + ligne));
  }
// fin de modif version originelle
}

// =================
// Boucle principale
// =================
void loop() {

  // ***********************************************************
  // Balayage des chiffres 0 à 9 pour mode compteur, chiffres de 9 à 0 pour mode compte à rebours et symboles 
  // ***********************************************************
 
 tone(BUZZER, 3000, 1000);
 delay(DENIED_DELAYTON);
 noTone(BUZZER);
 delay(1000);
 tone(BUZZER, 3000, 1000);
 delay(DENIED_DELAYTON);
 noTone(BUZZER);
 delay(1000);
 tone(BUZZER, 3000, 1000);
 delay(DENIED_DELAYTON);
 noTone(BUZZER);
 // =========================
  // seconde 8X32 allumée ...

  afficherChiffreOuSymbole(SYMBOLE_OFF, 4);
   afficherChiffreOuSymbole(SYMBOLE_OFF, 5);
    afficherChiffreOuSymbole(SYMBOLE_OFF, 6);
     afficherChiffreOuSymbole(SYMBOLE_OFF, 7);
 // =========================
 
   afficherChiffreOuSymbole(SYMBOLE_FLASH, 3);
  delay(delaiEntreChaqueChangementAffichage3);
  delay(DENIED_DELAY2);
  
  afficherChiffreOuSymbole(SYMBOLE_CROIX, 3);
  tone(BUZZER, 3000, 1000);
  delay(DENIED_DELAYTON);
  noTone(BUZZER);
  delay(delaiEntreChaqueChangementAffichage);
  
  afficherChiffreOuSymbole(CHIFFRE_9, 3);
  delay(delaiEntreChaqueChangementAffichage);

  afficherChiffreOuSymbole(CHIFFRE_8, 3);
  delay(delaiEntreChaqueChangementAffichage);

  afficherChiffreOuSymbole(CHIFFRE_7, 3);
  delay(delaiEntreChaqueChangementAffichage);

  afficherChiffreOuSymbole(CHIFFRE_6, 3);
  afficherChiffreOuSymbole(SYMBOLE_TIERS, 2);
  afficherChiffreOuSymbole(SYMBOLE_TIERS, 1);
  afficherChiffreOuSymbole(SYMBOLE_TIERS, 0);
  delay(delaiEntreChaqueChangementAffichage);

  afficherChiffreOuSymbole(CHIFFRE_5, 3);
  delay(delaiEntreChaqueChangementAffichage);

  afficherChiffreOuSymbole(CHIFFRE_4, 3);
  delay(delaiEntreChaqueChangementAffichage);

  afficherChiffreOuSymbole(CHIFFRE_3, 3);
  afficherChiffreOuSymbole(SYMBOLE_2TIERS, 2);
  afficherChiffreOuSymbole(SYMBOLE_2TIERS, 1);
  afficherChiffreOuSymbole(SYMBOLE_2TIERS, 0);
  delay(delaiEntreChaqueChangementAffichage);

  afficherChiffreOuSymbole(CHIFFRE_2, 3);
  delay(delaiEntreChaqueChangementAffichage);

  afficherChiffreOuSymbole(CHIFFRE_1, 3);
  delay(delaiEntreChaqueChangementAffichage);

  afficherChiffreOuSymbole(SYMBOLE_FLASH, 3);
  delay(delaiEntreChaqueChangementAffichage3);
  
 // =========================
  // seconde 8X32 eteinte ...

  afficherChiffreOuSymbole(SYMBOLE_PLEIN, 4);
   afficherChiffreOuSymbole(SYMBOLE_PLEIN, 5);
    afficherChiffreOuSymbole(SYMBOLE_PLEIN, 6);
     afficherChiffreOuSymbole(SYMBOLE_PLEIN, 7);
 // =========================
  afficherChiffreOuSymbole(SYMBOLE_OFF, 0);
   afficherChiffreOuSymbole(SYMBOLE_OFF, 1);
    afficherChiffreOuSymbole(SYMBOLE_OFF, 2);
     afficherChiffreOuSymbole(SYMBOLE_OFF, 3);
 digitalWrite(RELAIS, HIGH);
 tone(BUZZER, 3000, 1000);
  delay(DENIED_DELAY1);
  noTone(BUZZER);
  delay(delaiEntreChaqueChangementAffichage2);
  digitalWrite(RELAIS, LOW);
   tone(BUZZER, 3000, 1000);
 delay(DENIED_DELAYTON);
 noTone(BUZZER);
  afficherChiffreOuSymbole(SYMBOLE_CROIX, 0);
   afficherChiffreOuSymbole(SYMBOLE_CROIX, 1);
    afficherChiffreOuSymbole(SYMBOLE_CROIX, 2);
     afficherChiffreOuSymbole(SYMBOLE_CROIX, 3);
   afficherChiffreOuSymbole(SYMBOLE_OFF, 4);
   afficherChiffreOuSymbole(SYMBOLE_OFF, 5);
   afficherChiffreOuSymbole(SYMBOLE_OFF, 6);
   afficherChiffreOuSymbole(SYMBOLE_OFF, 7);
     delay(delaiEntreChaqueChangementAffichage2);
     
  afficherChiffreOuSymbole(SYMBOLE_Z, 0);
   afficherChiffreOuSymbole(SYMBOLE_A, 1);
    afficherChiffreOuSymbole(SYMBOLE_R, 2);
     afficherChiffreOuSymbole(SYMBOLE_PLEIN, 3);
    delay(delaiEntreChaqueChangementAffichage);


// =================
// Boucle secondaire qui effacera le dernier affichage de la matrice 8X32
// =================

  // *********************
  // EFFACEUR matrice 2
  // *********************

  for(int ligne = 0; ligne < 8; ligne++) {                              // Parcours des 8 lignes de la matrice LED
    for(int colonne = 0; colonne < 8; colonne++) {                          // Parcours des 8 colonnes de la matrice LED
      matriceLed.setLed(adresseDeLaMatrice2, ligne, colonne, true);              // extinction de la LED située à la position ligne/colonne
      delay(delaiAllumageLed);                                                  // Maintien de cette LED éteinte
      matriceLed.setLed(adresseDeLaMatrice2, ligne, colonne, false);             // Passage à la led suivante
    }
  }

   // *********************
  // EFFACEUR matrice 1
  // *********************

  for(int ligne = 0; ligne < 8; ligne++) {                              // Parcours des 8 lignes de la matrice LED
    for(int colonne = 0; colonne < 8; colonne++) {                          // Parcours des 8 colonnes de la matrice LED
      matriceLed.setLed(adresseDeLaMatrice1, ligne, colonne, true);              // extinction de la LED située à la position ligne/colonne
      delay(delaiAllumageLed);                                                  // Maintien de cette LED éteinte
      matriceLed.setLed(adresseDeLaMatrice1, ligne, colonne, false);             // Passage à la led suivante
    }
  }
   // *********************
  // EFFACEUR matrice 0
  // *********************

  for(int ligne = 0; ligne < 8; ligne++) {                              // Parcours des 8 lignes de la matrice LED
    for(int colonne = 0; colonne < 8; colonne++) {                          // Parcours des 8 colonnes de la matrice LED
      matriceLed.setLed(adresseDeLaMatrice3, ligne, colonne, true);              // extinction de la LED située à la position ligne/colonne
      delay(delaiAllumageLed);                                                  // Maintien de cette LED éteinte
      matriceLed.setLed(adresseDeLaMatrice3, ligne, colonne, false);             // Passage à la led suivante
    }
  }

 // *********************
  // EFFACEUR matrice 3 - compteur
  // *********************

  for(int ligne = 0; ligne < 8; ligne++) {                              // Parcours des 8 lignes de la matrice LED
    for(int colonne = 0; colonne < 8; colonne++) {                          // Parcours des 8 colonnes de la matrice LED
      matriceLed.setLed(adresseDeLaMatrice, ligne, colonne, true);              // extinction de la LED située à la position ligne/colonne
      delay(delaiAllumageLed);                                                  // Maintien de cette LED éteinte
      matriceLed.setLed(adresseDeLaMatrice, ligne, colonne, false);             // Passage à la led suivante
    }
  }
  // *********************
  // ARRET de la BOUCLE et retour début de programme avec mise en PAUSE
  // *********************
  digitalWrite(resetPin, LOW);
}

et le fichier "symboles" ...

// =======================================================
// Encodage des chiffres et symboles, pour matrice LED 8x8
// =======================================================
// Fichier reference chiffres_et_symboles.h
// 1) Chiffres 0 à 9
// 2) Symboles +, -, /, *, et % et divers...
// 3) Alpabet utile ; R ... A ... Z ... etc etc etc ..

const byte CHIFFRE_0[] PROGMEM = {
  0b00111100,   // 1ère ligne de leds pour ce chiffre
  0b01000010,   // 2ème ligne de leds pour ce chiffre
  0b01000010,   // 3ème ligne de leds pour ce chiffre
  0b01000010,   // 4ème ligne de leds pour ce chiffre
  0b01000010,   // 5ème ligne de leds pour ce chiffre
  0b01000010,   // 6ème ligne de leds pour ce chiffre
  0b01000010,   // 7ème ligne de leds pour ce chiffre
  0b00111100    // 8ème ligne de leds pour ce chiffre
};

const byte CHIFFRE_1[] PROGMEM = {
  0b00001000,   // 1ère ligne de leds pour ce chiffre
  0b00011000,   // 2ème ligne de leds pour ce chiffre
  0b00111000,   // 3ème ligne de leds pour ce chiffre
  0b01011000,   // 4ème ligne de leds pour ce chiffre
  0b00011000,   // 5ème ligne de leds pour ce chiffre
  0b00011000,   // 6ème ligne de leds pour ce chiffre
  0b00011000,   // 7ème ligne de leds pour ce chiffre
  0b00111100    // 8ème ligne de leds pour ce chiffre
};

const byte CHIFFRE_2[] PROGMEM = {
  0b00111100,   // 1ère ligne de leds pour ce chiffre
  0b01000010,   // 2ème ligne de leds pour ce chiffre
  0b01000010,   // 3ème ligne de leds pour ce chiffre
  0b00000100,   // 4ème ligne de leds pour ce chiffre
  0b00001000,   // 5ème ligne de leds pour ce chiffre
  0b00010000,   // 6ème ligne de leds pour ce chiffre
  0b00100000,   // 7ème ligne de leds pour ce chiffre
  0b01111110    // 8ème ligne de leds pour ce chiffre
};

const byte CHIFFRE_3[] PROGMEM = {
  0b01111110,   // 1ère ligne de leds pour ce chiffre
  0b00000100,   // 2ème ligne de leds pour ce chiffre
  0b00001000,   // 3ème ligne de leds pour ce chiffre
  0b00011100,   // 4ème ligne de leds pour ce chiffre
  0b00000010,   // 5ème ligne de leds pour ce chiffre
  0b00000010,   // 6ème ligne de leds pour ce chiffre
  0b01000010,   // 7ème ligne de leds pour ce chiffre
  0b00111100    // 8ème ligne de leds pour ce chiffre
};

const byte CHIFFRE_4[] PROGMEM = {
  0b00000100,   // 1ère ligne de leds pour ce chiffre
  0b00001100,   // 2ème ligne de leds pour ce chiffre
  0b00010100,   // 3ème ligne de leds pour ce chiffre
  0b00100100,   // 4ème ligne de leds pour ce chiffre
  0b01111110,   // 5ème ligne de leds pour ce chiffre
  0b00000100,   // 6ème ligne de leds pour ce chiffre
  0b00000100,   // 7ème ligne de leds pour ce chiffre
  0b00000100    // 8ème ligne de leds pour ce chiffre
};

const byte CHIFFRE_5[] PROGMEM = {
  0b00111100,   // 1ère ligne de leds pour ce chiffre
  0b01000000,   // 2ème ligne de leds pour ce chiffre
  0b01000000,   // 3ème ligne de leds pour ce chiffre
  0b01111100,   // 4ème ligne de leds pour ce chiffre
  0b00000010,   // 5ème ligne de leds pour ce chiffre
  0b00000010,   // 6ème ligne de leds pour ce chiffre
  0b01000010,   // 7ème ligne de leds pour ce chiffre
  0b00111100    // 8ème ligne de leds pour ce chiffre
};

const byte CHIFFRE_6[] PROGMEM = {
  0b00111100,   // 1ère ligne de leds pour ce chiffre
  0b01000010,   // 2ème ligne de leds pour ce chiffre
  0b01000000,   // 3ème ligne de leds pour ce chiffre
  0b01111100,   // 4ème ligne de leds pour ce chiffre
  0b01000010,   // 5ème ligne de leds pour ce chiffre
  0b01000010,   // 6ème ligne de leds pour ce chiffre
  0b01000010,   // 7ème ligne de leds pour ce chiffre
  0b00111100    // 8ème ligne de leds pour ce chiffre
};

const byte CHIFFRE_7[] PROGMEM = {
  0b01111110,   // 1ère ligne de leds pour ce chiffre
  0b00000010,   // 2ème ligne de leds pour ce chiffre
  0b00000010,   // 3ème ligne de leds pour ce chiffre
  0b00000100,   // 4ème ligne de leds pour ce chiffre
  0b00001000,   // 5ème ligne de leds pour ce chiffre
  0b00010000,   // 6ème ligne de leds pour ce chiffre
  0b00100000,   // 7ème ligne de leds pour ce chiffre
  0b01000000    // 8ème ligne de leds pour ce chiffre
};

const byte CHIFFRE_8[] PROGMEM = {
  0b00111100,   // 1ère ligne de leds pour ce chiffre
  0b01000010,   // 2ème ligne de leds pour ce chiffre
  0b01000010,   // 3ème ligne de leds pour ce chiffre
  0b00111100,   // 4ème ligne de leds pour ce chiffre
  0b01000010,   // 5ème ligne de leds pour ce chiffre
  0b01000010,   // 6ème ligne de leds pour ce chiffre
  0b01000010,   // 7ème ligne de leds pour ce chiffre
  0b00111100    // 8ème ligne de leds pour ce chiffre
};

const byte CHIFFRE_9[] PROGMEM = {
  0b00111100,   // 1ère ligne de leds pour ce chiffre
  0b01000010,   // 2ème ligne de leds pour ce chiffre
  0b01000010,   // 3ème ligne de leds pour ce chiffre
  0b01000010,   // 4ème ligne de leds pour ce chiffre
  0b00111110,   // 5ème ligne de leds pour ce chiffre
  0b00000010,   // 6ème ligne de leds pour ce chiffre
  0b01000010,   // 7ème ligne de leds pour ce chiffre
  0b00111100    // 8ème ligne de leds pour ce chiffre
};

const byte SYMBOLE_ADDITION[] PROGMEM = {
  0b00000000,   // 1ère ligne de leds pour ce chiffre
  0b00001000,   // 2ème ligne de leds pour ce chiffre
  0b00001000,   // 3ème ligne de leds pour ce chiffre
  0b00111110,   // 4ème ligne de leds pour ce chiffre
  0b00001000,   // 5ème ligne de leds pour ce chiffre
  0b00001000,   // 6ème ligne de leds pour ce chiffre
  0b00000000,   // 7ème ligne de leds pour ce chiffre
  0b00000000    // 8ème ligne de leds pour ce chiffre
};

const byte SYMBOLE_SOUSTRACTION[] PROGMEM = {
  0b00000000,   // 1ère ligne de leds pour ce chiffre
  0b00000000,   // 2ème ligne de leds pour ce chiffre
  0b00000000,   // 3ème ligne de leds pour ce chiffre
  0b01111110,   // 4ème ligne de leds pour ce chiffre
  0b00000000,   // 5ème ligne de leds pour ce chiffre
  0b00000000,   // 6ème ligne de leds pour ce chiffre
  0b00000000,   // 7ème ligne de leds pour ce chiffre
  0b00000000    // 8ème ligne de leds pour ce chiffre
};

const byte SYMBOLE_DIVISION[] PROGMEM = {
  0b00000000,   // 1ère ligne de leds pour ce chiffre
  0b00000010,   // 2ème ligne de leds pour ce chiffre
  0b00000100,   // 3ème ligne de leds pour ce chiffre
  0b00001000,   // 4ème ligne de leds pour ce chiffre
  0b00010000,   // 5ème ligne de leds pour ce chiffre
  0b00100000,   // 6ème ligne de leds pour ce chiffre
  0b01000000,   // 7ème ligne de leds pour ce chiffre
  0b00000000    // 8ème ligne de leds pour ce chiffre
};

const byte SYMBOLE_MULTIPLICATION[] PROGMEM = {
  0b00000000,   // 1ère ligne de leds pour ce chiffre
  0b01001001,   // 2ème ligne de leds pour ce chiffre
  0b00101010,   // 3ème ligne de leds pour ce chiffre
  0b00011100,   // 4ème ligne de leds pour ce chiffre
  0b01111111,   // 5ème ligne de leds pour ce chiffre
  0b00011100,   // 6ème ligne de leds pour ce chiffre
  0b00101010,   // 7ème ligne de leds pour ce chiffre
  0b01001001    // 8ème ligne de leds pour ce chiffre
};

const byte SYMBOLE_POURCENTAGE[] PROGMEM = {
  0b00000000,   // 1ère ligne de leds pour ce chiffre
  0b01100010,   // 2ème ligne de leds pour ce chiffre
  0b01100100,   // 3ème ligne de leds pour ce chiffre
  0b00001000,   // 4ème ligne de leds pour ce chiffre
  0b00010000,   // 5ème ligne de leds pour ce chiffre
  0b00100110,   // 6ème ligne de leds pour ce chiffre
  0b01000110,   // 7ème ligne de leds pour ce chiffre
  0b00000000    // 8ème ligne de leds pour ce chiffre
};

const byte SYMBOLE_CROIX[] PROGMEM = {
  0b10000001,   // 1ère ligne de leds pour ce chiffre
  0b01000010,   // 2ème ligne de leds pour ce chiffre
  0b00100100,   // 3ème ligne de leds pour ce chiffre
  0b00011000,   // 4ème ligne de leds pour ce chiffre
  0b00011000,   // 5ème ligne de leds pour ce chiffre
  0b00100100,   // 6ème ligne de leds pour ce chiffre
  0b01000010,   // 7ème ligne de leds pour ce chiffre
  0b10000001    // 8ème ligne de leds pour ce chiffre
};

const byte SYMBOLE_PLEIN[] PROGMEM = {
  0b11111111,   // 1ère ligne de leds pour ce chiffre
  0b11111111,   // 2ème ligne de leds pour ce chiffre
  0b11111111,   // 3ème ligne de leds pour ce chiffre
  0b11111111,   // 4ème ligne de leds pour ce chiffre
  0b11111111,   // 5ème ligne de leds pour ce chiffre
  0b11111111,   // 6ème ligne de leds pour ce chiffre
  0b11111111,   // 7ème ligne de leds pour ce chiffre
  0b11111111    // 8ème ligne de leds pour ce chiffre
};

const byte SYMBOLE_FLASH[] PROGMEM = {
  0b00000000,   // 1ère ligne de leds pour ce chiffre
  0b00000000,   // 2ème ligne de leds pour ce chiffre
  0b00000000,   // 3ème ligne de leds pour ce chiffre
  0b00011000,   // 4ème ligne de leds pour ce chiffre
  0b00011000,   // 5ème ligne de leds pour ce chiffre
  0b00000000,   // 6ème ligne de leds pour ce chiffre
  0b00000000,   // 7ème ligne de leds pour ce chiffre
  0b00000000    // 8ème ligne de leds pour ce chiffre
};

const byte SYMBOLE_EXCLAMATION[] PROGMEM = {
  0b00011000,   // 1ère ligne de leds pour ce chiffre
  0b00011000,   // 2ème ligne de leds pour ce chiffre
  0b00011000,   // 3ème ligne de leds pour ce chiffre
  0b00100100,   // 4ème ligne de leds pour ce chiffre
  0b00111100,   // 5ème ligne de leds pour ce chiffre
  0b00000000,   // 6ème ligne de leds pour ce chiffre
  0b00011000,   // 7ème ligne de leds pour ce chiffre
  0b00011000    // 8ème ligne de leds pour ce chiffre
};

const byte SYMBOLE_CIBLE[] PROGMEM = {
  0b11111111,   // 1ère ligne de leds pour ce chiffre
  0b10000001,   // 2ème ligne de leds pour ce chiffre
  0b10000001,   // 3ème ligne de leds pour ce chiffre
  0b10011001,   // 4ème ligne de leds pour ce chiffre
  0b10011001,   // 5ème ligne de leds pour ce chiffre
  0b10000001,   // 6ème ligne de leds pour ce chiffre
  0b10000001,   // 7ème ligne de leds pour ce chiffre
  0b11111111    // 8ème ligne de leds pour ce chiffre
};

const byte SYMBOLE_R[] PROGMEM = {
  0b00000000,   // 1ère ligne de leds pour ce chiffre
  0b01111100,   // 2ème ligne de leds pour ce chiffre
  0b01000010,   // 3ème ligne de leds pour ce chiffre
  0b01111110,   // 4ème ligne de leds pour ce chiffre
  0b01011000,   // 5ème ligne de leds pour ce chiffre
  0b01000100,   // 6ème ligne de leds pour ce chiffre
  0b01000010,   // 7ème ligne de leds pour ce chiffre
  0b00000000    // 8ème ligne de leds pour ce chiffre
};

const byte SYMBOLE_A[] PROGMEM = {
  0b00000000,   // 1ère ligne de leds pour ce chiffre
  0b00111100,   // 2ème ligne de leds pour ce chiffre
  0b01000010,   // 3ème ligne de leds pour ce chiffre
  0b01000010,   // 4ème ligne de leds pour ce chiffre
  0b01111110,   // 5ème ligne de leds pour ce chiffre
  0b01000010,   // 6ème ligne de leds pour ce chiffre
  0b01000010,   // 7ème ligne de leds pour ce chiffre
  0b00000000    // 8ème ligne de leds pour ce chiffre
};

const byte SYMBOLE_Z[] PROGMEM = {
  0b00000000,   // 1ère ligne de leds pour ce chiffre
  0b01111110,   // 2ème ligne de leds pour ce chiffre
  0b00000100,   // 3ème ligne de leds pour ce chiffre
  0b00001000,   // 4ème ligne de leds pour ce chiffre
  0b00010000,   // 5ème ligne de leds pour ce chiffre
  0b00100000,   // 6ème ligne de leds pour ce chiffre
  0b01111110,   // 7ème ligne de leds pour ce chiffre
  0b00000000    // 8ème ligne de leds pour ce chiffre
};

const byte SYMBOLE_OFF[] PROGMEM = {
  0b00000000,   // 1ère ligne de leds pour ce chiffre
  0b00000000,   // 2ème ligne de leds pour ce chiffre
  0b00000000,   // 3ème ligne de leds pour ce chiffre
  0b00000000,   // 4ème ligne de leds pour ce chiffre
  0b00000000,   // 5ème ligne de leds pour ce chiffre
  0b00000000,   // 6ème ligne de leds pour ce chiffre
  0b00000000,   // 7ème ligne de leds pour ce chiffre
  0b00000000   // 8ème ligne de leds pour ce chiffre
};

const byte SYMBOLE_TIERS[] PROGMEM = {
  0b00000000,   // 1ère ligne de leds pour ce chiffre
  0b00000000,   // 2ème ligne de leds pour ce chiffre
  0b00000000,   // 3ème ligne de leds pour ce chiffre
  0b00000000,   // 4ème ligne de leds pour ce chiffre
  0b00000000,   // 5ème ligne de leds pour ce chiffre
  0b11111111,   // 6ème ligne de leds pour ce chiffre
  0b11111111,   // 7ème ligne de leds pour ce chiffre
  0b11111111    // 8ème ligne de leds pour ce chiffre
};

const byte SYMBOLE_2TIERS[] PROGMEM = {
  0b00000000,   // 1ère ligne de leds pour ce chiffre
  0b00000000,   // 2ème ligne de leds pour ce chiffre
  0b00000000,   // 3ème ligne de leds pour ce chiffre
  0b11111111,   // 4ème ligne de leds pour ce chiffre
  0b11111111,   // 5ème ligne de leds pour ce chiffre
  0b11111111,   // 6ème ligne de leds pour ce chiffre
  0b11111111,   // 7ème ligne de leds pour ce chiffre
  0b11111111    // 8ème ligne de leds pour ce chiffre
};

const byte SYMBOLE_3TIERS[] PROGMEM = {
  0b00000000,   // 1ère ligne de leds pour ce chiffre
  0b00000000,   // 2ème ligne de leds pour ce chiffre
  0b00000000,   // 3ème ligne de leds pour ce chiffre
  0b00000000,   // 4ème ligne de leds pour ce chiffre
  0b00000000,   // 5ème ligne de leds pour ce chiffre
  0b00000000,   // 6ème ligne de leds pour ce chiffre
  0b00000000,   // 7ème ligne de leds pour ce chiffre
  0b00000000    // 8ème ligne de leds pour ce chiffre
};

la solution PAROLA est pas mal mais ça m'oblige à réécrire quasi tout le sketch ...

[neteraser]

une vidéo est dispo mais comment l'insérer dans la discussion ?...

[J-M-L]

vous la postez sur un compte youTube et vous mettez le lien youTube 'brut' directement dans le forum.

le forum affiche alors un lecteur directement dans la page.

[neteraser]

Ok ... c'est ce que je pensais ...
voici le code avec les "instructions" pour implémenter la troisième barre ( VERTE ) ...
je vais tenter les modifications avec la bibli de PAROLA et la modif pour ajout de la 3ème ...
je vais bricoler en fonction de mes "connaissances" ... je suis un "novice" malgré mon age ... ... je vais très certainement appeler au secours ...

// ========================
// #include et #define du  programme
// ========================
// Inclusion de la librairie LedControl
#include "LedControl.h"
#include "chiffres_et_symboles.h"

// Définition des broches de raccordement Arduino UNO ou Nano → Matrice LED pilotée par MAX7219
#define brochePourLhorloge              13         // Sortie 13 de l'Arduino vers la broche CLK de la matrice LED
#define brocheDeSelection               10         // Sortie 10 de l'Arduino vers la broche CS  de la matrice LED
#define brochePourLesDonnees            11         // Sortie 11 de l'Arduino vers la broche DIN de la matrice LED

// Définition des autres "constantes"

int resetPin = 12;                               // Sortie de la RAZ de la BOUCLE secondaire

#define nombreDeMatricesLedRaccordees   8         // Nombre pouvant aller de 1 à 12 (nombre maxi de matrice led pilotable ici)

// sélection de la matrice d'affichage A...
#define adresseDeLaMatrice              3        // Pour les 4 matrices max évoquées ci-dessus, leurs index respectifs (adresses) vont de 0 à 3
#define adresseDeLaMatrice2             2        // Pour les 4 matrices max évoquées ci-dessus, leurs index respectifs (adresses) vont de 0 à 3
#define adresseDeLaMatrice1             1        // Pour les 4 matrices max évoquées ci-dessus, leurs index respectifs (adresses) vont de 0 à 3
#define adresseDeLaMatrice3             0        // Pour les 4 matrices max évoquées ci-dessus, leurs index respectifs (adresses) vont de 0 à 3
// 0 pres du connecteur ... 3 au bout de la matrice de 4 ...

// sélection de la matrice d'affichage B...
#define adresseDeLaMatrice7             7        // Pour les 4 matrices max évoquées ci-dessus, leurs index respectifs (adresses) vont de 4 à 7
#define adresseDeLaMatrice6             6        // Pour les 4 matrices max évoquées ci-dessus, leurs index respectifs (adresses) vont de 4 à 7
#define adresseDeLaMatrice5             5        // Pour les 4 matrices max évoquées ci-dessus, leurs index respectifs (adresses) vont de 4 à 7
#define adresseDeLaMatrice4             4        // Pour les 4 matrices max évoquées ci-dessus, leurs index respectifs (adresses) vont de 4 à 7

// sélection de la matrice d'affichage C...
#define adresseDeLaMatrice11            11       // Pour les 4 matrices max évoquées ci-dessus, leurs index respectifs (adresses) vont de 4 à 7
#define adresseDeLaMatrice10            10       // Pour les 4 matrices max évoquées ci-dessus, leurs index respectifs (adresses) vont de 4 à 7
#define adresseDeLaMatrice9             9        // Pour les 4 matrices max évoquées ci-dessus, leurs index respectifs (adresses) vont de 4 à 7
#define adresseDeLaMatrice8             8        // Pour les 4 matrices max évoquées ci-dessus, leurs index respectifs (adresses) vont de 4 à 7


#define delaiEntreChaqueChangementAffichage  1000       // Délai d'attente entre chaque changement d'affichage (chiffres et symboles successifs )
#define delaiEntreChaqueChangementAffichage2  10000       // Délai d'utorisation action 
#define delaiEntreChaqueChangementAffichage3  100       // Délai d'attente changement FLASH
#define delaiAllumageLed                20       // Temps de maintien d'allumage LED, en millisecondes
#define DENIED_DELAYTON 300
#define DENIED_DELAYTON2 500
#define DENIED_DELAY1 500
#define DENIED_DELAY 2000
#define DENIED_DELAY2 3000
#define BOUTON1 7
#define RELAIS 5
// Buzzer
#define BUZZER 3 //buzzer pin
int relay_pin = 5;
// Display parameters
// const uint8_t TEXT_ZONE = 0;    // just change this to adjust display

// Define other dependent zone constants
// const uint8_t GRAPHIC_ZONE = (TEXT_ZONE == 1 ? 1 : 0);

// Instanciation de la matrice de leds
LedControl matriceLed = LedControl(brochePourLesDonnees, brochePourLhorloge, brocheDeSelection, nombreDeMatricesLedRaccordees);
// ========================

// ========================
// Initialisation programme
// ========================
void setup() {
// ===================================
  // RESET du démarrage du logiciel
// ===================================
  pinMode(RELAIS, OUTPUT);
 
 digitalWrite(resetPin, HIGH);
  delay(200);
  
// ===================================  
  // initialiser la broche numérique en tant que sortie.
  pinMode(resetPin, OUTPUT);   
// ===================================

 // ============= Initialisation matrice 8X32  référencée A ======================

// ===================================
  // Initialisation de la matrice LED 0
// ===================================  
  matriceLed.shutdown(adresseDeLaMatrice, false);       // shutdown     : "true" active le mode "sommeil", tandis que "false" active le mode "normal"
  matriceLed.setIntensity(adresseDeLaMatrice, 10);       // setIntensity : valeur pouvant aller de 0 à 15 (pour 16 niveaux de luminosité )
  matriceLed.clearDisplay(adresseDeLaMatrice);          // clearDisplay : éteint toutes les LEDs de la matrice
// ===================================
  // Initialisation de la matrice LED 1
// ===================================  
  matriceLed.shutdown(adresseDeLaMatrice1, false);       // shutdown     : "true" active le mode "sommeil", tandis que "false" active le mode "normal"
  matriceLed.setIntensity(adresseDeLaMatrice1, 10);       // setIntensity : valeur pouvant aller de 0 à 15 (pour 16 niveaux de luminosité )
  matriceLed.clearDisplay(adresseDeLaMatrice1);          // clearDisplay : éteint toutes les LEDs de la matrice
// ===================================
  // Initialisation de la matrice LED 2
// ===================================  
  matriceLed.shutdown(adresseDeLaMatrice2, false);       // shutdown     : "true" active le mode "sommeil", tandis que "false" active le mode "normal"
  matriceLed.setIntensity(adresseDeLaMatrice2, 10);       // setIntensity : valeur pouvant aller de 0 à 15 (pour 16 niveaux de luminosité )
  matriceLed.clearDisplay(adresseDeLaMatrice2);          // clearDisplay : éteint toutes les LEDs de la matrice
// ===================================
  // Initialisation de la matrice LED 3
// ===================================  
  matriceLed.shutdown(adresseDeLaMatrice3, false);       // shutdown     : "true" active le mode "sommeil", tandis que "false" active le mode "normal"
  matriceLed.setIntensity(adresseDeLaMatrice3, 10);       // setIntensity : valeur pouvant aller de 0 à 15 (pour 16 niveaux de luminosité )
  matriceLed.clearDisplay(adresseDeLaMatrice3);          // clearDisplay : éteint toutes les LEDs de la matrice  
 // ===================================

 // ============= Initialisation matrice 8X32  référencée B ======================
 
// ===================================
  // Initialisation de la matrice LED 7
// ===================================  
  matriceLed.shutdown(adresseDeLaMatrice7, false);       // shutdown     : "true" active le mode "sommeil", tandis que "false" active le mode "normal"
  matriceLed.setIntensity(adresseDeLaMatrice7, 10);       // setIntensity : valeur pouvant aller de 0 à 15 (pour 16 niveaux de luminosité )
  matriceLed.clearDisplay(adresseDeLaMatrice7);          // clearDisplay : éteint toutes les LEDs de la matrice
// ===================================
  // Initialisation de la matrice LED 6
// ===================================  
  matriceLed.shutdown(adresseDeLaMatrice6, false);       // shutdown     : "true" active le mode "sommeil", tandis que "false" active le mode "normal"
  matriceLed.setIntensity(adresseDeLaMatrice6, 10);       // setIntensity : valeur pouvant aller de 0 à 15 (pour 16 niveaux de luminosité )
  matriceLed.clearDisplay(adresseDeLaMatrice6);          // clearDisplay : éteint toutes les LEDs de la matrice
// ===================================
  // Initialisation de la matrice LED 5
// ===================================  
  matriceLed.shutdown(adresseDeLaMatrice5, false);       // shutdown     : "true" active le mode "sommeil", tandis que "false" active le mode "normal"
  matriceLed.setIntensity(adresseDeLaMatrice5, 10);       // setIntensity : valeur pouvant aller de 0 à 15 (pour 16 niveaux de luminosité )
  matriceLed.clearDisplay(adresseDeLaMatrice5);          // clearDisplay : éteint toutes les LEDs de la matrice
// ===================================
  // Initialisation de la matrice LED 4
// ===================================  
  matriceLed.shutdown(adresseDeLaMatrice4, false);       // shutdown     : "true" active le mode "sommeil", tandis que "false" active le mode "normal"
  matriceLed.setIntensity(adresseDeLaMatrice4, 10);       // setIntensity : valeur pouvant aller de 0 à 15 (pour 16 niveaux de luminosité )
  matriceLed.clearDisplay(adresseDeLaMatrice4);          // clearDisplay : éteint toutes les LEDs de la matrice  
  
 // ============= Initialisation matrice 8X32  référencée C ======================
 
// ===================================
  // Initialisation de la matrice LED 11
// ===================================  
  matriceLed.shutdown(adresseDeLaMatrice11, false);       // shutdown     : "true" active le mode "sommeil", tandis que "false" active le mode "normal"
  matriceLed.setIntensity(adresseDeLaMatrice11, 10);       // setIntensity : valeur pouvant aller de 0 à 15 (pour 16 niveaux de luminosité )
  matriceLed.clearDisplay(adresseDeLaMatrice11);          // clearDisplay : éteint toutes les LEDs de la matrice
// ===================================
  // Initialisation de la matrice LED 10
// ===================================  
  matriceLed.shutdown(adresseDeLaMatrice10, false);       // shutdown     : "true" active le mode "sommeil", tandis que "false" active le mode "normal"
  matriceLed.setIntensity(adresseDeLaMatrice10, 10);       // setIntensity : valeur pouvant aller de 0 à 15 (pour 16 niveaux de luminosité )
  matriceLed.clearDisplay(adresseDeLaMatrice10);          // clearDisplay : éteint toutes les LEDs de la matrice
// ===================================
  // Initialisation de la matrice LED 9
// ===================================  
  matriceLed.shutdown(adresseDeLaMatrice9, false);       // shutdown     : "true" active le mode "sommeil", tandis que "false" active le mode "normal"
  matriceLed.setIntensity(adresseDeLaMatrice9, 10);       // setIntensity : valeur pouvant aller de 0 à 15 (pour 16 niveaux de luminosité )
  matriceLed.clearDisplay(adresseDeLaMatrice9);          // clearDisplay : éteint toutes les LEDs de la matrice
// ===================================
  // Initialisation de la matrice LED 8
// ===================================  
  matriceLed.shutdown(adresseDeLaMatrice8, false);       // shutdown     : "true" active le mode "sommeil", tandis que "false" active le mode "normal"
  matriceLed.setIntensity(adresseDeLaMatrice8, 10);       // setIntensity : valeur pouvant aller de 0 à 15 (pour 16 niveaux de luminosité )
  matriceLed.clearDisplay(adresseDeLaMatrice8);          // clearDisplay : éteint toutes les LEDs de la matrice  
  


  
  // Initialisation du programme mis en pause
// ===================================  
  pinMode(BUZZER, OUTPUT);
  noTone(BUZZER);
  pinMode (BOUTON1, INPUT_PULLUP);
  while (digitalRead(BOUTON1)) ;
}

// ===================================
// Fonction : afficherChiffreOuSymbole
// ===================================
// version originelle
// void afficherChiffreOuSymbole(byte pointeurVersChiffreOuSymbole[]) {
// fin de V.O
// version modifiée
void afficherChiffreOuSymbole(byte pointeurVersChiffreOuSymbole[], int quellematrice) {
//fin de V.modifiée
 // seconde modification - version originelle
  // Parcours des 8 lignes
//  for (int ligne = 0; ligne < 8; ligne++){
    // Et affichage des 8 colonnes pour chacune de ces lignes, avec fonction :
    // setRow(numero_de_matrice, numero_de_ligne, valeur_pour_cette_ligne)
 //   matriceLed.setRow(adresseDeLaMatrice, ligne, pgm_read_byte_near(pointeurVersChiffreOuSymbole + ligne));
//  }
 // fin de seconde modification version originelle
// modif ajoutée
 // Parcours des 8 lignes
  for (int ligne = 0; ligne < 8; ligne++){
    // Et affichage des 8 colonnes pour chacune de ces lignes, avec fonction :
    // setRow(numero_de_matrice, numero_de_ligne, valeur_pour_cette_ligne)
    matriceLed.setRow(quellematrice, ligne, pgm_read_byte_near(pointeurVersChiffreOuSymbole + ligne));
  }
// fin de modif version originelle
}

// =================
// Boucle principale
// =================
void loop() {

  // ***********************************************************
  // Balayage des chiffres 0 à 9 pour mode compteur, chiffres de 9 à 0 pour mode compte à rebours et symboles 
  // ***********************************************************
 
 tone(BUZZER, 3000, 1000);
 delay(DENIED_DELAYTON);
 noTone(BUZZER);
 delay(1000);
 tone(BUZZER, 3000, 1000);
 delay(DENIED_DELAYTON);
 noTone(BUZZER);
 delay(1000);
 tone(BUZZER, 3000, 1000);
 delay(DENIED_DELAYTON);
 noTone(BUZZER);
 // =========================
  // seconde 8X32 ROUGE éteinte ...

  afficherChiffreOuSymbole(SYMBOLE_OFF, 4);
   afficherChiffreOuSymbole(SYMBOLE_OFF, 5);
    afficherChiffreOuSymbole(SYMBOLE_OFF, 6);
     afficherChiffreOuSymbole(SYMBOLE_OFF, 7);
 // =========================
  // première 8X32 BLEUE  ...
  
   afficherChiffreOuSymbole(SYMBOLE_FLASH, 3);
  delay(delaiEntreChaqueChangementAffichage3);
  delay(DENIED_DELAY2);
  
  afficherChiffreOuSymbole(SYMBOLE_CROIX, 3);
  tone(BUZZER, 3000, 1000);
  delay(DENIED_DELAYTON);
  noTone(BUZZER);
  delay(delaiEntreChaqueChangementAffichage);
  
  afficherChiffreOuSymbole(CHIFFRE_9, 3);
  delay(delaiEntreChaqueChangementAffichage);

  afficherChiffreOuSymbole(CHIFFRE_8, 3);
  delay(delaiEntreChaqueChangementAffichage);

  afficherChiffreOuSymbole(CHIFFRE_7, 3);
  delay(delaiEntreChaqueChangementAffichage);

  afficherChiffreOuSymbole(CHIFFRE_6, 3);
  afficherChiffreOuSymbole(SYMBOLE_TIERS, 2);
  afficherChiffreOuSymbole(SYMBOLE_TIERS, 1);
  afficherChiffreOuSymbole(SYMBOLE_TIERS, 0);
  delay(delaiEntreChaqueChangementAffichage);

  afficherChiffreOuSymbole(CHIFFRE_5, 3);
  delay(delaiEntreChaqueChangementAffichage);

  afficherChiffreOuSymbole(CHIFFRE_4, 3);
  delay(delaiEntreChaqueChangementAffichage);

  afficherChiffreOuSymbole(CHIFFRE_3, 3);
  afficherChiffreOuSymbole(SYMBOLE_2TIERS, 2);
  afficherChiffreOuSymbole(SYMBOLE_2TIERS, 1);
  afficherChiffreOuSymbole(SYMBOLE_2TIERS, 0);
  delay(delaiEntreChaqueChangementAffichage);

  afficherChiffreOuSymbole(CHIFFRE_2, 3);
  delay(delaiEntreChaqueChangementAffichage);

  afficherChiffreOuSymbole(CHIFFRE_1, 3);
  delay(delaiEntreChaqueChangementAffichage);

  afficherChiffreOuSymbole(SYMBOLE_FLASH, 3);
  delay(delaiEntreChaqueChangementAffichage3);
  
 // =========================
  // seconde 8X32  ROUGE allumée ...

  afficherChiffreOuSymbole(SYMBOLE_PLEIN, 4);
   afficherChiffreOuSymbole(SYMBOLE_PLEIN, 5);
    afficherChiffreOuSymbole(SYMBOLE_PLEIN, 6);
     afficherChiffreOuSymbole(SYMBOLE_PLEIN, 7);
 // =========================
 // première 8X32 BLEUE éteinte ...
 
  afficherChiffreOuSymbole(SYMBOLE_OFF, 0);
   afficherChiffreOuSymbole(SYMBOLE_OFF, 1);
    afficherChiffreOuSymbole(SYMBOLE_OFF, 2);
     afficherChiffreOuSymbole(SYMBOLE_OFF, 3);
 digitalWrite(RELAIS, HIGH);
 tone(BUZZER, 3000, 1000);
  delay(DENIED_DELAY1);
  noTone(BUZZER);
  delay(delaiEntreChaqueChangementAffichage2);
  digitalWrite(RELAIS, LOW);
   tone(BUZZER, 3000, 1000);
 delay(DENIED_DELAYTON);
 noTone(BUZZER);
 //========================
  // première 8X32 BLEUE activité
  // seconde 8X32 ROUGE eteinte
  
  afficherChiffreOuSymbole(SYMBOLE_CROIX, 0);
   afficherChiffreOuSymbole(SYMBOLE_CROIX, 1);
    afficherChiffreOuSymbole(SYMBOLE_CROIX, 2);
     afficherChiffreOuSymbole(SYMBOLE_CROIX, 3);
   afficherChiffreOuSymbole(SYMBOLE_OFF, 4);
   afficherChiffreOuSymbole(SYMBOLE_OFF, 5);
   afficherChiffreOuSymbole(SYMBOLE_OFF, 6);
   afficherChiffreOuSymbole(SYMBOLE_OFF, 7);
     delay(delaiEntreChaqueChangementAffichage2);
   
   // première 8X32 BLEUE activité 
      
  afficherChiffreOuSymbole(SYMBOLE_Z, 0);
   afficherChiffreOuSymbole(SYMBOLE_A, 1);
    afficherChiffreOuSymbole(SYMBOLE_R, 2);
     afficherChiffreOuSymbole(SYMBOLE_PLEIN, 3);
    delay(delaiEntreChaqueChangementAffichage);


// =================
// Boucle secondaire qui effacera affichage de la matrice 8X32 BLEUE
// =================

  // *********************
  // EFFACEUR matrice 2
  // *********************

  for(int ligne = 0; ligne < 8; ligne++) {                              // Parcours des 8 lignes de la matrice LED
    for(int colonne = 0; colonne < 8; colonne++) {                          // Parcours des 8 colonnes de la matrice LED
      matriceLed.setLed(adresseDeLaMatrice2, ligne, colonne, true);              // extinction de la LED située à la position ligne/colonne
      delay(delaiAllumageLed);                                                  // Maintien de cette LED éteinte
      matriceLed.setLed(adresseDeLaMatrice2, ligne, colonne, false);             // Passage à la led suivante
    }
  }

   // *********************
  // EFFACEUR matrice 1
  // *********************

  for(int ligne = 0; ligne < 8; ligne++) {                              // Parcours des 8 lignes de la matrice LED
    for(int colonne = 0; colonne < 8; colonne++) {                          // Parcours des 8 colonnes de la matrice LED
      matriceLed.setLed(adresseDeLaMatrice1, ligne, colonne, true);              // extinction de la LED située à la position ligne/colonne
      delay(delaiAllumageLed);                                                  // Maintien de cette LED éteinte
      matriceLed.setLed(adresseDeLaMatrice1, ligne, colonne, false);             // Passage à la led suivante
    }
  }
   // *********************
  // EFFACEUR matrice 0
  // *********************

  for(int ligne = 0; ligne < 8; ligne++) {                              // Parcours des 8 lignes de la matrice LED
    for(int colonne = 0; colonne < 8; colonne++) {                          // Parcours des 8 colonnes de la matrice LED
      matriceLed.setLed(adresseDeLaMatrice3, ligne, colonne, true);              // extinction de la LED située à la position ligne/colonne
      delay(delaiAllumageLed);                                                  // Maintien de cette LED éteinte
      matriceLed.setLed(adresseDeLaMatrice3, ligne, colonne, false);             // Passage à la led suivante
    }
  }

 // *********************
  // EFFACEUR matrice 3 - compteur
  // *********************

  for(int ligne = 0; ligne < 8; ligne++) {                              // Parcours des 8 lignes de la matrice LED
    for(int colonne = 0; colonne < 8; colonne++) {                          // Parcours des 8 colonnes de la matrice LED
      matriceLed.setLed(adresseDeLaMatrice, ligne, colonne, true);              // extinction de la LED située à la position ligne/colonne
      delay(delaiAllumageLed);                                                  // Maintien de cette LED éteinte
      matriceLed.setLed(adresseDeLaMatrice, ligne, colonne, false);             // Passage à la led suivante
    }
  }
  // *********************
  // ARRET de la BOUCLE et retour début de programme avec mise en PAUSE
  // *********************
  digitalWrite(resetPin, LOW);
}

le fichier json indiqué dans l'idée de modification avec le PAROLA ... je le mets dans le dossier du sketch avec le ino et le chiffres_et_symboles.h ?...

[neteraser]

compte à rebours tir sportif avec un Arduino nano

[neteraser]

Hello à tous ...
voici le fonctionnement actuel ... la demande des tireurs est que pendant le "chrono" , il faudrait que la troisième "barre" VERTE soit allumée et s'éteigne des que la ROUGE s'allume... ça je saurai faire ... le souci est comment ajouter la dite barre VERTE ... LedControl ne sait gérer que deux barres de 4 modules ... soit 8X32 X 3 = 8X96 ...

[fdufnews]

@neteraser

le souci est comment ajouter la dite barre VERTE

As-tu vu ceci

more the 8 daisy chained

[terwal]

@neteraser

le souci est comment ajouter la dite barre VERTE ... LedControl ne sait gérer que deux barres de 4 modules ... soit 8X32 X 3 = 8X96 ...

Pourquoi n'as tu pas simplement un objet de type LedControl par barres ?
Je ne connais pas cette librairie et si elle utilise des interruptions qui pourrait empêcher utiliser plusieurs instance de la classe LedControl

[neteraser]

Bonjour,

j'ai tenté comme expliqué :
" Pour faire fonctionner plus de 8 matrices, accédez au dossier de votre bibliothèque Arduino, dans mon cas, il se trouve à :

C:\Users{Nom d'utilisateur}\Documents\Arduino\libraries\LedControl\src

Ouvrez ensuite le fichier LedControl.cpp avec un éditeur comme Notepad++ et supprimez les lignes 50 et 51.
De cette façon, j'ai pu enchaîner 15 matrices, même si je ne suis pas sûr de la quantité maximale de matrices."
la compilation se fait sans souci ... mais ça ne fonctionne pas ... les matrices ne s'allument plus du tout mais les cycles se font bien ... faut il "activer" les matrices différemment du coup ?...

[neteraser]

ou alors ... souci de "capacité" à gérer le bidule pour le Nano ?... j'ai branché les alims des "barres" en direct ... donc pas de problème d' alimentation trop gourmande pour le Nano ... un manque de Ram ?...

[J-M-L]

L'alimentation électrique doit forcément venir d'ailleurs que la carte. C'est un montage comme cela (avec vos 3 bandeaux connectés sur l'adaptateur 5V et pas sur la pin 5V de l'arduino, il faut joindre les GND).

Pour l'usage de 3 matrices l'une sur l'autre, voici un exemple de code qui ne nécessite aucune bibliothèque particulière.

8 x 8 max7219 affichage matrice - Wokwi ESP32, STM32, Arduino Simulator

il y a un framebuffer qui représente la grille des 32x24 pixels.

// Un framebuffer pour stocker l'état de toute la matrice de LED
// Chaque octet représente une colonne de 8 pixels (dans un module)
uint8_t frameBuffer[nbModulesX][nbModulesY * 8];  // Taille 32x24

et une fonction qui vous sert à allumer ou éteindre un pixel à la position (x,y) dans la matrice.
le (0,0) est en bas à gauche

void definirPixel(int x, int y, bool alllume) 

une fois que vous avez mis à jour le framebuffer comme vous voulez vous appelez afficher() pour transférer les pixels aux modules.

dans le code, à la fin du setup il y a un exemple d'affichage qui parcourt chaque pixel et l'allume puis appelle l'affichage. (ce n'est pas du tout optimisé au niveau du transfert SPI - on pourrait faire mieux mais j'ai fait ça rapidement)

le code

/*

  ============================================
  code is placed under the MIT license
  Copyright (c) 2023 J-M-L
  For the Arduino Forum : https://forum.arduino.cc/u/j-m-l

  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files (the "Software"), to deal
  in the Software without restriction, including without limitation the rights
  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  copies of the Software, and to permit persons to whom the Software is
  furnished to do so, subject to the following conditions:

  The above copyright notice and this permission notice shall be included in
  all copies or substantial portions of the Software.

  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  THE SOFTWARE.
  ===============================================
*/

#include <SPI.h>

// Définition des constantes pour les broches et le nombre de segments
constexpr byte clkPin = 13;
constexpr byte dataPin = 11;
constexpr byte csPin = 3;
constexpr byte nbModulesX = 4;  // 32 pixels de large (4 segments de 8 pixels)
constexpr byte nbModulesY = 3;  // 24 pixels de haut (3 segments de 8 pixels)

// Un framebuffer pour stocker l'état de toute la matrice de LED
// Chaque octet représente une colonne de 8 pixels (dans un module)
uint8_t frameBuffer[nbModulesX][nbModulesY * 8];  // Taille 32x24

// Fonction pour envoyer des données à un MAX7219 spécifique
void envoiSPI(byte segment, byte adresse, byte donnees) {
  digitalWrite(csPin, LOW);
  for (byte i = 0; i < nbModulesX * nbModulesY; i++) {
    if (i == segment) {
      SPI.transfer(adresse);  // Envoyer l'adresse et les données pour le bon segment
      SPI.transfer(donnees);
    } else {
      SPI.transfer(0);  // Ne rien envoyer aux autres segments
      SPI.transfer(0);
    }
  }
  digitalWrite(csPin, HIGH);
}

// Fonction pour allumer ou éteindre un pixel aux coordonnées (x, y)
void definirPixel(int x, int y, bool alllume) {
  if (x < 0 || x >= nbModulesX * 8 || y < 0 || y >= nbModulesY * 8) return;  // Vérifie les limites

  // Calcul du segment (bloc 8x8) et de la position dans le segment
  int moduleX = x / 8;            // module horizontal (bloc de 8x8 pixels)
  int colonneDansModule = x % 8;  // Colonne dans le module
  int ligneSegment = y;           // Ligne dans la grille

  // Allume ou éteint le bit correspondant dans le framebuffer
  if (alllume) {
    frameBuffer[moduleX][ligneSegment] |= (1 << (7 - colonneDansModule)); // on met le bit à 1
  } else {
    frameBuffer[moduleX][ligneSegment] &= ~(1 << (7 - colonneDansModule)); // on met le bit à 0
  }
}

// Fonction pour envoyer le framebuffer aux MAX7219
void afficher() {
  for (byte ligne = 0; ligne < 8; ligne++) {  // Pour chaque ligne dans un module
    for (byte moduleX = 0; moduleX < nbModulesX; moduleX++) {  // Parcourt chaque segment horizontal
      for (byte segmentY = 0; segmentY < nbModulesY; segmentY++) {  // Parcourt chaque segment vertical
        byte colonne = frameBuffer[moduleX][ligne + (segmentY * 8)];
        envoiSPI(moduleX + segmentY * nbModulesX, 8 - ligne, colonne); 
      }
    }
  }
}

void setup() {
  Serial.begin(115200);
  pinMode(clkPin, OUTPUT);
  pinMode(dataPin, OUTPUT);
  pinMode(csPin, OUTPUT);
  SPI.beginTransaction(SPISettings(16000000, MSBFIRST, SPI_MODE0));

  // Configuration initiale pour chaque MAX7219
  for (byte i = 0; i < nbModulesX * nbModulesY; i++) {
    envoiSPI(i, 0x0f, 0x00);  // registre de test - mode test désactivé
    envoiSPI(i, 0x0b, 0x07);  // registre de limite de scan - affiche les chiffres 0 à 7
    envoiSPI(i, 0x0c, 0x01);  // registre de mise en marche - fonctionnement normal
    envoiSPI(i, 0x0a, 0x0f);  // registre d'intensité - luminosité maximale
    envoiSPI(i, 0x09, 0x00);  // registre de mode de décodeur - pas de décodeur
  }

  // exemple d'affichage
  // on parcourt chaque pixel de la matrice
  for (int y = 0; y < nbModulesY * 8; y++) {
    for (int x = 0; x < nbModulesX * 8; x++) {
      definirPixel(x, y, true);  // Allume le pixel
      afficher();  // Met à jour l'affichage
      // definirPixel(x, y, false); // Éteint le pixel
    }
  }
}

void loop() {}

[neteraser]

bonsoir,

j'ai fait le montage avec trois "barres" ... ça marche ! ... les trois sont bien gérées en affichage ... mais de temps en temps avec un peu de démarrage sur n'importe laquelle ... comme si le code prenait au vol une instruction ... mais ça marche ...
je vais regarder comment je pourrai incorporer dans mon sketch ...
merci de vos idées et aide ... ça me fait avancer et j'apprends ... c'est tip top ! ...