Costruire una Matrice di LED 8x8 con Arduino

Oct 6, 2020

Lo leggi in 11 minuti

In questo tutorial Arduino vedremo come realizzare una Matrice a LED 8×8 utilizzando il driver MAX7219 e una scheda Arduino.

Costruire una Matrice di LED 8x8 con Arduino

Questa è forse la più scenografica delle applicazioni con Arduino, facile da realizzare a livello hardware ma molto utile per imparare a programmare i chip “driver” delle Matrici a LED




IL CHIP “MAX7219”

Parliamo innanzitutto del “driver” MAX7219. Il chip è in grado di pilotare 64 LED individuali utilizzando solo 3 fili per il link con Arduino, e per di più lo possiamo collegare in configurazione “sequenziale” con altri driver usando sempre gli stessi 3 fili!

Driver matrice LED MAX7219 8x8

I 64 LED sono pilotati tutti dai 16 pin di uscita dell’IC. Come è possibile? Ebbene, il numero massimo di LED che si accendono contemporaneamente è in realtà otto. I LED sono disposti come un insieme di righe e colonne 8 × 8.
Il drive MAX7219 si attiva per ogni colonna solo per un periodo di tempo molto breve e allo stesso tempo accende in sequenza tutte le righe. Grazie all’effetto di permanenza delle luce sulla retina, i nostri occhi noteranno solamente una luce continua.



Sopra vediamo come i pin di una comune matrice LED 8×8 siano disposti internamente. Se vuoi modificare questo progetto e ti piace fare esperimenti, ti sarà di aiuto salvare la immagine da qualche parte. Le schede che adottano il MAX7219 prevedono in genere un resistenza opportunamente inserita tra il pin 5V di Arduino e il numero di pin IC 18. La resistenza viene utilizzata per impostare la luminosità o il flusso di corrente ai LED. La puoi vedere nella macro foto in basso con il cerchietto rosso.

Resistenza del regolatore di corrente MAX7219

La tabella seguente è presa pari pari dal datasheet della casa madre e mostra il valore della resistenza che dovremmo usare in base alla caduta di tensione diretta dei nostri LED.

Tabella della corrente del segmento MAX7219 rispetto alla caduta di tensione diretta dal datasheet

Schema del circuito


Adesso colleghiamo il modulo Matrice LED 8×8 alla nostra scheda Arduino. Ecco lo schema del circuito:

Schema del circuito MAX7219 a matrice di LED 8x8

Il VCC e GND del modulo vanno ai pin 5V e GND di Arduino e gli altri tre pin, DIN, CLK e CS vanno a un qualsiasi pin digitale della scheda Arduino. Se vogliamo collegare più di un modulo, colleghiamo semplicemente i pin di uscita della precedente scheda pin di ingresso del nuovo modulo.
In realtà questi pin sono tutti uguali tranne che il pin DOUT della scheda precedente va a finire nel pin DIN della nuova scheda. Ti ricordo che puoi ottenere i componenti necessari per questo tutorial dai link sottostanti:

Il programma base per il MAX7219 + Arduino


Una volta collegati i moduli siamo pronti per caricare il codice Arduino del primo esempio. Useremo la libreria MaxMatrix specifica per il MAX7219 che può essere scaricata da GitHub. Non hai bisogno di fare copia e incolla del programma, ti basta andare alla fine del listato e cliccare su una delle 2 icone sottostanti.

/*
   Esempio LED Matrix 8x8 con MAX7219
   by robotdazero.it, based on Dejan Nedelkovski
   tratto da: https://howtomechatronics.com/

   Basato sulla libreria Open Source
   GitHub - https://github.com/riyas-org/max7219
*/

#include <MaxMatrix.h>

int DIN = 7;   // pin DIN del chip MAX7219
int CLK = 6;   // pin CLK del chip MAX7219
int CS = 5;    // pin CS  del chip MAX7219
int maxInUse = 1;


MaxMatrix m(DIN, CS, CLK, maxInUse);

char A[] = {4, 8,
            B01111110,
            B00010001,
            B00010001,
            B01111110,
           };

char B[] = {4, 8,
            B01111111,
            B01001001,
            B01001001,
            B00110110,
           };

char smile01[] = {8, 8,
                  B00111100,
                  B01000010,
                  B10010101,
                  B10100001,
                  B10100001,
                  B10010101,
                  B01000010,
                  B00111100
                 };
char smile02[] = {8, 8,
                  B00111100,
                  B01000010,
                  B10010101,
                  B10010001,
                  B10010001,
                  B10010101,
                  B01000010,
                  B00111100
                 };
char smile03[] = {8, 8,
                  B00111100,
                  B01000010,
                  B10100101,
                  B10010001,
                  B10010001,
                  B10100101,
                  B01000010,
                  B00111100
                 };

void setup() {
  m.init(); // init del chip MAX7219
  m.setIntensity(8); // intensità dei LED tra 0-15
}

