diff --git a/CLAUDE.md b/CLAUDE.md index 23ed157..b4e5066 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -69,6 +69,11 @@ Le projet avance en deux temps : - Rejeté : LED WS2812B individuelles sur PCB rond de 10 mm (se touchent au pas de 10 mm, pas de place pour le câblage). - Alternative possible : bande à 100 LED/m (pas de 10 mm), à condition que sa largeur soit ≤ 10 mm. +### Panneau de test acquis : WS2812B 8 × 32 (dossier `matrice_8x32/`) +- Fils au dos : entrée `DIN` (rouge 5V, blanc GND, vert DIN + connecteur JST-SM), paire d'alim au milieu (rouge 5V, noir GND), sortie `DOUT` à l'autre bout. +- Alimenté par une **alimentation d'établi** (5,0 V, limite ≈ 3 A) sur la paire du milieu ; l'Arduino Uno relie seulement données (pin 6 via 330 Ω) et GND (fil blanc). +- Code : `matrice_8x32.ino` (FastLED), README pour débutants, schéma `schema_branchement.svg`. + ### Chiffres clés - 320 LED adressées (8 × 40) → 960 octets de RAM sur Uno (2 Ko) : serré, envisager Mega ou ESP32. - Rafraîchissement ≈ 30 µs par LED → ≈ 10 ms pour tout le panneau. diff --git a/matrice_8x32/README.md b/matrice_8x32/README.md new file mode 100644 index 0000000..e291f2f --- /dev/null +++ b/matrice_8x32/README.md @@ -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** : . +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. diff --git a/matrice_8x32/WS2812B 8x32 256pixels-back.jpg b/matrice_8x32/WS2812B 8x32 256pixels-back.jpg new file mode 100644 index 0000000..ecbb35a Binary files /dev/null and b/matrice_8x32/WS2812B 8x32 256pixels-back.jpg differ diff --git a/matrice_8x32/WS2812B 8x32 256pixels-front.jpg b/matrice_8x32/WS2812B 8x32 256pixels-front.jpg new file mode 100644 index 0000000..5eff049 Binary files /dev/null and b/matrice_8x32/WS2812B 8x32 256pixels-front.jpg differ diff --git a/matrice_8x32/matrice_8x32.ino b/matrice_8x32/matrice_8x32.ino new file mode 100644 index 0000000..2134380 --- /dev/null +++ b/matrice_8x32/matrice_8x32.ino @@ -0,0 +1,387 @@ +/* + * ============================================================================= + * MATRICE LED WS2812B 8 x 32 (256 pixels) — Arduino Uno + FastLED + * Workshop « Vitrine pixels » + * ============================================================================= + * + * Avant de téléverser ce programme, lisez le README.md de ce dossier + * et vérifiez le branchement avec schema_branchement.svg. + * + * + * CE QUI CHANGE PAR RAPPORT À LA MAQUETTE 3 x 3 + * --------------------------------------------- + * Sur la maquette 3 x 3, l'Arduino devait allumer lui-même chaque ligne, + * très vite, l'une après l'autre (le multiplexage). Il fallait 12 fils. + * + * Ici, chaque LED (WS2812B) contient une minuscule puce électronique. + * Les 256 LED sont reliées les unes aux autres en une longue CHAÎNE, + * et l'Arduino ne leur parle que par UN SEUL FIL : le fil de données. + * + * Imaginez une file de 256 personnes qui se passent un paquet de lettres : + * - l'Arduino envoie une longue suite de couleurs dans le fil ; + * - la 1re LED garde la 1re couleur pour elle, et transmet le reste ; + * - la 2e LED garde la couleur suivante, et transmet le reste ; + * - … et ainsi de suite jusqu'à la 256e. + * Puis chaque LED garde sa couleur affichée jusqu'au prochain envoi. + * Plus besoin de balayage : chaque LED « se souvient » de sa couleur. + * + * L'avantage : un seul fil de données, et chaque LED peut avoir n'importe + * laquelle de 16 millions de couleurs (256 niveaux de rouge × 256 de vert + * × 256 de bleu), au lieu des 8 couleurs « tout ou rien » de la maquette. + * + * + * BIBLIOTHÈQUE NÉCESSAIRE : FastLED + * --------------------------------- + * Dans l'IDE Arduino : menu Outils → Gérer les bibliothèques… + * → chercher « FastLED » → Installer. + * FastLED s'occupe d'envoyer les couleurs dans le fil, au bon rythme + * (800 000 bits par seconde !). Nous, on se contente de remplir un tableau + * de couleurs, puis de dire « envoie » avec FastLED.show(). + * + * + * ORGANISATION DU PROGRAMME + * ------------------------- + * 1. Réglages : broche, taille, luminosité, limite de courant. + * 2. Le tableau de couleurs (une case par LED). + * 3. La fonction XY() : trouver le numéro d'une LED à partir de sa + * position (x, y) sur la matrice. + * 4. Les outils de dessin. + * 5. Les animations. ← c'est ici que vous créez ! + * 6. setup() et loop(). + */ + +// On charge la bibliothèque FastLED. +#include + + +// ============================================================================= +// 1. RÉGLAGES +// ============================================================================= + +// Broche de l'Arduino reliée au fil VERT (DIN) de la matrice, +// à travers une résistance de 330 Ω. +#define PIN_DONNEES 6 + +// Taille de la matrice : 32 colonnes (largeur) × 8 lignes (hauteur). +#define LARGEUR 32 +#define HAUTEUR 8 +#define NB_LEDS (LARGEUR * HAUTEUR) // = 256 + +// LUMINOSITÉ générale, de 0 (éteint) à 255 (maximum). +// Ces LED sont TRÈS lumineuses : 40 suffit largement en intérieur, +// et ça ménage les yeux… et l'alimentation. +#define LUMINOSITE 40 + +// SÉCURITÉ : courant maximum autorisé, en milliampères (1000 mA = 1 A). +// Une LED en blanc à fond consomme environ 60 mA. +// 256 LED × 60 mA = 15 360 mA = plus de 15 A ! +// L'alimentation d'établi en fournit beaucoup moins (souvent 3 à 5 A). +// FastLED calcule à chaque image ce que les LED vont consommer et baisse +// automatiquement la luminosité si on dépasse cette limite. +// → Réglez cette valeur UN PEU EN DESSOUS de la limite de courant de +// l'alimentation (ex. : alimentation limitée à 3 A → 2500 mA ici). +#define COURANT_MAX_MA 2500 + +// ORIENTATION de la matrice. +// Selon la façon dont vous posez la matrice, la LED n° 0 peut se trouver +// dans n'importe quel coin. Lancez l'animation animTestCoins() : le pixel +// ROUGE doit être en HAUT À GAUCHE et le VERT en HAUT À DROITE. +// - Si rouge et vert sont inversés (gauche/droite) → INVERSER_X à true +// - Si rouge et vert sont en bas au lieu d'en haut → INVERSER_Y à true +// (true = vrai, false = faux) +#define INVERSER_X false +#define INVERSER_Y false + + +// ============================================================================= +// 2. LE TABLEAU DE COULEURS +// ============================================================================= +// +// leds[] est une liste de 256 cases, une par LED, numérotées de 0 à 255 +// dans l'ORDRE DE LA CHAÎNE (l'ordre dans lequel passe le fil de données). +// +// Chaque case est de type CRGB : une couleur faite de trois nombres, +// rouge, vert, bleu, chacun de 0 à 255. +// CRGB(255, 0, 0) = rouge vif +// CRGB(255, 128, 0) = orange +// CRGB(20, 0, 40) = violet sombre +// CRGB::Black = noir (éteint) — FastLED connaît aussi les noms +// CRGB::White, CRGB::Red, CRGB::Gold, CRGB::Pink… (noms anglais) +// +// Mémoire : 256 LED × 3 octets = 768 octets, sur les 2048 du Uno. +CRGB leds[NB_LEDS]; + + +// ============================================================================= +// 3. DE LA POSITION (x, y) AU NUMÉRO DE LED +// ============================================================================= +// +// Pour dessiner, on préfère penser en coordonnées, comme sur une feuille +// quadrillée : +// x = colonne, de 0 (à gauche) à 31 (à droite) +// y = ligne, de 0 (en haut) à 7 (en bas) +// +// Mais les LED, elles, sont numérotées dans l'ordre de la chaîne. Et cette +// chaîne fait des ZIGZAGS (on dit « en serpentin ») : elle descend la +// 1re colonne, remonte la 2e, redescend la 3e, etc. +// +// x=0 x=1 x=2 x=3 +// y=0 0 15 16 31 … +// y=1 1 14 17 30 +// y=2 2 13 18 29 +// … … … … … +// y=7 7 → 8 23 → 24 +// ↓ ↑ ↓ ↑ +// +// Les colonnes PAIRES (0, 2, 4…) descendent, les colonnes IMPAIRES +// (1, 3, 5…) remontent. La fonction XY() fait ce calcul pour nous. +// (L'animation animOrdreDesLeds() permet de VOIR ce zigzag.) + +uint16_t XY(int x, int y) { + // Si la matrice est posée « à l'envers », on retourne les coordonnées. + if (INVERSER_X) x = (LARGEUR - 1) - x; + if (INVERSER_Y) y = (HAUTEUR - 1) - y; + + if (x % 2 == 0) { + // Colonne paire : la chaîne DESCEND. + // On saute les x colonnes précédentes (x × 8 LED), puis on descend de y. + return x * HAUTEUR + y; + } else { + // Colonne impaire : la chaîne REMONTE. + // Même chose, mais on compte depuis le bas : (7 - y). + return x * HAUTEUR + (HAUTEUR - 1 - y); + } +} + + +// ============================================================================= +// 4. LES OUTILS DE DESSIN +// ============================================================================= +// +// Ces fonctions modifient le tableau leds[], mais n'allument rien tout de +// suite ! Comme un peintre qui prépare sa toile en coulisses : on dessine +// toute l'image, puis on la montre d'un coup avec FastLED.show(). + +// Colore un pixel. Si (x, y) est en dehors de la matrice, on ne fait rien : +// on peut donc dessiner des formes qui « dépassent » sans risque +// (pratique pour faire défiler une image qui entre et sort de l'écran). +void pixel(int x, int y, CRGB couleur) { + if (x >= 0 && x < LARGEUR && y >= 0 && y < HAUTEUR) { + leds[XY(x, y)] = couleur; + } +} + +// Éteint toute la matrice (dans le tableau seulement). +void effacer() { + fill_solid(leds, NB_LEDS, CRGB::Black); // fill_solid = tout remplir +} + +// Affiche réellement l'image : envoie les 256 couleurs dans le fil. +// Ça prend environ 8 millisecondes. +void montrer() { + FastLED.show(); +} + + +// ============================================================================= +// 5. LES ANIMATIONS +// ============================================================================= +// +// Comme pour la maquette 3 x 3, une animation est une suite d'images : +// effacer / dessiner → montrer() → attendre (delay) → recommencer. +// +// À VOUS DE JOUER : copiez une animation, renommez-la, modifiez-la, +// et ajoutez son nom dans loop() tout en bas. + + +// --- Animation 1 : test des coins (orientation) --- +// Un pixel de couleur dans chaque coin : +// ROUGE en haut à gauche VERT en haut à droite +// BLEU en bas à gauche BLANC en bas à droite +// Si ce n'est pas le cas, changez INVERSER_X / INVERSER_Y (partie 1). +void animTestCoins() { + effacer(); + pixel(0, 0, CRGB::Red); + pixel(LARGEUR - 1, 0, CRGB::Green); + pixel(0, HAUTEUR - 1, CRGB::Blue); + pixel(LARGEUR - 1, HAUTEUR - 1, CRGB::White); + montrer(); + delay(3000); // 3 secondes pour regarder +} + + +// --- Animation 2 : l'ordre de la chaîne --- +// Allume les LED une par une, dans l'ordre où le signal les traverse +// (n° 0, 1, 2… 255), SANS passer par XY(). On voit le serpentin ! +void animOrdreDesLeds() { + effacer(); + for (int i = 0; i < NB_LEDS; i++) { + leds[i] = CRGB::Orange; // la tête du serpent + montrer(); + leds[i] = CRGB(10, 3, 0); // laisse une trace très faible + delay(15); + } +} + + +// --- Animation 3 : arc-en-ciel qui défile --- +// Ici on utilise une autre façon de décrire une couleur : CHSV. +// H (hue, la TEINTE) : de 0 à 255, fait le tour de l'arc-en-ciel +// 0 = rouge, 32 = orange, 64 = jaune, 96 = vert, 128 = cyan, +// 160 = bleu, 192 = violet, 224 = rose… puis retour au rouge. +// S (saturation) : 0 = gris/blanc, 255 = couleur pure. +// V (valeur, la LUMINOSITÉ) : 0 = noir, 255 = plein. +// C'est souvent plus intuitif que RGB pour créer des dégradés. +void animArcEnCiel() { + for (int temps = 0; temps < 256; temps++) { + for (int x = 0; x < LARGEUR; x++) { + for (int y = 0; y < HAUTEUR; y++) { + // La teinte dépend de la colonne (x × 8) et du temps qui passe. + // Un byte revient tout seul à 0 après 255 : la teinte boucle. + byte teinte = x * 8 + temps * 2; + pixel(x, y, CHSV(teinte, 255, 255)); + } + } + montrer(); + delay(20); + } +} + + +// --- Animation 4 : la pluie --- +// Des gouttes tombent au hasard et laissent une traînée qui s'estompe. +void animPluie() { + for (int image = 0; image < 200; image++) { + + // fadeToBlackBy = « assombrir un peu » toutes les LED (ici de 25 % + // environ, 64 sur 256). Les gouttes laissent ainsi une traînée. + fadeToBlackBy(leds, NB_LEDS, 64); + + // Faire descendre toute l'image d'une ligne : on recopie chaque ligne + // dans celle du dessous, en partant du bas pour ne rien écraser. + for (int y = HAUTEUR - 1; y > 0; y--) { + for (int x = 0; x < LARGEUR; x++) { + leds[XY(x, y)] = leds[XY(x, y - 1)]; + } + } + + // La ligne du haut s'éteint… + for (int x = 0; x < LARGEUR; x++) { + pixel(x, 0, CRGB::Black); + } + // … et de nouvelles gouttes apparaissent au hasard. + // random(LARGEUR) = une colonne au hasard entre 0 et 31. + for (int n = 0; n < 3; n++) { + pixel(random(LARGEUR), 0, CRGB(0, 120, 255)); // bleu clair + } + + montrer(); + delay(60); + } +} + + +// --- Animation 5 : un dessin en pixel art qui défile --- +// Le dessin est écrit comme du texte : une ligne de caractères par ligne +// de pixels. Chaque lettre est une couleur (voir couleurDeLettre()), +// et le point « . » est un pixel éteint. +// → Dessinez le vôtre ! Gardez 8 lignes, et la même largeur partout. + +#define DESSIN_LARGEUR 9 +const char* dessin[HAUTEUR] = { + "..RR.RR..", + ".RBRRRRR.", + ".RRRRRRR.", + ".RRRRRRR.", + "..RRRRR..", + "...RRR...", + "....R....", + ".........", +}; + +// Traduit une lettre du dessin en couleur. +CRGB couleurDeLettre(char lettre) { + switch (lettre) { + case 'R': return CRGB::Red; + case 'O': return CRGB::Orange; + case 'J': return CRGB::Yellow; + case 'V': return CRGB::Green; + case 'C': return CRGB::Cyan; + case 'B': return CRGB::White; // B comme blanc + case 'L': return CRGB::Blue; // L comme bLeu (B est déjà pris) + case 'M': return CRGB::Magenta; + case 'P': return CRGB::DeepPink; // P comme rose Pink + default: return CRGB::Black; // « . » et tout le reste = éteint + } +} + +// Dessine le dessin avec son coin haut-gauche en (departX, 0). +void dessinerDessin(int departX) { + for (int y = 0; y < HAUTEUR; y++) { + for (int x = 0; x < DESSIN_LARGEUR; x++) { + char lettre = dessin[y][x]; // la lettre en ligne y, colonne x + if (lettre != '.') { + pixel(departX + x, y, couleurDeLettre(lettre)); + } + } + } +} + +void animDessinQuiDefile() { + // Le dessin entre par la droite (x = 32) et sort par la gauche + // (x = -9, complètement hors de l'écran). + for (int x = LARGEUR; x >= -DESSIN_LARGEUR; x--) { + effacer(); + dessinerDessin(x); + montrer(); + delay(70); + } +} + + +// --- Animation 6 : étincelles --- +// Des pixels de couleur au hasard s'allument puis s'éteignent doucement. +void animEtincelles() { + for (int image = 0; image < 300; image++) { + fadeToBlackBy(leds, NB_LEDS, 20); // tout s'estompe doucement + // random(256) = une teinte au hasard. + pixel(random(LARGEUR), random(HAUTEUR), CHSV(random(256), 200, 255)); + montrer(); + delay(15); + } +} + + +// ============================================================================= +// 6. SETUP ET LOOP +// ============================================================================= + +void setup() { + // On présente la matrice à FastLED : + // - WS2812B : le modèle de LED + // - PIN_DONNEES : la broche du fil de données + // - GRB : l'ordre des couleurs attendu par ces LED (Vert, Rouge, Bleu + // — eh oui, pas RGB ! Si vos rouges sortent verts, c'est ici.) + FastLED.addLeds(leds, NB_LEDS); + + FastLED.setBrightness(LUMINOSITE); + FastLED.setMaxPowerInVoltsAndMilliamps(5, COURANT_MAX_MA); + + // Graine du hasard (voir la maquette 3 x 3 : on lit le bruit + // électrique d'une broche analogique non branchée). + randomSeed(analogRead(A0)); + + effacer(); + montrer(); +} + +// La « playlist » des animations, jouée en boucle. +// Mettez // devant une ligne pour sauter une animation. +void loop() { + animTestCoins(); // 1. orientation (à retirer une fois réglée) + animOrdreDesLeds(); // 2. le serpentin de la chaîne + animArcEnCiel(); // 3. arc-en-ciel + animPluie(); // 4. pluie + animDessinQuiDefile(); // 5. pixel art + animEtincelles(); // 6. étincelles +} diff --git a/matrice_8x32/schema_branchement.svg b/matrice_8x32/schema_branchement.svg new file mode 100644 index 0000000..013f365 --- /dev/null +++ b/matrice_8x32/schema_branchement.svg @@ -0,0 +1,136 @@ + + Branchement matrice WS2812B 8×32, Arduino Uno et alimentation d'établi + + + + + + + + + + + + + Matrice WS2812B 8 × 32 — vue de dos (côté fils) + + + + + les données entrent par DIN et traversent les 256 LED + + + + 5VGNDDOUT + 5VGND + 5VGNDDIN + + + + + + + + + + Sortie DOUT : ne rien brancher + (sert à chaîner un 2e panneau) + + + + + + + + + + + + + − + Condensateur 1000 µF + bande « − » côté GND (fil noir) + patte + côté 5V (fil rouge) + + + + + + + + + + connecteur de la matrice + + fiche fournie (rouge / blanc / vert) + + + + + + + + + + fil rouge : NON branché, isolé (scotch) + + + + + + + + Résistance 330 Ω + (300 à 500 Ω) + + + + + + + GND + ~6 + Arduino Uno + + + 5V + + 5V de l'Arduino : NE PAS relier à la matrice + + + + câble USB → ordinateur + (alimente l'Arduino + téléversement) + + + + Alimentation d'établi + + 5.00 V + 3.00 A + + + tension + courant + + + + + − + bornes de + sortie + + + + Code couleur des fils + + rouge = + 5 V + + noir = GND (masse) + + blanc = GND (masse) + + vert = données + Tous les GND sont reliés : + Arduino ↔ fil blanc ↔ matrice + ↔ fil noir ↔ borne − de l'alim. + Alim. réglée sur 5,0 V maxi ! +