vitrine-pixels/CLAUDE.md

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, services systemd vitrine-pixels (lecteur) et vitrine-web (interface)). Docs : README, INSTALLATION_PI, GUIDE_KRITA, MODE_VITRINE (overlay FS), INTERFACE_WEB, CODER_EN_PYTHON.
• Interface web serveur_web.py (Flask, port 80, gabarits dans web/) : dépôt GIF/PNG/séquences, ordre (renommage 01_…), activer/désactiver (.desactivees/), corbeille (.corbeille/), « jouer maintenant » via post-it /run/vitrine-pixels/demande lu par le lecteur.
• Pi installé : Raspberry Pi 3 Model B, Raspbian 11 Bullseye 32 bits (dossier boot = /boot, Pillow 8.1, Flask 1.1), Ethernet débranché : accès uniquement en Wi-Fi, ssh devel@172.16.50.27 (clé ESADHaR) ; l'ancienne adresse câble était 172.16.7.199. Le Wi-Fi et le filaire de l'école ne se voient pas : depuis le Wi-Fi, page web sur http://172.16.50.27 (adresses DHCP, affichées en bas de la page). Matrice posée debout : ROTATION = 90, image 8 × 32 ; sur la vitrine INVERSER_X = INVERSER_Y = True (demi-tour) et DECALAGE_X = 1 (image décalée d'un pixel vers la droite). Vitesse de lecture réglable depuis la page web (.vitesse.txt, ×0,5 actuellement). QR code et affiche A5 : outils/generer_qrcode.py → qrcode/. Pas de 74AHCT125 pendant le workshop : montage A (GPIO 18 → 330 Ω → DIN, matrice en 4,4 V) testé et validé ; montage B (transistor 2N3904 inverseur) essayé : échec, trop lent (temps de stockage ≈ 0,2 µs face à un « 0 » de 0,4 µs), seule la 1re LED s'allume au hasard. Lecteur vitrine-pixels activé au démarrage le 2026-10-08.
• 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)

#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é ?).