La WeMos Matrix 8×8 shield è una delle shields che puoi utilizzare con la WeMos D1 mini e compatibili.

Ho voluto continuare con un articolo su schede WeMos per continuità con gli articoli di questi ultimi tempi.

La scelta della matrice 8×8 è nata in quanto ci sono pochi articoli e tutorial dedicati alla matrice 8×8 per WeMos D1.

Potrai trovare molti articoli e tutorial dedicati ai display OLED e WeMos oppure dedicati alle matrici 8×8 controllate dal MAX7219 mentre la WeMos Matrix 8×8 utilizza il controller TM1640 come puoi vedere nello schema.

Ovviamente siamo ancora in tema festivo per cui anche questo articolo mantiene vivo il tema ed essendo da pochi giorni iniziato il nuovo anno …

La shield WeMos Matrix 8×8

La shield è ben descritta e dettagliata sul sito del produttore che ti rilascia anche:

• lo schema elettronico
• la libreria per utilizzarla
• gli esempi base di controllo

Nonostante il materiale presente online, che ho trovato, è limitato.

Il primo esperimento, dopo aver testato gli esempi base della libreria al fine di verificare il funzionamento della shield, sono dedicati ad un augurio:

BUON 2018 !!!

Sketch WeMos Matrix 8×8

Lo scopo del progetto è testare la WeMos Matrix 8×8 shield con le librerie rilasciate dal produttore.

Uno degli aspetti che risontrerai da subito è la mancanza di metodi adatti a scrivere del testo, anche una sola lettera, con questa matrice:

/*******************************************
 * Buon 2018 !!! - sketch for WeMos
 *
 * Created: 03/01/2018
 * Author:  Mauro Alfieri
 *
 * Based on:
 * https://github.com/wemos/WEMOS_Matrix_LED_Shield_Arduino_Library
 * 
 *******************************************/
 
#include <WEMOS_Matrix_LED.h>
MLED mled(5); //set intensity=5

byte clear_Char[8] = {
  0b00000000,
  0b00000000,
  0b00000000,
  0b00000000,
  0b00000000,
  0b00000000,
  0b00000000,
  0b00000000
};

byte B_Char[8] = {
  0b01111100,
  0b01000010,
  0b01000010,
  0b01000010,
  0b01111100,
  0b01000010,
  0b01000010,
  0b01111100
};

byte u_Char[8] = {
  0b00000000,
  0b00000000,
  0b01000100,
  0b01000100,
  0b01000100,
  0b01000100,
  0b01000100,
  0b00111000
};

byte o_Char[8] = {
  0b00000000,
  0b00000000,
  0b00111000,
  0b01000100,
  0b01000100,
  0b01000100,
  0b01000100,
  0b00111000
};

byte n_Char[8] = {
  0b00000000,
  0b00000000,
  0b00000000,
  0b00111000,
  0b01000100,
  0b01000100,
  0b01000100,
  0b01000100
};

byte two_Char[8] = {
  0b00111100,
  0b01000010,
  0b00000010,
  0b00000100,
  0b00001000,
  0b00010000,
  0b00100000,
  0b01111110
};

byte zero_Char[8] = {
  0b00111100,
  0b01000010,
  0b01000010,
  0b01000010,
  0b01000010,
  0b01000010,
  0b01000010,
  0b00111100
};

byte one_Char[8] = {
  0b00001000,
  0b00011000,
  0b00101000,
  0b00001000,
  0b00001000,
  0b00001000,
  0b00001000,
  0b00111100
};

byte eight_Char[8] = {
  0b000111100,
  0b001000010,
  0b001000010,
  0b000111100,
  0b001000010,
  0b001000010,
  0b001000010,
  0b000111100
};

byte excl_Char[8] = {
  0b01010100,
  0b01010100,
  0b01010100,
  0b01010100,
  0b01010100,
  0b01010100,
  0b00000000,
  0b01010100
};

#define TIME 500

void setup() { }

void loop() {
  drawChar(B_Char);     delay(TIME);
  drawChar(u_Char);     delay(TIME); 
  drawChar(o_Char);     delay(TIME); 
  drawChar(n_Char);     delay(TIME);
  drawChar(clear_Char); delay(TIME);
  drawChar(two_Char);   delay(TIME);
  drawChar(zero_Char);  delay(TIME);
  drawChar(one_Char);   delay(TIME);
  drawChar(eight_Char); delay(TIME);
  drawChar(excl_Char);  delay(TIME);
  drawChar(clear_Char); delay(TIME);
}

void drawChar(byte character[8]) {
  for(int y=7;y>=0;y--) {
  for (int x=0; x <= 7; x++) { 
    if (character[(7-y)] & (B10000000 >> x)) {
     mled.dot(x,y); // draw dot
    } else {
     mled.dot(x,y,0);//clear dot
    }
  }
  mled.display();  
  }
}

questo sketch provvede a darti un esempio di scrittura di alcuni caratteri sul display che puoi realizzare utilizzando questo utile sito per disegnare sulle matrici 8×8 e trasformando ogni carattere nel formato binario indicato nelle linee 15-123.

Inizia dalla linea 12: includi la libreria per WeMos Matrix 8×8;

linea 13: inizializza l’istanza mled passando alla matrice l’intesità di luminosità 5, puoi decidere da 0 a 7;

linee 26-35: è la definizione della lettera B, osservando l’immagine sopra avrai notato che per ogni linea di 8 valori sono presenti i valori 0 = led spento e 1 = led acceso;

linea 125: definisci TIME, che userai come tempo di refresh;

linea 127: definisci la funzione setup() che come sai è necessaria, deve esserci anche se vuota, come adesso;

linea 130: chiama la funzione drawChar passandogli la lettera B, che vuoi visualizzare, ed attendi un tempo di refresh delay definito alla linea 125;

linee 131-140: invia in sequenza delle altre lettere del testo;

linea 143: definisci la funzione drawChar che si occupa della visualizzazione della lettera trasmessa sulla matrice 8×8;

linea 144: crea un ciclo dalla linea 7 alla 0 decrementando le linee da visualizzare sul display. Considera che il display, come puoi vedere nelle foro sopra, ha la posizione 0,0 in lasso a sinistra e 0,7 come primo led in alto a sinistra. Per questo motivo devi partire dalla linea 7 per iniziare a scrivere sulla linea più in alto;

linea 145: iniziando dalla posizione 0 alla 8 andando da sinistra a destra crea un cilo che incrementi di una posizione alla volta;

linea 146: è il cuore dello sketch. Confronta in & il valore binario della riga (7-y), ossia la prima della matrice-lettara, con il valore binario B10000000 shiftato della posizione x che in un primo momento vale 0 quindi il risultato della seconda operazione è esattamente B10000000 che in & con la prima linea della “B” restituisce 0, alla posizione x=1 il confronto avviene con B01000000 ed il valore di AND bitwise con la prima linea restituisce 1, ecc..

linea 147: se il risultato della linea 146 è 1 accendi il led in posizione x,y con il metodo dot della libreria;

linea 149: se il risultato della linea 146 è 0 spegni il led in posizione x,y con il metodo dot della libreria, passandogli come terzo valore 0;

In questo modo scorri tutta la linea accendendo e spegnendo i led corrispondenti a 1 e 0;

linea 152: con il metodo display invii alla matrice il risultato della linea;

Il sistema di visualizzazione della lettera si basa sulla persistenza dell’accensione del led fino al suo successivo spegnimento e scorrendo la matrice della riga 0 alla 7.

Ecco il risultato: