Problème place memoire

Merci J-M-L félicitation pour votre dévouement, j'ose profiter de vos compétenceS (Hi...) ... Je bute sur un problème de manque de mémoire dans un journal défilant sur matrices de LED 8x8
le croquis n'est pas de moi j'essaie de l'adapter à mon projet ) .... Le tableau de définition de la fonte des caractères, en constantes, semble prendre trop de mémoire. Je voudrais de l'aide pour le passer en PROGMEM. Par manque de mémoire je ne peux ni augmenter le nombre de matrices de LED ni afficher des messages un peu plus longs que 25 caractères.
ici le sketch pour info. Merci d'avance, toute aide sera la bienvenue.


// Easy bluetooth controlled scrolling text

//non - bluetooth version !!


// by Yoruk for Instructable

// 26 02 15 : first code
// 03 03 15 : buffer updating
// 04 03 15 : faster version, both buffers
// 05 03 15 : cleaning and help


/*
  WIRING
  pin 12 - DataIn of the first led matrix module
  pin 11 - CLK of the first led matrix module
  pin 10 - CS of the first led matrix module


  5V : 5v of the matrix module, 5v of the bluetooth module
  GND : the two GND signals of the matrix modules and the bluetooth module

  WARNING : Use a 3v3 arduino card (nano...) or a level converter !!!

  Wire the matrix modules in serie. See the Instructable steps.

*/

//Librairie for the LEDs matrix
#include "LedControl.h"

//How many matrixes we have ?
int MatrixNumber = 5;


// the delay between each screen display (ms)
int SpeedDelay = 8;


//total string lenght. The first message is 25 characters long (including spaces)
int LongueurChaine = 50;


char incomingByte; //incoming data from the link


// the two pixels arrays
char Buffer[200];   //contient tout les pixels de TOUTE LA PHRASE
char Buffer_inverse[200]; //contient tout les pixels de TOUTE LA PHRASE, mais symetrises pour affichage sur ecran inverses

// the message array
char Phrase[50];

//here we set up the led matrix
LedControl lc = LedControl(12, 11, 10, MatrixNumber);


