FR (and EN) : Matrice leds 8x5 sur structure 8x5 "externe"

pileroy · September 22, 2023, 7:40pm

Bjr, j'ai créé une jeu d'essai avec la matrice 8x8 MAX 7912 qui fonctionne très bien. Les chorégraphies sont conformes à mon programme (chorégraphie sur 8x5 leds). Afin d'externaliser les leds, j'ai créé une platine externe, en respectant la logique colonnes (négatif) / lignes (positif).
Sauf que le rendu n'a rien à voir avec les chorégraphies prédéfinies sur la mini matrice 8x8.
Avez vous déjà entendu ou rencontré ce type de curiosité?
Je ne sais pas ce qu'il faut changer sur ma platine externe!
merci des retours que vous pourrez me faire.

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
Après différents échanges et réflexions, nous avons trouvé l'explication à notre dysfonctionnement
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
CONSEIL pour fabriquer une matrice EXTERNE type 8x8 sur circuit MAX7912
1-préparer votre modèle avec circuit MAX7912 équipé de sa petite matrice leds 8x8
2-fabriquer votre platine externe ( voir photo dans les posts ci-joints)
3-ne pas installer les leds !!!
4-mettre une première led, et vérifier qu'elle s'allume et s’éteint selon votre modèle; si besoin l'inverser et vérifier la marche cohérente.
5-installer les autres leds sur la colonne précédente vu en 4-); vérifier la cohérence de son fonctionnement. Attention à respecter le sens non des pattes, mais des pièces métalliques dans la bulle de verre de la led initiale.
6-installer les leds sur la ligne de la première led installée. valider bon fonctionnement
7-installer ensembles des leds.
REMARQUE: selon les couleurs, les marques, ... il faudra peut être adapté le sens des leds. j'ai dû le faire !!!
Voir les différentes photos de la discussion
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
Voir ci-dessous les différents échanges
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

Hello, I have created a test set with the 8x8 MAX 7912 matrix which works very well. The choreography conforms to my program (choreography on 8x5 leds). In order to externalize the leds I've created an external turntable, following the logic of columns (negative) / rows (positive).
Except that the rendering has nothing to do with the predefined choreographies on the mini 8x8 matrix.
Have you ever heard or encountered this type of curiosity?
I don't know what to change on my external turntable!
thanks for any feedback you can give me.
Pierre

xfpd · September 22, 2023, 8:45pm

Vous n'avez pas abordé quelle matrice (0 ... 1 ... 2 ... et c), seulement la LED X,Y à l'intérieur d'une matrice.

pileroy · September 23, 2023, 5:08am

Hello, i use the picos of the little 8x8 matrix and connect them directly on my new external turntable. I just replace the little 8x8 ( with 8x5 choreographic leds) by others 8x5 external leds?!
Sorry for my incertain english.

xfpd · September 23, 2023, 5:14am

Montrez votre code et le schéma de vos appareils.

J-M-L · September 23, 2023, 9:00am

@xfpd @pileroy

dans le forum francophone on n'écrit qu'en français SVP (éditez vos posts pour les traduire)

pileroy · September 25, 2023, 2:03pm

Bonjour xfpd,
Voici le code, avec de nombreuses zones en commentaire en vue d'évolutions futures.
Comme précisé, cela fonctionne bien avec la mini matrice 8x8; et fonctionne mal, avec la matrice externe ( leds plus ou moins allumé, incohérence des allumages et extinction...) .
Mes questions sont :
? peut-on faire ce que j'ai fait?
? à priori, si ma platine externe est bien conçu avec les négatifs en colonnes et les positifs en lignes, est-ce que la platine MAX7912 permet de transposer mini platine 8x8 vers une platine externe?

//2016.12.9

//We always have to include the library
#include "LedControl.h"

// déclaration des variables
int k=1;
int u=10; //nbre de boucle pour vagues drapeau

