Perfectionnez-Vous Dans La Programmation Arduino: Concevez Des Matrices de Led

05/08/2016 OpenClassrooms
Concevez des matrices de LED
Bienvenue sur OpenClassrooms ! En poursuivant votre navigation, vous acceptez l'utilisation de cookies. En savoir OK
plus
  
Accueil Cours Perfectionnez-vous dans la programmation Arduino Concevez des matrices de LED
Perfectionnez-vous dans la programmation Arduino

   20 heures
  Moyenne Licence   
 
CONCEVEZ DES MATRICES DE LED
Une interface homme/machine, je le rappelle, est un moyen de communiquer avec votre Arduino. Nous venons de voir
l'utilisation du moniteur. Très pratique et qui permet d'échanger de façon assez complexe.
L'inconvénient de ce type de communication, c'est qu'il n'est pas "embarqué" c'est-à-dire qu'il vous faut garder une
connexion avec l'ordinateur. Ce chapitre est là pour vous montrer un moyen d'a icher des informations, plus ou moins
complexes sans connexion avec un ordinateur, donc embarqué avec sur le robot.
Vous allez apprendre dans ce chapitre à concevoir une matrice de LED, une matrice de LED, c'est-à-dire un réseau de LED
connectées dans une configuration souvent carrée ou rectangulaire. Donc vous allez en comprendre le principe, le
montage, la programmation. Ces matrices peuvent servir à la fois d'a ichage pour lire des informations, comme de réseaux
de lumières pour décorer et animer vos montages.
 Pour suivre ce chapitre, il vous faut prévoir 9 LED et trois résistances 220Ω.
Il s'agit donc d'une interface d'a ichage, comme l'écran de votre ordinateur mais en simplifié et plus petit pour pouvoir
être embarqué.
Qu'est-ce qu'une matrice de LED ?


Vous avez appris dans le cours d'initiation à piloter des LED grâce au pins numériques de l'Arduino.
C'est assez simple, et si vous ajoutez vos connaissances sur l'utilisation de la mesure du temps qui passe, vous pouvez
réaliser des a ichages assez complets.
Le problème est que le nombre de LED que vous pouvez piloter est limité. En e et, si vous utilisez tous les pins numériques
(14) plus les pins analogiques en mode numériques (6), vous piloterez au mieux 20 LED.
 C'est déjà pas mal non ?

https://openclassrooms.com/courses/perfectionnezvousdanslaprogrammationarduino/concevezdesmatricesdeled 1/13
05/08/2016 OpenClassrooms Concevez des matrices de LED
Oui, mais du coup votre Arduino ne peut pas faire autre chose (ne serait-ce qu'a icher des infos sur la console série, capter
des infos par un CAN, recevoir l'état d'un bouton poussoir...).
Et bien la matrice de LED vous permet de piloter un nombre plus important de LED avec bien moins de sorties.
Voici un exemple de matrice de 4x4 LED :
Une représentation simplifiée de matrice de LED 4x4
Cet exemple montre une matrice organisée en carré : 4 lignes, 4 colonnes. Donc 16 LED.
Et bien, comme vous allez le voir plus loin, on peut commander ces 16 LED avec seulement 8 pins (1 par ligne et 1 par
colonne). On peut assez facilement calculer le nombre de pins et le nombre de LED pilotables avec les formules suivantes :
nombre de pins = nombreDeLignes + nombreDeColonnes
nombre de LED pilotables = nombreDeLignes x nombreDeColonnes
On voit clairement sur le tableau suivant qu'à partir de 9 LED, le réseau devient intéressant pour des matrices disposées en
carré :
Nombre de LED à piloter Nombre de pins nécessaires
1 2
4 4
9 6
16 8
25 10
J'ai pris ici des nombres qui correspondent à des matrices carrées (nombreDeLignes=nombreDeColonnes).
Mais si on prend l'exemple des premières matrices de caractères, elles s'a ichaient sur des matrices de 5 x 7 pixels (donc
5x7 LED pour nous). Il faudrait donc 7+5=12 pins de pilotage pour un total de 7x5=35 LED.
Ce chapitre va vous montrer le pilotage d'une matrice de 3 x 3. Donc 9 LED et 6 pins pour le pilotage.
Le principe est ensuite le même pour les matrices plus importantes !
Montez une matrice de 3x3 LED en carré


Avant d'aborder le fonctionnement et la programmation d'une matrice, vous devez d'abord voir le schéma de connexion de
ces LED pour former un réseau. Je donne un schéma avec les numéros de pins qu'on utilisera pour programmer ce réseau :
Schéma d'un réseau de 3x3 LED
Vous pouvez remarquer la disposition et le branchement :
Les LED sont connectées par lignes de trois ensembles.

Les LED sont connectées par colonne de trois ensembles.
Chaque LED appartient à une paire ligne/colonne unique.
On voit que trois résistances sont placées à l'entrée des lignes (pour protéger les LED).
Le courant qui peut allumer une LED va circuler d'une ligne vers une colonne.
 Mais comment fait-on pour allumer une LED ?

(un peu de patience Cunégonde...)
Allumez une seule LED


Pour allumer une LED, on va utiliser la capacité de l'Arduino à gérer ses sorties à l'état haut ou bas. On place donc toutes les
sorties (de 2 à 7) en mode OUTPUT .
Nous mettons ensuite toutes les sorties en position LOW : rien ne va s'allumer. En e et le courant ne circule nulle part.
Si Je positionne la sortie 2 en HIGH , le courant va circuler entre cette sortie et toutes les autres en respectant deux règles
:
Le courant ne revient pas sur une branche du circuit où il circule déjà en sens inverse.
Le courant ne peut circuler dans une LED que dans un seul sens.
Du coup en mettant le pin 2 en HIGH , on allume les trois LED en bas du schéma ! Or on ne souhaite en allumer qu'une
seule (celle en bas à gauche par exemple) !
 Donc c'est bien ma question, comment fait-on pour allumer une seule LED ?