// character lib
int fontDefinitions[480] = {
  0x00, 0x00, 0x00, 0x00, 0x00,/*space*/ // is 32 in ASCII
  0x00, 0xF6, 0xF6, 0x00, 0x00, /*!*/
  0x00, 0xE0, 0x00, 0xE0, 0x00, /*"*/
  0x28, 0xFE, 0x28, 0xFE, 0x28, /*#*/
  0x00, 0x64, 0xD6, 0x54, 0x08, /*$*/
  0xC2, 0xCC, 0x10, 0x26, 0xC6, /*%*/
  0x4C, 0xB2, 0x92, 0x6C, 0x0A, /*&*/
  0x00, 0x00, 0xE0, 0x00, 0x00, /*'*/
  0x00, 0x38, 0x44, 0x82, 0x00, /*(*/
  0x00, 0x82, 0x44, 0x38, 0x00, /*)*/
  0x88, 0x50, 0xF8, 0x50, 0x88, /***/
  0x08, 0x08, 0x3E, 0x08, 0x08, /*+*/
  0x00, 0x00, 0x05, 0x06, 0x00, /*,*/
  0x08, 0x08, 0x08, 0x08, 0x08, /*-*/
  0x00, 0x00, 0x06, 0x06, 0x00, /*.*/
  0x02, 0x0C, 0x10, 0x60, 0x80, /*/*/
  0x7C, 0x8A, 0x92, 0xA2, 0x7C, /*0*/
  0x00, 0x42, 0xFE, 0x02, 0x00, /*1*/
  0x42, 0x86, 0x8A, 0x92, 0x62, /*2*/
  0x44, 0x82, 0x92, 0x92, 0x6C, /*3*/
  0x10, 0x30, 0x50, 0xFE, 0x10, /*4*/
  0xE4, 0xA2, 0xA2, 0xA2, 0x9C, /*5*/
  0x3C, 0x52, 0x92, 0x92, 0x0C, /*6*/
  0x80, 0x86, 0x98, 0xE0, 0x80, /*7*/
  0x6C, 0x92, 0x92, 0x92, 0x6C, /*8*/
  0x60, 0x92, 0x92, 0x94, 0x78, /*9*/
  0x00, 0x00, 0x36, 0x36, 0x00, /*:*/
  0x00, 0x00, 0x35, 0x36, 0x00, /*;*/
  0x10, 0x28, 0x44, 0x82, 0x00, /*<*/
  0x28, 0x28, 0x28, 0x28, 0x28, /*=*/
  0x00, 0x82, 0x44, 0x28, 0x10, /*>*/
  0x40, 0x80, 0x8A, 0x90, 0x60, /*?*/
  0x7C, 0x82, 0xBA, 0xBA, 0x62, /*@*/
  0x3E, 0x48, 0x88, 0x48, 0x3E, /*A*/
  0xFE, 0x92, 0x92, 0x92, 0x6C, /*B*/
  0x7C, 0x82, 0x82, 0x82, 0x44, /*C*/
  0xFE, 0x82, 0x82, 0x82, 0x7C, /*D*/
  0xFE, 0x92, 0x92, 0x92, 0x82, /*E*/
  0xFE, 0x90, 0x90, 0x90, 0x80, /*F*/
  0x7C, 0x82, 0x82, 0x8A, 0x4E, /*G*/
  0xFE, 0x10, 0x10, 0x10, 0xFE, /*H*/
  0x82, 0x82, 0xFE, 0x82, 0x82, /*I*/
  0x84, 0x82, 0xFC, 0x80, 0x80, /*J*/
  0xFE, 0x10, 0x28, 0x44, 0x82, /*K*/
  0xFE, 0x02, 0x02, 0x02, 0x02, /*L*/
  0xFE, 0x40, 0x20, 0x40, 0xFE, /*M*/
  0xFE, 0x60, 0x10, 0x0C, 0xFE, /*N*/
  0x7C, 0x82, 0x82, 0x82, 0x7C, /*O*/
  0xFE, 0x90, 0x90, 0x90, 0x60, /*P*/
  0x7C, 0x82, 0x82, 0x86, 0x7E, /*Q*/
  0xFE, 0x90, 0x98, 0x94, 0x62, /*R*/
  0x64, 0x92, 0x92, 0x92, 0x4C, /*S*/
  0x80, 0x80, 0xFE, 0x80, 0x80, /*T*/
  0xFC, 0x02, 0x02, 0x02, 0xFC, /*U*/
  0xF8, 0x04, 0x02, 0x04, 0xF8, /*V*/
  0xFC, 0x02, 0x0C, 0x02, 0xFC, /*W*/
  0xC6, 0x28, 0x10, 0x28, 0xC6, /*X*/
  0xC0, 0x20, 0x1E, 0x20, 0xC0, /*Y*/
  0x86, 0x8A, 0x92, 0xA2, 0xC2, /*Z*/
  0x00, 0x00, 0xFE, 0x82, 0x00, /*[*/
  0x00, 0x00, 0x00, 0x00, 0x00, /*this should be / */
  0x80, 0x60, 0x10, 0x0C, 0x02, /*]*/
  0x20, 0x40, 0x80, 0x40, 0x20, /*^*/
  0x01, 0x01, 0x01, 0x01, 0x01, /*_*/
  0x80, 0x40, 0x20, 0x00, 0x00, /*`*/
  0x04, 0x2A, 0x2A, 0x2A, 0x1E, /*a*/
  0xFE, 0x12, 0x22, 0x22, 0x1C, /*b*/
  0x1C, 0x22, 0x22, 0x22, 0x14, /*c*/
  0x1C, 0x22, 0x22, 0x12, 0xFE, /*d*/
  0x1C, 0x2A, 0x2A, 0x2A, 0x18, /*e*/
  0x10, 0x7E, 0x90, 0x80, 0x40, /*f*/
  0x18, 0x25, 0x25, 0x25, 0x1E, /*g*/
  0xFE, 0x10, 0x10, 0x10, 0x0E, /*h*/
  0x00, 0x12, 0x5E, 0x02, 0x00, /*i*/
  0x02, 0x01, 0x01, 0x11, 0x5E, /*j*/
  0xFE, 0x08, 0x08, 0x14, 0x22, /*k*/
  0x00, 0x82, 0xFE, 0x02, 0x00, /*l*/
  0x3E, 0x20, 0x1C, 0x20, 0x1E, /*m*/
  0x3E, 0x20, 0x20, 0x20, 0x1E, /*n*/
  0x1C, 0x22, 0x22, 0x22, 0x1C, /*o*/
  0x3F, 0x24, 0x24, 0x24, 0x18, /*p*/
  0x18, 0x24, 0x24, 0x3F, 0x01, /*q*/
  0x3E, 0x10, 0x20, 0x20, 0x10, /*r*/
  0x12, 0x2A, 0x2A, 0x2A, 0x04, /*s*/
  0x00, 0x10, 0x3C, 0x12, 0x04, /*t*/
  0x3C, 0x02, 0x02, 0x02, 0x3E, /*u*/
  0x30, 0x0C, 0x02, 0x0C, 0x30, /*v*/
  0x38, 0x06, 0x18, 0x06, 0x38, /*w*/
  0x22, 0x14, 0x08, 0x14, 0x22, /*x*/
  0x38, 0x05, 0x05, 0x05, 0x3E, /*y*/
  0x22, 0x26, 0x2A, 0x32, 0x22, /*z*/
  0x00, 0x10, 0x6C, 0x82, 0x82, /*{*/
  0x00, 0x00, 0xFF, 0x00, 0x00, /*|*/
  0x04, 0x02, 0xFF, 0x02, 0x04, /*|, arrow*/
  0x82, 0x82, 0x6C, 0x10, 0x00, /*}*/
  0x08, 0x10, 0x18, 0x08, 0x10 /*~*/
};

void setup() {

  //matrix modules init
  for (int adresse = 0; adresse < MatrixNumber; adresse++) {
    /*The MAX72XX is in power-saving mode on startup*/
    lc.shutdown(adresse, false);
    /* Set the brightness to a medium values */
    lc.setIntensity(adresse, 4);
    /* and clear the display */
    lc.clearDisplay(adresse);
  }

  BufferBuilding("EPINAL", 25);   //first message on the led screen



  Serial.begin(9600); //we also set the normal serial link, for debug



  //we sent a message on the serial port...
  Serial.println("Bienvenue");

}
void loop() {

  DrawText( LongueurChaine); //draw the message, in a loop

  //or, if we get something on the virtual bluetooth port...
  if (Serial.available() > 0) {

    LongueurChaine = Serial.available(); //incoming string lenght

    for  (int i = 0; i < LongueurChaine; i++) {

      // read the incoming byte:
      incomingByte = Serial.read();

      Phrase[i] = incomingByte; ///store the character into the string array

    }


    //buffers cleaning, to store the new message
    for (int k = 0; k < 200; k++) {
      Buffer[k] = 0;
      Buffer_inverse[k] = 0;

    }

    //we create the new buffers, so the new message will be drawn when leaving the sub
    BufferBuilding(Phrase, LongueurChaine);
  }

}



void BufferBuilding(char * stringToDisplay, byte stringLength)
{
  int i = 0;

  //loop on every characters (on the string)
  for (int k = 0; k < stringLength; k++) {
    //here we call the characters library
    int caract = k;
    Buffer[i + 0] =  fontDefinitions[((stringToDisplay[caract] - 32) * 5) + 0];
    Buffer[i + 1] =  fontDefinitions[((stringToDisplay[caract] - 32) * 5) + 1];
    Buffer[i + 2] =  fontDefinitions[((stringToDisplay[caract] - 32) * 5) + 2];
    Buffer[i + 3] =  fontDefinitions[((stringToDisplay[caract] - 32) * 5) + 3];
    Buffer[i + 4] =  fontDefinitions[((stringToDisplay[caract] - 32) * 5) + 4];
    Buffer[i + 5] =  B00000000; //one blank column of leds between two characters
    i = i + 6;
  }

  // here, we create a second buffer, to display the message on the switched matrixes
  for (int k = 0; k < stringLength * 6; k++) {
    for (int i = 0; i < 8; i++) {
      bitWrite(  Buffer_inverse[k] , i,  bitRead(Buffer[k] , 7 - i) )   ;
    }
  }
}

void DrawText( byte stringLength) {

  for (int k = 0; k < stringLength * 6; k++) {

    delay(SpeedDelay);


    //delay(10000);
    //k is the column

    //buffer drawing
    for (int m = 0; m < MatrixNumber; m++) {  //loop on the matrix
      if (m % 2 ==  0) //check is the module is upside-down or not...
      {
        //here, the matrix is flipped upside-down
        for (int i = 0; i < 8; i++) {  //loop on the columns

          lc.setRow(m, 7 - i, Buffer[i + k + 8 * m]);
        }
      }
      else
      {
        //classical
        for (int i = 0; i < 8; i++) {  //loop on the columns


          lc.setRow(m, i, Buffer_inverse[i + k + 8 * m]);
        }
      }
    }
  }

}

