Matrice LED MAX7219

Matrice LED et module Max 7219
Matrice LED et module Max 7219

Dans ce post nous allons connaître le module matrice led de 8 x 8 contrôlé par le circuit intégré Max 7219. La combinaison de ces deux dispositifs nous permettra de montrer des nombres, des caractères ou même des dessins et animations.

Qu’est-ce une matrice led? Il s’agit d’un display composé par multiples diodes distribuées de façon rectangulaire. La matrice plus commune est celle de 8 x 8 et elle peut se combiner avec d’autres pour former de matrices plus complexes et de différentes mesures. On peut la contrôler à travers de ses 16 broches, mais, normalement, elle est accompagnée d’un contrôleur intégré, le Max 7219, qui facilite la connexion entre Arduino et la matrice (réduisant les broches à 5).

Schéma de la matrice led 8x8  de cathode commune.

Sur l’image on peut observer que les cathodes des diodes que conforment une ligne sont connectées entre elles; de la même manière que les anodes sont connectées entre elles aussi et par colonnes. Pour connecter une diode déterminée comme la première de l’angle supérieur gauche, on doit lui envoyer un signal Low sur la ligne 1 et un High sur la colonne 1. Si on veut allumer la led numéro 5 de la première ligne, alors on envoie le signal Low sur la file1, mais High sur la colonne 5.

Pour que le contrôle de la matrice soit plus simple, on utilise le circuit intégré Max 7219. La communication avec ce dispositif se réalise à travers de SPI, alors on aura besoin seulement de 3 pins d’ Arduino.

Contrôleur de matrice LED Max 7219. Détail des broches.

Connexion avec Arduino

On reliera le pin VCC au pin 5V de la carte, le pin GND au GND d’ Arduino, le pin DIN au pin 11 de la carte, CLK au pin 13 et CS au pin 10 de notre carte:

Schéma des connexions entre la carte Arduino et le module matrice Max 7219

Exemple 1:

Avec ce premier exemple nous allons allumer et éteindre chaque led de la matrice de façon successive.

#include "LedControl.h"
LedControl matriceLed=LedControl(11,13,10,1);

D’abord, on inclut la bibliothèque LedControl.h qui va gérer le contrôle de la marice et on crée un objet du type LedControl nomée matriceLed, en configurant les paramètres suivants:

Ledcontrol( DIN, CLK, CS, nº de matrices)

Dans la fonction setup():

void setup() {
  matriceLed.shutdown(0,false);
  matriceLed.setIntensity(0,4);
  matriceLed.clearDisplay(0);
}

On utilise le mandat shutdown() pour indiquer qu’on active la matrice. Il comporte deux paramètres: le numéro du dispositif (de 0 à 7, zéro indique un dispositif, pour quatre dispositifs on indiquera 3) et son état (true ou false; nous indiquons false: allumé).

shutdown( nº du dispositif, état)

La fonction setIntensity() configure le niveau d’intensité de la diode. Elle demande deux paramètres: le nº du dispositif et l’intensité (entre 0 et 5).

setIntensity(nº du dispositif, intensité)

Le mandat clearDisplay() éteint toutes les diodes de la matrice. On lui indique uniquement le numéro du dispositif comme paramètre principal.

clearDisplay(nº du dispositif)

Dans la fonction loop() nous avons deux boucles for() imbriqués qui vont parcourir les lignes et les colonnes de la matrice.

void loop(){
  for(int ligne = 0; ligne < 8; ligne++) {
    for(int colonne = 0; colonne < 8; colonne++) {
      matriceLed.setLed(0,ligne,colonne,true);
      delay(100);
      matriceLed.setLed(0,ligne,colonne,false);
      delay(100);
    }
  }
}

La fonction setLed() va se charger de nous indiquer si la led de la file et de la colonne correspondante est allumée ou éteinte. Cette fonction a quatre paramètres: le numéro du dispositif, la ligne, la colonne et si elle est allumée (true) ou éteinte (false).

setLed(nº dispositif, ligne, colonne, valeur)

Code complet:

#include "LedControl.h"
LedControl matriceLed=LedControl(11,13,10,1);

void setup() {
  Serial.begin(9600);
  matriceLed.shutdown(0,false);
  matriceLed.setIntensity(0,4);
  matriceLed.clearDisplay(0);
}

void loop(){
  for(int ligne = 0; ligne < 8; ligne++) {
    Serial.print(ligne);
    Serial.println("------");
    for(int colonne = 0; colonne < 8; colonne++) {
      Serial.println(colonne);
      matriceLed.setLed(0,ligne,colonne,true);
      delay(100);
      matriceLed.setLed(0,ligne,colonne,false);
      delay(100);
    }
  }
}

Exemple 2:

Nous allons visualisé les nombres du zéro au neuf sur notre matrice. Mais avant tout, on réalise un croquis afin de prévoir comment on vera nos chiffres:

Sur l’image ci dessus, ils sont représentés le 0 et le 1 sur une matrice de 8×8. À droite du zéro on peut découvrir un array de huit éléments constitué de zéros (cases vides) et d’uns (cases pleines). Il existe la possibilité d’indiquer au compilateur d’ Arduino qui nous montre le nombre en binaire mettant un B devant de chaque file. Cela simplifie énormément le travail puisque on peut visualisé la matrice comme on le souhaite. Pour montrer, par exemple, l’ array du zéro:

byte zero[8]= {
  B00111000,
  B01000100,
  B01000100,
  B01000100,
  B01000100,
  B01000100,
  B01000100,
  B00111000
}

Code:

#include "LedControl.h"

LedControl lc=LedControl(11,13,10,1);

#define attente 1000

byte zero[8]= {B00111000,B01000100,B01000100,B01000100,B01000100,B01000100,B01000100,B00111000};
byte un[8]= {B00010000,B00110000,B00010000,B00010000,B00010000,B00010000,B00010000,B00111000};
byte deux[8]= {B00111000,B01000100,B00000100,B00000100,B00001000,B00010000,B00100000,B01111100};
byte trois[8]= {B00111000,B01000100,B00000100,B00011000,B00000100,B00000100,B01000100,B00111000};
byte quatre[8]= {B00001000,B00011000,B00101000,B01001000,B01001000,B01111100,B00001000,B00001000};
byte cinq[8]= {B01111100,B01000000,B01000000,B01111000,B00000100,B00000100,B01000100,B00111000};
byte six[8]= {B00111000,B01000100,B01000000,B01111000,B01000100,B01000100,B01000100,B00111000};
byte sept[8]= {B01111100,B00000100,B00000100,B00001000,B00010000,B00100000,B00100000,B00100000};
byte huit[8]= {B00111000,B01000100,B01000100,B00111000,B01000100,B01000100,B01000100,B00111000};
byte neuf[8]= {B00111000,B01000100,B01000100,B01000100,B00111100,B00000100,B01000100,B00111000};

void setup() {
  lc.shutdown(0,false);
  lc.setIntensity(0,4);
  lc.clearDisplay(0);
}

void loop(){
  montrer(zero);
  delay(attente);
  montrer(un);
  delay(attente);
  montrer(deux);
  delay(attente);
  montrer(trois);
  delay(attente);
  montrer(quatre);
  delay(attente);
  montrer(cinq);
  delay(attente);
  montrer(six);
  delay(attente);
  montrer(sept);
  delay(attente);
  montrer(huit);
  delay(attente);
  montrer(neuf);
  delay(attente);
}

void montrer(byte numero[]){
  for (int i = 0; i < 8; i++){
    lc.setRow(0,i,numero[i]);
  }
}

setRow() est une nouvelle fonction qui va nous montrer les caractères. Elle se trouve dans la boucle du mandat montrer(). Elle a besoin de configurer trois paramètres: le numéro du dispositif, la ligne et une valeur de 8 bits (qui correspond a un séquence de zéros et de uns pour chaque ligne, afin de former le chiffre que nous voulons).

setRow( nº dispositif, ligne, valeur)

Articles similaires
Laisser un commentaire