diff --git a/8x32 PI/README.md b/8x32 PI/README.md index 31d26eb..87f847d 100644 --- a/8x32 PI/README.md +++ b/8x32 PI/README.md @@ -70,7 +70,7 @@ chaîne de LED), l'Arduino est idéal. Pour **diffuser les créations d'une | **Raspberry Pi 3B+, 4 ou Zero 2 W** | 1 | ⚠️ **pas le Pi 5** (voir encadré) | | Bloc secteur USB **officiel** du Pi | 1 | micro-USB 2,5 A (3B+, Zero 2 W) ou USB-C 3 A (Pi 4) | | Carte micro-SD 16 Go ou plus | 1 | « classe 10 » / « A1 » | -| Puce **74AHCT125** (boîtier DIP 14 pattes) | 1 | l'adaptateur 3,3 V → 5 V (partie 4). Le **74HCT125** convient aussi | +| Puce **74AHCT125** (boîtier DIP 14 pattes) | 1 | l'adaptateur 3,3 V → 5 V (partie 4). Le **74HCT125** convient aussi. **Pas de puce ?** Voir les solutions de dépannage, partie 4 | | Alimentation d'établi | 1 | réglée sur **5,0 V**, limite ≈ 3 A | | 2 cordons banane → pince crocodile | 1 rouge + 1 noir | | | Résistance **330 Ω** | 1 | orange-orange-marron | @@ -153,6 +153,63 @@ gauche, la patte 1 est **en bas à gauche**. On compte ensuite dans le sens inverse des aiguilles d'une montre : 1 à 7 en bas, de gauche à droite, puis 8 à 14 en haut, de droite à gauche. +### Pas de 74AHCT125 sous la main ? Deux solutions de dépannage + +**Solution A : baisser la tension de la matrice (conseillée, aucun composant).** +Le seuil du « 1 » vaut 70 % de la tension d'alimentation **des LED**. Si on +alimente la matrice en **4,4 V** au lieu de 5 V, le seuil tombe à +0,7 × 4,4 ≈ **3,1 V**, et les 3,3 V du Pi suffisent. Les WS2812B fonctionnent +entre 3,5 et 5,3 V : 4,4 V ne les gêne pas, elles sont juste un peu moins +lumineuses. + +![Branchement sans puce, solution A](schemas/branchement_sans_puce.svg) + +En résumé : + +``` + Pi patte 12 (GPIO 18) ──[ 330 Ω ]── fil VERT de la fiche DIN + Pi patte 6 (GND) ───────────── fil BLANC de la fiche DIN + fil ROUGE de la fiche DIN : NON branché, isolé (comme avec l'Arduino) + alimentation d'établi : 4,4 V (au lieu de 5,0 V) sur les fils du milieu +``` + +- Réglez l'alimentation d'établi sur **4,4 V** (entre 4,2 et 4,5 V) ; ne + descendez pas sous 4,0 V, les couleurs se dérègleraient (le bleu et le vert + faiblissent en premier). +- ⚠️ Le fil **rouge** de la fiche reste **isolé** : il porte la tension de la + matrice, et ne doit **jamais** toucher une patte du Pi. +- Gardez le fil de données **court** (moins de 30 cm). + +**Solution B : un transistor « inverseur » (si la solution A scintille).** +Avec un transistor NPN du kit, de préférence un **2N3904** (le plus rapide du +kit ; un BC337 ou un S8050 peuvent convenir), on fabrique un adaptateur 5 V. +Le transistor **inverse** le signal (un 1 devient un 0) : il faut le dire au +programme avec `INVERSER_SIGNAL = True` dans [`matrice.py`](matrice.py). + +![Branchement avec un transistor, solution B](schemas/branchement_transistor.svg) + +Le même montage, en schéma électrique : + +``` + fil ROUGE de la fiche (5 V) + │ + [ 1 kΩ ] ← résistance de « tirage » + │ + ├────────── fil VERT de la fiche (DIN) + │ + Pi patte 12 ──[ 1 kΩ ]──── B C transistor NPN 2N3904 + \│/ (vérifier l'ordre E-B-C + E sur la datasheet !) + │ + Pi patte 6 (GND) ───────────────┴───────── fil BLANC de la fiche (GND) +``` + +Ici l'alimentation d'établi reste à **5,0 V**. Le 5 V n'atteint jamais le Pi : +il s'arrête au collecteur du transistor. Ce montage est plus lent qu'un +74AHCT125 : il marche souvent bien, mais c'est un dépannage. + +> Dans les deux cas, le reste (logiciel, installation, Krita) ne change pas. + > **Pourquoi « AHCT » et pas « HC » ?** Les lettres **T** (comme dans HCT, > AHCT) veulent dire que la puce accepte des entrées « faibles » de 3,3 V même > quand elle est alimentée en 5 V. Un 74**HC**125, lui, ne serait pas plus @@ -179,6 +236,11 @@ inverse des aiguilles d'une montre : 1 à 7 en bas, de gauche à droite, puis ![Schéma de branchement](schemas/branchement.svg) +> **Sans 74AHCT125 ?** Cette partie décrit le montage avec la puce. Pour la +> solution A (matrice en 4,4 V), suivez l'étape A ci-dessous en réglant +> l'alimentation sur **4,4 V**, puis le [schéma de la solution A](schemas/branchement_sans_puce.svg) : +> 3 fils seulement entre la fiche et le Pi, pas de plaque d'essai. + **Tout est débranché** : alimentation d'établi éteinte, Pi sans son bloc secteur. @@ -375,6 +437,8 @@ Une fenêtre s'ouvre avec 256 ronds de couleur qui imitent la matrice. | **Le simulateur s'ouvre au lieu de la matrice** | Même cause : `rpi_ws281x` introuvable | Idem | | **Ça marche, puis tout se fige ou scintille quand on branche un casque / lance un son** | La sortie audio utilise le même circuit que GPIO 18 | Vérifier `dtparam=audio=off` dans `/boot/firmware/config.txt`, redémarrer | | **Couleurs aléatoires, scintillement** | Puce absente ou de type HC (sans T) | Vérifier les lettres sur la puce | +| | Montage sans puce (solution A) | Baisser encore un peu l'alimentation (4,2 V), raccourcir le fil vert, ou passer à la solution B | +| **Rien ne s'allume avec le transistor** (solution B) | `INVERSER_SIGNAL` oublié, ou transistor à l'envers | `INVERSER_SIGNAL = True` dans `matrice.py` ; vérifier E-B-C | | | Masse mal serrée | Revérifier toutes les masses | | **Couleurs fausses** (rouge ↔ vert) | Ordre des couleurs | Dans `matrice.py`, remplacer `WS2811_STRIP_GRB` par `WS2811_STRIP_RGB` | | **Les couleurs sombres de mon dessin n'apparaissent pas** | Normal : correction gamma + luminosité faible | Voir [GUIDE_KRITA.md, partie 5](GUIDE_KRITA.md#5-ce-qui-change-entre-lécran-et-les-led) | diff --git a/8x32 PI/outils/schemas.py b/8x32 PI/outils/schemas.py index 491e5de..a63a7b2 100755 --- a/8x32 PI/outils/schemas.py +++ b/8x32 PI/outils/schemas.py @@ -1,6 +1,8 @@ #!/usr/bin/env python3 """Dessine les schémas du dossier « schemas » : - branchement.svg : Raspberry Pi + 74AHCT125 + matrice + alimentation + - branchement_sans_puce.svg : solution A sans puce (matrice en 4,4 V) + - branchement_transistor.svg : solution B sans puce (transistor inverseur) - brochage_74ahct125.svg : la puce adaptatrice de niveau, patte par patte - chaine_krita_matrice.svg : le trajet d'une animation, de Krita à la matrice Usage : python3 outils/schemas.py""" @@ -66,10 +68,9 @@ def hop_h(x_croise, sens=1, r=7): # 1. BRANCHEMENT # ============================================================================= -def branchement(): - s = Svg(1200, 940, "Branchement matrice WS2812B 8×32, Raspberry Pi, 74AHCT125 " - "et alimentation d'établi") - +def _matrice_et_alimentation(s, tension="5.00 V"): + """Partie commune à tous les montages : matrice vue de dos, sortie DOUT, + alimentation d'établi + condensateur, connecteur DIN et sa fiche.""" # ---------- matrice (vue de dos) ---------- s.texte(60, 38, "Matrice WS2812B 8 × 32 — vue de dos (côté fils)", 20, "#222", gras=True) s.add('') @@ -127,6 +128,102 @@ def branchement(): s.texte(966, 358, "connecteur DIN de la matrice", 13, "#555") s.texte(966, 381, "+ fiche fournie (rouge / blanc / vert)", 13, "#555") + +def _resistance_v(s, x, y, couleurs, valeur, sous_titre=None): + """Résistance verticale de 40 de haut, centrée en x, du haut y à y + 40.""" + s.rect(x - 9, y, 18, 40, "#e8d3a8", 6, "#a88a52") + for i, c in enumerate(couleurs): + s.rect(x - 9, y + 8 + i * 8, 18, 4, c) + s.rect(x - 9, y + 32, 18, 3, "#c9a227") + s.texte(x + 18, y + 16, valeur, 13, "#7a5a1e", gras=True) + if sous_titre: + s.texte(x + 18, y + 33, sous_titre, 12, "#7a5a1e") + + +def _resistance_h(s, x, y, couleurs, valeur): + """Résistance horizontale de 40 de large, centrée en y, de x à x + 40.""" + s.rect(x, y - 9, 40, 18, "#e8d3a8", 6, "#a88a52") + for i, c in enumerate(couleurs): + s.rect(x + 8 + i * 8, y - 9, 4, 18, c) + s.rect(x + 32, y - 9, 3, 18, "#c9a227") + s.texte(x + 20, y - 15, valeur, 13, "#7a5a1e", "middle", True) + + +ANNEAUX_330 = ["#e67e22", "#e67e22", "#8b4513"] # orange-orange-marron +ANNEAUX_1K = ["#8b4513", "#1a1a1a", ROUGE] # marron-noir-rouge + + +def _raspberry_pi(s, x0, pas=16, y=645): + """Carte Raspberry Pi avec son connecteur 40 pattes. + x0 = abscisse de la patte 2 ; renvoie un dictionnaire n° de patte → x.""" + largeur = 19 * pas + 104 + gauche = x0 - 52 + s.rect(gauche, y, largeur, 230, "#1f7a3a", 12) + s.rect(x0 - 13, y + 10, 19 * pas + 26, 42, "#143d20", 3) + xs = {} + for i in range(20): + for n, yy in ((2 * i + 2, y + 21), (2 * i + 1, y + 39)): # bord : paires + xs[n] = x0 + i * pas + couleur = "#d4af37" + if n in (2, 4): + couleur = ROUGE + elif n in (6, 14): + couleur = NOIR + elif n == 12: + couleur = JAUNE_GPIO + s.rect(xs[n] - 5, yy - 5, 10, 10, couleur, 1) + s.texte(x0 - 9, y + 25, "2", 9, "#cde", "end") + s.texte(x0 - 9, y + 43, "1", 9, "#cde", "end") + s.texte(x0 + 19 * pas + 9, y + 25, "40", 9, "#cde") + s.texte(x0 + 19 * pas + 9, y + 43, "39", 9, "#cde") + centre = gauche + largeur / 2 + s.texte(centre, y + 125, "Raspberry Pi", 24, "#fff", "middle", True) + s.texte(centre, y + 149, "3B+, 4 ou Zero 2 W (pas le Pi 5)", 14, "#d8f0dd", "middle") + s.texte(xs[12] + 3, y + 67, "patte 12 = GPIO 18", 12, "#ffe08a", "start", True) + s.texte(xs[6] - 2, y + 67, "patte 6 = GND", 12, "#fff", "end", True) + s.add(f'') + s.texte(gauche + 56, y + 201, "pattes 2 et 4 (5 V) : NE PAS relier à la matrice", 12, "#ffd6d6") + # alimentation USB du Pi + droite = gauche + largeur + s.rect(droite, y + 145, 18, 34, "#b8b8b8", 3) + s.fil(f"M{droite + 18} {y + 162} H{droite + 30} V{y + 255}", "#555") + s.texte(droite + 25, y + 273, "bloc secteur USB du Pi", 13, "#333", "end") + s.texte(droite + 25, y + 290, "(5 V, 2,5 A ou plus)", 12, "#777", "end") + return xs + + +def _legende(s, fils, lignes_gnd, alerte, notes=()): + s.rect(40, 470, 236, 140 + 28 * len(fils) + 18 * len(lignes_gnd) + 14 * len(notes), + "#f8f9fa", 8, "#dee2e6") + s.texte(56, 496, "Code couleur des fils", 15, "#222", gras=True) + for i, (c, t) in enumerate(fils): + y = 520 + i * 28 + s.add(f'') + s.texte(100, y + 5, t, 14) + y = 520 + len(fils) * 28 + 10 + for ligne in lignes_gnd: + s.texte(56, y, ligne, 13, "#555") + y += 18 + y += 6 + s.texte(56, y, alerte, 13, "#b00020", gras=True) + y += 22 + for ligne in notes: + s.texte(56, y, ligne, 12, "#777") + y += 14 + + +FILS_5V = [(ROUGE, "rouge = + 5 V"), (NOIR, "noir = GND (masse)"), + (BLANC_FIL, "blanc = GND (masse)"), (VERT, "vert = données 5 V"), + (JAUNE_GPIO, "jaune = données 3,3 V")] + + +def branchement(): + s = Svg(1200, 940, "Branchement matrice WS2812B 8×32, Raspberry Pi, 74AHCT125 " + "et alimentation d'établi") + _matrice_et_alimentation(s) + # ---------- plaque d'essai + 74AHCT125 ---------- s.rect(700, 425, 440, 190, "#f6f1e3", 8, "#d9cfb2", 2) s.texte(1132, 608, "plaque d'essai", 12, "#a8997a", "end") @@ -164,75 +261,114 @@ def branchement(): s.texte(broche_bas(3) + 6, 545, "1Y", 11, VERT, "start", True) s.texte(broche_bas(7) + 8, 545, "GND", 11, "#333", "start", True) - # résistance 330 Ω - s.rect(1071, 470, 18, 40, "#e8d3a8", 6, "#a88a52") - for y, c in [(478, "#e67e22"), (486, "#e67e22"), (494, "#8b4513")]: - s.rect(1071, y, 18, 4, c) - s.rect(1071, 502, 18, 3, "#c9a227") - s.texte(1098, 486, "330 Ω", 13, "#7a5a1e", gras=True) + _resistance_v(s, 1080, 470, ANNEAUX_330, "330 Ω") s.texte(966, 404, "fil rouge de la fiche : il alimente", 12, ROUGE, gras=True) s.texte(966, 418, "la puce (patte 14 = VCC, 5 V)", 12, ROUGE, gras=True) # ---------- Raspberry Pi ---------- - s.rect(700, 645, 440, 230, "#1f7a3a", 12) - s.rect(750, 655, 336, 42, "#143d20", 3) - x0 = broche_bas(2) - 80 # x de la patte 2 → la patte 12 tombe sous « 1A » - for i in range(20): - for rang, y in ((0, 666), (1, 684)): # rangée du bord : pattes paires - n = 2 * i + 2 if rang == 0 else 2 * i + 1 - couleur = "#d4af37" - if n in (2, 4): - couleur = ROUGE - elif n in (6, 14): - couleur = NOIR - elif n == 12: - couleur = JAUNE_GPIO - s.rect(x0 + i * 16 - 5, y - 5, 10, 10, couleur, 1) - s.texte(x0 - 9, 670, "2", 9, "#cde", "end") - s.texte(x0 - 9, 688, "1", 9, "#cde", "end") - s.texte(x0 + 19 * 16 + 9, 670, "40", 9, "#cde") - s.texte(x0 + 19 * 16 + 9, 688, "39", 9, "#cde") - - # GPIO 18 (patte 12) → 1A (patte 2) - s.fil(f"M{broche_bas(2)} 528 V661", JAUNE_GPIO) - # GND (patte 6) ← rail - s.fil(f"M780 585 V630 H{x0 + 32} V661", NOIR, 4) - - s.texte(920, 770, "Raspberry Pi", 24, "#fff", "middle", True) - s.texte(920, 794, "3B+, 4 ou Zero 2 W (pas le Pi 5)", 14, "#d8f0dd", "middle") - s.texte(x0 + 80, 712, "patte 12 = GPIO 18", 12, "#ffe08a", "start", True) - s.texte(x0 + 30, 712, "patte 6 = GND", 12, "#fff", "end", True) - s.add(f'') - s.texte(x0 + 34, 846, "pattes 2 et 4 (5 V) : NE PAS relier à la matrice", 12, "#ffd6d6") - - # alimentation USB du Pi - s.rect(1140, 790, 18, 34, "#b8b8b8", 3) - s.fil("M1158 807 H1180 V900", "#555") - s.texte(1170, 918, "bloc secteur USB du Pi", 13, "#333", "end") - s.texte(1170, 935, "(5 V, 2,5 A ou plus)", 12, "#777", "end") - - # ---------- légende ---------- - s.rect(40, 470, 236, 300, "#f8f9fa", 8, "#dee2e6") - s.texte(56, 496, "Code couleur des fils", 15, "#222", gras=True) - for i, (c, t) in enumerate([(ROUGE, "rouge = + 5 V"), (NOIR, "noir = GND (masse)"), - (BLANC_FIL, "blanc = GND (masse)"), (VERT, "vert = données 5 V"), - (JAUNE_GPIO, "jaune = données 3,3 V")]): - y = 520 + i * 28 - s.add(f'') - s.texte(100, y + 5, t, 14) - s.texte(56, 670, "Tous les GND sont reliés :", 13, "#555") - s.texte(56, 688, "Pi ↔ puce ↔ fil blanc ↔ matrice", 13, "#555") - s.texte(56, 706, "↔ fil noir ↔ borne − de l'alim.", 13, "#555") - s.texte(56, 730, "Alim. réglée sur 5,0 V maxi !", 13, "#b00020", gras=True) - s.texte(56, 752, "Un pont = les fils se croisent", 12, "#777") - s.texte(56, 766, "sans se toucher.", 12, "#777") + pattes = _raspberry_pi(s, broche_bas(2) - 80) # la patte 12 tombe sous « 1A » + s.fil(f"M{broche_bas(2)} 528 V661", JAUNE_GPIO) # GPIO 18 → 1A + s.fil(f"M780 585 V630 H{pattes[6]} V661", NOIR, 4) # GND (patte 6) ← rail + _legende(s, FILS_5V, + ["Tous les GND sont reliés :", "Pi ↔ puce ↔ fil blanc ↔ matrice", + "↔ fil noir ↔ borne − de l'alim."], + "Alim. réglée sur 5,0 V maxi !", + ["Un pont = les fils se croisent", "sans se toucher."]) s.save("branchement.svg") +def branchement_sans_puce(): + """Solution A : pas d'adaptateur, la matrice est alimentée en 4,4 V.""" + s = Svg(1200, 940, "Branchement sans 74AHCT125 (solution A) : matrice en 4,4 V, " + "Raspberry Pi relié directement") + _matrice_et_alimentation(s, "4.40 V") + + pattes_x0 = 832 # le Pi doit tenir dans la largeur du dessin + # fil rouge de la fiche : isolé + s.fil("M880 386 V420", ROUGE) + s.rect(872, 418, 16, 16, "#f2c94c", 2) + s.texte(864, 431, "fil rouge : NON branché, isolé (scotch)", 13, "#b00020", "end", True) + # fil vert → 330 Ω → patte 12 ; fil blanc → patte 6 + s.fil("M940 386 V440 H948 V470", VERT) + _resistance_v(s, 948, 470, ANNEAUX_330, "330 Ω", "(300 à 500 Ω)") + pattes = _raspberry_pi(s, pattes_x0, pas=14) + s.fil(f"M948 510 V620 H{pattes[12]} V661", JAUNE_GPIO) + s.fil(f"M910 386 V600 H{pattes[6]} V661", BLANC_FIL) + + # encadré d'explication + s.rect(660, 455, 230, 120, "#fff8e1", 8, "#f2c94c", 2) + for i, (t, gras) in enumerate([("Pourquoi 4,4 V ?", True), + ("Le « 1 » doit dépasser 70 %", False), + ("de la tension des LED :", False), + ("0,7 × 4,4 V ≈ 3,1 V", True), + ("→ les 3,3 V du Pi suffisent.", False)]): + s.texte(675, 480 + i * 20, t, 13, "#7a5a00", gras=gras) + + _legende(s, [(ROUGE, "rouge = + 4,4 V"), (NOIR, "noir = GND (masse)"), + (BLANC_FIL, "blanc = GND (masse)"), (VERT, "vert = données"), + (JAUNE_GPIO, "jaune = données 3,3 V")], + ["Tous les GND sont reliés :", "Pi ↔ fil blanc ↔ matrice", + "↔ fil noir ↔ borne − de l'alim."], + "Alim. réglée sur 4,4 V !", + ["Entre 4,2 et 4,5 V.", "Fil de données : moins de 30 cm."]) + s.save("branchement_sans_puce.svg") + + +def branchement_transistor(): + """Solution B : un transistor NPN (2N3904) en inverseur, matrice en 5 V.""" + s = Svg(1200, 940, "Branchement sans 74AHCT125 (solution B) : transistor 2N3904 " + "en adaptateur de niveau") + _matrice_et_alimentation(s) + + s.rect(700, 425, 440, 190, "#f6f1e3", 8, "#d9cfb2", 2) + s.texte(1132, 608, "plaque d'essai", 12, "#a8997a", "end") + + XC = 1030 # verticale du collecteur et de l'émetteur + XB = 1013 # barre de base du transistor + # rouge (5 V) → résistance de tirage 1 kΩ → nœud du collecteur + s.fil(f"M880 386 V440 H{XC} V455", ROUGE) + _resistance_v(s, XC, 455, ANNEAUX_1K, "1 kΩ", "tirage") + # vert (DIN) ← nœud du collecteur + s.fil(f"M940 386 V400 H1100 V505 H{XC}", VERT) + s.fil(f"M{XC} 495 V520", VERT) + s.point(XC, 505, VERT) + # transistor NPN + s.add(f'') + s.add(f'') + s.fil(f"M{XB} 534 L{XC} 520", "#333", 3) + s.fil(f"M{XB} 546 L{XC} 560 V585", "#333", 3) + s.add(f'') + s.texte(XC + 10, 524, "C", 12, "#333", gras=True) + s.texte(XC + 10, 570, "E", 12, "#333", gras=True) + s.texte(XB - 4, 528, "B", 12, "#333", "end", True) + s.texte(XC + 26, 545, "2N3904", 13, "#333", gras=True) + s.texte(XC + 26, 561, "(NPN)", 12, "#555") + # base ← 1 kΩ ← GPIO 18 + pattes_x0 = 843 - 80 + _resistance_h(s, 930, 540, ANNEAUX_1K, "1 kΩ") + s.fil(f"M970 540 H{XB}", JAUNE_GPIO, 4) + s.fil(f"M843 661 V540 {hop_h(910, 1)} H930", JAUNE_GPIO) + # masses : blanc → rail → émetteur et Pi + s.fil(f"M910 386 V585 H{XC}", BLANC_FIL) + s.point(XC, 585, NOIR) + s.point(910, 585, BLANC_FIL) + pattes = _raspberry_pi(s, pattes_x0) + s.fil(f"M910 585 V630 {hop_h(843, -1)} H{pattes[6]} V661", NOIR, 4) + + s.texte(712, 448, "fil rouge (5 V) : seulement", 11, ROUGE, gras=True) + s.texte(712, 461, "vers la résistance de tirage", 11, ROUGE, gras=True) + + _legende(s, FILS_5V, + ["Tous les GND sont reliés :", "Pi ↔ émetteur ↔ fil blanc", + "↔ matrice ↔ borne − de l'alim."], + "Dans matrice.py :", + ["INVERSER_SIGNAL = True", "(le transistor inverse le signal)", + "Vérifier l'ordre E-B-C du", "transistor sur sa datasheet !"]) + s.save("branchement_transistor.svg") + + # ============================================================================= # 2. BROCHAGE DU 74AHCT125 # ============================================================================= @@ -285,7 +421,7 @@ def chaine(): ("#c9682a", "3. Vérifier", ["verifier_animation.py", "+ simulateur", "sur l'ordinateur"]), ("#b08900", "4. Déposer", ["dossier « animations »", "carte SD ou réseau", "(01_, 02_… = ordre)"]), ("#1f7a3a", "5. Lire", ["Raspberry Pi", "lecteur.py : gamma,", "luminosité, serpentin"]), - ("#2f6fc4", "6. Afficher", ["74AHCT125 (3,3 → 5 V)", "puis 256 LED", "WS2812B"]), + ("#2f6fc4", "6. Afficher", ["adaptateur 3,3 → 5 V", "(ou matrice en 4,4 V)", "puis 256 LED WS2812B"]), ] larg, ecart = 170, 28 for i, (c, titre, lignes) in enumerate(etapes): @@ -311,6 +447,8 @@ def chaine(): if __name__ == "__main__": os.makedirs(SORTIE, exist_ok=True) branchement() + branchement_sans_puce() + branchement_transistor() brochage() chaine() print("Schémas écrits dans", SORTIE) diff --git a/8x32 PI/schemas/branchement.svg b/8x32 PI/schemas/branchement.svg index be6ffb7..13e2689 100644 --- a/8x32 PI/schemas/branchement.svg +++ b/8x32 PI/schemas/branchement.svg @@ -109,8 +109,8 @@ 330 Ω fil rouge de la fiche : il alimente la puce (patte 14 = VCC, 5 V) - - + + @@ -155,19 +155,19 @@ 1 40 39 + Raspberry Pi + 3B+, 4 ou Zero 2 W (pas le Pi 5) + patte 12 = GPIO 18 + patte 6 = GND + + pattes 2 et 4 (5 V) : NE PAS relier à la matrice + + + bloc secteur USB du Pi + (5 V, 2,5 A ou plus) - Raspberry Pi - 3B+, 4 ou Zero 2 W (pas le Pi 5) - patte 12 = GPIO 18 - patte 6 = GND - - pattes 2 et 4 (5 V) : NE PAS relier à la matrice - - - bloc secteur USB du Pi - (5 V, 2,5 A ou plus) - + Code couleur des fils rouge = + 5 V diff --git a/8x32 PI/schemas/branchement_sans_puce.svg b/8x32 PI/schemas/branchement_sans_puce.svg new file mode 100644 index 0000000..a9070a1 --- /dev/null +++ b/8x32 PI/schemas/branchement_sans_puce.svg @@ -0,0 +1,150 @@ + + Branchement sans 74AHCT125 (solution A) : matrice en 4,4 V, Raspberry Pi relié directement + + + Matrice WS2812B 8 × 32 — vue de dos (côté fils) + + + + + les données entrent par DIN et traversent les 256 LED + 5V + GND + DOUT + 5V + GND + 5V + GND + DIN + + + + + Sortie DOUT : ne rien brancher + (sert à chaîner un 2e panneau) + + + + + + + − + Condensateur 1000 µF + bande « − » côté GND (fil noir) + patte + côté 5V (fil rouge) + + Alimentation d'établi + + 4.40 V + 3.00 A + + tension + + courant + + + + + − + bornes de + sortie + + + + + + connecteur DIN de la matrice + + fiche fournie (rouge / blanc / vert) + + + fil rouge : NON branché, isolé (scotch) + + + + + + + 330 Ω + (300 à 500 Ω) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 2 + 1 + 40 + 39 + Raspberry Pi + 3B+, 4 ou Zero 2 W (pas le Pi 5) + patte 12 = GPIO 18 + patte 6 = GND + + pattes 2 et 4 (5 V) : NE PAS relier à la matrice + + + bloc secteur USB du Pi + (5 V, 2,5 A ou plus) + + + + Pourquoi 4,4 V ? + Le « 1 » doit dépasser 70 % + de la tension des LED : + 0,7 × 4,4 V ≈ 3,1 V + → les 3,3 V du Pi suffisent. + + Code couleur des fils + + rouge = + 4,4 V + + noir = GND (masse) + + blanc = GND (masse) + + vert = données + + jaune = données 3,3 V + Tous les GND sont reliés : + Pi ↔ fil blanc ↔ matrice + ↔ fil noir ↔ borne − de l'alim. + Alim. réglée sur 4,4 V ! + Entre 4,2 et 4,5 V. + Fil de données : moins de 30 cm. + diff --git a/8x32 PI/schemas/branchement_transistor.svg b/8x32 PI/schemas/branchement_transistor.svg new file mode 100644 index 0000000..d21aca3 --- /dev/null +++ b/8x32 PI/schemas/branchement_transistor.svg @@ -0,0 +1,170 @@ + + Branchement sans 74AHCT125 (solution B) : transistor 2N3904 en adaptateur de niveau + + + Matrice WS2812B 8 × 32 — vue de dos (côté fils) + + + + + les données entrent par DIN et traversent les 256 LED + 5V + GND + DOUT + 5V + GND + 5V + GND + DIN + + + + + Sortie DOUT : ne rien brancher + (sert à chaîner un 2e panneau) + + + + + + + − + Condensateur 1000 µF + bande « − » côté GND (fil noir) + patte + côté 5V (fil rouge) + + Alimentation d'établi + + 5.00 V + 3.00 A + + tension + + courant + + + + + − + bornes de + sortie + + + + + + connecteur DIN de la matrice + + fiche fournie (rouge / blanc / vert) + + plaque d'essai + + + + + + + 1 kΩ + tirage + + + + + + + + + C + E + B + 2N3904 + (NPN) + + + + + + 1 kΩ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 2 + 1 + 40 + 39 + Raspberry Pi + 3B+, 4 ou Zero 2 W (pas le Pi 5) + patte 12 = GPIO 18 + patte 6 = GND + + pattes 2 et 4 (5 V) : NE PAS relier à la matrice + + + bloc secteur USB du Pi + (5 V, 2,5 A ou plus) + + fil rouge (5 V) : seulement + vers la résistance de tirage + + Code couleur des fils + + rouge = + 5 V + + noir = GND (masse) + + blanc = GND (masse) + + vert = données 5 V + + jaune = données 3,3 V + Tous les GND sont reliés : + Pi ↔ émetteur ↔ fil blanc + ↔ matrice ↔ borne − de l'alim. + Dans matrice.py : + INVERSER_SIGNAL = True + (le transistor inverse le signal) + Vérifier l'ordre E-B-C du + transistor sur sa datasheet ! + diff --git a/8x32 PI/schemas/chaine_krita_matrice.svg b/8x32 PI/schemas/chaine_krita_matrice.svg index 69b3ec1..445c12d 100644 --- a/8x32 PI/schemas/chaine_krita_matrice.svg +++ b/8x32 PI/schemas/chaine_krita_matrice.svg @@ -46,9 +46,9 @@ 6. Afficher - 74AHCT125 (3,3 → 5 V) - puis 256 LED - WS2812B + adaptateur 3,3 → 5 V + (ou matrice en 4,4 V) + puis 256 LED WS2812B De Krita à la matrice Étapes 1 à 4 : l'équipe design, sur n'importe quel ordinateur. Étapes 5 et 6 : automatiques, dans la vitrine.