Excuses manque un s à compétenceS

J’ai déplacé votre post dans Le forum principal

Merci de lire et mettre en application les recommandations listées dans « Les bonnes pratiques du Forum Francophone”

➜ Merci d’éditer votre post pour rajouter les balises de de code, c’est quasiment illisible tel quel:

  • sélectionner la partie du texte qui correspond au code
  • appuyez sur l’icône </> dans la barre d’outils pour indiquer que c’est du code

(Assurez vous aussi d’indenter le code correctement dans l’IDE avant de le copier pour le coller ici. Cela se fait en pressant ctrlT sur PC ou cmdT sur un Mac)

Merci pour ces conseils, je patauge un peu dans les différentes sections de ce forum.
Très cordiales salutations.

Si vous pouviez éditer le premier post et mettre les balises, ce serait plus lisible…

Oui, Jackson, merci je vais le faire dès que possible... sans doute ce dimanche en fin de journée .. Bonne journée.. Amicales salutations
Risafran

Non ce n’est pas mieux - il faut utiliser les balises de code

Détruisez les posts inutiles et modifiez le premier

Non

  • Il faut ouvrir l'IDE Arduino et ouvrir le sketch que tu veux nous montrer.
  • Faire Ctrl-t le code va être mis en forme correctement.
  • Sélectionner tout le texte (Ctrl-a) et le copier (Ctrl-c)
  • Ouvrir ce fil de discussion.
  • Remonter sur le premier message.
  • L'ouvrir en édition (l'icône représentant un crayon dans le bas de ton message)
  • Sélectionner la partie avec le programme, la supprimer.
  • Cliquer sur l'icône </> tu vois apparaître
    ```
    type or paste code here
    ```
  • Coller ton code à la place du texte "type or paste code here"
  • tu pourras même au passage ajouter le s manquant à compétence.

Pour les messages à supprimer dans le bas des messages cliquer sur ... le jeu d'icônes change cliquer sur la poubelle.

Bon je crois que ce coup cela doit être correct .. J'espère ??

c'est tout de suite plus lisible ! :wink:
merci


je suppose que vous voulez récupérer la RAM occupée par la police:

int fontDefinitions[480] = {
  0x00, 0x00, 0x00, 0x00, 0x00,/*space*/ // is 32 in ASCII
  0x00, 0xF6, 0xF6, 0x00, 0x00, /*!*/
...
  0x00, 0x00, 0xFF, 0x00, 0x00, /*|*/
  0x04, 0x02, 0xFF, 0x02, 0x04, /*|, arrow*/
  0x82, 0x82, 0x6C, 0x10, 0x00, /*}*/
  0x08, 0x10, 0x18, 0x08, 0x10 /*~*/
};

