bsc/vitrine-pixels
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

WS2812B 8x32 256pixels

Browse Source
This commit is contained in:
bach
2026-10-08 11:03:41 +02:00
parent 06921fde2f
commit 3a0addaa55
6 changed files with 887 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
CLAUDE.md
+5
View File
@@ -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.
matrice_8x32/README.md
+359
View File
@@ -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.
matrice_8x32/WS2812B 8x32 256pixels-back.jpg
BIN
View File
Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 37 KiB

matrice_8x32/WS2812B 8x32 256pixels-front.jpg
BIN
View File
Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 126 KiB

matrice_8x32/matrice_8x32.ino
+387
View File
@@ -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 <FastLED.h>
// =============================================================================
// 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<WS2812B, PIN_DONNEES, GRB>(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
}
matrice_8x32/schema_branchement.svg
+136
View File
@@ -0,0 +1,136 @@
<svg xmlns="http://www.w3.org/2000/svg" width="1200" height="860" viewBox="0 0 1200 860" font-family="Helvetica, Arial, sans-serif">
<title>Branchement matrice WS2812B 8×32, Arduino Uno et alimentation d'établi</title>
<defs>
<pattern id="pix" x="60" y="55" width="30.625" height="30.625" patternUnits="userSpaceOnUse">
<rect x="9" y="9" width="12" height="12" rx="1" fill="#2b2b2b"/>
</pattern>
<marker id="fleche" viewBox="0 0 10 10" refX="8" refY="5" markerWidth="7" markerHeight="7" orient="auto">
<path d="M1 1 L9 5 L1 9 Z" fill="#cfcfcf"/>
</marker>
</defs>
<rect width="1200" height="860" fill="#ffffff"/>
<!-- ===================== MATRICE ===================== -->
<text x="60" y="38" font-size="20" font-weight="bold" fill="#222">Matrice WS2812B 8 × 32 — vue de dos (côté fils)</text>
<rect x="60" y="55" width="980" height="245" rx="6" fill="#141414"/>
<rect x="60" y="55" width="980" height="245" rx="6" fill="url(#pix)"/>
<line x1="760" y1="150" x2="340" y2="150" stroke="#cfcfcf" stroke-width="3" marker-end="url(#fleche)"/>
<text x="550" y="135" font-size="15" fill="#e6e6e6" text-anchor="middle">les données entrent par DIN et traversent les 256 LED</text>
<!-- pastilles imprimées : sortie DOUT (gauche) -->
<g font-size="12" fill="#cfcfcf" text-anchor="middle">
<text x="110" y="268">5V</text><text x="150" y="268">GND</text><text x="194" y="268">DOUT</text>
<text x="490" y="268">5V</text><text x="550" y="268">GND</text>
<text x="880" y="268">5V</text><text x="910" y="268">GND</text><text x="940" y="268">DIN</text>
</g>
<!-- ===================== SORTIE DOUT (non utilisée) ===================== -->
<g stroke-width="5" fill="none" stroke-linecap="round">
<path d="M110 282 V340" stroke="#d62828"/>
<path d="M150 282 V340" stroke="#bdbdbd"/>
<path d="M190 282 V340" stroke="#2a9d3a"/>
</g>
<rect x="96" y="340" width="108" height="24" rx="3" fill="#222"/>
<text x="150" y="390" font-size="14" fill="#555" text-anchor="middle">Sortie DOUT : ne rien brancher</text>
<text x="150" y="408" font-size="13" fill="#888" text-anchor="middle">(sert à chaîner un 2e panneau)</text>
<!-- ===================== ALIMENTATION (fils du milieu) ===================== -->
<g stroke-width="6" fill="none" stroke-linecap="round" stroke-linejoin="round">
<path d="M490 282 V440 H530 V586" stroke="#d62828"/>
<path d="M550 282 V420 H590 V586" stroke="#1a1a1a"/>
</g>
<!-- condensateur entre 5V et GND -->
<line x1="490" y1="352" x2="506" y2="352" stroke="#777" stroke-width="2"/>
<line x1="534" y1="352" x2="550" y2="352" stroke="#777" stroke-width="2"/>
<rect x="506" y="340" width="28" height="24" rx="5" fill="#1f4e9c"/>
<rect x="524" y="340" width="10" height="24" fill="#c9d6ee"/>
<text x="529" y="356" font-size="13" font-weight="bold" fill="#1f4e9c" text-anchor="middle">−</text>
<text x="474" y="340" font-size="14" font-weight="bold" fill="#1f4e9c" text-anchor="end">Condensateur 1000 µF</text>
<text x="474" y="358" font-size="13" fill="#1f4e9c" text-anchor="end">bande « − » côté GND (fil noir)</text>
<text x="474" y="375" font-size="13" fill="#1f4e9c" text-anchor="end">patte + côté 5V (fil rouge)</text>
<!-- ===================== ENTRÉE DIN ===================== -->
<g stroke-width="5" fill="none" stroke-linecap="round" stroke-linejoin="round">
<path d="M880 282 V340" stroke="#d62828"/>
<path d="M910 282 V340" stroke="#bdbdbd"/>
<path d="M940 282 V340" stroke="#2a9d3a"/>
</g>
<rect x="866" y="340" width="88" height="22" rx="3" fill="#222"/>
<rect x="870" y="364" width="80" height="22" rx="3" fill="#3a3a3a"/>
<text x="966" y="358" font-size="13" fill="#555">connecteur de la matrice</text>
<text x="966" y="381" font-size="13" fill="#555">+ fiche fournie (rouge / blanc / vert)</text>
<g stroke-width="5" fill="none" stroke-linecap="round" stroke-linejoin="round">
<path d="M880 386 V420" stroke="#d62828"/>
<path d="M910 386 V524" stroke="#bdbdbd"/>
<path d="M940 386 V440 H990 V452" stroke="#2a9d3a"/>
<path d="M990 492 V524" stroke="#2a9d3a"/>
</g>
<!-- fil rouge isolé -->
<rect x="872" y="418" width="16" height="16" rx="2" fill="#f2c94c"/>
<text x="864" y="431" font-size="13" fill="#b00020" text-anchor="end">fil rouge : NON branché, isolé (scotch)</text>
<!-- résistance -->
<rect x="981" y="452" width="18" height="40" rx="6" fill="#e8d3a8" stroke="#a88a52"/>
<rect x="981" y="460" width="18" height="4" fill="#e67e22"/>
<rect x="981" y="468" width="18" height="4" fill="#e67e22"/>
<rect x="981" y="476" width="18" height="4" fill="#8b4513"/>
<rect x="981" y="484" width="18" height="3" fill="#c9a227"/>
<text x="1010" y="468" font-size="14" font-weight="bold" fill="#7a5a1e">Résistance 330 Ω</text>
<text x="1010" y="486" font-size="13" fill="#7a5a1e">(300 à 500 Ω)</text>
<!-- ===================== ARDUINO ===================== -->
<rect x="760" y="520" width="300" height="190" rx="10" fill="#00878f"/>
<rect x="800" y="526" width="230" height="18" rx="2" fill="#1b1b1b"/>
<rect x="903" y="529" width="14" height="12" fill="#d4af37"/>
<rect x="983" y="529" width="14" height="12" fill="#d4af37"/>
<text x="910" y="562" font-size="14" font-weight="bold" fill="#fff" text-anchor="middle">GND</text>
<text x="990" y="562" font-size="14" font-weight="bold" fill="#fff" text-anchor="middle">~6</text>
<text x="910" y="625" font-size="22" font-weight="bold" fill="#fff" text-anchor="middle">Arduino Uno</text>
<rect x="820" y="686" width="130" height="16" rx="2" fill="#1b1b1b"/>
<rect x="853" y="688" width="14" height="12" fill="#d4af37"/>
<text x="860" y="678" font-size="13" font-weight="bold" fill="#fff" text-anchor="middle">5V</text>
<path d="M852 712 L868 728 M868 712 L852 728" stroke="#d62828" stroke-width="3"/>
<text x="880" y="745" font-size="13" fill="#b00020">5V de l'Arduino : NE PAS relier à la matrice</text>
<!-- USB -->
<rect x="736" y="598" width="34" height="38" rx="3" fill="#b8b8b8"/>
<path d="M736 617 H700 V790" stroke="#555" stroke-width="5" fill="none" stroke-linecap="round"/>
<text x="700" y="812" font-size="14" fill="#333" text-anchor="middle">câble USB → ordinateur</text>
<text x="700" y="830" font-size="13" fill="#777" text-anchor="middle">(alimente l'Arduino + téléversement)</text>
<!-- ===================== ALIMENTATION D'ÉTABLI ===================== -->
<rect x="300" y="500" width="330" height="210" rx="10" fill="#e9ecef" stroke="#adb5bd" stroke-width="2"/>
<text x="465" y="526" font-size="16" font-weight="bold" fill="#333" text-anchor="middle">Alimentation d'établi</text>
<rect x="318" y="540" width="160" height="96" rx="4" fill="#1d2b1d"/>
<text x="398" y="578" font-size="28" font-weight="bold" fill="#7dff7d" text-anchor="middle" font-family="monospace">5.00 V</text>
<text x="398" y="618" font-size="20" fill="#ffb347" text-anchor="middle" font-family="monospace">3.00 A</text>
<circle cx="345" cy="672" r="16" fill="#666"/>
<circle cx="420" cy="672" r="16" fill="#666"/>
<text x="345" y="702" font-size="11" fill="#555" text-anchor="middle">tension</text>
<text x="420" y="702" font-size="11" fill="#555" text-anchor="middle">courant</text>
<circle cx="530" cy="600" r="13" fill="#d62828" stroke="#7a0f0f" stroke-width="2"/>
<circle cx="590" cy="600" r="13" fill="#1a1a1a" stroke="#000" stroke-width="2"/>
<text x="530" y="637" font-size="15" font-weight="bold" fill="#d62828" text-anchor="middle">+</text>
<text x="590" y="637" font-size="15" font-weight="bold" fill="#1a1a1a" text-anchor="middle">−</text>
<text x="560" y="660" font-size="12" fill="#555" text-anchor="middle">bornes de</text>
<text x="560" y="675" font-size="12" fill="#555" text-anchor="middle">sortie</text>
<!-- ===================== LÉGENDE ===================== -->
<rect x="40" y="470" width="236" height="250" rx="8" fill="#f8f9fa" stroke="#dee2e6"/>
<text x="56" y="496" font-size="15" font-weight="bold" fill="#222">Code couleur des fils</text>
<line x1="56" y1="520" x2="90" y2="520" stroke="#d62828" stroke-width="6" stroke-linecap="round"/>
<text x="100" y="525" font-size="14" fill="#333">rouge = + 5 V</text>
<line x1="56" y1="548" x2="90" y2="548" stroke="#1a1a1a" stroke-width="6" stroke-linecap="round"/>
<text x="100" y="553" font-size="14" fill="#333">noir = GND (masse)</text>
<line x1="56" y1="576" x2="90" y2="576" stroke="#bdbdbd" stroke-width="6" stroke-linecap="round"/>
<text x="100" y="581" font-size="14" fill="#333">blanc = GND (masse)</text>
<line x1="56" y1="604" x2="90" y2="604" stroke="#2a9d3a" stroke-width="6" stroke-linecap="round"/>
<text x="100" y="609" font-size="14" fill="#333">vert = données</text>
<text x="56" y="642" font-size="13" fill="#555">Tous les GND sont reliés :</text>
<text x="56" y="660" font-size="13" fill="#555">Arduino ↔ fil blanc ↔ matrice</text>
<text x="56" y="678" font-size="13" fill="#555">↔ fil noir ↔ borne − de l'alim.</text>
<text x="56" y="702" font-size="13" font-weight="bold" fill="#b00020">Alim. réglée sur 5,0 V maxi !</text>
</svg>
Side by Side

After

Width:  |  Height:  |  Size: 9.0 KiB