/* Now we need a LedControl to work with.
 ***** These pin numbers will probably not work with your hardware *****
 pin 12 is connected to the DataIn 
 pin 11 is connected to LOAD(CS)
 pin 10 is connected to the CLK 
 We have only a single MAX72XX.
 */
LedControl lc=LedControl(12,10,11,1);

/* we always wait a bit between updates of the display */
unsigned long delaytime1=600;
unsigned long delaytime2=300;
unsigned long delaytime3=300;
unsigned long delaytime4=200;
unsigned long delaytime5=1000;

void setup() {
  /*
   le MAX72XX est en mode faible consommation avant démarrage,
   Il est nécessaire de l'activer
   */
  lc.shutdown(0,false);
  /* Set the brightness to a medium values */
  lc.setIntensity(0,1);
  /* and clear the display */
  lc.clearDisplay(0);
}

  /* paramétrage des lettres du mot THIES  pour les faire apparaitre sur la matrice leds/jets.  */
void writeTHIESOnMatrix() {
  /* definition des lettres pour la matrice leds/jets */
      byte T[5]={B00111110,B00001000,B00001000,B00001000,B00001000}; 
      byte H[5]={B00100010,B00100010,B00111110,B00100010,B00100010};
      byte I[5]={B00111110,B00001000,B00001000,B00001000,B00111110};
      byte E[5]={B00111110,B00100000,B00111110,B00100000,B00111110};
      byte S[5]={B00011110,B00100000,B00011100,B00000010,B00111100};
      byte N[5]={B00000000,B00000000,B00001000,B00000000,B00000000}; //byte leds/jets neutre

  /* Visualisation lettre/jet par lettre/jet avec un délai réglable "delaytime1" */
  lc.setRow(0,0,T[0]);   lc.setRow(0,1,T[1]);   lc.setRow(0,2,T[2]);   lc.setRow(0,3,T[3]);   lc.setRow(0,4,T[4]);
  delay(delaytime1);
  lc.setRow(0,0,H[0]);   lc.setRow(0,1,H[1]);   lc.setRow(0,2,H[2]);   lc.setRow(0,3,H[3]);   lc.setRow(0,4,H[4]);
  delay(delaytime1);
  lc.setRow(0,0,I[0]);   lc.setRow(0,1,I[1]);   lc.setRow(0,2,I[2]);   lc.setRow(0,3,I[3]);   lc.setRow(0,4,I[4]);
  delay(delaytime1);
  lc.setRow(0,0,E[0]);   lc.setRow(0,1,E[1]);   lc.setRow(0,2,E[2]);   lc.setRow(0,3,E[3]);   lc.setRow(0,4,E[4]);
  delay(delaytime1);
  lc.setRow(0,0,S[0]);   lc.setRow(0,1,S[1]);   lc.setRow(0,2,S[2]);   lc.setRow(0,3,S[3]);   lc.setRow(0,4,S[4]);
  delay(delaytime1);

/* mise à zero des jets/leds*/
      lc.setRow(0,0,N[0]); lc.setRow(0,1,N[1]); lc.setRow(0,2,N[2]); lc.setRow(0,3,N[3]); lc.setRow(0,4,N[4]);
        delay(delaytime5);
}


