Matrices de LED RGB [Partie 1]
Les matrices de LED RGB, on en a tous vu un jour ou l’autre : elles composent les écrans géants dans les concerts, sur les plateaux TV ou dans les transports en commun sur les bornes d’information voyageur ou sur les girouettes des bus.
Détails techniques
Les différentes matrices de LED RGB se différencient par :
- leur définition : généralement 32×16, 32×32, 64×32, 64×64…
- leur résolution matérialisée par la distance entre les pixels : P5 pour un espacement de 5mm, P3 pour un espacement de 3mm. Ou trouve des P2.5, P3, P4, P5, P10…
- leurs dimensions : 64×64 pixels en P3 donne 192x192mm
- le type de LED utilisé : SMD2121, SMD3528…
- le multiplexage : « scan line » 1/8, 1/16, 1/32 par exemple, à un instant t seulement une partie des LED sont allumées.
Dans la doc on trouve d’autres informations intéressantes :
- La tension d’alimentation : 5V
- La consommation max d’une matrice (elle sera différente si on affiche tout en blanc ou juste du texte par exemple) : 4A pour celle utilisée ici.
Scanline
Ce qui va se passer, c’est qu’on va s’occuper de seulement 2 lignes à chaque fois. Sur un panneau avec un scanline de 1/32, on allumera les ligne 0 et la ligne 32, puis la ligne 1 et la ligne 33 et ainsi de suite jusqu’à la ligne 31 et 63… après ça et bien on recommence. C’est la persistance rétinienne qui va faire que l’on croit voir une image entière.
Les LED sont allumées ou éteintes, il n’y a pas d’entre-deux, donc le panneau ne s’occupe pas de la gestion des couleurs. C’est le contrôleur qui va devoir gérer le PWM afin de générer les différentes couleurs.
Et il va falloir aller très vite… Si on veut une profondeur de couleurs de 24bits, soit 8 par canal (R, G, B) avec une fréquence de 100fps, il va falloir rafraîchir l’intégralité de la matrice 256×100=25600 fois par seconde !
La connectique
À l’arrière du panneau on trouve :
- un connecteur d’entrée « HUB75 » (JIN)
- un connecteur de sortie (JOUT)
- un connecteur d’alimentation (avec VCC et GND… deux fois).
Pourquoi un connecteur de sortie ? Car ces matrices peuvent êtres chaînées en série pour faire un afficheur plus grand. La sortie de la matrice N est connectée à l’entrée de la matrice N+1. Les flèches indiquent le sens de propagation des données.
| Pin | Nom | Description |
| 1 | R1 | Rouge ligne 1 (allumé ou éteint) |
| 2 | G1 | Vert ligne 1 |
| 3 | B1 | Bleu ligne 1 |
| 4 | GND | Masse |
| 5 | R2 | Rouge ligne 2 |
| 6 | G2 | Vert ligne 2 |
| 7 | B2 | Bleu ligne 2 |
| 8 | E | Adresse de la ligne (MSB) (scanline 1/32 seulement) |
| 9 | A | Adresse de la ligne (LSB) |
| 10 | B | Adresse de la ligne |
| 11 | C | Adresse de la ligne |
| 12 | D | Adresse de la ligne (MSB) (scanline 1/16 et 1/32 seulement) |
| 13 | CLK | Horloge |
| 14 | LATCH | Transfert le buffer de données vers le buffer d’affichage. |
| 15 | OE | Allume les LED de la ligne sélectionnée (actif à l’état bas) |
| 16 | GND | Masse |
Sur ma matrice, il y a une erreur de sérigraphie, il y a GND à la place de D.
Le principe de fonctionnement
Maintenant qu’on connait la fonction de chaque broche et le principe du scanline, ça va se passer comme ça :
Lors de l’initialisation du programme :
- OE est à l’état haut pour désactiver l’affichage : la matrice est éteinte.
- LAT est à l’état bas : le transfert du registre à décalage dans le buffer d’affichage est bloqué.
Ensuite on boucle pour rafraîchir la matrice, pendant qu’on affiche la ligne N (et N+32 en scanline 1/32) on transfert les données de la ligne N+1 (et N+1+32) :
- On sélectionne les lignes à afficher avec les broches A à E pour du scanline 1/32, ou de A à D pour du 1/16 (la table de vérité qui suit est pour du scanline 1/32).
- LAT est à l’état bas : le transfert du registre à décalage dans le buffer d’affichage est bloqué.
- OE est à l’état bas pour activer l’affichage : les 2 lignes sélectionnées s’allument.
- On envoie les données de la ligne suivante dans le registre à décalage. On applique les valeurs RGB du dernier pixel de la ligne 1 suivante sur R1, G1 et B1 et celles du dernier pixel de la ligne 2 suivante sur R2, G2 et B2. Pourquoi du dernier pixel ? On a à faire ici à un registre à décalage, la première donnée qui entre va aller « tout au fond » au fur et à mesure que les nouvelles données qui entrent vont venir les pousser à chaque tick d’horloge.
- On fait avancer l’horloge (état haut puis retour à l’état bas).
- On répète les étapes 4 et 5 jusqu’au premier pixel des deux lignes actives… 64 fois pour la matrice 64×64 de l’exemple.
- Tout le registre est rempli…
- On met OE à l’état haut pour éteindre la matrice.
- On met LAT à l’état haut pour transférer le registre à décalage dans le buffer d’affichage. À la prochaine itération c’est cette ligne qui va s’afficher.
- On recommence à l’étape 1 avec le couple de lignes suivant.
Si on a chaîné deux matrices pour former un écran de 128×64, on va répéter les étapes 4 et 5 128 fois car la première matrice va continuer de décaler les données dans la seconde… on enverra en premier le dernier pixel de la 2ème matrice.
En bref, on va convertir 6 signaux de données séries (R1, G1, B1, R2, G2, B2) en autant de données parallèles qu’il y a de LED sur les deux lignes à afficher, c’est un peu le principe élémentaire du registre à décalage.
| E | D | C | B | A | Ligne 1 | Ligne 2 |
| 0 | 0 | 0 | 0 | 0 | 0 | 32 |
| 0 | 0 | 0 | 0 | 1 | 1 | 33 |
| 0 | 0 | 0 | 1 | 0 | 2 | 34 |
| 0 | 0 | 0 | 1 | 1 | 3 | 35 |
| 0 | 0 | 1 | 0 | 0 | 4 | 36 |
| 0 | 0 | 1 | 0 | 1 | 5 | 37 |
| 0 | 0 | 1 | 1 | 0 | 6 | 38 |
| 0 | 0 | 1 | 1 | 1 | 7 | 39 |
| 0 | 1 | 0 | 0 | 0 | 8 | 40 |
| 0 | 1 | 0 | 0 | 1 | 9 | 41 |
| 0 | 1 | 0 | 1 | 0 | 10 | 42 |
| 0 | 1 | 0 | 1 | 1 | 11 | 43 |
| 0 | 1 | 1 | 0 | 0 | 12 | 44 |
| 0 | 1 | 1 | 0 | 1 | 13 | 45 |
| 0 | 1 | 1 | 1 | 0 | 14 | 46 |
| 0 | 1 | 1 | 1 | 1 | 15 | 47 |
| 1 | 0 | 0 | 0 | 0 | 16 | 48 |
| 1 | 0 | 0 | 0 | 1 | 17 | 49 |
| 1 | 0 | 0 | 1 | 0 | 18 | 50 |
| 1 | 0 | 0 | 1 | 1 | 19 | 51 |
| 1 | 0 | 1 | 0 | 0 | 20 | 52 |
| 1 | 0 | 1 | 0 | 1 | 21 | 53 |
| 1 | 0 | 1 | 1 | 0 | 22 | 54 |
| 1 | 0 | 1 | 1 | 1 | 23 | 55 |
| 1 | 1 | 0 | 0 | 0 | 24 | 56 |
| 1 | 1 | 0 | 0 | 1 | 25 | 57 |
| 1 | 1 | 0 | 1 | 0 | 26 | 58 |
| 1 | 1 | 0 | 1 | 1 | 27 | 59 |
| 1 | 1 | 1 | 0 | 0 | 28 | 60 |
| 1 | 1 | 1 | 0 | 1 | 29 | 61 |
| 1 | 1 | 1 | 1 | 0 | 30 | 62 |
| 1 | 1 | 1 | 1 | 1 | 31 | 63 |
Connexion à l’Arduino Nano
Le gros connecteur d’alimentation de la matrice doit être branché sur une alimentation stabilisée de 5V pouvant fournir l’intensité nécessaire au fonctionnement de la matrice. Ne surtout pas l’alimenter via le 5V de l’arduino, ça risquerait de le griller…
| Pin Matrice | Nom Matrice | Pin Arduino |
| 1 | R1 | 8 |
| 2 | G1 | 9 |
| 3 | B1 | 10 |
| 4 | GND | GND |
| 5 | R2 | 11 |
| 6 | G2 | 12 |
| 7 | B2 | 13 |
| 8 | E | A4 |
| 9 | A | A0 |
| 10 | B | A1 |
| 11 | C | A2 |
| 12 | D | A3 |
| 13 | CLK | 5 |
| 14 | LATCH | 6 |
| 15 | OE | 7 |
| 16 | GND | GND |
Programme de test
bus1_bits est une image XBM à afficher sur la matrice. Dans ce test on affiche uniquement une image monochrome en utilisant le canal rouge. On se rend vite compte que l’arduino nano, bien qu’assez rapide pour afficher l’image sur une seule matrice manque cruellement de RAM avec ses 2Ko pour pouvoir afficher des images avec plus de couleurs.
Le programme utilise la lib Fast GPIO : https://github.com/pololu/fastgpio-arduino
Le Pin 4 qui change d’état sert à mesurer la fréquence de rafraîchissement avec l’oscilloscope. Pas question de faire de Serial.print ça prendrait beaucoup trop de temps. On a une fréquence de 4.73kHz, ce qui signifie qu’on affiche une ligne différente 4730 fois par seconde.