pouvez vous préciser pourquoi vous avez choisi le type int (2 ou 4 octets suivant la plateforme) alors que vous ne stockez que des octets dedans ? en faisant juste const byte fontDefinitions[480] = { ... vous allez gagner pas mal de place (au moins diviser par 2) sans rien modifier d'autre.

si ensuite vous voulez mettre tout le tableau en mémoire flash (PROGMEM) il faudra changer la façon dont les octets sont récupérés en mémoire. Quel Arduino utilisez vous ?

Merci encore de "prendre soin de moi".. comme indiqué je suis parti sur un croqui glané sur le net qui semblait pouvoir s'adapter à mon projet de journal défilant modifiable a partie d'un envoi de texte soit a partir du moniteur soit depuis un portable.

J'utilise un arduino uno, mais effectivement j'ai en commande un "mega" qui a plus de mémoire, mais pour essayer de me perfectionner sur arduino et d'en apprendre plus je tente dele faire sur le UNO

voici un exemple qui utilise votre tableau en PROGMEM et imprime son contenu

const uint8_t charSet[] PROGMEM = {
  0x00, 0x00, 0x00, 0x00, 0x00,/*space*/ // is 32 in ASCII
  0x00, 0xF6, 0xF6, 0x00, 0x00, /*!*/
  0x00, 0xE0, 0x00, 0xE0, 0x00, /*"*/
  0x28, 0xFE, 0x28, 0xFE, 0x28, /*#*/
  0x00, 0x64, 0xD6, 0x54, 0x08, /*$*/
  0xC2, 0xCC, 0x10, 0x26, 0xC6, /*%*/
  0x4C, 0xB2, 0x92, 0x6C, 0x0A, /*&*/
  0x00, 0x00, 0xE0, 0x00, 0x00, /*'*/
  0x00, 0x38, 0x44, 0x82, 0x00, /*(*/
  0x00, 0x82, 0x44, 0x38, 0x00, /*)*/
  0x88, 0x50, 0xF8, 0x50, 0x88, /***/
  0x08, 0x08, 0x3E, 0x08, 0x08, /*+*/
  0x00, 0x00, 0x05, 0x06, 0x00, /*,*/
  0x08, 0x08, 0x08, 0x08, 0x08, /*-*/
  0x00, 0x00, 0x06, 0x06, 0x00, /*.*/
  0x02, 0x0C, 0x10, 0x60, 0x80, /*/*/
  0x7C, 0x8A, 0x92, 0xA2, 0x7C, /*0*/
  0x00, 0x42, 0xFE, 0x02, 0x00, /*1*/
  0x42, 0x86, 0x8A, 0x92, 0x62, /*2*/
  0x44, 0x82, 0x92, 0x92, 0x6C, /*3*/
  0x10, 0x30, 0x50, 0xFE, 0x10, /*4*/
  0xE4, 0xA2, 0xA2, 0xA2, 0x9C, /*5*/
  0x3C, 0x52, 0x92, 0x92, 0x0C, /*6*/
  0x80, 0x86, 0x98, 0xE0, 0x80, /*7*/
  0x6C, 0x92, 0x92, 0x92, 0x6C, /*8*/
  0x60, 0x92, 0x92, 0x94, 0x78, /*9*/
  0x00, 0x00, 0x36, 0x36, 0x00, /*:*/
  0x00, 0x00, 0x35, 0x36, 0x00, /*;*/
  0x10, 0x28, 0x44, 0x82, 0x00, /*<*/
  0x28, 0x28, 0x28, 0x28, 0x28, /*=*/
  0x00, 0x82, 0x44, 0x28, 0x10, /*>*/
  0x40, 0x80, 0x8A, 0x90, 0x60, /*?*/
  0x7C, 0x82, 0xBA, 0xBA, 0x62, /*@*/
  0x3E, 0x48, 0x88, 0x48, 0x3E, /*A*/
  0xFE, 0x92, 0x92, 0x92, 0x6C, /*B*/
  0x7C, 0x82, 0x82, 0x82, 0x44, /*C*/
  0xFE, 0x82, 0x82, 0x82, 0x7C, /*D*/
  0xFE, 0x92, 0x92, 0x92, 0x82, /*E*/
  0xFE, 0x90, 0x90, 0x90, 0x80, /*F*/
  0x7C, 0x82, 0x82, 0x8A, 0x4E, /*G*/
  0xFE, 0x10, 0x10, 0x10, 0xFE, /*H*/
  0x82, 0x82, 0xFE, 0x82, 0x82, /*I*/
  0x84, 0x82, 0xFC, 0x80, 0x80, /*J*/
  0xFE, 0x10, 0x28, 0x44, 0x82, /*K*/
  0xFE, 0x02, 0x02, 0x02, 0x02, /*L*/
  0xFE, 0x40, 0x20, 0x40, 0xFE, /*M*/
  0xFE, 0x60, 0x10, 0x0C, 0xFE, /*N*/
  0x7C, 0x82, 0x82, 0x82, 0x7C, /*O*/
  0xFE, 0x90, 0x90, 0x90, 0x60, /*P*/
  0x7C, 0x82, 0x82, 0x86, 0x7E, /*Q*/
  0xFE, 0x90, 0x98, 0x94, 0x62, /*R*/
  0x64, 0x92, 0x92, 0x92, 0x4C, /*S*/
  0x80, 0x80, 0xFE, 0x80, 0x80, /*T*/
  0xFC, 0x02, 0x02, 0x02, 0xFC, /*U*/
  0xF8, 0x04, 0x02, 0x04, 0xF8, /*V*/
  0xFC, 0x02, 0x0C, 0x02, 0xFC, /*W*/
  0xC6, 0x28, 0x10, 0x28, 0xC6, /*X*/
  0xC0, 0x20, 0x1E, 0x20, 0xC0, /*Y*/
  0x86, 0x8A, 0x92, 0xA2, 0xC2, /*Z*/
  0x00, 0x00, 0xFE, 0x82, 0x00, /*[*/
  0x00, 0x00, 0x00, 0x00, 0x00, /*this should be / */
  0x80, 0x60, 0x10, 0x0C, 0x02, /*]*/
  0x20, 0x40, 0x80, 0x40, 0x20, /*^*/
  0x01, 0x01, 0x01, 0x01, 0x01, /*_*/
  0x80, 0x40, 0x20, 0x00, 0x00, /*`*/
  0x04, 0x2A, 0x2A, 0x2A, 0x1E, /*a*/
  0xFE, 0x12, 0x22, 0x22, 0x1C, /*b*/
  0x1C, 0x22, 0x22, 0x22, 0x14, /*c*/
  0x1C, 0x22, 0x22, 0x12, 0xFE, /*d*/
  0x1C, 0x2A, 0x2A, 0x2A, 0x18, /*e*/
  0x10, 0x7E, 0x90, 0x80, 0x40, /*f*/
  0x18, 0x25, 0x25, 0x25, 0x1E, /*g*/
  0xFE, 0x10, 0x10, 0x10, 0x0E, /*h*/
  0x00, 0x12, 0x5E, 0x02, 0x00, /*i*/
  0x02, 0x01, 0x01, 0x11, 0x5E, /*j*/
  0xFE, 0x08, 0x08, 0x14, 0x22, /*k*/
  0x00, 0x82, 0xFE, 0x02, 0x00, /*l*/
  0x3E, 0x20, 0x1C, 0x20, 0x1E, /*m*/
  0x3E, 0x20, 0x20, 0x20, 0x1E, /*n*/
  0x1C, 0x22, 0x22, 0x22, 0x1C, /*o*/
  0x3F, 0x24, 0x24, 0x24, 0x18, /*p*/
  0x18, 0x24, 0x24, 0x3F, 0x01, /*q*/
  0x3E, 0x10, 0x20, 0x20, 0x10, /*r*/
  0x12, 0x2A, 0x2A, 0x2A, 0x04, /*s*/
  0x00, 0x10, 0x3C, 0x12, 0x04, /*t*/
  0x3C, 0x02, 0x02, 0x02, 0x3E, /*u*/
  0x30, 0x0C, 0x02, 0x0C, 0x30, /*v*/
  0x38, 0x06, 0x18, 0x06, 0x38, /*w*/
  0x22, 0x14, 0x08, 0x14, 0x22, /*x*/
  0x38, 0x05, 0x05, 0x05, 0x3E, /*y*/
  0x22, 0x26, 0x2A, 0x32, 0x22, /*z*/
  0x00, 0x10, 0x6C, 0x82, 0x82, /*{*/
  0x00, 0x00, 0xFF, 0x00, 0x00, /*|*/
  0x04, 0x02, 0xFF, 0x02, 0x04, /*|, arrow*/
  0x82, 0x82, 0x6C, 0x10, 0x00, /*}*/
  0x08, 0x10, 0x18, 0x08, 0x10, /*~*/
};

const size_t charSetSize = sizeof(charSet);

void setup() {
  Serial.begin(115200); Serial.println();
  Serial.print(F("charSet contient ")); Serial.print(charSetSize); Serial.println(F(" octets."));
  for (size_t i = 0; i < charSetSize; i++) {
    Serial.print("0x"); Serial.print(pgm_read_byte(charSet + i), HEX); Serial.print(F(", "));
    if ((i + 1) % 5 == 0) Serial.println();
  }
}

void loop() {}

Bien reçu .. Je vais de ce pas essayer ... je vous tiendrai au couant.. Vraiment merci...merci... pour votre amabilité, reactivité et compétenceS..( re Hi...)

il y a sans doute un bug, faut que je regarde la lecture de la taille du tableau et sa compatibilité avec le UNO

EDIT: j'avais juste pas fait attention, la taille du tableau étant de plus de 255 il faut bien sûr ne pas utiliser un byte pour la taille... Avec cela pas de souci

const size_t charSetSize = sizeof(charSet);

On a bien vos 480 valeurs

Bonjour Jackson, grâce à vos judicieux conseils j'ai pu avancer dans mon projet et je vous en remercie très sincèrement.
J'obtiens un fonctionnement correct de mon affichage défilant sur 5 matrices 8x8 (bien que l'affichage commence toujours à la 4eme colonne de la première matrice, je n'ai pas trouvé pourquoi ). Je bute sur un autre problème : je voudrais faire l'affichage sur 8 matrices 8x8 mais je n'y parviens pas. l'affichage reste sur 5 matrices pas plus : soit de la N°1 à la N°5, soit de la N°4 à la N°8. j'ai bien entendu indiqué dans le sketch le nombre de matrices utilisées vers la librairie MaxMatrix. L'étape suivante future sera d'incorporer les caractères Français accentués et spéciaux (ç , à , etc ..)
A l'aide svp pour cet affichage sur 8 matrices ...
Merci d'avance. Amicales salutations
Risafran (François)

/*
  ################################################################################
  Texte défilant
   MATRICE N° 1 A DROITE : ORDRE 8-7-6-5-4-3-2-1
  ################################################################################
*/

#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, // AT
  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, // ~
};