void global() { 

      /* definition des états neutre ou allumé pour la matrice leds/jets */
      byte N[5]={B00000000,B00000000,B00001000,B00000000,B00000000}; //byte leds/jets neutre
      byte A[5]={B11111111,B11111111,B11111111,B11111111,B11111111}; //byte leds/jets actif

    /*byte C1[5]={B10000000,B10000000,B10000000,B10000000,B10000000}; //byte leds/jets ? à définir
      byte C2[5]={B01000000,B01000000,B01000000,B01000000,B01000000}; //byte leds/jets ?  à définir
      byte C3[5]={B00100000,B00100000,B00100000,B00100000,B00100000}; //byte leds/jets ?  à définir
      byte C4[5]={B00010000,B00010000,B00010000,B00010000,B00010000}; //byte leds/jets ?  à définir
      byte C5[5]={B00001000,B00001000,B00001000,B00001000,B00001000}; //byte leds/jets ?  à définir
      byte C6[5]={B00000100,B00000100,B00000100,B00000100,B00000100}; //byte leds/jets ?  à définir
      byte C7[5]={B00000010,B00000010,B00000010,B00000010,B00000010}; //byte leds/jets ?  à définir
      byte C8[5]={B00000001,B00000001,B00000001,B00000001,B00000001}; //byte leds/jets ?  à définir
*/
      /* display leds/jets en totalité  on/off/on/off  etc*/
  for ( int k=0;k<6;k++ ) {
      lc.setRow(0,0,N[0]); lc.setRow(0,1,N[1]); lc.setRow(0,2,N[2]); lc.setRow(0,3,N[3]); lc.setRow(0,4,N[4]);
      delay(delaytime3); {
      lc.setRow(0,0,A[0]); lc.setRow(0,1,A[1]); lc.setRow(0,2,A[2]); lc.setRow(0,3,A[3]); lc.setRow(0,4,A[4]);
      delay(delaytime3);
                         }
                          }
             
        /* mise à zero des jets/leds*/
      lc.setRow(0,0,N[0]); lc.setRow(0,1,N[1]); lc.setRow(0,2,N[2]); lc.setRow(0,3,N[3]); lc.setRow(0,4,N[4]);
        delay(delaytime5);
}


void rows()  // programme elegoo
{
  for(int row=0;row<5;row++) {
    delay(delaytime2);
    lc.setRow(0,row,B10100000);
    delay(delaytime2);
    lc.setRow(0,row,(byte)0);
    for(int i=0;i<row;i++) {
      delay(delaytime2);
      lc.setRow(0,row,B10100000);
      delay(delaytime2);
      lc.setRow(0,row,(byte)0);
    }
  }
}


/*
  This function lights up a some Leds in a column.
 The pattern will be repeated on every column.
 The pattern will blink along with the column-number.
 column number 4 (index==3) will blink 4 times etc.
 */

void columns()  // programme elegoo
{
  for(int col=0;col<8;col++) {
    delay(delaytime2);
    lc.setColumn(0,col,B00100000);
    delay(delaytime2);
    lc.setColumn(0,col,(byte)0);
    for(int i=0;i<col;i++) {
      delay(delaytime2);
      lc.setColumn(0,col,B00100000);
      delay(delaytime2);
      lc.setColumn(0,col,(byte)0);
    }
  }
 }//www.elegoo.com


/* 
 This function will light up every Led on the matrix.
 The led will blink along with the row-number.
 row number 4 (index==3) will blink 4 times etc.
 */
void single()  // programme elegoo
{
  for(int row=0;row<5;row++) {
    for(int col=0;col<8;col++) {
      delay(delaytime2);
      lc.setLed(0,row,col,true);
      delay(delaytime2);
      for(int i=0;i<col;i++) {
        lc.setLed(0,row,col,false);
        delay(delaytime2);
        lc.setLed(0,row,col,true);
        delay(delaytime2);
      }
    }
  }
}


/* definition des états du drapeau pour la matrice leds/jets */
/* display leds/jets en totalité  drapeau*/


