Une seule LED peut être pratique pour tester des projets Arduino. Mais lorsque vous ajoutez une matrice de LED, vous pouvez être vraiment créatif, en épelant des lettres, des chiffres et des symboles. C’est également un moyen pratique d’apprendre comment des écrans plus complexes – comme celui que vous lisez ici – fonctionnent. Dans ce guide, nous allons vous montrer comment configurer une matrice de LED 8 × 8 de base.
Comment fonctionnent les matrices de LED
Une matrice de LED de base comme celle que nous utiliserons comporte une grille de LED 8 × 8 qui peut être utilisée pour dessiner des caractères, des images de base et plus encore. Dans les guides précédents, nous avons montré comment l’Arduino peut contrôler une seule LED. Ce composant étend ce concept à travers un réseau de 64 LED qui peuvent toutes être contrôlées avec un seul Arduino.
Matrice de LED
Dans une matrice de LED, un courant traverse des rangées de LED. Afin de compléter le circuit et d’activer une lumière individuelle, une colonne est connectée à la masse. Là où les lignes d’alimentation et de masse se croisent, des LED sont activées. Vous pouvez y penser un peu comme le jeu de société Battleship. Par exemple, si les lignes A, B et C sont alimentées, mais que seule la colonne 1 est connectée à la masse, les voyants A1, B1 et C1 s’allument. Le reste restera sombre.
C’est un moyen pratique d’allumer plusieurs LED à la fois, mais cela crée un problème si vous souhaitez uniquement que certaines LED d’une colonne s’allument. Disons plutôt que vous vouliez que les lumières A1, B2 et C3 s’allument pour créer une ligne diagonale. L’activation des trois lignes et colonnes activerait toute la grille, ce qui n’est pas ce que nous voulons.
Pour résoudre ce problème, un Arduino peut parcourir une boucle, n’activant qu’une seule rangée de LED à la fois. De cette façon, vous pouvez activer autant de colonnes que vous le souhaitez sans affecter la ligne suivante. Sans une longue fonction delay(), les lignes seront activées dans une succession si rapide que l’œil humain ne pourra pas le dire. Mais nous allons montrer comment ajouter un délai afin que vous puissiez voir comment cela fonctionne de toute façon.
Ce dont vous aurez besoin
Nous utilisons une méthode plus compliquée pour contrôler la matrice de LED à des fins éducatives – d’autres composants peuvent réduire le nombre de broches requises – et cela prendra donc un peu plus de broches et de fils que la plupart de nos autres guides. Pour cette raison, nous utiliserons un Arduino Mega 2560, au lieu de l’Arduino Uno habituel, pour contrôler cette matrice. Vous aurez également besoin des éléments suivants:
| Carte Arduino 2560 |  |
| 8×8 Matrice de LED | 
|
| 8 résistance x 220ohm
La plupart des LED s’éteindront si vous les connectez directement à la sortie 5V d’un Arduino. Placez une résistance de votre kit entre la broche de sortie et la LED. |
 |
