Mise en oeuvre du module MAX7219 (matrice de leds) avec une carte arduino (présentation du module, présentation succincte de la programmation sous Arduino, exemples de code)

Sommaire

1) Présentation du module

2) Présentation succincte de la programmation Arduino

3) Programmation du module avec exemples de code

4) Conclusion

1) Présentation du module

Le module MAX7219 est un afficheur qui comporte 8 lignes et 8 colonnes de leds que l’on peut contrôler individuellement.

Il permet d’afficher des caractères alphabétiques, numériques et spéciaux grâce aux 64 leds qui le compose.

La brillance des leds peut aussi être ajusté.

Le module est fourni en kit simple à souder.

Pour contrôler un ou plusieurs afficheurs, il suffit de 3 fils de commandes et 2 fils d’alimentation.

Du module à l’Arduino :

GND -> GND

VCC -> 5V

DIN -> PIN 8

CS -> PIN 9

CLK -> PIN 10

Montage de la matrice de leds

Aucune librairie spécifique n’est nécessaire pour la programmation du module.

2) Présentation succincte de la programmation Arduino

Pour pouvoir programmer sur une carte Arduino, il faudra télécharger l’IDE qui nous permettra d’écrire du code et de le téléverser dans la carte. L’IDE fonctionne avec Windows, Mac OS X et Linux.

Pour télécharger l’IDE Arduino vous pouvez vous rendre sur le site officiel et le télécharger à l’adresse suivante : https://www.arduino.cc/en/Main/Software

Une fois que vous l’avez téléchargé démarrer-le, la fenêtre de code suivante va apparaître.

Fenêtre avec du code au démarrage de l'IDE

1. Dans la barre supérieur nous avons un bouton qui nous permettra de valider notre programme (détecter des erreurs).

2. Un autre bouton pour pouvoir téléverser le code que l’on aura écrit dans la carte Arduino.

3. Un bouton pour créer un nouveau fichier.

4. Un bouton pour ouvrir un fichier.

5. Un bouton pour enregistrer le fichier en cours d’édition.

6. Un bouton pour ouvrir le moniteur de série.

7. Dans le code par défaut nous avons deux fonctions qui nous permettront de diviser notre code en deux parties.

La fonction « setup() » va nous permettre d’écrire du code qui n’aura besoin d’être exécuté qu’une fois, c’est une fonction d’initialisation. On y initialisera nos variables, constantes, etc...

Après la fonction « setup() » vient la fonction « loop() » qui comme son nom l’indique est une boucle, on va donc y écrire le contenu du programme.

Ces deux fonctions sont obligatoires même si elles ne contiennent aucun code.

Pour information le langage Arduino est très proche du C, il est donc typé. On retrouve donc les types de variables tels que : int, long, char, float, double.

8. Le débogueur est important pour nous aider à corriger les erreurs dans notre programme.

Exemple de code pour une led en Arduino :

Voici un petit exemple de code pour bien comprendre comment se découpe un programme Arduino.

Montage :

Montage d'une led avec la carte Arduino

 

Dans le montage ci-dessus, on relie la résistance à la PIN 2 de la carte Arduino et à l’anode (+) de la led puis on relie la cathode (-) à la pin GND de la carte.

Code :

// On défini la broche 2 de la carte

const int ma_led = 2;

// Ici c’est notre fonction d’initilisation

void setup() {

    // On dit que la broche 2 est une sortie

    pinMode(ma_led, OUTPUT);

}

// Et ici c’est notre fonction principale qui est une boucle

void loop() {

     // On écrit en sortie l’état HIGH

     digitalWrite(ma_led, HIGH);

     // On attends 1 seconde

     delay(1000);

     // On écrit en sortie l’état LOW

     digitalWrite(ma_led, LOW);

     delay(1000);

}

Dans le code ci-dessus on défini en constante « ma_led » qui correspondra à la PIN 2 de la carte, ensuite dans notre fonction « setup() » on initialise « ma_led » en sortie avec « pinMode() ». Dans notre fonction « loop() », on écrit en sortie l’état « HIGH » qui correspond au voltage grâce à « digitalWrite() », on attends 1 seconde avec « delay() » et on écrit en sortie l’état « LOW » puis on attends encore 1 seconde.

Cliquez sur le bouton « téléverser » et voyez le résultat, la led clignote !

Maintenant que cette présentation de la programmation Arduino est terminée, nous allons voir quelques exemples détaillés avec la matrice de leds.

3) Programmation du module avec exemples de code

Bien que ce module ne nécessite pas de bibliothèque spécifique, nous allons utiliser la bibliothèque « LedControl » pour les exemples qui vont suivre, elle nous permettra de programmer le module beaucoup plus facilement.

