Matrice LED 8×8 con Arduino: lettere, simboli e scorrimento

// Ogni byte rappresenta una riga della matrice.
// 1 = LED acceso
// 0 = LED spento

const byte letteraM[8] = {
 B10000001,
 B11000011,
 B10100101,
 B10011001,
 B10000001,
 B10000001,
 B10000001,
 B00000000
};

// ==========================================================
// MATRICE LED 8x8 CON ARDUINO
// Lettere, simboli e scorrimento
// ==========================================================

// Colonne: stessa mappatura del progetto
const int colonne[8] = {
 9, 12, 7, 13, 2, 6, A1, 5
};

// Righe: stessa mappatura del progetto
const int righe[8] = {
 A3, A2, 3, 8, 4, 10, 11, A0
};

// ----------------------------------------------------------
// Alcuni caratteri 8x8.
// Ogni elemento descrive una riga.
// ----------------------------------------------------------

const byte carR[8] = {
 B11100000,
 B10010000,
 B10010000,
 B11100000,
 B11000000,
 B10101000,
 B10010000,
 B00000000
};

const byte carI[8] = {
 B00100000,
 B00000000,
 B00100000,
 B00100000,
 B00100000,
 B00100000,
 B00010000,
 B00000000
};

const byte carM[8] = {
 B00000000,
 B00000000,
 B00000000,
 B01101100,
 B10010010,
 B10010010,
 B10010001,
 B00000000
};

const byte carN[8] = {
 B00000000,
 B00000000,
 B00000000,
 B11100000,
 B10010000,
 B10010000,
 B10010000,
 B00000000
};

// Buffer visualizzato sul display.
// Ogni byte rappresenta una colonna dello schermo.
byte schermo[8] = {0,0,0,0,0,0,0,0};

// ----------------------------------------------------------
// Spegne completamente la matrice.
// ----------------------------------------------------------
void spegniMatrice() {

 for (int i = 0; i < 8; i++) {
 digitalWrite(righe[i], LOW);
 digitalWrite(colonne[i], HIGH);
 }
}

// ----------------------------------------------------------
// Visualizza per alcuni millisecondi il contenuto
// del buffer "schermo" tramite multiplexing.
// ----------------------------------------------------------
void refreshMatrice(unsigned long durataMs) {

 unsigned long inizio = millis();

 while (millis() - inizio < durataMs) {

 for (int col = 0; col < 8; col++) {

 // Evita accensioni fantasma mentre
 // prepariamo la colonna successiva.
 spegniMatrice();

 // Per ogni riga controlla il bit
 // corrispondente nel buffer.
 for (int riga = 0; riga < 8; riga++) {

 bool acceso = bitRead(schermo[col], 7 - riga);

 digitalWrite(righe[riga], acceso ? HIGH : LOW);
 }

 // Nel cablaggio la colonna selezionata
 // viene portata LOW.
 digitalWrite(colonne[col], LOW);

 // Tempo molto breve per la persistenza visiva
 delayMicroseconds(800);
 }
 }

 spegniMatrice();
}

// ----------------------------------------------------------
// Converte una bitmap descritta per righe
// in otto colonne da inserire nel buffer.
// ----------------------------------------------------------
void caricaCarattere(const byte carattere[8]) {

 // Pulisce lo schermo
 for (int c = 0; c < 8; c++) {
 schermo[c] = 0;
 }

 // Legge riga e colonna del carattere
 for (int r = 0; r < 8; r++) {

 for (int c = 0; c < 8; c++) {

 // Controlla il bit della bitmap
 if (bitRead(carattere[r], 7 - c)) {

 // Inserisce il pixel nella colonna
 bitSet(schermo[c], 7 - r);
 }
 }
 }
}

// ----------------------------------------------------------
// Mostra un carattere fermo.
// ----------------------------------------------------------
void mostraCarattere(const byte carattere[8], int durata) {

 caricaCarattere(carattere);
 refreshMatrice(durata);
}

// ----------------------------------------------------------
// Fa entrare un carattere da destra.
// La nuova colonna viene aggiunta e tutto il buffer
// viene spostato verso sinistra.
// ----------------------------------------------------------
void scorriCarattere(const byte carattere[8]) {

 byte colonneCarattere[8] = {0,0,0,0,0,0,0,0};

 // Converte la bitmap in colonne
 for (int r = 0; r < 8; r++) {

 for (int c = 0; c < 8; c++) {

 if (bitRead(carattere[r], 7 - c)) {
 bitSet(colonneCarattere[c], 7 - r);
 }
 }
 }

 // Inserisce una colonna alla volta da destra
 for (int nuova = 0; nuova < 8; nuova++) {

 // Sposta tutte le colonne verso sinistra
 for (int c = 0; c < 7; c++) {
 schermo[c] = schermo[c + 1];
 }

 // Inserisce a destra la nuova colonna
 schermo[7] = colonneCarattere[nuova];

 // Mantiene visibile questa posizione
 // per creare l'effetto di movimento.
 refreshMatrice(90);
 }

 // Aggiunge una colonna vuota come spazio
 for (int c = 0; c < 7; c++) {
 schermo[c] = schermo[c + 1];
 }

 schermo[7] = 0;
 refreshMatrice(90);
}

void setup() {

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

 spegniMatrice();
}

void loop() {

 // Lo sketch scorre la parola "Rimini".
 scorriCarattere(carR);
 scorriCarattere(carI);
 scorriCarattere(carM);
 scorriCarattere(carI);
 scorriCarattere(carN);
 scorriCarattere(carI);

 // Fa uscire completamente il testo
 // aggiungendo otto colonne vuote.
 for (int i = 0; i < 8; i++) {

 for (int c = 0; c < 7; c++) {
 schermo[c] = schermo[c + 1];
 }

 schermo[7] = 0;
 refreshMatrice(90);
 }

 delay(500);
}

const byte cuore[8] = {
 B00000000,
 B01100110,
 B11111111,
 B11111111,
 B01111110,
 B00111100,
 B00011000,
 B00000000
};