void loop() {
  // Setta i LED On e Off a x,y
  m.setDot(6,2,true);
  delay(1000);
  m.setDot(6,3,true);
  delay(1000);
  m.clear(); // Azzera il display
  for (int i=0; i<8; i++){
    m.setDot(i,i,true);
    delay(300);
  }
  m.clear();
  // Mostra il carattere a x,y
  m.writeSprite(2, 0, A);
  delay(1000);

  m.writeSprite(2, 0, B);
  delay(1000);

  m.writeSprite(0, 0, smile01);
  delay(1000);

  m.writeSprite(0, 0, smile02);
  delay(1000);

  m.writeSprite(0, 0, smile03);
  delay(1000);

  for (int i=0; i<8; i++){
    m.shiftLeft(false,false);
    delay(300);
  }
  m.clear();
}

source

source

Clicca sulla icona di Github per il codice originale oppure clicca
sulla icona più a destra per scaricare il file dal nostro canale #Slack


Descrizione del programma:

All’inizio del listato vediamo la include della libreria MaxMatrix.h, poi definiamo i pin a cui è connesso il modulo, impostiamo il numero dei moduli utilizzati e usiamo le capacità Object Oriented di Arduino C++ per definire l’oggetto MaxMatrix. Per visualizzare i caratteri dobbiamo definirli in un array di caratteri o byte, e qui ti mostro degli esempi. Possiamo notare come i bit formino dei caratteri composti soltanto da zero e uno. In questo programma specifico vengono ruotati di 90 gradi, ma solo perchè l’esempio della libreria consiglia questo trucchetto. La rotazione serve a semplificare la funzione personalizzata shiftLeft() per lo scorrimento del testo. Noi ci siamo comunque attenuti alle specifiche dell’autore.

Nella sezione setup inizializziamo il modulo a LED impostimo la luminosità. Nella sezione loop utilizzamo la funzione setDot() con cui possiamo impostare qualsiasi singolo LED in modo che si accenda alla posizione desiderata. Quindi usiamo la funzione clear() per cancellare il display.

display con lettera G

Per visualizzare i caratteri predefiniti usiamo la funzione writeSprite(): i primi due argomenti sono la posizione X e Y dell’angolo superiore sinistro del carattere. A fine sorgente usiamo la funzione shiftLeft() per spostare il carattere verso sinistra.

Il secondo programma di esempio con lo con SCROLL del testo sulla matrice luminosa


Adesso diamo un’occhiata al programma con il testo scorrevole e vediamo cosa c’è di diverso. Sotto il codice troverai il mio commento su alcuni punti qualificanti del sorgente.

/*
   Esempio Scroll LED Matrix 8x8 con MAX7219
   by robotdazero.it, based on Dejan Nedelkovski
   tratto da: https://howtomechatronics.com/

   Basato sulla libreria Open Source
   GitHub - https://github.com/riyas-org/max7219
*/


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

int DIN = 7;   // pin DIN del chip MAX7219
int CLK = 6;   // pin CLK del chip MAX7219
int CS  = 5;   // pin CS  del chip MAX7219
int maxInUse = 2;

MaxMatrix m(DIN, CS, CLK, maxInUse);

byte buffer[10];

char text[]= "Testo in scorrimento ** ";

void setup() {
  m.init(); // init del modulo
  m.setIntensity(15); // intensità tra 0-15
}

void loop() {

  printStringWithShift(text, 100); // testo e velocità

}

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, false);
  }
}
// Estrae il carattere dalla stringa
void printStringWithShift(char* s, int shift_speed) {
  while (*s != 0) {
    printCharWithShift(*s, shift_speed);
    s++;
  }
}

source

source

Clicca sulla icona di Github per il codice originale oppure clicca
sulla icona più a destra per scaricare il file dal nostro canale #Slack

Descrizione:

All’inizio dobbiamo fare l’include di una libreria aggiuntiva per poter usare PROGMEN, che è un modificatore di variabili. Ci serve per salvare i dati nella memoria flash invece che nella SRAM: quando abbiamo un gruppo sostanzioso di variabili statiche, come in questo caso è meglio memorizzarle nella più capiente memoria flash. La memoria flash infatti possiede ben 32K byte, sedici volte la capacità della SRAM (2K byte).


8x8 LED Matrix Scrolling Text Codice Arduino
Successivamente con un array di caratteri definiamo il testo scorrevole e nella sezione loop() definiamo la funzione custom printStringWithShift(), che stampa il testo scorrevole sulla matrice LED con una velocità di scorrimento variabile. Puoi cambiare la velocità modificando il secondo argomento, ma ti consiglio di fare esperimenti solo dopo che tutto funzioni secondo il progetto. Altrimenti non capirai se hai sbagliate le modifiche o la costruzione in se stessa.

La funzione printStringWithShift() estrae i caratteri dalla stringa e li visualizza con effetto scroll sulla matrice a LED. La puoi considerare il “nucleo” del programma.

Ancora una volta mi preme evidenziare come le difficoltà nel realizzare circuiti complessi come questo siano legate al software, piuttosto che all’hardware. I chip di ultima generazione riducono moltissimo la complessità del progetto. Grazie alle tante funzioni automatiche puoi diventare davvero creativo e concentrarti sui problemi da risolvere piuttosto che sulla corrente.
Con gli ultimi sviluppi della Microelettronica puoi facilmente creare i tuoi progetti, testarli con amici o colleghi e venderli in rete su una piattaforma come Woocommerce, o Shopify o sul nuovo catalogo Facebook.