Message défilant et MAX7219

Gerard68 · September 8, 2016, 7:30pm

Bonjour,

Ca fait bien 2 semaines que je fouille la toile avec Google pour trouver quelque chose qui pourrait faire défiler du texte sur une matrice à LED mais ça na marche jamais.
Soit ça ne compile pas, soit ça défile dans le mauvais sens, soit ...
De plus, vu la faible étendue de mes connaissance en arduino, je suis bien incapable de comprendre certains programme. Conclusion, c'est très frustrant.

Donc, si une âme charitable avait un soft sous la main (ou sous le coude), ce serait cool de m'en dire un peu plus. Mais attention, comme j'aime comprendre (pas envie de pomper sans savoir ce qui se passe), je poserai certainement plein de questions.

Merci de m'avoir lu et merci d'avance pour l'aide.

J-M-L · September 8, 2016, 9:13pm

Postez le code qui défile à l'envers et que vous comprenez... On vous aidera le faire défiler à l'endroit...

infobarquee · September 9, 2016, 6:40am

bonjour,
merci de donner les infos demandées ICI
combien de max7219
code comme demandé par J-M-L

Gerard68 · September 10, 2016, 9:05am

Bonjour, Avec code c'est mieux.
Comme le code est trop long, j'ai supprimé toutes les définitions des différents caractères. Je n'en ai laissé que 2 (@ et A).
Le texte défile sur les 2 afficheurs en même temps au lieu de commencer par le 1er et continuer sur le 2e.

Merci d'avance.

// based on an orginal sketch by Arduino forum member "danigom"
// http://forum.arduino.cc/index.php?action=profile;u=188950

///////////////////////////////
// EN PREMIER LES INCLUDES ! //
///////////////////////////////

#include <avr/pgmspace.h>
#include "LedControl.h"

///////////////////////////
// ENSUITE LES VARIABLES //
//////////////////////////

const int numDevices = 2;      // number of MAX7219s used
const long scrollDelay = 150;  // adjust scrolling speed

unsigned long bufferLong [14] = {0}; 

LedControl lc=LedControl(12,11,10,numDevices);

const unsigned char scrollText[] PROGMEM ={
/*    "  THE QUICK BROWN FOX JUMPED OVER THE LAZY DOG 1234567890 the quick brown fox jumped over the lazy dog   \0"};
*/
      " CA FONCTIONNE UN PEU MIEUX QU'AVANT  \0"}; 

////////////////////////////////////////
// PUIS LA DECLARATION DES PROTOTYPES //
////////////////////////////////////////

void setup();
void loop();
void scrollFont();
void scrollMessage(const unsigned char * messageString);
void loadBufferLong(int ascii);
void rotateBufferLong();
void printBufferLong();

/////////////////////
// DEBUT PROGRAMME //
/////////////////////

void setup(){
    for (int x=0; x<numDevices; x++){
        lc.shutdown(x,false);       //The MAX72XX is in power-saving mode on startup
        lc.setIntensity(x,8);       // Set the brightness to default value
        lc.clearDisplay(x);         // and clear the display
    }
}

