Files

T

2026-10-08 11:03:41 +02:00

16 KiB

Raw Permalink Blame History

Matrice LED 8 × 32 (WS2812B) avec un Arduino

Workshop « Vitrine pixels » : on allume un écran de 256 pixels de couleur avec un Arduino, un seul fil de données et une alimentation d'établi.

Pas de panique : il n'y a que 5 fils à brancher. Lisez ce document dans l'ordre, et faites vérifier votre montage avant de mettre sous tension.

Sommaire

Le matériel
Comment ça marche ?
Repérer les fils de la matrice
Les 4 règles d'or
Régler l'alimentation d'établi
Brancher, étape par étape
Installer le logiciel et téléverser
Premier allumage : vérifier l'orientation
Créer vos propres images
Ça ne marche pas ?
Petit lexique

1. Le matériel

Quoi	Combien	Remarque
Matrice LED WS2812B 8 × 32, souple	1	256 LED, 32 × 8 cm
Arduino Uno + son câble USB	1
Alimentation d'établi (de laboratoire)	1	réglable en tension et en courant
2 cordons banane → pince crocodile	1 rouge + 1 noir	pour relier l'alimentation à la matrice
Résistance 330 Ω	1	bandes orange-orange-marron (entre 300 et 500 Ω, ça marche)
Condensateur électrolytique 1000 µF, 10 V ou plus	1	cylindre avec une bande « − » sur le côté
Fils de prototypage (« Dupont ») mâle-mâle	3 ou 4
Petite plaque d'essai (breadboard)	1	facultatif mais pratique
Ruban isolant (ou scotch d'électricien)	un peu	pour isoler le fil rouge non utilisé

2. Comment ça marche ?

Chaque LED de la matrice contient une minuscule puce électronique. Les 256 LED sont reliées les unes aux autres en une seule longue chaîne.

L'Arduino envoie dans un seul fil (le fil de données) une longue liste de couleurs. La 1re LED garde la 1re couleur et fait passer le reste, la 2e garde la suivante, et ainsi de suite jusqu'à la 256e, un peu comme un paquet de cartes qu'on se passe de main en main. Ensuite, chaque LED garde sa couleur affichée jusqu'au prochain envoi.

Il faut donc deux choses à la matrice :

de l'énergie (le courant électrique, en 5 volts) : elle vient de l'alimentation d'établi ;
des informations (les couleurs) : elles viennent de l'Arduino.

Pourquoi pas l'Arduino pour l'énergie aussi ? Une LED allumée en blanc à fond consomme environ 0,06 A. 256 LED × 0,06 A = plus de 15 A ! Le port USB d'un ordinateur fournit 0,5 A. On grillerait l'Arduino, voire le port USB de l'ordinateur.

3. Repérer les fils de la matrice

Retournez la matrice : les fils sont au dos. Il y a trois groupes de fils, et à côté de chaque fil, un petit texte est imprimé sur le circuit.

Où	Fils	Texte imprimé	Rôle	On branche ?
À une extrémité	rouge, blanc, vert + connecteur	`5V` `GND` `DIN`	Entrée des données (Data IN)	Oui → vers l'Arduino
Au milieu	rouge, noir (bouts dénudés)	`5V` `GND`	Arrivée de l'énergie	Oui → vers l'alimentation
À l'autre extrémité	rouge, blanc, vert + connecteur	`5V` `GND` `DOUT`	Sortie des données (Data OUT)	Non, on n'y touche pas

⚠️ Lisez bien DIN / DOUT sur le circuit : les deux connecteurs se ressemblent ! Si on branche l'Arduino sur DOUT, rien ne s'allume (sans danger, mais on perd du temps).

Une fiche est fournie avec la matrice : elle s'emboîte dans le connecteur DIN et donne trois fils rouge / blanc / vert à bouts libres.

Code couleur des fils :

Couleur	Signification
🔴 rouge	+5 V : le « plus » de l'énergie
⚫ noir ou ⚪ blanc	GND (masse) : le « moins », le retour du courant
🟢 vert	Données : les couleurs envoyées par l'Arduino

4. Les 4 règles d'or

5 volts, pas plus. Au-delà de 5,5 V, les LED peuvent être détruites en une fraction de seconde. On règle l'alimentation avant de brancher.
Jamais le 5V de l'Arduino vers la matrice. L'énergie de la matrice vient uniquement de l'alimentation d'établi.
Toutes les masses (GND) reliées ensemble. L'Arduino et la matrice doivent avoir le même « zéro volt » de référence, sinon le signal de données n'est pas compris. Ici, c'est le fil blanc qui fait ce lien.
On câble hors tension, et on fait vérifier avant d'allumer.

5. Régler l'alimentation d'établi

Une alimentation d'établi a deux réglages :

la tension (en volts, V) : la « pression » électrique ;
la limite de courant (en ampères, A) : le maximum qu'elle accepte de fournir. C'est une sécurité : en cas de court-circuit ou d'erreur, elle bride le courant au lieu de laisser chauffer les fils.

Procédure, sans rien brancher sur les bornes :

Allumez l'alimentation, sortie désactivée si elle a un bouton OUTPUT.
Tournez le bouton de tension jusqu'à lire 5,0 V (entre 4,9 et 5,1).
Réglez la limite de courant sur 3 A (ou le maximum de l'alimentation s'il est plus petit, voir la remarque ci-dessous).
- Selon le modèle, la façon d'afficher et de régler cette limite change : demandez à l'encadrant de vous montrer.
Éteignez l'alimentation (ou désactivez la sortie).
Ne touchez plus au bouton de tension pendant toute la séance. Un bouton tourné par erreur peut griller la matrice.

Si l'alimentation ne fournit que 2 A ou moins : dans le programme, baissez COURANT_MAX_MA (voir partie 7) à environ 80 % de cette valeur (par exemple 1500 pour une alimentation de 2 A).

6. Brancher, étape par étape

Tout est débranché : alimentation éteinte, Arduino non relié à l'ordinateur.

Étape A : l'énergie (alimentation → fils du milieu)

Cordon rouge : borne + de l'alimentation → fil rouge du milieu (5V).
Cordon noir : borne − de l'alimentation → fil noir du milieu (GND).
Condensateur 1000 µF entre ces deux fils, au plus près de la matrice :
- sa patte côté bande « − » (la patte la plus courte) → fil noir ;
- l'autre patte → fil rouge.
Le condensateur est un petit réservoir d'énergie : il absorbe les à-coups de courant quand beaucoup de LED s'allument d'un coup. ⚠️ Il a un sens : branché à l'envers, il peut gonfler, voire éclater.

Étape B : les données (Arduino → connecteur DIN)

Emboîtez la fiche dans le connecteur marqué DIN.
Fil vert de la fiche → une patte de la résistance 330 Ω. L'autre patte de la résistance → broche 6 de l'Arduino (marquée ~6).

La résistance protège l'entrée de la 1re LED et adoucit le signal. Une résistance n'a pas de sens : on peut la brancher dans les deux sens.
Fil blanc de la fiche → une broche GND de l'Arduino (il y en a trois, n'importe laquelle convient).
Fil rouge de la fiche → ne pas brancher. Entourez son bout de ruban isolant pour qu'il ne touche rien.

Étape C : vérifier

Comparez votre montage avec le schéma et cochez :

Alimentation réglée sur 5,0 V, limite de courant réglée
+ rouge → fil rouge du milieu ; − noir → fil noir du milieu
Condensateur : bande « − » côté noir
Fiche branchée sur DIN (pas DOUT)
Vert → résistance → broche 6
Blanc → GND de l'Arduino
Fil rouge de la fiche isolé, branché nulle part
Rien de branché sur la broche 5V de l'Arduino
Montage vérifié par l'encadrant

Ordre d'allumage et d'extinction

Allumer	Éteindre
1. l'alimentation d'établi	1. débrancher l'USB de l'Arduino
2. puis le câble USB de l'Arduino	2. puis éteindre l'alimentation

Règle simple : la matrice est alimentée avant de recevoir des données, et le reste jusqu'à la fin. Envoyer des données à une matrice éteinte peut abîmer la première LED.

7. Installer le logiciel et téléverser

Installez l'IDE Arduino : https://www.arduino.cc/en/software.
Installez la bibliothèque FastLED : menu Outils → Gérer les bibliothèques…, cherchez FastLED, cliquez Installer.
Ouvrez le fichier matrice_8x32.ino (Fichier → Ouvrir…).
Branchez l'Arduino en USB (alimentation d'établi déjà allumée).
Choisissez la carte : Outils → Type de carte → Arduino Uno.
Choisissez le port : Outils → Port → celui qui mentionne « Arduino Uno ».
Cliquez sur la flèche → Téléverser.

Les réglages importants sont tout en haut du programme :

Réglage	Valeur	À quoi ça sert
`PIN_DONNEES`	`6`	broche reliée au fil vert
`LUMINOSITE`	`40`	de 0 à 255 ; 40 suffit largement (ces LED éblouissent !)
`COURANT_MAX_MA`	`2500`	courant max en milliampères, un peu sous la limite de l'alimentation
`INVERSER_X`, `INVERSER_Y`	`false`	orientation de l'image (voir ci-dessous)

8. Premier allumage : vérifier l'orientation

Selon le sens dans lequel on pose la matrice, l'image peut apparaître retournée. La première animation (animTestCoins) allume un pixel dans chaque coin. Posez la matrice face LED vers vous, puis regardez :

 ROUGE ●· · · · · · · · · · · · · · · · ● VERT
       · · · · · · · · · · · · · · · · ·
       · · · · · · · · · · · · · · · · ·
 BLEU  ●· · · · · · · · · · · · · · · · ● BLANC

Ce que vous voyez	Ce qu'il faut faire
Rouge en haut à gauche, vert en haut à droite	Rien, c'est parfait ✅
Rouge et vert inversés (gauche ↔ droite)	`INVERSER_X` → `true`
Rouge et vert en bas	`INVERSER_Y` → `true`
Les deux à la fois	les deux → `true`

Puis re-téléversez. La deuxième animation (animOrdreDesLeds) montre le trajet du signal : un point orange parcourt les 256 LED dans l'ordre de la chaîne, en zigzag de colonne en colonne.

9. Créer vos propres images

Le programme est découpé pour que vous n'ayez à modifier que la partie 5 (les animations) et la fonction loop().

Les outils de dessin

Fonction	Effet
`pixel(x, y, couleur);`	colore le pixel de la colonne `x` (0 à 31) et de la ligne `y` (0 à 7)
`effacer();`	éteint tout
`montrer();`	affiche l'image (rien n'apparaît tant qu'on ne l'appelle pas !)
`delay(100);`	attend 100 millisecondes (0,1 s)

Le point (0, 0) est en haut à gauche, comme sur un écran d'ordinateur.

Les couleurs

Par leur nom (en anglais) : CRGB::Red, CRGB::Orange, CRGB::Gold, CRGB::Pink, CRGB::Purple, CRGB::Turquoise… (liste complète)
En rouge, vert, bleu (de 0 à 255 chacun) : CRGB(255, 120, 0) = orange.
En teinte, saturation, luminosité : CHSV(teinte, 255, 255). La teinte fait le tour de l'arc-en-ciel de 0 à 255 : 0 rouge, 32 orange, 64 jaune, 96 vert, 128 cyan, 160 bleu, 192 violet, 224 rose.

Dessiner en pixel art

Dans l'animation 5, le dessin est écrit comme du texte, une lettre par pixel :

const char* dessin[HAUTEUR] = {
  "..RR.RR..",
  ".RBRRRRR.",
  ".RRRRRRR.",
  ".RRRRRRR.",
  "..RRRRR..",
  "...RRR...",
  "....R....",
  ".........",
};

. = éteint, R rouge, O orange, J jaune, V vert, C cyan, L bleu, M magenta, P rose, B blanc. Remplacez par votre propre dessin. Gardez 8 lignes, toutes de la même longueur, et mettez cette longueur dans DESSIN_LARGEUR.

Exemple : votre première animation

void animMaPremiere() {
  for (int x = 0; x < LARGEUR; x++) {   // x va de 0 à 31
    effacer();
    pixel(x, 3, CRGB::Gold);            // un point doré sur la ligne 3
    pixel(x, 4, CRGB::Gold);            // et juste en dessous
    montrer();
    delay(50);
  }
}

Ajoutez ensuite animMaPremiere(); dans loop(), puis téléversez.

10. Ça ne marche pas ?

Symptôme	Causes probables	Solution
Rien ne s'allume	Fiche sur `DOUT` au lieu de `DIN`	Changer de côté
	Alimentation éteinte ou sortie désactivée	Allumer, activer `OUTPUT`
	Pas de GND commun	Vérifier le fil blanc vers le GND de l'Arduino
	Mauvaise broche	Le fil vert doit aller sur la broche 6, ou changer `PIN_DONNEES`
	Le téléversement a échoué	Lire le message en bas de l'IDE, vérifier carte et port
Seule la 1re LED fait n'importe quoi	Résistance absente, ou faux contact sur le fil vert	Vérifier la résistance et le fil
Couleurs fausses (rouge ↔ vert)	Mauvais ordre des couleurs	Dans `setup()`, essayer `RGB` au lieu de `GRB`
Couleurs aléatoires, scintillement	GND commun absent ou mal serré	Revisser, revérifier le fil blanc
	Fil de données trop long	Le garder court (< 50 cm)
Ça marche puis ça clignote / devient orange quand tout s'allume	L'alimentation atteint sa limite de courant (le voyant `CC` s'allume)	Baisser `LUMINOSITE` ou `COURANT_MAX_MA`
L'image est à l'envers	Orientation	Voir la partie 8
L'Arduino redémarre tout seul	Le 5V de l'Arduino est relié à la matrice	Débrancher ce fil (règle d'or n° 2)
Ça chauffe, ça sent le brûlé	Court-circuit ou condensateur à l'envers	Couper l'alimentation immédiatement, appeler l'encadrant

11. Petit lexique

Mot	Signification
LED	Diode électroluminescente : un composant qui émet de la lumière
WS2812B	Modèle de LED RGB avec une puce intégrée, qu'on peut chaîner (on dit aussi « NeoPixel »)
RGB / RVB	Rouge, vert, bleu : les trois lumières qui, mélangées, font toutes les couleurs
Pixel	Un point de l'image : ici, une LED
Tension (V, volts)	La « pression » électrique. Ici : 5 V
Courant (A, ampères)	La « quantité » d'électricité qui circule. 1 A = 1000 mA
GND, masse	Le « moins », la référence 0 V ; le chemin de retour du courant
DIN / DOUT	Data IN / Data OUT : entrée et sortie des données dans la chaîne
Résistance (Ω, ohms)	Composant qui freine le courant
Condensateur (µF)	Petit réservoir d'énergie ; celui-ci a un sens (+ / −)
Bibliothèque	Code écrit par d'autres, qu'on réutilise (ici FastLED)
Téléverser	Envoyer le programme de l'ordinateur vers l'Arduino
Serpentin	Câblage en zigzag des LED : une colonne descend, la suivante remonte

Pour aller plus loin

Chaîner deux matrices : le connecteur DOUT de la première se branche sur le DIN de la suivante. Il faut alors une alimentation plus puissante, et ramener le 5V / GND à chaque matrice.
Simuler sans matériel : le site Wokwi permet de tester un programme FastLED avec un Arduino et une matrice virtuels.
Le projet final (7 × 39 pixels) reprend exactement les mêmes principes : la fonction XY(), FastLED et une alimentation externe.

16 KiB Raw Permalink Blame History Unescape Escape