int data = 10;
int load = 9;
int clock = 8;

int maxInUse = 8;    //A modifier pour changer le nombre d'afficheur, ici on en a HUIT

MaxMatrix m(data, load, clock, maxInUse);

byte buffer[10];

// Les lignes de texte vous pouvez en rajoutez mais attention a la limite de la mémoire
char string1[] = " Utilisation d'un Arduino pour journal lumineux ? ";
char string2[] = " C'est un SACRE BOULOT";
char string3[] = "  the quick brown fox jump over the lazy dog";

void setup() {
  m.init(); // initialisation du MAX7219
  m.setIntensity(04); // Règlage de l'intensité lumineuse de 0 a 15
  Serial.begin(9600); // initialisation du prot série
}

void loop() {



  printStringWithShift(string1, 100); // 100 = vitesse de défilement soit 100ms
  printStringWithShift(string2, 100);
  printStringWithShift(string3, 100);

}

void printCharWithShift(char c, int shift_speed) {
  if (c < 32) return;
  c -= 32;
  memcpy_P(buffer, CH + 7 * c, 7);
  m.writeSprite(32, 0, buffer);
  m.setColumn(32 + buffer[0], 0);

  for (int i = 0; i < buffer[0] + 1; i++)
  {
    delay(shift_speed);
    m.shiftLeft(false, true);
  }
}