Pour télécharger « LedControl » vous pouvez suivre la marche suivante dans l’IDE Arduino :

Croquis -> Inclure une bibliothèque -> Gérer les bibliothèques.

Dans le gestionnaire de bibliothèques qui vient de s’ouvrir tapez dans la barre de recherche le nom du module et chercher dans les résultats affichés « LedControl » et cliquez sur installer.

une deuxième solution consiste à vous rendre à suivre ce lien pour télécharger le fichier .zip :

https://github.com/wayoda/LedControl/archive/master.zip

Une fois le fichier .zip télécharger il vous suffit de le dé-zipper dans le dossier « libraries » qui se trouve dans le dossier d’installation de l’IDE Arduino, enfin redémarrez l’IDE. Maintenant pour inclure la bibliothèque dans notre programme, il suffira d’écrire « #include "LedControl.h" ».

Il y a trois fonctions très utiles dans cette bibliothèque qui sont : « setLed() » pour contrôler une seule led, « setRow() » pour contrôler une ligne et « setColumn() » pour contrôler une colonne.

Les paramètres de chaque fonctions sont les suivants :

- setLed(adresse, ligne, colonne, état)

- setRow(adresse, ligne, valeur)

- setColumn(adresse, colonne, valeur)

À noter que le paramètre « adresse » correspond au nombre de matrices connectés, par exemple si il n’y en a qu’une l’adresse sera zéro.

Pour ce premier exemple nous allons voir comment dessiner un smiley sur notre matrice de leds.

Mais avant voyons comment on dessine sur notre matrice de leds.

Schéma smiley

 

L’exemple ci-dessus représente la matrice de leds sur laquelle est dessiné notre smiley, les leds éteintes auront comme valeur un 0, à l’inverse celles qui sont allumées auront comme valeur un 1.

Ce qui nous donnera pour la première ligne :

00111100

Simple, non ?

Et pour les lignes suivantes :

01000010

10100101

10000001

10100101

10011001

01000010

00111100

Code smiley – 1ère partie :

#include "LedControl.h"

#include "binary.h"

/*

* DIN est connecté à la PIN 8

* CLK est connecté à la PIN 10

* CS est connecté à la PIN 9

*/

LedControl lc = LedControl(8, 10, 9, 1);

byte smiley[8] = {

    B00111100,

    B01000010,

    B10100101,

    B10000001,

    B10100101,

    B10011001,

    B01000010,

    B00111100

};

Dans le code ci-dessus on commence par inclure les bibliothèques « LedControl » et « binary » puis on crée une variable de type « LedControl », les valeurs passées en paramètres dépendent du numéro des PINS connectés, le dernier paramètre dépend du nombre de matrice que nous avons en l’occurrence ici nous n’en n’avons qu’un.

Ensuite on crée un tableau de type « byte » et de taille 8, ce tableau contiendra chacune des lignes de notre dessin.

Code smiley – 2ème partie :

void draw() {

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

        lc.setRow(0, i, smiley[i]);

    }

}

void setup() {

    // Pour allumer le module

    lc.shutdown(0, false);

    // On entre une luminosité

    lc.setIntensity(0,8);

    // On efface l'affichage

    lc.clearDisplay(0);

}

void loop() {

    draw();

}

On crée une fonction « draw() » qui contient une boucle « for » dans laquelle on appelle la fonction « setRow() » pour dessiner nos lignes une par une.

Dans la fonction « setup() » on « réveille » le module (car au démarrage il est en mode économie d’énergie) en mettant « shutdown() » à « false », puis on règle l’intensité de l’affichage avec « setIntensity() » et enfin on efface l’affichage avec « clearDisplay() ».

Pour finir dans notre fonction « loop() » on appelle la fonction « draw() ».

Il ne vous reste plus qu’à téléverser votre code et voila nous avons dessiné un magnifique smiley avec une faciliter déconcertante grâce à la bibliothèque LedControl.

Dans l’exemple à suivre nous allons faire un chenillard qui donnera l’impression que la matrice se rempli de lumière puis se vide.

Code chenillard – 1ère partie :

#include "LedControl.h"

LedControl lc = LedControl(8, 10, 9, 1);

void setup() {

    // Pour allumer le module

    lc.shutdown(0, false);

    // On entre une luminosité

    lc.setIntensity(0,8);

    // On efface l'affichage

    lc.clearDisplay(0);

}

Dans cette première partie de code rien de bien nouveau, on notre variable de type « LedControl », on y passe les paramètres selon les PINS qui ont été connectées et le nombre de matrice connecté.

La boucle « setup() » est exactement la même que dans l’exemple précédent.

Code chenillard – 2ème partie :

