• 20 hours
  • Medium

Free online content available in this course.

course.header.alt.is_certifying

Got it!

Last updated on 7/13/17

Concevez des matrices de LED

Log in or subscribe for free to enjoy all this course has to offer!

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'afficher 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'affichage pour lire des informations, comme de réseaux de lumières pour décorer et animer vos montages.

 

Il s'agit donc d'une interface d'affichage, 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 affichages assez complets.

Le problème est que le nombre de LED que vous pouvez piloter est limité. En effet, 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 ?

Oui, mais du coup votre Arduino ne peut pas faire autre chose (ne serait-ce qu'afficher 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
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'affichaient 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 LED 3x3
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 effet 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 diffé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 :

/*
 * Matrice de LED 3 lignes, 3 colonnes
 * pin 2 = ligne 0, pin 3 = ligne 1, pin 4 = ligne 2
 * pin 5 = colonne 0, pin 6 = colonne 1, pin 7 =  colonne 2
 */

void setup() {
  //initialisation des pins en OUTPUT et mise à l'état LOW
  for (int l=2;l<8;l++){
    pinMode(l,OUTPUT);
    digitalWrite(l,LOW);
  }
  //on passe les pins de colonne à l'état HIGH
  for (int l=5;l<8;l++){
    digitalWrite(l,HIGH);
  }
}

void loop() {
  // on allume la LED ligne 0 colonne 0
  digitalWrite(2,HIGH);
  digitalWrite(5,LOW);
  delay(500);
  // on l'éteint
  digitalWrite(2,LOW);
  digitalWrite(5,HIGH);
  delay(500);
}

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 suffit à 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 suffit à 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 :

/*
 * Matrice de LED 3 lignes, 3 colonnes
 * pin 2 = ligne 0, pin 3 = ligne 1, pin 4 = ligne 2
 * pin 5 = colonne 0, pin 6 = colonne 1, pin 7 =  colonne 2
 */
void setup() {
  //initialisation des pins en OUTPUT et mise à l'état LOW
  for (int l = 2; l < 8; l++) {
    pinMode(l, OUTPUT);
    digitalWrite(l, LOW);
  }
  //on passe les pins de colonne à l'état HIGH
  for (int l = 5; l < 8; l++) {
    digitalWrite(l, HIGH);
  }
}

void loop() {
  affiche();
}
// fonction d'affichage
void affiche(){
  //allumage de la LED en bas à gauche
  digitalWrite(2,HIGH);
  digitalWrite(5,LOW);
  delay(2); // petit délai pour l'oeil
  //on l'éteint
  digitalWrite(2,LOW);
  digitalWrite(5,HIGH);
  //allumage de la LED en haut à droite
  digitalWrite(4,HIGH);
  digitalWrite(7,LOW);
  delay(2); // petit délai pour l'oeil
  //on l'éteint
  digitalWrite(4,LOW);
  digitalWrite(7,HIGH);
}

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 effet, 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 :

boolean matrice[3][3]={
  0,0,1,
  0,0,0,
  1,0,0
 };

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 :

byte ligne[3]={4,3,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.

Nous avons maintenant trois tableaux. Ils 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 suffira 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 ;) :


 boolean matrice[3][3]={
  0,0,1,
  0,0,0,
  1,0,0
 };
 byte ligne[3]={4,3,2};
 byte colonne[3]={5,6,7};

void setup() {
  //initialisation des pins en OUTPUT et mise à l'état LOW
  for (int l = 2; l < 8; l++) {
    pinMode(l, OUTPUT);
    digitalWrite(l, LOW);
  }
  //on passe les pins de colonne à l'état HIGH
  for (int l = 5; l < 8; l++) {
    digitalWrite(l, HIGH);
  }
}

void loop() {
  affiche(); //appel de la fonction d'affichage
}
// fonction d'affichage
void affiche(){
  for (byte l=0;l<3;l++){//on parcourt les lignes
    for (byte c=0;c<3;c++){//puis chaque case de la ligne (colonne)
      digitalWrite(ligne[l],matrice[l][c]); //on allume ou non en fonction du tableau matrice
      digitalWrite(colonne[c],LOW);
      delay(2); // attente pour l'oeil
      digitalWrite(ligne[l],LOW); //on éteint
      digitalWrite(colonne[c],HIGH); //et on place à l'état HIGH pour la suivante 
    }
  }
}

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 affichage de matrice).

Voici une proposition d'amélioration :


boolean matrice[3][3] = {
  0, 0, 1,
  0, 0, 0,
  1, 0, 0
};
byte ligne[3] = {4, 3, 2};
byte colonne[3] = {5, 6, 7};

void setup() {
  //initialisation des pins en OUTPUT et mise à l'état LOW
  for (int l = 2; l < 8; l++) {
    pinMode(l, OUTPUT);
    if (l > 1 && l < 4)
      digitalWrite(l, LOW);
    else
      digitalWrite(l, HIGH);
  }
}

void loop() {
  affiche(); //appel de la fonction d'affichage
}
// fonction d'affichage
void affiche() {
  for (byte l = 0; l < 3; l++) { //on parcourt les lignes
    digitalWrite(ligne[l], HIGH); //on prépare la ligne à l'affichage
    for (byte c = 0; c < 3; c++) { //on parcourt chaque case de la ligne (colonne)
      if (matrice[l][c]) { //on teste si affichage dans matrice
        digitalWrite(colonne[c], LOW); //on allume
        delay(2); //avec un delai
        digitalWrite(colonne[c], HIGH); //on éteint
      }
    }
    digitalWrite(ligne[l], LOW); //on arrête la ligne
  }
}

 

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 suffirait de modifier le tableau matrice, et on devrait alors appeler la fonction  digitalWrite()  6+9*2=24 fois.

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 :

char matrice[10]="eeaeeeaee";

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

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 effet, 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 effort 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'affichage

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'affichage de votre matrice. En effet, si au lieu d'un seul tableau de matrice, vous aviez plusieurs tableaux possibles, vous auriez à votre disposition une séquence d'affichage (ou un jeu de caractères ;) ).

Je vous donne donc le programme précédent modifié pour afficher une matrice diffé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 :

//tableau des matrices
char matrices[10][10] = {
  "aeeeeeeee",
  "eaeeeeeee",
  "eeaeeeeee",
  "eeeeeaeee",
  "eeeeaeeee",
  "eeeaeeeee",
  "eeeeeeaee",
  "eeeeeeeae",
  "eeeeeeeea",
  "eeeeaeeee"
};
byte pos = 0; //variable de position dans le tableaud des matrices
int vitesse=1000; // variable pour la vitesse en ms entre chaque matrice
char matriceAct[10]="eeeeeeeee"; //tableau de matrice en cours
unsigned long tpsDep = millis(); //initialisation du temps
byte ligne[3] = {4, 3, 2}; //stockage des pins ligne
byte colonne[3] = {5, 6, 7}; // stockage des pins colonne

void setup() {
  //initialisation des pins en OUTPUT et mise à l'état LOW ou HIGH
  for (byte l = 2; l < 8; l++) {
    pinMode(l, OUTPUT);
    if (l > 1 && l < 4)
      digitalWrite(l, LOW);
    else
      digitalWrite(l, HIGH);
  }
}

void loop() {
  unsigned long tpsAct = millis();
  if (tpsAct - tpsDep > vitesse) { //teste si temps écoulé
    copie(pos); //appel de la fonction de mise à jour de la matrice en cours
    pos = (pos + 1) % 10; //avancée du curseur de position avec retour à zéro si au dessus de 10
    tpsDep = tpsAct; //réinitialisation du temps
  }
  affiche(); //appel de la fonction d'affichage
}

// fonction d'affichage
void affiche() {
  for (byte p = 0; p < 9; p++) { //parcours du tableau matrice
    if (matriceAct[p] == 'a') { //test si 'a'
      //allumage
      digitalWrite(ligne[p / 3], HIGH);
      digitalWrite(colonne[p % 3], LOW);
      delay(2);
      //exctinction
      digitalWrite(colonne[p % 3], HIGH);
      digitalWrite(ligne[p / 3], LOW);
    }
  }
}

//fonction de copie de tableau en fonction de la position.
void copie(byte n) {
  for (byte p = 0; p < 10; p++) {
    matriceAct[p] = matrices[n][p];
  }
}

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ée 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 !

//tableau des matrices
char matrices[26][10] = {
  "aaaaeaaea", //a
  "aeeaaeaae", //b
  "aaaaeeaaa", //c
  "eeaeaaeaa", //d
  "aaaaaeaaa", //e
  "aaaaaeaee", //f
  "aaeaeaaaa", //g
  "aeaaaaaea", //h
  "eaeeaeeae", //i
  "eaeeaeaae", //j
  "aeaaaeaea", //k
  "aeeaeeaaa", //l
  "aaaaaaaea", //m
  "aeeaeaaea", //n
  "aaaaeaaaa", //o
  "aaeaaeaee", //p
  "eaaeaaeea", //q
  "aaeaaeaea", //r
  "eaaeaeaae", //s
  "aaaeaeeae", //t
  "aeaaeaaaa", //u
  "aeaaeaeae", //v
  "aeaaaaaaa", //w
  "aeaeaeaea", //x
  "aeaeaeeae", //y
  "aaeeaeeaa"  //z
};
char mot[10]="salut"; //mot à épeler
int pos = 0; //variable de position dans le mot
int vitesse=500; // variable pour la vitesse en ms entre chaque matrice
char matriceAct[10]="eeeeeeeee"; //tableau de matrice en cours
unsigned long tpsDep = millis(); //initialisation du temps
byte ligne[3] = {4, 3, 2}; //stockage des pins ligne
byte colonne[3] = {5, 6, 7}; // stockage des pins colonne

void setup() {
  //initialisation des pins en OUTPUT et mise à l'état LOW ou HIGH
  for (byte l = 2; l < 8; l++) {
    pinMode(l, OUTPUT);
    if (l > 1 && l < 4)
      digitalWrite(l, LOW);
    else
      digitalWrite(l, HIGH);
  }
}

void loop() {
  unsigned long tpsAct = millis();
  if (tpsAct - tpsDep > vitesse) { //teste si temps écoulé
    char lettre=mot[pos]; //on lit la lettre du mot
    copie(byte(lettre)-97); //appel de la fonction de mise à jour de la matrice en cours
    pos = (pos + 1) % 10; //avancée du curseur de position dans le mot
    tpsDep = tpsAct; //réinitialisation du temps
  }
  affiche(); //appel de la fonction d'affichage
}

// fonction d'affichage
void affiche() {
  for (byte p = 0; p < 9; p++) { //parcours du tableau matrice
    if (matriceAct[p] == 'a') { //test si 'a'
      //allumage
      digitalWrite(ligne[p / 3], HIGH);
      digitalWrite(colonne[p % 3], LOW);
      delay(2);
      //exctinction
      digitalWrite(colonne[p % 3], HIGH);
      digitalWrite(ligne[p / 3], LOW);
    }
  }
}

//fonction de copie de tableau en fonction du code de la lettre.
void copie(byte n) {
  for (byte p = 0; p < 10; p++) {
    matriceAct[p] = matrices[n][p];
  }
}

É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 diffé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'affichage 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 différence qu'une puce permet de gérer l'affichage, 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 affichages 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'affichage 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 afficheur 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)

Example of certificate of achievement
Example of certificate of achievement