void drapeau() {


      byte B[5]={B10000000,B10000000,B10000000,B10000000,B10000000}; // pour display hampe

 /* definition des colonnes pour la matrice drapeau leds/jets ; VAGUE LARGE     */
      byte V1[5]={B10110011,B10110011,B10110011,B10110011,B10110011};
      byte V2[5]={B11011001,B11011001,B11011001,B11011001,B11011001};
      byte V3[5]={B11101100,B11101100,B11101100,B11101100,B11101100};
      byte V4[5]={B10110110,B10110110,B10110110,B10110110,B10110110};
      byte V5[5]={B10011011,B10011011,B10011011,B10011011,B10011011};
      byte V6[5]={B11001101,B11001101,B11001101,B11001101,B11001101};
      byte V7[5]={B11100110,B11100110,B11100110,B11100110,B11100110};

 /* definition des colonnes pour la matrice drapeau leds/jets ; VAGUE FINE 
      byte V1[5]={B10100010,B10100010,B10100010,B10100010,B10100010};
      byte V2[5]={B10010001,B10010001,B10010001,B10010001,B10010001};
      byte V3[5]={B11001000,B11001000,B11001000,B11001000,B11001000};
      byte V4[5]={B10100100,B10100100,B10100100,B10100100,B10100100};
      byte V5[5]={B10010010,B10010010,B10010010,B10010010,B10010010};
      byte V6[5]={B11001001,B11001001,B11001001,B11001001,B11001001};
      byte V7[5]={B10000000,B10000000,B10001000,B10000000,B10000000};            */

  byte N[5]={B00000000,B00000000,B00001000,B00000000,B00000000}; //byte leds/jets neutre

 /* display leds/jets en totalité  drapeau ondulent  etc*/ /* première colonne la hampe du drapeau*/

 { lc.setRow(0,0,B[0]);   lc.setRow(0,1,B[1]);   lc.setRow(0,2,B[2]);   lc.setRow(0,3,B[3]);   lc.setRow(0,4,B[4]);}
  delay(delaytime5);

  for ( int j=0;j<u;j++ ) {
 
    lc.setRow(0,0,V1[0]);   lc.setRow(0,1,V1[1]);   lc.setRow(0,2,V1[2]);   lc.setRow(0,3,V1[3]);   lc.setRow(0,4,V1[4]);
  delay(delaytime4);
  lc.setRow(0,0,V2[0]);   lc.setRow(0,1,V2[1]);   lc.setRow(0,2,V2[2]);   lc.setRow(0,3,V2[3]);   lc.setRow(0,4,V2[4]);
  delay(delaytime4);
  lc.setRow(0,0,V3[0]);   lc.setRow(0,1,V3[1]);   lc.setRow(0,2,V3[2]);   lc.setRow(0,3,V3[3]);   lc.setRow(0,4,V3[4]);
  delay(delaytime4);
  lc.setRow(0,0,V4[0]);   lc.setRow(0,1,V4[1]);   lc.setRow(0,2,V4[2]);   lc.setRow(0,3,V4[3]);   lc.setRow(0,4,V4[4]);
  delay(delaytime4);
  lc.setRow(0,0,V5[0]);   lc.setRow(0,1,V5[1]);   lc.setRow(0,2,V5[2]);   lc.setRow(0,3,V5[3]);   lc.setRow(0,4,V5[4]);
  delay(delaytime4);
  lc.setRow(0,0,V6[0]);   lc.setRow(0,1,V6[1]);   lc.setRow(0,2,V6[2]);   lc.setRow(0,3,V6[3]);   lc.setRow(0,4,V6[4]);
  delay(delaytime4);
  lc.setRow(0,0,V7[0]);   lc.setRow(0,1,V7[1]);   lc.setRow(0,2,V7[2]);   lc.setRow(0,3,V7[3]);   lc.setRow(0,4,V7[4]);
  delay(delaytime4);
              }
/* mise à zero des jets/leds*/
      lc.setRow(0,0,N[0]); lc.setRow(0,1,N[1]); lc.setRow(0,2,N[2]); lc.setRow(0,3,N[3]); lc.setRow(0,4,N[4]);
        delay(delaytime5);   
 
  // programme elegoo
  /*for(int col=0;col<8;col++) {
    for(int row=0;row<5;row++) {
      delay(delaytime2);
      lc.setLed(0,row,col,false);
      delay(delaytime2);
      /*for(int i=0;i<col;i++) {
        lc.setLed(0,row,col,true);
        delay(delaytime2);
        lc.setLed(0,row,col,false);
        delay(delaytime2);
      }
    }
  }*/
}


void loop() { 
  writeTHIESOnMatrix();
  global();
  //rows();     // programme elegoo
  //columns();  // programme elegoo
  //single();   // programme elegoo
  drapeau();
}

