Matrice LED 8×8 con Arduino: collegamenti e test

Cosa imparerai

• come è organizzata una matrice LED 8×8;
• come distinguere righe e colonne;
• come collegare i 16 terminali ad Arduino;
• come usare anche i pin analogici come uscite digitali;
• come verificare il cablaggio accendendo progressivamente le righe;
• come preparare il circuito per il progetto successivo con lettere e simboli.

La matrice LED 8×8

Nel sito questa immagine era visualizzata a circa 191 px: manteniamo la stessa dimensione massima.

Una matrice 8×8 permette di visualizzare punti, figure, lettere e simboli. Questo primo tutorial serve soprattutto a verificare che ogni riga e ogni colonna sia collegata correttamente; nel progetto successivo useremo la stessa matrice per comporre caratteri.

Come sono organizzati i 64 LED

Queste due immagini nel sito erano impostate su larghezza automatica, quindi non vengono ingrandite artificialmente.

Materiale necessario

Schema del circuito

schema del collegamento. Nel sito la larghezza era automatica.

Pin usati dal progetto

Lo sketch utilizza ben 16 linee di Arduino. Oltre ai pin digitali D2–D13 sfrutta anche A0–A3 come normali pin digitali.

Mappatura di righe e colonne

Il sketch crea prima un array generale dei 16 pin e poi due array separati per colonne e righe. Manteniamo la stessa corrispondenza, ma scritta direttamente in modo più leggibile.

Codice Arduino commentato

// ==========================================================
// MATRICE LED 8x8 CON ARDUINO - TEST COLLEGAMENTI
// Versione semplificata del progetto
// ==========================================================

// Le otto colonne della matrice.
// La sequenza mantiene esattamente la mappatura
// utilizzata nello sketch.
const int colonne[8] = {
 9, // colonna 1
 12, // colonna 2
 7, // colonna 3
 13, // colonna 4
 2, // colonna 5
 6, // colonna 6
 A1, // colonna 7
 5 // colonna 8
};

// Le otto righe della matrice.
const int righe[8] = {
 A3, // riga 1
 A2, // riga 2
 3, // riga 3
 8, // riga 4
 4, // riga 5
 10, // riga 6
 11, // riga 7
 A0 // riga 8
};

void setup() {

 // Configura tutte le colonne come uscite.
 for (int i = 0; i < 8; i++) {
 pinMode(colonne[i], OUTPUT);
 }

 // Configura tutte le righe come uscite.
 for (int i = 0; i < 8; i++) {
 pinMode(righe[i], OUTPUT);
 }

 // Stato iniziale del progetto:
 // colonne a LOW e righe a LOW.
 // In questa configurazione nessuna riga viene
 // inizialmente portata al livello attivo HIGH.
 for (int i = 0; i < 8; i++) {
 digitalWrite(colonne[i], LOW);
 digitalWrite(righe[i], LOW);
 }
}

void loop() {

 // --------------------------------------------------------
 // ACCENSIONE PROGRESSIVA DELLE RIGHE
 // --------------------------------------------------------
 // Le colonne restano a LOW.
 // Portando una riga alla volta a HIGH,
 // si verifica visivamente il suo collegamento.
 for (int i = 0; i < 8; i++) {

 digitalWrite(righe[i], HIGH);

 // Lascia il risultato visibile per 100 ms
 delay(100);
 }

 // --------------------------------------------------------
 // SPEGNIMENTO PROGRESSIVO DELLE RIGHE
 // --------------------------------------------------------
 for (int i = 0; i < 8; i++) {

 digitalWrite(righe[i], LOW);

 delay(100);
 }
}

Cosa deve succedere

Lo sketch è volutamente semplice: serve come test del cablaggio. Le righe vengono portate progressivamente a HIGH e poi riportate a LOW.

Perché questo test è utile

Con 16 collegamenti è molto facile scambiare una riga con una colonna. Prima di provare a disegnare lettere o simboli conviene quindi verificare la matrice con una sequenza elementare.

Una volta sicuri del cablaggio, nel progetto successivo potremo passare al vero controllo dei singoli LED e creare caratteri tramite mappe di bit.

Come si accende un singolo LED

Ogni punto della matrice si trova all’intersezione tra una riga e una colonna. Per accenderne uno solo bisogna quindi selezionare la riga corretta e contemporaneamente impostare la colonna con la polarità richiesta.

Perché servono le resistenze

I LED devono avere una limitazione di corrente. Nel progetto vengono utilizzate 8 resistenze da 220 Ω. Non eliminare le resistenze pensando che la matrice possa essere collegata direttamente ai pin.

Limiti del collegamento diretto

Questo circuito è molto utile per capire il funzionamento della matrice, ma occupa praticamente tutti i pin disponibili di Arduino Uno. Per progetti più complessi si usano spesso driver come MAX7219, che riducono drasticamente il numero di collegamenti richiesti.

Immagine del test

Scarica lo sketch

Debug rapido

• controlla l’orientamento fisico della matrice;
• non dare per scontata la piedinatura: verifica il modello utilizzato;
• ricontrolla una per una le otto righe e le otto colonne;
• verifica le connessioni verso A0–A3 oltre ai pin digitali;
• se una riga non si accende, controlla sia quella riga sia le colonne comuni;
• se si accendono punti inattesi, cerca collegamenti invertiti tra righe e colonne;
• controlla che siano presenti le resistenze da 220 Ω previste dal circuito.

Varianti del progetto

• testare anche le colonne una alla volta;
• accendere un singolo LED alla volta;
• creare una diagonale animata;
• realizzare un effetto scansione;
• visualizzare lettere e simboli;
• usare un MAX7219 per liberare i pin di Arduino.

Cosa devi ricordare

Domande frequenti