max 7219 girare testo di 90°

Ciao a tutti… sto provando a far funzionare una matrice led da 4 moduli max 7219. Ho provato diversi esempi di scroll del testo ma invece di fare un’unica riga mi compare come se ci fossero impostate 4 righe. (vedi foto allegata)
C’è un comando per girare il testo?

allego la foto e di seguito un esempio

// maxmatrix-disp-scroll-text-7219
#include <MaxMatrix.h>
#include <avr/pgmspace.h>

#define maxDisplays 4 // Number of MAX7219's in use.

byte Buf7219[7]; // "width,height,data[5]" single character buffer.
const int data  = 11;     // DIN or MOSI
const int load  = 10;     // CS
const int clock = 13;     // SCK
  
MaxMatrix m(data, load, clock, maxDisplays);
// Data array is stored in program memory (see memcpy_P for access).
// Parameters are width, height, character data...
// There is a speed improvement for characters with height 8 bits see lib.

PROGMEM const unsigned char CH[] = {
3, 8, B0000000, B0000000, B0000000, B0000000, B0000000, // space
1, 8, B1011111, B0000000, B0000000, B0000000, B0000000, // !
3, 8, B0000011, B0000000, B0000011, B0000000, B0000000, // "
5, 8, B0010100, B0111110, B0010100, B0111110, B0010100, // #
4, 8, B0100100, B1101010, B0101011, B0010010, B0000000, // $
5, 8, B1100011, B0010011, B0001000, B1100100, B1100011, // %
5, 8, B0110110, B1001001, B1010110, B0100000, B1010000, // &
1, 8, B0000011, B0000000, B0000000, B0000000, B0000000, // '
3, 8, B0011100, B0100010, B1000001, B0000000, B0000000, // (
3, 8, B1000001, B0100010, B0011100, B0000000, B0000000, // )
5, 8, B0101000, B0011000, B0001110, B0011000, B0101000, // * 
5, 8, B0001000, B0001000, B0111110, B0001000, B0001000, // +
2, 8, B10110000, B1110000, B0000000, B0000000, B0000000, // ,
4, 8, B0001000, B0001000, B0001000, B0001000, B0000000, // -
2, 8, B1100000, B1100000, B0000000, B0000000, B0000000, // .
4, 8, B1100000, B0011000, B0000110, B0000001, B0000000, // /
4, 8, B0111110, B1000001, B1000001, B0111110, B0000000, // 0
3, 8, B1000010, B1111111, B1000000, B0000000, B0000000, // 1
4, 8, B1100010, B1010001, B1001001, B1000110, B0000000, // 2
4, 8, B0100010, B1000001, B1001001, B0110110, B0000000, // 3
4, 8, B0011000, B0010100, B0010010, B1111111, B0000000, // 4
4, 8, B0100111, B1000101, B1000101, B0111001, B0000000, // 5
4, 8, B0111110, B1001001, B1001001, B0110000, B0000000, // 6
4, 8, B1100001, B0010001, B0001001, B0000111, B0000000, // 7
4, 8, B0110110, B1001001, B1001001, B0110110, B0000000, // 8
4, 8, B0000110, B1001001, B1001001, B0111110, B0000000, // 9
2, 8, B01010000, B0000000, B0000000, B0000000, B0000000, // :
2, 8, B10000000, B01010000, B0000000, B0000000, B0000000, // ;
3, 8, B0010000, B0101000, B1000100, B0000000, B0000000, // <
3, 8, B0010100, B0010100, B0010100, B0000000, B0000000, // =
3, 8, B1000100, B0101000, B0010000, B0000000, B0000000, // >
4, 8, B0000010, B1011001, B0001001, B0000110, B0000000, // ?
5, 8, B0111110, B1001001, B1010101, B1011101, B0001110, // @
4, 8, B1111110, B0010001, B0010001, B1111110, B0000000, // A
4, 8, B1111111, B1001001, B1001001, B0110110, B0000000, // B
4, 8, B0111110, B1000001, B1000001, B0100010, B0000000, // C
4, 8, B1111111, B1000001, B1000001, B0111110, B0000000, // D
4, 8, B1111111, B1001001, B1001001, B1000001, B0000000, // E
4, 8, B1111111, B0001001, B0001001, B0000001, B0000000, // F
4, 8, B0111110, B1000001, B1001001, B1111010, B0000000, // G
4, 8, B1111111, B0001000, B0001000, B1111111, B0000000, // H
3, 8, B1000001, B1111111, B1000001, B0000000, B0000000, // I
4, 8, B0110000, B1000000, B1000001, B0111111, B0000000, // J
4, 8, B1111111, B0001000, B0010100, B1100011, B0000000, // K
4, 8, B1111111, B1000000, B1000000, B1000000, B0000000, // L
5, 8, B1111111, B0000010, B0001100, B0000010, B1111111, // M
5, 8, B1111111, B0000100, B0001000, B0010000, B1111111, // N
4, 8, B0111110, B1000001, B1000001, B0111110, B0000000, // O
4, 8, B1111111, B0001001, B0001001, B0000110, B0000000, // P
4, 8, B0111110, B1000001, B1000001, B10111110, B0000000, // Q
4, 8, B1111111, B0001001, B0001001, B1110110, B0000000, // R
4, 8, B1000110, B1001001, B1001001, B0110010, B0000000, // S
5, 8, B0000001, B0000001, B1111111, B0000001, B0000001, // T
4, 8, B0111111, B1000000, B1000000, B0111111, B0000000, // U
5, 8, B0001111, B0110000, B1000000, B0110000, B0001111, // V
5, 8, B0111111, B1000000, B0111000, B1000000, B0111111, // W
5, 8, B1100011, B0010100, B0001000, B0010100, B1100011, // X
5, 8, B0000111, B0001000, B1110000, B0001000, B0000111, // Y
4, 8, B1100001, B1010001, B1001001, B1000111, B0000000, // Z
2, 8, B1111111, B1000001, B0000000, B0000000, B0000000, // [
4, 8, B0000001, B0000110, B0011000, B1100000, B0000000, // backslash
2, 8, B1000001, B1111111, B0000000, B0000000, B0000000, // ]
3, 8, B0000010, B0000001, B0000010, B0000000, B0000000, // hat
4, 8, B1000000, B1000000, B1000000, B1000000, B0000000, // _
2, 8, B0000001, B0000010, B0000000, B0000000, B0000000, // `
4, 8, B0100000, B1010100, B1010100, B1111000, B0000000, // a
4, 8, B1111111, B1000100, B1000100, B0111000, B0000000, // b
4, 8, B0111000, B1000100, B1000100, B0000000, B0000000, // c // JFM MOD.
4, 8, B0111000, B1000100, B1000100, B1111111, B0000000, // d
4, 8, B0111000, B1010100, B1010100, B0011000, B0000000, // e
3, 8, B0000100, B1111110, B0000101, B0000000, B0000000, // f
4, 8, B10011000, B10100100, B10100100, B01111000, B0000000, // g
4, 8, B1111111, B0000100, B0000100, B1111000, B0000000, // h
3, 8, B1000100, B1111101, B1000000, B0000000, B0000000, // i
4, 8, B1000000, B10000000, B10000100, B1111101, B0000000, // j
4, 8, B1111111, B0010000, B0101000, B1000100, B0000000, // k
3, 8, B1000001, B1111111, B1000000, B0000000, B0000000, // l
5, 8, B1111100, B0000100, B1111100, B0000100, B1111000, // m
4, 8, B1111100, B0000100, B0000100, B1111000, B0000000, // n
4, 8, B0111000, B1000100, B1000100, B0111000, B0000000, // o
4, 8, B11111100, B0100100, B0100100, B0011000, B0000000, // p
4, 8, B0011000, B0100100, B0100100, B11111100, B0000000, // q
4, 8, B1111100, B0001000, B0000100, B0000100, B0000000, // r
4, 8, B1001000, B1010100, B1010100, B0100100, B0000000, // s
3, 8, B0000100, B0111111, B1000100, B0000000, B0000000, // t
4, 8, B0111100, B1000000, B1000000, B1111100, B0000000, // u
5, 8, B0011100, B0100000, B1000000, B0100000, B0011100, // v
5, 8, B0111100, B1000000, B0111100, B1000000, B0111100, // w
5, 8, B1000100, B0101000, B0010000, B0101000, B1000100, // x
4, 8, B10011100, B10100000, B10100000, B1111100, B0000000, // y
3, 8, B1100100, B1010100, B1001100, B0000000, B0000000, // z
3, 8, B0001000, B0110110, B1000001, B0000000, B0000000, // {
1, 8, B1111111, B0000000, B0000000, B0000000, B0000000, // |
3, 8, B1000001, B0110110, B0001000, B0000000, B0000000, // }
4, 8, B0001000, B0000100, B0001000, B0000100, B0000000, // ~
};