(Tenez-vous un peu Cunégonde !)
Et bien on va ruser ! On sait depuis le cours d'initiation à l'Arduino, que le courant ne circule que s'il y a une di érence de
potentiel. Donc du HIGH vers le LOW . Mais il ne circule pas de LOW vers LOW (ça paraît évident) et ne circule pas
non plus de HIGH vers HIGH (c'est moins évident).
On va donc agir, non pas sur un seul pin (le 2) mais sur deux pins (le 2 et le 5) qui correspondent finalement au pins de
repérage pour la LED en bas à gauche. Voici donc la procédure :
On place les pins 2, 3 et 4 à LOW (on pourrait tout mettre en HIGH, mais on économise le courant).
On place les pins 5, 6, 7 à HIGH (rien ne s'allume car le courant ne peut pas traverser une LED dans le mauvais sens).
On place le pin 2 à HIGH (rien ne se passe encore car pas de circulation de HIGH vers HIGH).
On place le pin 5 à LOW (le courant passe du pin 2 vers le pin 5, ce qui allume la diode en bas à gauche).
Pour éteindre, on place le pin 2 à LOW et le pin 5 à HIGH (pour préparer l'éventuel allumage d'une autre LED).
Voici donc le programme qui permet de faire clignoter la LED en bas à gauche du montage :
c_cpp
1 /*
2 * Matrice de LED 3 lignes, 3 colonnes
3 * pin 2 = ligne 0, pin 3 = ligne 1, pin 4 = ligne 2
4 * pin 5 = colonne 0, pin 6 = colonne 1, pin 7 = colonne 2
5 */
6
7 void setup() {
8 //initialisation des pins en OUTPUT et mise à l'état LOW
9 for (int l=2;l<8;l++){
10 pinMode(l,OUTPUT);
11 digitalWrite(l,LOW);
12 }
13 //on passe les pins de colonne à l'état HIGH
14 for (int l=5;l<8;l++){
15 digitalWrite(l,HIGH);
16 }
17 }
18
19 void loop() {
20 // on allume la LED ligne 0 colonne 0
21 digitalWrite(2,HIGH);
22 digitalWrite(5,LOW);
23 delay(500);
24 // on l'éteint
27 delay(500);
28 }
Si vous avez tout bien connecté, la diode en bas à gauche de la matrice clignote.
Petit exercice : essayer de faire clignoter la LED en bas à gauche, sans utiliser la fonction delay() , mais en utilisant les
calculs sur le temps qui passe (vu dans les chapitre précédents) à l'aide de la fonction millis() .
Retrouvez la correction de l'exercice dans la partie Annexes du cours !
 Super, et si je veux allumer deux LED ou plus ?

(Vous me courez sur le haricot Cunégonde...)
Allumez plusieurs LED

Pour allumer plusieurs LED, je ne dirai qu'un mot : persistance rétinienne !
(OUI ça fait deux mots ! Et vous Cunégonde, c'était vos derniers, silence jusqu'à la fin de ce chapitre ! Non mais, alors, je
vous jure, qui c'est le chef ici ? hein ? où en étais-je ? ha oui...)
La persistance rétinienne est une sorte d'anti-capacité de notre œil. Lorsqu'une lumière est perçue par ce dernier, l'image
(ou le point lumineux) reste un moment comme incrusté. Un court moment certes (quoique cela dépende de la durée
d'exposition de la rétine à la lumière) mais qui su it à nous berner !
Nous l'avons vu dans le cours d'initiation : une LED qui clignote trop vite est perçue comme restant allumée.
Le principe est le suivant : nous allons allumer (ou non), puis éteindre chaque LED les unes après les autres, et ce de
manière très rapide. Du coup, même si une LED reste éteinte pendant qu'on traite les autres, notre œil nous trompera et
nous verrons la LED allumée. Le flash lumineux qu'elle a produit su it à imprégner la rétine.
Nous allons donc concevoir le programme qui allume la LED en bas à gauche et celle en haut à droite :
Toutes les autres seront éteintes.

Du fait de la connexion en matrice, on ne peut allumer qu'une LED à la fois. Il faut donc l'allumer et l'éteindre
rapidement pour passer à la suivante.
Pour y voir plus clair, on va aussi créer un fonction affiche() qui gèrera l'état des pins.
Voici le code :
c_cpp
1 /*
2 * Matrice de LED 3 lignes, 3 colonnes
3 * pin 2 = ligne 0, pin 3 = ligne 1, pin 4 = ligne 2
4 * pin 5 = colonne 0, pin 6 = colonne 1, pin 7 = colonne 2
5 */
6 void setup() {
8 for (int l = 2; l < 8; l++) {
9 pinMode(l, OUTPUT);
10 digitalWrite(l, LOW);
11 }
13 for (int l = 5; l < 8; l++) {
14 digitalWrite(l, HIGH);
15 }
16 }
17
18 void loop() {
19 affiche();
20 }
21 // fonction d'affichage
22 void affiche(){
23 //allumage de la LED en bas à gauche
26 delay(2); // petit délai pour l'oeil
27 //on l'éteint
30 //allumage de la LED en haut à droite
33 delay(2); // petit délai pour l'oeil
34 //on l'éteint
37 }
38
Le delay(2) sert à la fois pour que la lumière imprime la rétine et pour laisser le temps à la LED de s'allumer. En e et, le
temps entre allumage et extinction est très court. Il faut à la LED un temps minimum pour briller correctement. Faites vos
tests (augmentez ou diminuez ce temps) pour en voir les limites.
Bon, en observant ce programme, on s'aperçoit qu'il risque d'être long de coder l'allumage de toutes les LED ! C'est la
raison pour laquelle nous allons utiliser un tableau d'état (dans notre cas de 3 sur 3 ) que nous allons parcourir très vite
pour chaque allumage/extinction. Pour allumer la LED en bas à gauche et celle en haut à droite, si l'on veut que ce soit
facile à lire pour nous, il nous faudrait déclarer un tableau comme suit :
c_cpp
1 boolean matrice[3][3]={
2 0,0,1,
3 0,0,0,
4 1,0,0
5 };
Un tableau de booléens car les états ne sont que HIGH ou LOW . Mais si l'on procède ainsi, on remarque que la LED en
bas à droite correspond à la ligne 2, colonne 0 (et non ligne 0, colonne 0). Il nous faut donc définir clairement les pins de
lignes et de colonnes ! Là encore, nous allons utiliser des tableaux :
c_cpp
1 byte ligne[3]={4,3,2};
2 byte colonne[3]={5,6,7};
Si on veut donc la LED à la ligne 2, colonne 0, (qui correspond à notre tableau précédent), on retrouve bien les pins 2 et 5
qui correspondent à notre montage.
 Dans ce genre de programmation par tableau, mieux vaut privilégier une forme de tableau lisible pour vous, et
coder pour que l'Arduino fasse correspondre au montage. Cela vous évitera bien des prises de tête.
Je vous conseille aussi de toujours tester si les repérages et les correspondances dans les tableaux sont bons.
 Vous remarquerez le type 'byte'. J'aurais pu utiliser le type 'int'. byte prend moins de place en mémoire.
Nous avons maintenant trois tableaux. Il vont fonctionner ensemble ! Nous allons parcourir le tableau matrice avec deux
variables l (ligne) et c (colonne). Ces deux variables correspondront aux positions dans chaque tableau de pins.
Il nous su ira ensuite d'allumer (ou non) en fonction de ce que le tableau matrice contient, puis d'éteindre pour passer à la
LED suivante.
Le code est finalement assez simple si on maîtrise bien les tableaux :

c_cpp
1
2 boolean matrice[3][3]={
3 0,0,1,
4 0,0,0,
5 1,0,0
6 };
7 byte ligne[3]={4,3,2};
8 byte colonne[3]={5,6,7};
9
10 void setup() {
12 for (int l = 2; l < 8; l++) {
15 }
17 for (int l = 5; l < 8; l++) {
19 }
20 }
21
22 void loop() {
23 affiche(); //appel de la fonction d'affichage
24 }
26 void affiche(){
27 for (byte l=0;l<3;l++){//on parcourt les lignes
28 for (byte c=0;c<3;c++){//puis chaque case de la ligne (colonne)
29 digitalWrite(ligne[l],matrice[l][c]); //on allume ou non en fonction du tableau matrice
30 digitalWrite(colonne[c],LOW);
31 delay(2); // attente pour l'oeil
32 digitalWrite(ligne[l],LOW); //on éteint
33 digitalWrite(colonne[c],HIGH); //et on place à l'état HIGH pour la suivante
34 }
35 }
36 }
37
Si on observe le déroulement du programme, on s'aperçoit qu'on appelle la fonction digitalWrite() même si le

tableau matrice montre un état à 0 .
De même, on fait appel 4*9=36 fois à la fonction digitalWrite() à chaque appel de la fonction affichage() .
On peut donc améliorer un peu ce programme pour gagner du temps (ce qui est primordial dans le cas d'un a ichage de
matrice).
Voici une proposition d'amélioration :

c_cpp
1
2 boolean matrice[3][3] = {
3 0, 0, 1,
4 0, 0, 0,
5 1, 0, 0
6 };
7 byte ligne[3] = {4, 3, 2};
8 byte colonne[3] = {5, 6, 7};
9
10 void setup() {
12 for (int l = 2; l < 8; l++) {
14 if (l > 1 && l < 4)
16 else
18 }
19 }
20
21 void loop() {
23 }
25 void affiche() {
26 for (byte l = 0; l < 3; l++) { //on parcourt les lignes
27 digitalWrite(ligne[l], HIGH); //on prépare la ligne à l'affichage
28 for (byte c = 0; c < 3; c++) { //on parcourt chaque case de la ligne (colonne)
29 if (matrice[l][c]) { //on teste si affichage dans matrice
30 digitalWrite(colonne[c], LOW); //on allume
31 delay(2); //avec un delai
32 digitalWrite(colonne[c], HIGH); //on éteint
33 }
34 }
35 digitalWrite(ligne[l], LOW); //on arrête la ligne
36 }
37 }
38
Le programme n'appelle la fonction digitalWrite() que 6 fois (2*par ligne) plus 2 fois par case allumée (soit 4 fois
dans notre configuration), donc un total de 10 fois pour cet exemple.
Si on voulait allumer toutes les LED, il su irait de modifier le tableau matrice, et on devrait alors appeler la fonction
digitalWrite() 6+9*2=24 fois.
 Cette di érence de nombre d'appel à la fonction digitalWrite() paraît anodin, mais elle joue sur le temps
d'exécution de la fonction affiche() qui sera plus ou moins long en fonction du nombre de diodes à a icher.
C'est à prendre en compte si vous souhaitez un a ichage précis dans le temps.
Allez, maintenant que vous avez compris le principe, nous allons tenter de modifier à nouveau ce programme pour essayer
de gagner encore un peu de temps pour l'Arduino... Je vous propose donc un exercice.
Exercice : Gérez la matrice de LED avec un tableau à simple entrée

Il s'agit en fait de ne plus parcourir un tableau à double entrée, mais un tableau de 9 cases (donc à simple entrée). Chaque
case correspond à une LED du montage. La première case étant en haut à gauche et la dernière en bas à droite.
En d’autres termes, les numéros de cases du tableau en ligne “012345678” correspondront aux états des LED dans la
matrice avec la position suivante :
LED0 LED1 LED2
LED3 LED4 LED5
LED6 LED7 LED8
Le stockage des états ne se fait plus sur un tableau de booléens, mais grâce à une chaîne de caractères du genre :
c_cpp
1 char matrice[10]="eeaeeeaee";
où "e" correspond à éteint et "a" à allumé.
 Comme c'est une déclaration de chaîne de caractères, il faut bien penser à déclarer un caractère de plus pour le
caractère NULL .
La fonction affiche() doit donc parcourir cette chaîne et ne procéder à l'allumage de la LED que si le caractère à la
position donnée est "a".
Vous garderez les tableaux ligne[] et colonne[] pour le repérage des pins.
Je vous donne tout de même deux indications d'orde mathématique :
Si "valeur" est un entier (type char ou int ) et x un autre entier, "valeur/x" donnera un entier tronqué à la valeur
inférieure (c'est la division euclidienne). Donc 7/3 donnera 2.
Si "valeur" est un entier (type char ou int ) et x un autre entier, "valeur%n" donnera le reste de la division
euclidienne. Donc 7%3 donnera 1. L'opérateur % est appelé modulo en informatique. Il est très pratique quand on
sait l'utiliser (comme d'habitude ).
 Pourquoi ces précisions ?

Ces deux opérations vont vous permettre de repérer la ligne et la colonne liées à la LED dans le tableau matrice. En e et, si
nous prenons le caractère en position 7 du tableau en ligne (cases 012345678) :
Son numéro de ligne dans la matrice de LED est 7/3=2 (car il y a 3 caractères par ligne) donc nous sommes bien sur la
dernière ligne.
Son numéro de colonne dans la matrice de LED est 7%3=1 (reste de la division par trois, donc position dans la ligne).
Il s'agit donc bien de la LED ligne d'indice 2, colonne d'indice 1, c'est-à-dire la dernière ligne et la deuxième colonne
(attention, la numérotation des tableaux commence toujours à 0 !).
Bien, ceci étant dit, à votre tour de travailler. Ça demande un petit e ort de réflexion, mais je suis sûr que vous en êtes
capables.
Je vais encore me répéter, mais il est important d'essayer de faire ce travail seul(e) avant de regarder la correction
Retrouvez la correction dans la partie Annexes du cours !
Créez des séquences d'a㐰㈱ichage

Bon, je ne vous ai pas fait faire le programme précédent par hasard.
Il est assez pratique pour gérer plusieurs états d'a ichage de votre matrice. En e et, si au lieu d'un seul tableau de matrice,
vous aviez plusieurs tableaux possibles, vous auriez à votre disposition une séquence d'a ichage (ou un jeu de caractères
).
Je vous donne donc le programme précédent modifié pour a icher une matrice di érente toutes les secondes. Ce
programme allie gestion du temps et utilisation des tableaux.
Voici le code avec une séquence qui allume chaque LED successivement en donnant l'impression qu'une lumière "dessine"
un S :
c_cpp
1 //tableau des matrices
2 char matrices[10][10] = {
3 "aeeeeeeee",
4 "eaeeeeeee",
5 "eeaeeeeee",
6 "eeeeeaeee",
7 "eeeeaeeee",
8 "eeeaeeeee",
9 "eeeeeeaee",
10 "eeeeeeeae",
11 "eeeeeeeea",
12 "eeeeaeeee"
13 };
14 byte pos = 0; //variable de position dans le tableaud des matrices
15 int vitesse=1000; // variable pour la vitesse en ms entre chaque matrice
16 char matriceAct[10]="eeeeeeeee"; //tableau de matrice en cours
17 unsigned long tpsDep = millis(); //initialisation du temps
18 byte ligne[3] = {4, 3, 2}; //stockage des pins ligne
19 byte colonne[3] = {5, 6, 7}; // stockage des pins colonne
20
21 void setup() {
22 //initialisation des pins en OUTPUT et mise à l'état LOW ou HIGH
23 for (byte l = 2; l < 8; l++) {
25 if (l > 1 && l < 4)
27 else
29 }
30 }
31
32 void loop() {
33 unsigned long tpsAct = millis();
34 if (tpsAct ‐ tpsDep > vitesse) { //teste si temps écoulé
35 copie(pos); //appel de la fonction de mise à jour de la matrice en cours
36 pos = (pos + 1) % 10; //avancée du curseur de position avec retour à zéro si au dessus de 10
37 tpsDep = tpsAct; //réinitialisation du temps
38 }
40 }
41
43 void affiche() {
44 for (byte p = 0; p < 9; p++) { //parcours du tableau matrice
45 if (matriceAct[p] == 'a') { //test si 'a'
46 //allumage
47 digitalWrite(ligne[p / 3], HIGH);
48 digitalWrite(colonne[p % 3], LOW);
49 delay(2);
50 //exctinction
51 digitalWrite(colonne[p % 3], HIGH);
52 digitalWrite(ligne[p / 3], LOW);
53 }
54 }
55 }
56
57 //fonction de copie de tableau en fonction de la position.
58 void copie(byte n) {
59 for (byte p = 0; p < 10; p++) {
60 matriceAct[p] = matrices[n][p];
61 }
62 }
63
 Vous remarquerez le code pos=(pos+1)%10 qui est très utilisé en programmation. Il permet d'incrémenter une
valeur et de la faire passer à zéro si elle dépasse une limite. En e et 10%10=0 (le reste de la division de 10 par 10 est
0). C'est bien pratique !
Un alphabet matrice 3x3

Je vous propose enfin une dernière évolution de notre programme d’allumage de LED grâce aux matrices.
Nous allons nous servir de notre matrice pour épeler un mot (écrit en minuscules) contenu dans un tableau de char .
Le principe est simple : on créé les 26 lettres de l'alphabet dans un tableau de matrices (donc 26 matrices). Puis on parcourt
le tableau du mot à épeler et on appelle la bonne matrice en fonction de la lettre.
Nous allons ruser un peu. Comme une lettre est un code, et que les lettres de l'alphabet se suivent, les codes de ces lettres
se suivent aussi. Du coup, le caractère 'a' a pour code ASCII 97. Donc si notre tableau de matrice démarre de 0, la position
de 'a' est :
(code ASCII de 'a') - 97=0
Ce qui correspond bien.
Le plus long est finalement de concevoir les matrices de l'alphabet ! Vous pouvez tout à fait le faire seul(e)s.
Je vous propose dans le code suivant un exemple, mais il est loin d'être le meilleur . À vous de l'améliorer !
c_cpp
1 //tableau des matrices
2 char matrices[26][10] = {
3 "aaaaeaaea", //a
4 "aeeaaeaae", //b
5 "aaaaeeaaa", //c
6 "eeaeaaeaa", //d
7 "aaaaaeaaa", //e
8 "aaaaaeaee", //f
9 "aaeaeaaaa", //g
10 "aeaaaaaea", //h
11 "eaeeaeeae", //i
12 "eaeeaeaae", //j
13 "aeaaaeaea", //k
14 "aeeaeeaaa", //l
15 "aaaaaaaea", //m
16 "aeeaeaaea", //n
17 "aaaaeaaaa", //o
18 "aaeaaeaee", //p
19 "eaaeaaeea", //q
20 "aaeaaeaea", //r
21 "eaaeaeaae", //s
22 "aaaeaeeae", //t
23 "aeaaeaaaa", //u
24 "aeaaeaeae", //v
25 "aeaaaaaaa", //w
26 "aeaeaeaea", //x
27 "aeaeaeeae", //y
28 "aaeeaeeaa" //z
29 };
30 char mot[10]="salut"; //mot à épeler
31 int pos = 0; //variable de position dans le mot
32 int vitesse=500; // variable pour la vitesse en ms entre chaque matrice
33 char matriceAct[10]="eeeeeeeee"; //tableau de matrice en cours
34 unsigned long tpsDep = millis(); //initialisation du temps
35 byte ligne[3] = {4, 3, 2}; //stockage des pins ligne
36 byte colonne[3] = {5, 6, 7}; // stockage des pins colonne
37
38 void setup() {
39 //initialisation des pins en OUTPUT et mise à l'état LOW ou HIGH
40 for (byte l = 2; l < 8; l++) {
42 if (l > 1 && l < 4)
44 else
46 }
47 }
48
49 void loop() {
50 unsigned long tpsAct = millis();
51 if (tpsAct ‐ tpsDep > vitesse) { //teste si temps écoulé
52 char lettre=mot[pos]; //on lit la lettre du mot
53 copie(byte(lettre)‐97); //appel de la fonction de mise à jour de la matrice en cours
54 pos = (pos + 1) % 10; //avancée du curseur de position dans le mot
55 tpsDep = tpsAct; //réinitialisation du temps
56 }
58 }
59
61 void affiche() {
62 for (byte p = 0; p < 9; p++) { //parcours du tableau matrice
63 if (matriceAct[p] == 'a') { //test si 'a'
64 //allumage
65 digitalWrite(ligne[p / 3], HIGH);
66 digitalWrite(colonne[p % 3], LOW);
67 delay(2);
68 //exctinction
69 digitalWrite(colonne[p % 3], HIGH);
70 digitalWrite(ligne[p / 3], LOW);
71 }
72 }
73 }
74
75 //fonction de copie de tableau en fonction du code de la lettre.
76 void copie(byte n) {
77 for (byte p = 0; p < 10; p++) {
78 matriceAct[p] = matrices[n][p];
79 }
80 }
81
Évidemment, ce n'est pas simple de refaire l'alphabet sur une matrice 3x3. C'est bien plus simple sur une 4x4.
Nous verrons plus loin qu'il existe des matrices toutes faites, que l'on peut piloter par I2C avec 8x8 LED.
Toujours est-il qu'il est tout de même pratique, pour des projets embarqués de pouvoir utiliser le principe des matrices de
LED, pour libérer de la place pour les di érents capteurs.
Nous les avons disposées en carré dans ce chapitre, rien n'empêche de garder le même principe pour une disposition en
ligne (les 3 lignes se suivent mais les connexions restent celles du carré), c'est juste ensuite une question de connexions.
Pour aller plus loin...

digitalWrite() ou registre ?
Je vais tout de même ajouter une dernière chose. Je vous ai déjà parlé un peu des registres (juste évoqué). Il s'agit en fait
d'une adresse mémoire où sont stockées des informations que l'Arduino utilise pour la gestion de ses courants (entrées,
sorties, LOW, HIGH...).
Il existe en fait une méthode pour allumer directement les LED concernées en passant par les registres.
L'a ichage est plus rapide (et simultané), mais le code est moins lisible.
Voici une explication sur l'utilisation de ces registres (à manipuler avec quelques précautions ).
Enfin, Il existe des matrices toutes faites avec plus de LED et programmables en I2C dans le commerce.
Voici un exemple monochromatique et trichromatique.
Elles fonctionnent sur le même principe, à la di érence qu'une puce permet de gérer l'a ichage, et l'Arduino commande la
puce par le protocole I2C. Ces matrices peuvent être mises côte à côte ou dans d'autres configurations. Je les utilise pour
ma part pour créer des a ichages pour du texte ou des petits jeux du genre mini-Mario ou Tetris. C'est très sympa à
programmer et une bibliothèque existe pour la gestion de l'a ichage et la gestion du texte.
Il est possible de piloter des matrices de LED grâce à des puces I2C telles que la Pcf8574 ou la Mcp23017. Ce sera peut-être
l'objet d'un troisième cours... , mais rien ne vous empêche de vous y intéresser !
En résumé

Voilà, je pense que nous avons fait le tour du principe des matrices de LED.
Vous avez vu le montage, qui peut être appliqué à des matrices plus importantes, et la programmation qui repose surtout
sur la persistance rétinienne.
Vous disposez donc d'un a icheur embarqué, à vous maintenant d'utiliser ces matrices dans vos projets.
Voyons maintenant les matrices de boutons !
(Lukas, vous pouvez enlever le bâillon de Cunégonde, je vous remercie)
 J'ai terminé ce chapitre et je passe au suivant
 Codez et décodez des informations Concevez des claviers pour l'Arduino 
L'auteur
Jean-Noël Rousseau
Professeur des écoles passionné d'informatique et de
micro-robotique.
OpenClassrooms Professionnels En plus Suivez-nous

Qui sommes-nous ? A iliation Créer un cours Le blog OpenClassrooms
Fonctionnement de nos coursEntreprises CourseLab
Recrutement Universités et écoles Conditions Générales d'Utilisation      
Nous contacter
English Español

Perfectionnez-Vous Dans La Programmation Arduino: Concevez Des Matrices de Led

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Perfectionnez-Vous Dans La Programmation Arduino: Concevez Des Matrices de Led

Transféré par

Droits d'auteur :

Formats disponibles

05/08/2016 OpenClassrooms

Perfectionnez-vous dans la programmation Arduino

CONCEVEZ DES MATRICES DE LED

Qu'est-ce qu'une matrice de LED ?

 C'est déjà pas mal non ?

Voici un exemple de matrice de 4x4 LED :

Une représentation simplifiée de matrice de LED 4x4

nombre de pins = nombreDeLignes + nombreDeColonnes

nombre de LED pilotables = nombreDeLignes x nombreDeColonnes

Nombre de LED à piloter Nombre de pins nécessaires

Le principe est ensuite le même pour les matrices plus importantes !

Montez une matrice de 3x3 LED en carré

Schéma d'un réseau de 3x3 LED

Vous pouvez remarquer la disposition et le branchement :

Les LED sont connectées par lignes de trois ensembles.

 Mais comment fait-on pour allumer une LED ?

Allumez une seule LED

Retrouvez la correction de l'exercice dans la partie Annexes du cours !

 Super, et si je veux allumer deux LED ou plus ?

(Vous me courez sur le haricot Cunégonde...)

Allumez plusieurs LED

Toutes les autres seront éteintes.

Le code est finalement assez simple si on maîtrise bien les tableaux :

Si on observe le déroulement du programme, on s'aperçoit qu'on appelle la fonction digitalWrite() même si le

Voici une proposition d'amélioration :

dans notre configuration), donc un total de 10 fois pour cet exemple.

Exercice : Gérez la matrice de LED avec un tableau à simple entrée

où "e" correspond à éteint et "a" à allumé.

Je vous donne tout de même deux indications d'orde mathématique :

 Pourquoi ces précisions ?

Retrouvez la correction dans la partie Annexes du cours !

Créez des séquences d'a㐰㈱ichage

Un alphabet matrice 3x3

(code ASCII de 'a') - 97=0

Ce qui correspond bien.

Pour aller plus loin...

Voici un exemple monochromatique et trichromatique.

Voyons maintenant les matrices de boutons !

(Lukas, vous pouvez enlever le bâillon de Cunégonde, je vous remercie)

 J'ai terminé ce chapitre et je passe au suivant

 Codez et décodez des informations Concevez des claviers pour l'Arduino 

OpenClassrooms Professionnels En plus Suivez-nous

Vous aimerez peut-être aussi