pileroy · September 25, 2023, 2:09pm

Désolé pour cette petite méconnaissance de ma part. Je découvre et Arduino, et Elegoo, et le forum, et tout et tout et tout!!! j'ai un cerveau à l'image de mes 68 ans.

xfpd · September 25, 2023, 3:30pm

Le MAX7219 facilite l'éclairage des LED, matrice de LED, segments de LED et segments de LED entiers sur les éléments LED fonctionnels de votre projet.

(MAX7219 datasheet)

fdufnews · September 25, 2023, 4:46pm

Un truc n'est pas clair, sur la carte avec le MAX7912 il y a déjà une matrice de diodes qui est câblée?

fdufnews · September 25, 2023, 7:48pm

Non, les messages disent simplement que le programme n'arrive pas à télécharger ton code car il ne trouve pas COM4

Soit tu n'as pas sélectionné le bon port, soit une autre application ou une autre instance de l'IDE à déjà ouvert ce port de communication.

fdufnews · September 25, 2023, 8:08pm

Quand on met au point un montage, il faut commencer simple.
Simple, c'est-à-dire allumer l'une après l'autre les LEDs dans l'ordre:
1ère LED de la 1ère ligne
2ème LED de la 1ère ligne
...
5ème LED de la 1ère ligne
1ère LED de la 2ère ligne
...

et ainsi de suite de façon à voir s'il n'y aurait pas des lignes ou des colonnes mélangées.

pileroy · September 25, 2023, 10:49pm

fdufnews, pour ce premier point, vous avez raison, mais parce que faisant différents tests, je n'avais pas rebranché le cable USB !!
Erreur de débutant!!

pileroy · September 25, 2023, 10:57pm

J'ai fait simple, puisque la mini matrice fonctionne bien. Par contre, comme le montre la photo, la platine externe, ne donne pas le résultat escompté. Par branchement et débranchement successif des câbles de liaison rouges et/ou bleus, les colonnes fonctionnent, les lignes fonctionnent, mais pas ensemble !? ou pas comme le permet la mini matrice 8x8.

fdufnews · September 26, 2023, 9:49am

Tu es certain d'avoir câblé tes LEDs externes comme l'étaient celles de la matrice d'origine?

pileroy · September 26, 2023, 10:51am

Bjr, je pense que oui, en respectant le principe lignes/colonnes; j'ai aussi fait un programme simplifié (ci-dessous) pour tester ligne par ligne, voire colonne par colonne en limitant les branchements. il y a probablement un pb d'adressage, mais je ne vois pas lequel !!! dans la photo nouvelle matrice, les leds restent allumées, alors que dans la mini matrice 8x8 cela fonctionne.

Quand je déplace les câbles sur les picos/bornes, je simule bien soit les lignes, soit les colonnes, et c'est cohérent avec les adressages n°picos/bornes et les colonnes/lignes.
Peut-il y avoir des retours électriques entre les leds, des pertes en lignes, ... j'ai constaté que la mini matrice 8x8 fonctionne moins bien entre 3,3V et 5V !

//2016.12.9

//We always have to include the library
#include "LedControl.h"


/* Now we need a LedControl to work with.
 ***** These pin numbers will probably not work with your hardware *****
 pin 12 is connected to the DataIn 
 pin 11 is connected to LOAD(CS)
 pin 10 is connected to the CLK 
 We have only a single MAX72XX.
 */
LedControl lc=LedControl(12,10,11,1);

/* we always wait a bit between updates of the display */
  unsigned long delaytime3=1000;

void setup()
  {
  /*
   le MAX72XX est en mode faible consommation avant démarrage, 
   Il est nécessaire de l'activer
   */ /*
    lc.shutdown(0,false);
    lc.setIntensity(0,1);  // Set the brightness to a medium values
    lc.clearDisplay(0);    //and clear the display
  */
  }


void global() 
    { 
      /* definition des états neutre ou allumé pour la matrice leds/jets */
      byte N [5]={B00000000,B00000000,B00001000,B00000000,B00000000};
      byte A [5]={B11111111,B11111111,B11111111,B11111111,B11111111};

      for (int n=0;n<5;n++) lc.setRow(0,n,N[n]);
        delay(delaytime3);

      for (int a=0;a<5;a++) lc.setRow(0,a,A[a]);
        delay(delaytime3); 
    }
             
void ligne() // test ligne 1, puis 2, etc et ensemble, en changeant valeurs n et a
    {
      /* definition des états neutre ou allumé pour la matrice leds/jets */
      byte N [5]={B00000000,B00000000,B00000000,B00000000,B00000000};
      byte A [5]={B11111111,B11111111,B11111111,B11111111,B11111111};


      for (int n=0;n<8;n++) lc.setRow(0,n,N[n]); // mise à blanc de toute la matrice 8x5

      for (int n=0;n<1;n++) lc.setRow(0,n,N[n]);
        delay(delaytime3);
      
      for (int a=0;a<1;a++) lc.setRow(0,a,A[a]);
        delay(delaytime3);                  
    }

void loop() { 
    //global();
    ligne();
}

fdufnews · September 26, 2023, 1:22pm

Tu peux faire une photo du dos de ta carte matrice externe

pileroy · September 26, 2023, 2:27pm

Voilà la photo, où j'ai indiqué les données; avec un ohmmètre, j'ai vérifié les continuités, les ruptures (micro perçage); pour le plus+ (ligne ou row) , j'ai doublé (en haut à droite) l'alimentation, faites en bas de carte, (limiter pb de perte en ligne?)
...

pileroy · September 26, 2023, 2:53pm

En mode 8x5,
Les colonnes 4,5,6,7,8 puissance leds correcte; col1 zéro, col2 et 3 minimum !!??
aucune action du programme, ou incohérente. avec programme simplifié #post16.
Par exemple, avec le programme du #post6, seule les leds colonnes 1,2,3 battent partiellement la chorégraphie, à puissance réduite, ... mais pas comme il faudrait. normalement les 8colonnesx5lignes dansent la chorégraphie.

fdufnews · September 26, 2023, 4:00pm

Avant de faire un programme, on peut facilement tester la matrice avec une alimentation 5V et une résistance de 1K.
Tu connectes le GND de l'alim sur une colonne et tu appliques le + à travers la résistance sur les rangées l'une après l'autre. Tu devrais voir une (et une seule) LED s'allumer sur chaque rangée.
Tu passes le GND sur la colonne suivante et tu continues pour vérifier toutes les LEDs.
Tu pourras ainsi voir si les LEDs sont bien raccordées (mauvais contact ou montée à l'envers), si les lignes et les colonnes ne sont pas coupées ou en court-circuit quelque part.

pileroy · September 26, 2023, 4:20pm

Merci fdufnews pour le temps que tu passes
Je viens de travailler une autre piste de réflexion.... qui rejoint ton propos
Les leds (même fournisseur!!) ne sont pas toutes pareilles.... les blanches et vertes identiques, les jaunes et rouges différentes !!!... cf.photo ; j'ai suivi la queue longue, et non la structure métallique des leds
je vais travailler cette piste avant de retester selon ton protocole

**** j'ai commencé à retourner les leds à l'envers... cela fonctionne déjà mieux ****

Topic		Replies	Views
UNO-Q - utiliser un tableau ASCII pour la fonction matrixWrite() Le bar	21	310	January 3, 2026
Multiplexage 16 Leds Français	22	179	December 30, 2025
MIDI Controller PART 3 Deutsch	651	2577	February 14, 2026
Serial.print qui bloque tout Français	42	267	October 17, 2025
Chainer trois matrices led avec un MAX 7219 Français	50	863	August 24, 2025

FR (and EN) : Matrice leds 8x5 sur structure 8x5 "externe"

Related topics