void loop(){ 
    scrollMessage(scrollText);
    scrollFont();
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////

const unsigned char font5x7 [] PROGMEM = {      //Numeric Font Matrix (Arranged as 7x font data + 1x kerning data)

    B01110000,  //@
    B10001000,
    B00001000,
    B01101000,
    B10101000,
    B10101000,
    B01110000,
    6,

    B01110000,  //A
    B10001000,
    B10001000,
    B10001000,
    B11111000,
    B10001000,
    B10001000,
    6,

};

void scrollFont() {
    for (int counter=0x20;counter<0x80;counter++){
        loadBufferLong(counter);
        delay(500);
    }
}

// Scroll Message
void scrollMessage(const unsigned char * messageString) {
    int counter = 0;
    int myChar=0;
    do {
        // read back a char 
        myChar =  pgm_read_byte_near(messageString + counter); 
        if (myChar != 0){
            loadBufferLong(myChar);
        }
        counter++;
    } 
    while (myChar != 0);
}
// Load character into scroll buffer
void loadBufferLong(int ascii){
    if (ascii >= 0x20 && ascii <=0x7f){
        for (int a=0;a<7;a++){                      // Loop 7 times for a 5x7 font
            unsigned long c = pgm_read_byte_near(font5x7 + ((ascii - 0x20) * 8) + a);     // Index into character table to get row data
            unsigned long x = bufferLong [a*2];     // Load current scroll buffer
            x = x | c;                              // OR the new character onto end of current
            bufferLong [a*2] = x;                   // Store in buffer
        }
        byte count = pgm_read_byte_near(font5x7 +((ascii - 0x20) * 8) + 7);     // Index into character table for kerning data
        for (byte x=0; x<count;x++){
            rotateBufferLong();
            printBufferLong();
            delay(scrollDelay);
        }
    }
}
// Rotate the buffer
void rotateBufferLong(){
    for (int a=0;a<7;a++){                      // Loop 7 times for a 5x7 font
        unsigned long x = bufferLong [a*2];     // Get low buffer entry
        byte b = bitRead(x,31);                 // Copy high order bit that gets lost in rotation
        x = x<<1;                               // Rotate left one bit
        bufferLong [a*2] = x;                   // Store new low buffer
        x = bufferLong [a*2+1];                 // Get high buffer entry
        x = x<<1;                               // Rotate left one bit
        bitWrite(x,0,b);                        // Store saved bit
        bufferLong [a*2+1] = x;                 // Store new high buffer
    }
}  
// Display Buffer on LED matrix
void printBufferLong(){
  for (int a=0;a<7;a++){                    // Loop 7 times for a 5x7 font
    unsigned long x = bufferLong [a*2+1];   // Get high buffer entry
    byte y = x;                             // Mask off first character
    lc.setRow(3,a,y);                       // Send row to relevent MAX7219 chip
    x = bufferLong [a*2];                   // Get low buffer entry
    y = (x>>24);                            // Mask off second character
    lc.setRow(2,a,y);                       // Send row to relevent MAX7219 chip
    y = (x>>16);                            // Mask off third character
    lc.setRow(1,a,y);                       // Send row to relevent MAX7219 chip
    y = (x>>8);                             // Mask off forth character
    lc.setRow(0,a,y);                       // Send row to relevent MAX7219 chip
  }
}

J-M-L · September 10, 2016, 9:55am

dans votre fonction printBufferLong() on dirait que vous avez en tête 4 afficheurs hors au début de votre code vous faites un numDevices = 2

void printBufferLong() {
  for (int a = 0; a < 7; a++) {             // Loop 7 times for a 5x7 font
    unsigned long x = bufferLong [a * 2 + 1]; // Get high buffer entry
    byte y = x;                             // Mask off first character
    lc.setRow(3, a, y);                     // Send row to relevent MAX7219 chip
    x = bufferLong [a * 2];                 // Get low buffer entry
    y = (x >> 24);                          // Mask off second character
    lc.setRow(2, a, y);                     // Send row to relevent MAX7219 chip
    y = (x >> 16);                          // Mask off third character
    lc.setRow(1, a, y);                     // Send row to relevent MAX7219 chip
    y = (x >> 8);                           // Mask off forth character
    lc.setRow(0, a, y);                     // Send row to relevent MAX7219 chip
  }
}

    lc.setRow([color=red]3[/color], a, y);                     // Send row to relevent MAX7219 chip
    lc.setRow([color=red]2[/color], a, y);                     // Send row to relevent MAX7219 chip

ces parties seront ignorées par la librairie parce que l'adresse du MAX7219 n'existe pas mais les maths que vous faites entre temps sur y vont jouer

sylvainmahe · September 10, 2016, 10:52am

Si tu veux comprendre:

Essayes d'allumer déjà 1 pixel (coordonnées x y) d'1 seule matrice à led.
Ensuite dessines une lettre.
Ensuite fait un décalage de bits ou de coordonnées pour faire translater le texte.
Ensuite gère le passage d'une matrice à l'autre.
Ensuite gère le débordement (le bord des 2 matrices) si besoin.

Une fois que tu auras fait cette démarche, tu n'en sauras toujours rien sur le fonctionnement du MAX7219 et encore moins du microcontrôleur. Mais ça vaut la peine de commencer par la ! (si comme tu le dis tu veux comprendre).

Gerard68 · September 10, 2016, 12:14pm

J-M-L, ce soir je teste, merci pour ta remarque.
Sylvain :
je sais allumer un pixel, dessiner une lettre, c'est après que ça se corse.

Je connais plutôt bien le MAX7219, j'ai fait des essais avec un PIC mais ayant trouvé plusieurs exemples avec arduino (que je connais très peu), j'en ai acheté un mais ce que j'ai essayé ne fonctionne pas.

manumanu · September 10, 2016, 4:56pm

Salut.
En soutient dans les Tutos du forum tu trouvera une traduction en français du Datasheet pour le MAX 7219.

sylvainmahe · September 10, 2016, 6:19pm

Gerard68, si tu connais bien le max7219, dans ce cas tu devrais être en mesure de faire du code sans arduino pour gérer ton problème assez facilement !

Si tu traces une lettre dans cette logique la:

matrice.dessiner (0b00011000, 1);
matrice.dessiner (0b00111100, 2);
matrice.dessiner (0b01100110, 3);
matrice.dessiner (0b11000011, 4);
matrice.dessiner (0b11000011, 5);
matrice.dessiner (0b11111111, 6);
matrice.dessiner (0b11000011, 7);
matrice.dessiner (0b11000011, 8);

Et bien ensuite il suffit de faire un décalage de bits pour faire translater la lettre:

matrice.dessiner (0b00011000 << x, 1);

Dans une boucle for.

Gerard68 · September 12, 2016, 8:21pm

Bonsoir tout le monde,
Depuis le 10, je n'ai toujours pas testé la proposition de J-M-L, honte à moi. J'espère y arriver demain parce que mercredi je pars en vacances.

Sylvain, je me suis pas mal trituré les neurones sans résultat. Peut-être que je prends le problème par un mauvais coté.
Connaitre le MAX est une chose, le faire avec arduino dont je ne maîtrise pas le langage en est une autre. Mais je ne désespère pas.

sylvainmahe · September 12, 2016, 9:56pm

Pas de soucis, mais tu dois bien avoir une fonction (dans une bibliothèque ou une autre) qui te permette de dessiner une ligne sur ta matrice de cette façon:

matrice.dessiner (0b00011000, 1);

Et à partir de la, une fois que tu sais faire ça, tu peux décaler les bits avec << ou >>

infobarquee · September 13, 2016, 6:00am

voila un code que j'avais fait avec un menu via un bouton

#include <MaxMatrix.h>
#include <avr/pgmspace.h>
PROGMEM const unsigned char CH[] = {
3, 8, B00000000, B00000000, B00000000, B00000000, B00000000, // space
1, 8, B01011111, B00000000, B00000000, B00000000, B00000000, // !
3, 8, B00000011, B00000000, B00000011, B00000000, B00000000, // "
5, 8, B00010100, B00111110, B00010100, B00111110, B00010100, // #
4, 8, B00100100, B01101010, B00101011, B00010010, B00000000, // $
5, 8, B01100011, B00010011, B00001000, B01100100, B01100011, // %
5, 8, B00110110, B01001001, B01010110, B00100000, B01010000, // &
1, 8, B00000011, B00000000, B00000000, B00000000, B00000000, // '
3, 8, B00011100, B00100010, B01000001, B00000000, B00000000, // (
3, 8, B01000001, B00100010, B00011100, B00000000, B00000000, // )
5, 8, B00101000, B00011000, B00001110, B00011000, B00101000, // *
5, 8, B00001000, B00001000, B00111110, B00001000, B00001000, // +
2, 8, B10110000, B01110000, B00000000, B00000000, B00000000, // ,
4, 8, B00001000, B00001000, B00001000, B00001000, B00000000, // -
2, 8, B01100000, B01100000, B00000000, B00000000, B00000000, // .
4, 8, B01100000, B00011000, B00000110, B00000001, B00000000, // /
4, 8, B00111110, B01000001, B01000001, B00111110, B00000000, // 0
3, 8, B01000010, B01111111, B01000000, B00000000, B00000000, // 1
4, 8, B01100010, B01010001, B01001001, B01000110, B00000000, // 2
4, 8, B00100010, B01000001, B01001001, B00110110, B00000000, // 3
4, 8, B00011000, B00010100, B00010010, B01111111, B00000000, // 4
4, 8, B00100111, B01000101, B01000101, B00111001, B00000000, // 5
4, 8, B00111110, B01001001, B01001001, B00110000, B00000000, // 6
4, 8, B01100001, B00010001, B00001001, B00000111, B00000000, // 7
4, 8, B00110110, B01001001, B01001001, B00110110, B00000000, // 8
4, 8, B00000110, B01001001, B01001001, B00111110, B00000000, // 9
2, 8, B01010000, B00000000, B00000000, B00000000, B00000000, // :
2, 8, B10000000, B01010000, B00000000, B00000000, B00000000, // ;
3, 8, B00010000, B00101000, B01000100, B00000000, B00000000, // <
3, 8, B00010100, B00010100, B00010100, B00000000, B00000000, // =
3, 8, B01000100, B00101000, B00010000, B00000000, B00000000, // >
4, 8, B00000010, B01011001, B00001001, B00000110, B00000000, // ?
5, 8, B00111110, B01001001, B01010101, B01011101, B00001110, // @
4, 8, B01111110, B00010001, B00010001, B01111110, B00000000, // A
4, 8, B01111111, B01001001, B01001001, B00110110, B00000000, // B
4, 8, B00111110, B01000001, B01000001, B00100010, B00000000, // C
4, 8, B01111111, B01000001, B01000001, B00111110, B00000000, // D
4, 8, B01111111, B01001001, B01001001, B01000001, B00000000, // E
4, 8, B01111111, B00001001, B00001001, B00000001, B00000000, // F
4, 8, B00111110, B01000001, B01001001, B01111010, B00000000, // G
4, 8, B01111111, B00001000, B00001000, B01111111, B00000000, // H
3, 8, B01000001, B01111111, B01000001, B00000000, B00000000, // I
4, 8, B00110000, B01000000, B01000001, B00111111, B00000000, // J
4, 8, B01111111, B00001000, B00010100, B01100011, B00000000, // K
4, 8, B01111111, B01000000, B01000000, B01000000, B00000000, // L
5, 8, B01111111, B00000010, B00001100, B00000010, B01111111, // M
5, 8, B01111111, B00000100, B00001000, B00010000, B01111111, // N
4, 8, B00111110, B01000001, B01000001, B00111110, B00000000, // O
4, 8, B01111111, B00001001, B00001001, B00000110, B00000000, // P
4, 8, B00111110, B01000001, B01000001, B10111110, B00000000, // Q
4, 8, B01111111, B00001001, B00001001, B01110110, B00000000, // R
4, 8, B01000110, B01001001, B01001001, B00110010, B00000000, // S
5, 8, B00000001, B00000001, B01111111, B00000001, B00000001, // T
4, 8, B00111111, B01000000, B01000000, B00111111, B00000000, // U
5, 8, B00001111, B00110000, B01000000, B00110000, B00001111, // V
5, 8, B00111111, B01000000, B00111000, B01000000, B00111111, // W
5, 8, B01100011, B00010100, B00001000, B00010100, B01100011, // X
5, 8, B00000111, B00001000, B01110000, B00001000, B00000111, // Y
4, 8, B01100001, B01010001, B01001001, B01000111, B00000000, // Z
2, 8, B01111111, B01000001, B00000000, B00000000, B00000000, // [
4, 8, B00000001, B00000110, B00011000, B01100000, B00000000, // \ backslash
2, 8, B01000001, B01111111, B00000000, B00000000, B00000000, // ]
3, 8, B00000010, B00000001, B00000010, B00000000, B00000000, // hat
4, 8, B01000000, B01000000, B01000000, B01000000, B00000000, // _
2, 8, B00000001, B00000010, B00000000, B00000000, B00000000, // `
4, 8, B00100000, B01010100, B01010100, B01111000, B00000000, // a
4, 8, B01111111, B01000100, B01000100, B00111000, B00000000, // b
4, 8, B00111000, B01000100, B01000100, B00101000, B00000000, // c
4, 8, B00111000, B01000100, B01000100, B01111111, B00000000, // d
4, 8, B00111000, B01010100, B01010100, B00011000, B00000000, // e
3, 8, B00000100, B01111110, B00000101, B00000000, B00000000, // f
4, 8, B10011000, B10100100, B10100100, B01111000, B00000000, // g
4, 8, B01111111, B00000100, B00000100, B01111000, B00000000, // h
3, 8, B01000100, B01111101, B01000000, B00000000, B00000000, // i
4, 8, B01000000, B10000000, B10000100, B01111101, B00000000, // j
4, 8, B01111111, B00010000, B00101000, B01000100, B00000000, // k
3, 8, B01000001, B01111111, B01000000, B00000000, B00000000, // l
5, 8, B01111100, B00000100, B01111100, B00000100, B01111000, // m
4, 8, B01111100, B00000100, B00000100, B01111000, B00000000, // n
4, 8, B00111000, B01000100, B01000100, B00111000, B00000000, // o
4, 8, B11111100, B00100100, B00100100, B00011000, B00000000, // p
4, 8, B00011000, B00100100, B00100100, B11111100, B00000000, // q
4, 8, B01111100, B00001000, B00000100, B00000100, B00000000, // r
4, 8, B01001000, B01010100, B01010100, B00100100, B00000000, // s
3, 8, B00000100, B00111111, B01000100, B00000000, B00000000, // t
4, 8, B00111100, B01000000, B01000000, B01111100, B00000000, // u
5, 8, B00011100, B00100000, B01000000, B00100000, B00011100, // v
5, 8, B00111100, B01000000, B00111100, B01000000, B00111100, // w
5, 8, B01000100, B00101000, B00010000, B00101000, B01000100, // x
4, 8, B10011100, B10100000, B10100000, B01111100, B00000000, // y
3, 8, B01100100, B01010100, B01001100, B00000000, B00000000, // z
3, 8, B00001000, B00110110, B01000001, B00000000, B00000000, // {
1, 8, B01111111, B00000000, B00000000, B00000000, B00000000, // |
3, 8, B01000001, B00110110, B00001000, B00000000, B00000000, // }
//4, 8, B00001000, B00000100, B00001000, B00000100, B00000000, // ~
4, 8, B00000000, B00000000, B00000000, B00000000, B00000000,
//8, 8, B11111111, B11111111, B11111111, B11111111, B11111111,B11111111,

};
int data = 11;    // DIN pin of MAX7219 module
int load = 10;    // CS pin of MAX7219 module
int clock = 13;  // CLK pin of MAX7219 module
int maxInUse = 6;  //how many MAX7219 are connected
MaxMatrix m(data, load, clock, maxInUse); // define Library
byte buffer[50];
char string1[] = "~ ! RALENTIR~  ! DANGER ! ~    CHASSE  ~  EN COURS ~      TIR    ~  A BALLE !!";  // Scrolling Text
char string2[] = "~ ! DANGER !~    CHASSE  ~  EN COURS ~      TIR    ~  A BALLE !!";  // Scrolling Text
char string3[]="Ralentir~";
char string4[]="Danger~";

int vitesse = 0;
const int bouton = 3;
int debounce = 2000;
boolean state = false;
const int bouton_menu = 9;

void setup(){
m.init(); // module MAX7219
m.setIntensity(15); // LED Intensity 0-15
Serial.begin(9600);
pinMode(bouton, INPUT_PULLUP);
//digitalWrite(bouton, HIGH);
pinMode(bouton_menu, INPUT_PULLUP);

//attachInterrupt(1, change_message, RISING);
//attachInterrupt(1, change_message, CHANGE);

while(digitalRead(bouton_menu) != LOW){
 //Serial.println("attente validation"); 
 //Serial.println(state);
 if(digitalRead(bouton) == LOW){
   delay(debounce);
   state = !state;
   Serial.println(state);
  m.clear();

}
 if (state == 0) printStringWithShift(string3, vitesse + 100);
 if (state == 1) printStringWithShift(string4, vitesse + 100);

}

}

void change_message(){
    delay(debounce);
  state = !state; 
  
}

infobarquee · September 13, 2016, 6:00am

suite

void loop(){
 Serial.println(state);
/* if (digitalRead(bouton)== LOW)
 {
    delay(debounce);
    state = !state;
    Serial.println("bouton");
    Serial.println(state);
  }
 */ 
       if (state == false){
         Serial.println("ralentir");
          printStringWithShift(string1, vitesse);  // Send scrolling Text
      }  
      
      if (state == true) {
         Serial.println("danger");
          printStringWithShift(string2, vitesse);  // Send scrolling Text
      } 
byte c;
delay(100);
m.shiftLeft(false, true);
//printStringWithShift(string3, vitesse);  // Send scrolling Text
}


// Put extracted character on Display
void printCharWithShift(char c, int shift_speed){
if (c < 32) return;
c -= 32;
memcpy_P(buffer, CH + 7*c, 7);
m.writeSprite(maxInUse*8, 0, buffer);
m.setColumn(maxInUse*8 + buffer[0], 0);
for (int i=0; i<buffer[0]+1; i++) 
{
delay(shift_speed);
m.shiftLeft(false, false);
}
}
// Extract characters from Scrolling text
void printStringWithShift(char* s, int shift_speed){

while (*s != 0){

   // Serial.println(*s);
 if (*s == '~')delay(1000);
printCharWithShift(*s, shift_speed);
s++;
}

}

infobarquee · September 13, 2016, 6:01am

le texte défile de droite à gauche

Gerard68 · September 13, 2016, 2:52pm

J-M-L : pas de succès avec ton idée.
infobarquee : avec 3 matrices, les messages défilent sur les 3 matrices en même temps.

Merci quand même pour vos suggestions.

infobarquee · September 13, 2016, 3:34pm

Gerard68:
J-M-L : pas de succès avec ton idée.
infobarquee : avec 3 matrices, les messages défilent sur les 3 matrices en même temps.

Merci quand même pour vos suggestions.

as tu modifié le nb de modules?

int maxInUse = 3;  //pour 3 modules 6 pour 6 modules

dans mon code qui fonctionne parfaitement, j'en utilise 6
comment sont reliés tes modules?

photo de ton montage et des connexions entre modules

Gerard68 · September 13, 2016, 7:42pm

Oui j'ai modifié le nombre de modules. Essais avec 3 modules et maxInUse = 2 ou 3 ou 4 sans résultat.
Mes modules sont de ce genre : Mes modules

Les connections sont assurées par des cavaliers et je suis sûr des branchements.

Peut-être que ces modules fonctionnent autrement : Autres modules

infobarquee · September 13, 2016, 8:31pm

deuxième lien avec I2C, ca marche nettement mieux et on peu les cummuler.
je pense que le soucis vient de là
mets une photo de tes connections

Gerard68 · September 13, 2016, 8:57pm

Je n'ai aucun doute quant à ma connectique.
Ce n'est pas de l'I2C le 2e lien.

infobarquee · September 14, 2016, 7:08am

Gerard68:
Je n'ai aucun doute quant à ma connectique.
Ce n'est pas de l'I2C le 2e lien.

autant pour moi pour l"I2C, gourage de ma part
j'ai les même modules que ton deuxième lien, et cela fonctionne impec.

de toute facon, si tu as 3 modules et que tu mets en max 1-2, cela va fonctionner sur les 1-2 modules et pas le 3eme
donc plusieurs sources a exploiter
mauvais branchement, d'où la demande de photo
défaut sur un composant
version ide ?

EDIT :
tes modules sont bien connectés l'un après l'autre et non pas sur les même pins?

Topic		Replies	Views
Controle de matrices leds 8x8 MAX7219 Français	3	1268	May 6, 2021
Text Scrolling with Dot Matrix 8x8 and MAX7219 LEDs and Multiplexing	16	35312	March 16, 2025
LED matrix display - MD_Parola, MD_MAX72xx and MD_MAXPanel Showcase	1867	746166	February 27, 2026
Max7219 Scoreboard Programming	21	292	January 19, 2025
MAX7219 does not scroll (or do other things as expected) Displays	64	2695	September 2, 2021

Message défilant et MAX7219

Related topics