WS2812B 8x32 256pixels
This commit is contained in:
bach
@@ -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).
|
- 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.
|
- 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
|
### Chiffres clés
|
||||||
- 320 LED adressées (8 × 40) → 960 octets de RAM sur Uno (2 Ko) : serré, envisager Mega ou ESP32.
|
- 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.
|
- Rafraîchissement ≈ 30 µs par LED → ≈ 10 ms pour tout le panneau.
|
||||||
|
|||||||
@@ -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.
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
> **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.
|
||||||
Binary file not shown.
|
After Width: | Height: | Size: 37 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 126 KiB |
@@ -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
|
||||||
|
}
|
||||||
@@ -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>
|
||||||
|
After Width: | Height: | Size: 9.0 KiB |
Reference in New Issue
Block a user