# Projet : matrice LED RGB 7 × 39 (Arduino)

## Objectif

Construire une matrice LED RGB de **7 lignes × 39 colonnes** (273 pixels), avec un **pas de 10 mm** entre les centres des LED (grille physique déjà définie).

Le projet avance en deux temps :
1. **Maquette expérimentale 3 × 3** en LED RGB classiques multiplexées (en cours).
2. **Matrice finale 7 × 39**, probablement en LED adressables WS2812B (piste privilégiée, pas encore arrêtée).

## Langue et conventions

- Échanges, commentaires de code et noms de variables en **français**.
- Code Arduino (C++), IDE Arduino. Préciser si on passe à arduino-cli ou PlatformIO.
- Garder le code lisible et pédagogique : c'est aussi un projet d'apprentissage du multiplexage.

---

## Étape 1 : maquette 3 × 3 (multiplexage)

### Matériel
- 1 Arduino (Uno supposé, à confirmer).
- 9 LED RGB **à cathode commune**.
- Transistors **NPN BC337** (ou 2N2222), un par ligne, pour commuter le GND des lignes.
  - Kit utilisé : assortiment 10 modèles (A1015, BC327, BC337, C1815, S8050, S8550, 2N2222, 2N2907, 2N3904, 2N3906).
  - Éviter C1815 et 2N3904 (courant max trop juste pour une ligne en blanc ≈ 180 mA).
  - **Attention au brochage** : BC337 = C-B-E, 2N2222 / S8050 en TO-92 = E-B-C. Vérifier la datasheet.

### Principe
- **12 pins Arduino** : 9 pour les couleurs (3 colonnes × R, G, B), 3 pour les bases des transistors de lignes.
- Balayage ligne par ligne : on éteint toutes les lignes, on écrit les 9 pins couleur de la ligne suivante, on allume cette ligne, on attend ~1 à 3 ms, on recommence.
- Toujours **éteindre les lignes avant de changer les couleurs** (évite les « fantômes »).

### Câblage
- Par ligne : émetteur → GND, collecteur → les 3 cathodes de la ligne, base → pin Arduino via **1 kΩ**.
- Par ligne couleur : pin Arduino → résistance → anodes de cette couleur dans la colonne.
  - Rouge ≈ **220 Ω**, vert et bleu ≈ **150 Ω** (≈ 15 mA sous 5 V).
- Logique : pin de ligne HIGH = ligne allumée ; pin couleur HIGH = couleur allumée.

### Affectation des pins (provisoire, à adapter au câblage réel)
| Rôle | Pins |
|---|---|
| Colonne 0 (R, G, B) | 2, 3, 4 |
| Colonne 1 (R, G, B) | 5, 6, 7 |
| Colonne 2 (R, G, B) | 8, 9, 10 |
| Lignes 0, 1, 2 (bases transistors) | 11, 12, 13 |

### Logiciel
- Pas de bibliothèque de matrice dédiée : balayage écrit à la main.
- Bibliothèque **TimerOne** pour rafraîchir par interruption (≈ 1 ms par ligne), afin de laisser `loop()` libre pour les animations.
- Image stockée dans `volatile byte image[3][3]` (bits : 0 = R, 1 = G, 2 = B → 7 couleurs en tout ou rien).
- Étape suivante prévue : **PWM logiciel** dans l'interruption pour mélanger les couleurs (dégradés).

---

## Étape 2 : matrice finale 7 × 39

### Pourquoi pas le multiplexage à cette échelle
- 39 × 3 = 117 lignes couleur → registres à décalage ou drivers (74HC595, TLC5940, STP16CP05).
- Une ligne allumée tire ≈ 2,3 A → MOSFET logic-level nécessaires.
- Luminosité divisée par 7 et PWM lourd pour un Arduino.

### Piste privilégiée : WS2812B
- LED avec puce intégrée, chaînées (DOUT → DIN), **un seul fil de données**.
- Protocole 800 kHz, 24 bits par LED dans l'ordre **GRB**, reset par niveau bas > 50 µs (≥ 280 µs sur versions récentes).
- Bibliothèque : **FastLED** (ou Adafruit NeoPixel).
- Format envisagé : **panneaux flexibles 8 × 32 + 8 × 8** (pas de 10 mm) → matrice 8 × 40, dont on n'utilise que 7 × 39.
  - Ne pas couper la 8e ligne : le serpentin suit les colonnes de 8, couper casserait la chaîne. La 8e ligne reste éteinte (masquée ou repliée doucement à l'arrière).
- 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`.

### Variante Raspberry Pi (dossier `8x32 PI/`)
- Une équipe design dessine les animations dans **Krita** (32 × 8 px, export séquence PNG ou GIF) ; le Pi les joue telles quelles.
- Python : `matrice.py` (moteur : réglages, `XY()`, gamma 2.2, limite de courant, écrans `MatriceReelle` / `Simulateur` tkinter / `Enregistreur` GIF), `lecteur.py` (joue en boucle `/boot/firmware/animations` ou `animations/`), `test_matrice.py`, `mes_animations.py` (animations de l'Arduino traduites).
- Matériel : Pi 3B+ / 4 / Zero 2 W (pas le Pi 5 : `rpi_ws281x` ne le gère pas), GPIO 18 (patte 12) → **74AHCT125** (3,3 V → 5 V, VCC pris sur le fil rouge de la fiche DIN) → 330 Ω → DIN. Audio désactivé (`dtparam=audio=off`).
- Installation : `installation/installer.sh` (venv `~/vitrine-env`, service systemd `vitrine-pixels`). Docs : README, INSTALLATION_PI, GUIDE_KRITA, MODE_VITRINE (overlay FS), CODER_EN_PYTHON.
- Schémas générés par `outils/schemas.py`, exemples et palette Krita par `outils/generer_exemples.py`.

### 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.
- Consommation max ≈ 60 mA par LED en blanc plein → limiter par logiciel :
  `FastLED.setMaxPowerInVoltsAndMilliamps(5, 4000);`
- Alimentation 5 V externe ≈ 10 A, jamais via le 5 V de l'Arduino.

### Câblage
- Résistance 300 à 500 Ω en série sur la ligne de données.
- Condensateur 1000 µF entre 5 V et GND à l'entrée.
- GND Arduino relié au GND de l'alimentation.
- Réinjecter 5 V / GND à plusieurs endroits de la chaîne.

### Correspondance (x, y) → index (serpentin par colonnes de 8)
```cpp
#define HAUTEUR_PANNEAU 8   // 8 LED physiques par colonne, même si on n'en utilise que 7

int XY(int x, int y) {
  if (x % 2 == 0) return x * HAUTEUR_PANNEAU + y;                    // colonnes paires : vers le bas
  else return x * HAUTEUR_PANNEAU + (HAUTEUR_PANNEAU - 1 - y);       // colonnes impaires : vers le haut
}
```
Le sens réel est à vérifier sur les flèches imprimées au dos du panneau (départ en haut ou en bas).

---

## À préciser
- Modèle exact d'Arduino.
- Choix définitif pour la version finale (panneaux WS2812B, bande 100 LED/m, ou multiplexage).
- Usage visé de la matrice (texte défilant, animations, interactivité ?).