bachandClaude Opus 5.5
156f9ce438
- serveur_web.py : séquences limitées à 120 PNG (message clair au-delà), envois jusqu'à 200 Mo, fichiers temporaires sur la carte SD (et plus dans /run, trop petit), garde-fou si une séquence est envoyée dans le cadre « fichiers séparés ». - outils/test_fil_donnees.py : met GPIO 18 à 1 puis à 0 toutes les 10 s, pour suivre le signal au multimètre du Pi jusqu'à DIN. - README : montage A (Pi en direct, LED en 4,4 V) testé et validé ; montage B (transistor 2N3904) déconseillé, trop lent (temps de stockage ≈ 0,2 µs face à un « 0 » de 0,4 µs) ; mise en garde sur les convertisseurs HV/LV ; dépannage « seule la 1re LED s'allume ». - INTERFACE_WEB.md, CLAUDE.md : nouvelles limites, accès au Pi en Wi-Fi seul, lecteur activé au démarrage. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
116 lines
7.8 KiB
Markdown
116 lines
7.8 KiB
Markdown
# 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. 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)
|
||
```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é ?).
|