void setup()
{
  m.init();
  m.setIntensity(10); //change brightness
}

// Scrolling Text
char string[] = "Arduino Matrix "; //edit text message 
char string2[] = "test 123 ";

void loop()        //Send text
{      
  delay(1000);//delay between messages
  m.shiftLeft(false, true);
  printStringWithShift(string,50);   //number is message speed
  delay(1000);
  m.shiftLeft(false, true);
  printStringWithShift(string2,50);
}


// Put text on Display
void printCharWithShift(char c, int shift_speed)
{
  if (c < 32) return;
  c -= 32;
  memcpy_P(Buf7219, CH + 7*c, 7);
  m.writeSprite(maxDisplays*8, 0, Buf7219);
  m.setColumn(maxDisplays*8 + Buf7219[0], 0);


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

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

Manca la foto allegata.

Metti il link all'esatto modulo (max7219) che hai usato e magari anche ad un documento di specifiche.

Non ho un modulo come quello, ma il codice mi sembra abbastanza "standard" come da esempi per cui dacci intanto quelle info.

Tra l'altro mancando la foto non ho capito bene: sono le lettere ad essere "verticali" mentre lo scroll è correttamente verso sinistra (e credo sia così), o è tutto ruotato come se il display dovesse andare in verticale?

Nel primo caso magari è la mappatura dei caratteri che è per un altro tipo di display che ha la mappa bitmap invertita. Ad esempio vedo che la "I" è definita come:

3, 8, B1000001, B1111111, B1000001, B0000000, B0000000, // I

Se i valori sono per "righe", a me pare che questa configurazione la disegni in orizzontale invece che in verticale se data in pasto alla libreria che invece la interpreta per colonne.

Se così fosse, o ruoti a mano i vari bit, o cerchi in rete una definizione che disegni i caratteri per colonne, oppure prova ad usare QUESTA libreria che ti dovrebbe permettere la rotazione.

Scusate ma non riuscivo a caricare la foto!!! c’era scritto di attendere 5 minuti!!!
ma matrice è max7219 modulo per arduino microcontrollore 4 display a matrice di punti con 5p linea

foto copia.gif

Ok dalla foto sembra di capire che i 4 moduli ricevono lo stesso testo invece di essere in cascata, e che lo scroll è comunque invertito (come se, appunto, fosse un modulo che va installato in verticale e non in orizzontale).
Hai scritto la descrizione ma non hai detto da quale fornitore, eBay? Amazon? Banggood? Altro?

Ora però per fare prima devi mandarci il link esatto del display che hai acquistato, per capire meglio se quello per caso si gestisca in modo differente, o se ci sia qualche suo settaggio per determinare l'orientamento o se a quel punto sia invece proprio difettoso.

EDIT: per un modulo simile su Amazon leggo alcune domande interessanti, in particolare vedi questa, che secondo me ti dovrebbe aiutare (ma devi cambiare libreria...):

Ho un problema le lettere che visualizzo non sono coordinate e sembrano specchiate qualcuno mi sa dire perché
Risposta: Stai usando la libreria MD_MAX72XX e/o Parola per Arduino?
Se sì, vai nella cartella "src" e apri il file MD_MAX72xx_lib.h
Nelle sezioni di commento è spiegato bene come configurare i parametri, in particolare questi:

  • HW_DIG_ROWS - MAX72xx digits are mapped to rows in on the matrix. If digits are
    not rows then they are columns!
  • HW_REV_COLS - Normal column coordinates orientation is 0 col on the right side
    of the display. Set to 1 to reverse this (0 on the left).
  • HW_REV_ROWS - Normal row coordinates orientation is 0 row at top of the display.
    Set to 1 to reverse this (0 at the bottom).

Io usai la seguente libreria per lavorare con quel tipo di display a matrice: LedControl.h
Dispone di due funzioni, setRow e setColumn, che in qualche modo ti permettono di impostare un orientamento delle scritte. Non è comunque una gestione plug and play, bisogna lavorarci un po'.
Sketch d'esempio:
LCDemoMatrix.ino
Di particolare utilità può essere questo sito:
led-matrix-editor
Che è in sostanza un tool per creare animazioni che poi si possono esportare in codice da caricare su Arduino.