Bonjour, de retour sur le forum..
Essayez de ne pas faire de commentaire hors sujet qui mène à comme d’habitude.
Je voudrais un code et une explication de montage pour gérer 88 interrupteurs commandant chacun une led de façon indépendant.
J’attends.
Quand on est trop flemmard pour faire des recherches soit même, que l'on croit que le monde et à ses ordres et que l'on est trop grossier pour dire s'il vous plait, je pense que le meilleur moyen de ne pas être déçu c'est de poser la question à ChatGPT. Je pense que ça tu pourrais y arriver. Cela t'éviterait bien des déconvenues. Le seul effort à fournir, correctement formuler la question.
Vous avez dit :
Sur la base d'un montage Arduino, je voudrais un code et une explication de montage pour gérer 88 interrupteurs commandant chacun une led de façon indépendante.
ChatGPT a dit :
Gérer 88 interrupteurs et 88 LEDs de façon indépendante avec un Arduino est un projet ambitieux, car un Arduino Uno ou Mega n'a pas assez de broches GPIO disponibles pour connecter directement autant de composants.
Pour y parvenir, il faut utiliser des extensions de ports comme :
- Des registres à décalage (ex: 74HC595 pour les sorties LED)
- Des extenseurs d’entrées (ex: 74HC165 ou PCF8574 pour les boutons)
- Ou utiliser un multiplexage ou des matrices
Solution recommandée : Registres à décalage (74HC595) + Entrées en matrice
Objectif
- 88 LEDs → Commandées via registres à décalage 74HC595
- 88 interrupteurs (ou boutons) → Lus via une matrice 11 x 8
Matériel nécessaire
- 11 x 74HC595 (8 sorties chacun → 11 x 8 = 88 sorties pour les LEDs)
- 11 lignes + 8 colonnes de boutons (matrice 11x8 = 88 boutons)
- Résistances de pull-down ou pull-up pour les boutons
- LEDs + résistances (~220Ω)
- Arduino Mega (recommandé pour la RAM et les broches)
- Fils de connexion, breadboards
Principe de fonctionnement
LEDs (sorties)
- Utiliser les registres à décalage 74HC595 pour contrôler les 88 LEDs avec 3 broches Arduino (Data, Clock, Latch)
- Chaque registre gère 8 LEDs
Boutons (entrées)
- Organiser les 88 boutons en matrice : 11 lignes x 8 colonnes
- On connecte les lignes aux sorties numériques (ou aux mêmes 74HC595 si on peut libérer des bits)
- On lit les colonnes via des entrées analogiques ou numériques de l'Arduino
Schéma simplifié
Boutons (Matrice 11 x 8) LEDs via 74HC595
+---------+ +-----------+
| | | |
| Arduino |--(11 lignes)---> | 74HC595 x11 ---> LEDs
| |<--(8 colonnes)-- | |
+---------+ +-----------+
^ ^
| |
Lecture Écriture (Data, Clock, Latch)
Exemple de code Arduino
Connexions LED via 74HC595
- Data → Pin 8
- Clock → Pin 12
- Latch → Pin 11
Stockage des états LED
On va utiliser un tableau de 11 octets (chaque octet = 8 LEDs) pour stocker l’état de chaque LED.
Code
// Connexions 74HC595
const int latchPin = 11;
const int clockPin = 12;
const int dataPin = 8;
// Matrice de boutons : 11 lignes, 8 colonnes
const int numRows = 11;
const int numCols = 8;
int rowPins[numRows] = {2, 3, 4, 5, 6, 7, 9, 10, A0, A1, A2}; // à adapter
int colPins[numCols] = {A3, A4, A5, A6, A7, A8, A9, A10}; // à adapter
// État des LEDs (88 LEDs = 11 x 8 bits)
byte ledState[11] = {0};
void setup() {
// Pins pour 74HC595
pinMode(latchPin, OUTPUT);
pinMode(clockPin, OUTPUT);
pinMode(dataPin, OUTPUT);
// Initialisation des lignes comme sorties
for (int i = 0; i < numRows; i++) {
pinMode(rowPins[i], OUTPUT);
digitalWrite(rowPins[i], LOW);
}
// Initialisation des colonnes comme entrées avec pull-down (ou pull-up selon montage)
for (int i = 0; i < numCols; i++) {
pinMode(colPins[i], INPUT_PULLDOWN);
}
// Allumer toutes les LEDs éteintes au départ
updateLEDs();
}
void loop() {
// Scanner chaque ligne de la matrice de boutons
for (int row = 0; row < numRows; row++) {
digitalWrite(rowPins[row], HIGH); // activer ligne
delayMicroseconds(50); // petit délai pour stabilisation
for (int col = 0; col < numCols; col++) {
if (digitalRead(colPins[col]) == HIGH) { // bouton appuyé
// Inverser l’état de la LED correspondante
ledState[row] ^= (1 << col); // Toggle bit
updateLEDs();
delay(200); // Anti-rebond simple
}
}
digitalWrite(rowPins[row], LOW); // désactiver ligne
}
}
void updateLEDs() {
digitalWrite(latchPin, LOW);
// Envoyer les données dans l’ordre inverse (dernier registre en premier)
for (int i = 10; i >= 0; i--) {
shiftOut(dataPin, clockPin, MSBFIRST, ledState[i]);
}
digitalWrite(latchPin, HIGH);
}
Tests et conseils
- Commencer avec 1 registre 74HC595 et 1 rangée de 8 boutons
- Vérifier que l’appui sur un bouton change bien l’état d’une LED
- Étendre progressivement jusqu’à 88
Alternatives
- Utiliser des PCF8574 (extenseurs d’E/S I2C, 8 bits) pour les entrées : beaucoup plus propres que la matrice.
- Utiliser un multiplexeur CD74HC4067 pour scanner les entrées
- Si tu veux une gestion plus propre, un ESP32 avec plus de broches + meilleure RAM pourrait aider.
Souhaites-tu que je t’aide à générer le PCB, dessiner le schéma de câblage (Fritzing), ou passer à une autre méthode (I2C, multiplexage, etc.) ?
ChatGPT peut commettre des erreurs. Il est recommandé de vérifier les informations importantes. Voir les préférences en matière de cookies.
1 Like
ChatGPT affirme des choses, mais ce n'est pas Dieu le Père...
Pour ce projet, on peut parfaitement utiliser:
− une seule broche (voir exemple) pour mettre les interrupteurs. Je l'ai testé avec des résistances carbone avec une tolérance de 10% et avec 100 boutons. Avec des couches métalliques je sui sûr qu'on peut en mettre plus. Mon problème était surtout de répondre à la question "quand a-t-on besoin de 100 boutons?"
− une seule broche pour les 88 leds si on prend des leds adressables
Pour les boutons, la lecture ci-dessus est en analogique. Si on veut utiliser une structure matricielle pour 88 boutons, cela peut faire un câblage plus important, mais il faut 11 entrées/sorties si on n'y met pas une usine à gaz de multiplexeurs. Avec les 17 entrées d'une nano, cela passe largement.
Pour les deux solutions avec interrupteurs, cela ne fonctionne que si on n'a qu'un seul appui à un instant donné. Si on veut une matrice avec la possibilité d'appuyer sur autant de boutons que l'on veut, il faut une matrice 9x9 soit 18 GPIO ce qui passe si on utilise une Mega.
Pour les liens, il y a les schémas et un programme de test. Il y a tout ce qu'il faut.
[edit]
Si on veut une lecture avec possibilité de lire l'état de tous les boutons, on peut aussi utiliser une lecture analogique de 6 keypads et il faudra alors 6 GPIO en analogique.
Le problème du choix de la solution est surtout lié à la configuration. Par exemple si on veut avoir tous les boutons ensembles, une structure matricielle est possible. Si on veut mettre les boutons autour d'une pièce, cela ferait trop de fils et une structure avec les boutons en série est alors meilleure...
Merci @vileroi , les interrupteurs sont momentanée, et un ou deux interrupteur correspond à une ou deux Led, c’est à définir de ma part. Peux tu m’aiguiller d’avantage, le code doit enregistrer dans une matrice la led qui s’allume.
@fdufnews t’es sympa, mais s’il te plaît ne devie pas le fil. Tu es en mesure de m’aiguiller aussi. C’est ce genre de comportement de certains du club qui mène à ce tu sais. J’apprécie la non intervention de ceux là.
J’ai déjà fais du multiplexage.
Au modérateur : si un jour je dois aller au ban : je souhaite jusqu'au 22eme siècle, car il est essentiel pour moi d’être le meilleur.
Bon !
On fait quoi là, vous continuez à pourrir le fil du sujet et ça va finir comme d’habitude ou alors on essaie de finir le sujet sans qu’il soit complètement réécris par rapport à l’original avant d’être fermé.
La sujet est précisé avant l’intervention des ******
Alors J’ATTENDS !!!
J'aime bien l'intelligence artificielle!
Pour lire une matrice, elle met lignes en LOW:
Puis pour lire les colonnes on commence par mettre une des lignes à HIGH;
Du coup si on appuie sur deux boutons d'une même colonne, on connecte ensemble une entrée à LOW et une entrée à HIGH.
Après, on invente un nouveau mode pour une Mega conseillée:
Et j'aime bien ce commentaire:
Il faut comprendre qu'on les allume à "éteint"
Après si on va plus loin:
Pour les broches, une nano suffit, mais effectivement pour stocker les 88 états des leds, il faut 11 octets (c'est dit dans le programme!), et pour stocker 11 octets, je ne savais pas que cela ne tenait pas dans une plus petite carte!
Des excuses peut être ?
Mais surtout tu fais quoi toi ?
@vileroi t’a donné toutes les informations pour multiplexer tes 88 interrupteurs en analogique.
Mais comme d’habitude tu ne montre aucun code ou essai, voir quelque chose qui indique que tu t’investis dans ton projet, même @jpbbricole qui fait régulièrement du code complet pour les membres du forum, n’intervient pas!
Donc pour moi la balle est dans ton camp, tu as tout ce qu’il faut pour réaliser ton projet et si tu as des questions sur des points que tu n’aurais pas compris ou une problématique dans ton code, tu as t’a disposition plein de gens pour t’aider.
Donc n’attends plus, fonce, nous seront là pour t’épauler!
C’est là ou réside la plus grande fracture entre les gens dit pro IA et les contre IA.
Même si en vrai les contre IA, ne sont pas forcément contre :), bien sûre et que beaucoup s’accorde que c’est un outil très intéressant et utile.
Je fais le même constat que toi, il est quand même assez laborieux de faire produire à l’IA un code complet fonctionnel.
J’avoue que sans vouloir créer de polémique, je n’arrive pas à comprendre comment fait @jpbbricole pour avoir en générale un code d’assez bonne qualité?
Après je n’utilise pas de IA payante, peut être que la différence est vraiment notable?
Et pour gérer les coordonnées de 4 matrices néo Led 8x8 disposées en carré, comment on fait ?
Comment associer les interrupteurs au 4 matrices ?
Je n’ai pas compris ce que tu veux faire, tu as 256 LEDs en matrice et 88 interrupteurs.
tu veux en fonction d’un interrupteur(On/Off):
- allumer/éteindre une triplette de LEDs ?
- activer/désactiver l’animation d’une triplette de LEDs
Je suis désolé mais tes questions sont un peu trop ouvert, il y a une beaucoup de possibilité.
J’ai l’impression que tu veux allumer/eteindre des LEDs.
donc le plus simple est d’avoir dans ta loop l’affichage en continue de ta matrice de LED neo avec Fast.show().
Par contre je ne connais pas le temps d’exécution de cette fonction et si elle est compatible avec la gestion en analogique des interrupteurs (@vileroi ?)
Du coup dans ta partie qui lit l’état de chaque bouton, si tu détecte un changement d’état de ton bouton, tu appliques l’allumage/extinction de ta série de LEDs dans ton tableau(bande de LED, physiquement en matrice) de LEDs.
Je veux allumer puis éteindre la néo Led coordonnée x et y. x entre 0 et 15, Idem y. En couleur jaune. Quand j’appuie sur l’interrupteur n° Z, Z entre 0 et 7, H entre 0 et 70 step 10. Les autres interrupteurs c’est pour autre chose.
Ok, donc je suppose que le lien est directe, car je n’ai pas vraiment compris comment tu associe un interrupteur à une LED.
Tu as mis en pratique le code d’exemple du @vileroi ?
Dans le if(touche != oldTouche) tu appliques la relation entre tes boutons et ta matrice de LED.
tu obtient donc un x et y pour ta LED, que tu va convertir pour ton tableau une dimension de LED utilisé par FastLED X=y*16+x.
Il faut bien sûr que dans le code de @vileroi tu ajoutes l’affichage des LEDs.
La difficulté est d'allumer une des LEDs sur les 4 matrice neoled avec un tableau 16*16
J’attends
Je pense que pour 88 leds il ne faut pas 4 matrices de 8x8, deux suffisent. Sauf si 8 fois 8 font 22...
Les leds se transforment en neoleds, les nombres de leds fluctuent...
Si on veut pouvoir aider, il faut qu'on y comprenne quelque chose. Il nous faut savoir à quoi cela va servir, quels sont les choix des composants qui sont déjà fait, comment va fonctionner l'ensemble...(par exemple un cahier des charges).
Avec ce que je vois, un commutateur à 8 positions serait plus adapté.
Nous attendons un vrai cahier des charges...
D’accord.
Cahier des charges :
4 matrice neoled 8*8 disposée en carré
16+++16 interrupteurs poussoir momentané = 32 ( par coordonnées x et y)
Pour deux interrupteur correspond une led.
On appuie une fois sur deux interrupteur ça allume la neoled correspondant. On re appuie sur l’un des deux ça éteint la neoled, puis sur un autre différents colonne rangée ça allume une nouvelle néo Led correspond aux nouvelles coordonnées.
7 interrupteur à enclenchement pour le choix de la couleur : red Blue green…
Une alimentation correspondant aux neoled.
Un esp 32 lolin32 je pense.
Un circuit imprimé pour les interrupteurs. Un autre pour les neoled.
Objectif faire du pixel Art.
Pouvoir mémoriser dans une matrice objet les étapes du dessin j’ai réalisé et le revoir en accéléré.
Eh oui j’ai un sens artistique assez rétro.
P.s : j’ai l’impression de rêver quand je vois un sujet j’écris se passer normalement.
Merci de votre aide.
Signé : Lapino
Mais alors quel rapport avec les 88 interrupteurs et les 88 leds?
Aucun
J’ai changé le titre du sujet
En gros, tu te moques des personnes qui sont sur le forum. Tu n'est pas intéressé par les 88 leds, tu n'en a rien à faire des réponses qui traite du sujet, et en changeant le titre, ces réponses deviennent introuvables.
Le nouveau sujet a déjà eu récemment trois discussions sur le même sujet:
********************************************************************
Ce serait bien... jusqu'en 2050 comme proposé. Cela permettrait un peu plus de sérénité sur le forum.
Stop spam non publicitaire.
J’attends une réponse en adéquation avec le sujet