bsc/vitrine-pixels
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
98fca3314288fa5323a3eea340e637d2c3d601bc
vitrine-pixels/CLAUDE.md
T
bach da4fac3af7 8x32 PI
2026-10-08 15:25:14 +02:00

6.6 KiB
Raw Blame History

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)

#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é ?).
Reference in New Issue View Git Blame Copy Permalink