| Une paire de planches à pain | 
|
| Arduino Arduino | 
|
Vous aurez également besoin d’un câble USB et de quelques fils – au moins 32!
Il existe un certain nombre de façons d’organiser le câblage pour ce projet, mais comme cela peut devenir complexe, nous recommandons d’utiliser une paire de planches à pain verrouillées ensemble, l’une pour gérer la matrice de LED et l’autre pour le câblage dans les résistances. Il est possible d’accomplir la même chose en utilisant des fils avec des extrémités femelles allant jusqu’à la matrice de LED, bien qu’il soit assis sur le côté au lieu d’être stationnaire, ce qui peut être un peu plus encombrant.
Le Code
Le code de ce projet utilisera des boucles et des tableaux pour écrire chaque LED individuellement. Le résultat sera un tableau en haut de votre script que vous pourrez modifier facilement pour changer l’image affichée par votre matrice LED. Tout d’abord, collez le code complet dans l’ Arduino Arduino et téléchargez-le sur votre Mega Arduino.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
|
int àaFficher = {
{1,0,0,0,0,0,0,0},
{1,0,0,0,0,0,0,0},
{1,0,0,0,0,0,1,0},
{1,0,0,0,0,0,0,0},
{1,1,1,1,0,0,1,0},
{1,0,0,1,0,0,1,0},
{1,0,0,1,0,0,1,0},
{1,0,0,1,0,0,1,0}
};
je ne peux pas utiliser le code de configuration de void() {
pour (int i = 2; i & lt; = 9; i++) {
pinMode(i, SORTIE);
Mode PIN (i+44, SORTIE);
Écriture numérique (i, FAIBLE);
Écriture numérique (i +44, ÉLEVÉ);
}
Mode PIN (A0, ENTRÉE);
}
la boucle vide() {
pour (int i = 0; i & lt; 8; i++) {
if(i==0) {
Écriture numérique (9, FAIBLE);
}
else {
Écriture numérique (i+1, FAIBLE);
}
pour (int j = 0; j & lt; 8; j++) {
if(toDisplay == 1) {
Écriture numérique (j+46, FAIBLE);
}
else {
Écriture numérique (j+46, ÉLEVÉ);
}
}
Écriture numérique (i+2, HAUT); délai
(1);
}
}
|
Ensuite, passons en revue le fonctionnement de chacune de ces sections.
|
1
2
3
4
5
6
7
8
9
10
|
int àaFficher = {
{1,0,0,0,0,0,0,0},
{1,0,0,0,0,0,0,0},
{1,0,0,0,0,0,1,0},
{1,0,0,0,0,0,0,0},
{1,1,1,1,0,0,1,0},
{1,0,0,1,0,0,1,0},
{1,0,0,1,0,0,1,0},
{1,0,0,1,0,0,1,0}
};
|
Avant l’une des boucles principales de l’esquisse, ce tableau multidimensionnel définira quelles LED doivent être allumées et lesquelles doivent rester sombres. Il y a huit rangées de huit valeurs chacune, qui correspondent aux huit rangées de LED de la matrice. En les plaçant dans une grille dans l’esquisse, il est plus facile de visualiser la forme que les LED composeront.
|
1
2
3
4
5
6
7
8
9
|
j’ai essayé de le faire pour que je puisse le faire, mais j’ai essayé de le faire pour que je puisse le faire, mais j’ai essayé de le faire pour que je puisse le faire. , HAUT);
}
Code PIN (A0, ENTRÉE);
}
|
Dans la section setup(), nous initialiserons les broches dont nous avons besoin pour la matrice. Puisqu’il y a seize broches différentes, nous pouvons le faire plus efficacement qu’une à la fois. Les broches allant à la masse seront branchées sur les broches 2 à 9. Les broches qui envoient de l’énergie à la matrice s’exécuteront sur les broches 46 à 53. Cette section utilisera une boucle pour initialiser les deux jeux de broches.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
la boucle vide() {
pour (int i = 0; i & lt; 8; i++) {
if(i==0) {
Écriture numérique (9, FAIBLE);
}
else {
Écriture numérique (i+1, FAIBLE);
}
pour (int j = 0; j & lt; 8; j++) {
if(toDisplay == 1) {
Écriture numérique (j+46, FAIBLE);
}
else {
Écriture numérique (j+46, ÉLEVÉ);
}
}
Écriture numérique (i+2, HAUT); délai
(1);
}
}
|
Dans la section boucle principale() de l’esquisse, il y a une boucle en plusieurs étapes. La première instruction if réinitialisera la dernière ligne utilisée à LOW, ce qui empêchera la puissance de s’écouler vers elle.
La boucle for imbriquée suivante vérifiera les données du tableau. Si une cellule est répertoriée comme 1, le fil de terre de cette colonne sera réglé sur BAS, ce qui permettra au courant de s’écouler. Sinon, il réglera la broche sur HAUTE, ce qui empêchera un circuit d’être terminé le long de cette colonne. Il le fera pour les huit cellules d’une ligne donnée.
Enfin, la dernière instruction digitalWrite() activera la ligne entière. Toutes les colonnes définies sur FAIBLE s’allument. Le reste restera sombre. Lorsque l’esquisse se boucle à nouveau, elle commence immédiatement par désactiver cette ligne.
La dernière commande est une instruction delay() qui définit le délai entre chaque ligne. Il est réglé sur 1 milliseconde dans notre exemple car lorsque l’instruction n’est pas là, les LED deviennent un peu trop faibles. Cependant, vous pouvez augmenter le délai pour voir ce que l’esquisse fait plus lentement. Vous devriez voir chaque rangée s’allumer une à la fois, avant de s’éteindre lorsque la rangée suivante s’allume.
Le câblage
Pour ce projet, le câblage est relativement simple, il y en a juste beaucoup. Comme il y a beaucoup de broches, nous décrirons ce que vous voulez faire pour chaque circuit complet, plutôt que de répertorier chaque fil individuel comme nous le faisons habituellement.
Les broches 2 à 9 doivent être vos broches d’alimentation, et les broches 46 à 53 doivent être vos broches de masse. Exécutez un fil de la broche d’alimentation à la matrice de LED (vérifiez pour plus de détails sur les broches ci–dessous – c’est important), de la matrice de LED dans une résistance de 220 ohms, puis renvoyez un fil à une broche sur l’Arduino. La broche 2 devrait éventuellement conduire à la broche 46, la broche 3 devrait conduire à la broche 47 et ainsi de suite.
La principale complication ici réside dans la matrice LED elle-même. De manière contre-intuitive, les broches de chaque côté de la matrice ne sont pas du tout dans un ordre cohérent. Par exemple, nous voulons que la broche 2 alimente ce que nous appellerons la ligne A. Pourtant, la broche pour cela est la quatrième broche à partir de la gauche en haut de la matrice de LED. L’autre extrémité de ce circuit – qui doit conduire à la colonne 1 – est la première broche à droite en bas de la matrice.
Comme cet ordre est assez compliqué, nous allons préciser les broches de la matrice sur lesquelles chaque broche Arduino doit être câblée directement.
Le long du haut de la matrice (le côté avec le numéro imprimé dessus), il y a huit épingles. De gauche à droite, ceux-ci doivent être câblés aux broches suivantes de l’Arduino:
- Broche 7
- Broche 4
- Broche 49
- Broche 2
- Broche 51
- Broche 52
- Broche 3
- Broche 5
Ensuite, la rangée inférieure de huit broches de la matrice (le côté sans chiffres) doit être câblée aux broches suivantes (de gauche à droite, les chiffres étant toujours orientés vers le haut):
- Broche 9
- Broche 50
- Broche 48
- Broche 6
- Broche 53
- Broche 8
- Broche 47
- Broche 46
Une fois que tous les fils sont connectés, vous pouvez allumer votre projet et vous verrez votre matrice de LED s’allumer. Essayez de modifier la disposition des 1 dans le tableau initial et téléchargez à nouveau le script pour créer différentes formes. Vous pouvez également ajuster la longueur de la commande delay() pour voir chaque ligne s’allumer une à la fois.