void loop() {

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

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

            lc.setLed(0, colonne, ligne, true); // On allume la led qui correspond à la ligne et à la colonne

            delay(50);

        }

    }

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

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

           lc.setLed(0, colonne, ligne, false); // Cette fois ci on éteint la led

            delay(50);

        }

    }

}

Dans la boucle « loop() », il y a une première boucle pour parcourir les lignes et une autre imbriquée dans la première pour parcourir les colonnes, dans cette boucle on utilise la fonction « setLed() », pour rappel cette fonction prend en paramètre l’adresse qui correspond au nombre de matrice connectée, la colonne, la ligne et l’état que l’on met à « true » pour allumer la led. Pour finir on mais une petite pause avec la fonction « delay() ».

Les deux boucles suivantes sont identiques aux premières sauf qu’ici on éteint la led en changeant le quatrième paramètre de la fonction « setLed() » à « false ».

Dans le prochaine exemple nous allons voir comment écrire le fameux « Hello World! » en affichant les caractères un par un.

Code Hello World ! - 1ère partie

#include "LedControl.h"

#include "binary.h"

LedControl lc = LedControl(8, 10, 9, 1);

byte letters[8][8] = {

{

B00000000,

B00100100,

B00100100,

B00111100,

B00100100,

B00100100,

B00100100,

B00000000

}, // H

{

B00000000,

B00000000,

B00011000,

B00100100,

B00111100,

B00100000,

B00011100,

B00000000

}, // e

{

B00000000,

B00000000,

B00010000,

B00010000,

B00010000,

B00010000,

B00001100,

B00000000

}, // l

{

B00000000,

B00000000,

B00011000,

B00100100,

B00100100,

B00100100,

B00011000,

B00000000

}, // o

{

B00000000,

B00100010,

B00100010,

B00100010,

B00101010,

B00101010,

B00010100,

B00000000

}, // W

{

B00000000,

B00000000,

B00011100,

B00100000,

B00100000,

B00100000,

B00100000,

B00000000

}, // r

{

B00000000,

B00000000,

B00000100,

B00000100,

B00011100,

B00100100,

B00011100,

B00000000

}, // d

{

B00000000,

B00001000,

B00001000,

B00001000,

B00001000,

B00000000,

B00001000,

B00000000

} // !

};

Dans ce code on crée une variable de type « LedControl » avec toujours les même paramètres que pour les exemples précédents, ensuite on crée un tableau de type « byte » qui contiendra tous les caractères qui seront nécessaire à l’écriture de notre texte.

Code Hello World ! - 2ème partie :

void draw() {

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

        lc.setRow(0, i, letters[0][i]); // Dessine H

    }

    delay(100);

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

        lc.setRow(0, i, letters[1][i]); // Dessine e

    }

    delay(100);

    for (int j = 0; j < 2; j++) {

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

            lc.setRow(0, i, letters[2][i]); // Dessine les deux l

        }

    }

    delay(100);

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

        lc.setRow(0, i, letters[3][i]); // Dessine o

    }

    delay(100);

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

        lc.setRow(0, i, letters[4][i]); // Dessine W

    }

    delay(100);

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

        lc.setRow(0, i, letters[3][i]); // Dessine o

    }

    delay(100);

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

        lc.setRow(0, i, letters[5][i]); // Dessine r

    }

    delay(100);

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

        lc.setRow(0, i, letters[2][i]); // Dessine l

    }

    delay(100);   

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

        lc.setRow(0, i, letters[6][i]); // Dessine d

    }

    delay(100);

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

        lc.setRow(0, i, letters[7][i]); // Dessine !

    }

    delay(100);

}

Dans notre fonction « draw() » on crée une boucle « for » pour chacun de nos caractères en utilisant la fonction « setRow() » en précisant bien l’index de notre tableau à deux dimensions et à chaque fin de boucle, on fait une pause avec la fonction « delay() ».

Code Hello World ! - 3ème partie :

void setup() {

    // Pour allumer le module

    lc.shutdown(0, false);

    // On entre une luminosité

    lc.setIntensity(0,8);

    // On efface l'affichage

    lc.clearDisplay(0);

}

void loop() {

    draw();

}

Dans cette dernière partie la fonction « setup() » et la fonction « loop() » reste les même que pour l’exemple précédent.

4) Conclusion

Il est assez facile de programmer le module MAX7219 car car bien que l’on puisse en utiliser pour nous faciliter la tâche, il ne nécessite aucune bibliothèque spécifique pour être utilisé.

Dans cette article nous avons vu comme utiliser une des bibliothèque « LedControl » qui nous permet de simplifier et d’alléger le code nécessaire à la programmation du module.

Nous avons aussi vu comment dessiner sur la matrice de leds en insérant dans un tableau de bytes des données en binaire qui permettent de déterminer si une led est allumé ou non.

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *