WS2812B 8x32 256pixels

2026-10-08 11:03:41 +02:00
parent 06921fde2f
commit 3a0addaa55
6 changed files with 887 additions and 0 deletions
@@ -0,0 +1,359 @@
+# 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.
+
+![Schéma de branchement](schema_branchement.svg)
+
+> **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
+
+1. [Le matériel](#1-le-matériel)
+2. [Comment ça marche ?](#2-comment-ça-marche-)
+3. [Repérer les fils de la matrice](#3-repérer-les-fils-de-la-matrice)
+4. [Les 4 règles d'or](#4-les-4-règles-dor)
+5. [Régler l'alimentation d'établi](#5-régler-lalimentation-détabli)
+6. [Brancher, étape par étape](#6-brancher-étape-par-étape)
+7. [Installer le logiciel et téléverser](#7-installer-le-logiciel-et-téléverser)
+8. [Premier allumage : vérifier l'orientation](#8-premier-allumage--vérifier-lorientation)
+9. [Créer vos propres images](#9-créer-vos-propres-images)
+10. [Ça ne marche pas ?](#10-ça-ne-marche-pas-)
+11. [Petit lexique](#11-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
+
+1. **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.
+2. **Jamais le 5V de l'Arduino vers la matrice.** L'énergie de la matrice
+   vient **uniquement** de l'alimentation d'établi.
+3. **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.
+4. **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 :**
+
+1. Allumez l'alimentation, sortie désactivée si elle a un bouton `OUTPUT`.
+2. Tournez le bouton de **tension** jusqu'à lire **5,0 V** (entre 4,9 et 5,1).
+3. 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.
+4. **Éteignez** l'alimentation (ou désactivez la sortie).
+5. **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)
+
+1. Cordon **rouge** : borne **+** de l'alimentation → fil **rouge** du milieu (`5V`).
+2. Cordon **noir** : borne **−** de l'alimentation → fil **noir** du milieu (`GND`).
+3. **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)
+
+4. Emboîtez la **fiche** dans le connecteur marqué **`DIN`**.
+5. 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.
+
+6. Fil **blanc** de la fiche → une broche **GND** de l'Arduino
+   (il y en a trois, n'importe laquelle convient).
+7. 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](schema_branchement.svg) 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
+
+1. Installez l'**IDE Arduino** : <https://www.arduino.cc/en/software>.
+2. Installez la bibliothèque **FastLED** :
+   menu **Outils → Gérer les bibliothèques…**, cherchez `FastLED`, cliquez
+   **Installer**.
+3. Ouvrez le fichier [`matrice_8x32.ino`](matrice_8x32.ino)
+   (**Fichier → Ouvrir…**).
+4. Branchez l'Arduino en USB (alimentation d'établi **déjà allumée**).
+5. Choisissez la carte : **Outils → Type de carte → Arduino Uno**.
+6. Choisissez le port : **Outils → Port** → celui qui mentionne « Arduino Uno ».
+7. 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](https://github.com/FastLED/FastLED/wiki/Pixel-reference#predefined-colors-list))
+- **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 :
+
+```cpp
+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
+
+```cpp
+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](#8-premier-allumage--vérifier-lorientation) |
+| **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](https://wokwi.com) 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.