void printStringWithShift(char* s, int shift_speed) {
  while (*s != 0) {
    printCharWithShift(*s, shift_speed);
    s++;
  }
}

void printString(char* s)
{
  int col = 0;
  while (*s != 0)
  {
    if (*s < 32) continue;
    char c = *s - 32;
    memcpy_P(buffer, CH + 7 * c, 7);
    m.writeSprite(col, 0, buffer);
    m.setColumn(col + buffer[0], 0);
    col += buffer[0] + 1;
    s++;
  }
}

Salut François — Moi c'est Jean-Marc - Jackson c'est un petit badge que m'a donné le logiciel du forum :wink:

je ne connais pas cette bibliothèque mais je remarque que dans votre code vous écrivez toujours le glyph (dessin) du nouveau caractère en colonne x=32

  m.writeSprite(32, 0, buffer);

Vous pouvez préciser à quoi correspond ce 32 qui est câblé en dur?

il y a une autre bibliothèque avec le même nom:

Bonjour Jean-Marc alors ... , merci pour la réponse. Malgré mon état "d'Ancêtre" de la programmation , comme je suis très novice en C++ j'ai donc puisé dans les exemples trouvés ça et là , je n'ai pas assez de pratique pour comprendre toutes les fonctions et je ne comprends pas bien justement cette partie du sketch. Je vais essayer la librairie que vous m'indiquez.
Toutefois, pour le décalage d'affichage de 3 colonnes à partir de la première matrice, j'ai une piste : la largeur des caractères. En effets tous les caractères larges comme M ou W (majuscules) démarrent , eux , à la 3eme colonne. La fonte est, semble t'il, en 5X8 d'où l'indication en tête de chaque ligne de définition de codage de caractère des deux paramètres : 5,8, ou 3,8, ou 4,8, etc ...
A bientôt donc . Très Amicalement...
François

x, c'est la position dans la matrice

void MaxMatrix::writeSprite(int x, int y, const byte* sprite)

La librairie se trouve ici

Oui j’ai vu cette autre bibliothèque mais je ne vois pas à quoi correspond la colonne 32 dans son exemple

(sauf s’il a un module de 4 afficheurs 8x8 et encore ce serait plutôt de 0 à 31…)