Bonjour à tous!
J'ai une question concernant le mulitplexage en général:
Quasi tous les projets impliquant du multiplexage que j'ai vus étaient câblés avec des grilles en [8 x quelquechose],
et on m'a d'ailleurs moi-même conseillé de faire pareil sur ce forum.
J'aimerais comprendre pourquoi?
Merci
Très difficile de répondre à ta question sans boule de cristal,
Tout dépend du nombre d'équipements que tu as à raccorder et de manière plus générale de l'architecture du système
[b]le bon sens est un fardeau, car il faut s'entendre avec ceux qui ne l'ont pas [/b]
Le multiplexage permet de lire des touches de clavier par exemple, le but est pouvoir lire plus de touches que le nombre de fils utilisés.
Le nombre de croisement entre x et y est donc le produit.
Si X= 4 et y=2 on a 6 fils et 8 contacts, pas trop intéressant...
Si x=8 et y=8 on a 16 fils et 64 contacts, un bon gain.
On lit par exemple les X a chaque passage soit 8 contacts.
Il suffit alors de mettre un 1 sur un bit de Y et les autres à 0, la touche enclenchée sera 1 bit de X, le poids de la colonne Y vaudra (numéro du bit y) x (8 fils sur x) et la touche sera la somme des 2 (no du bit x) et y.
exemple de codage 4 x 4 soit 8 fils et 16 contacts
Code:0 4 8 12 ============== 0| 0 4 8 12 1| 1 5 9 13 2| 2 6 10 14 3| 3 7 11 15
Merci pour vos réponses!
Je sais bien à quoi sert le multiplexage, c'est juste que je ne comprends pas d'où sort ce 8 "magique".
je me demandais s'il y'avait un rapport avec les bytes par exemple... pourquoi il vaut mieux du 16x8 (24 entrées) que du 11x12 (23 entrées)?
(ou alors c'est une coïncidence que je voie des 8 partout, et le 11x12 est mieux?)
Architecture du système, c'est à dire? quel µc?Tout dépend du nombre d'équipements que tu as à raccorder et de manière plus générale de l'architecture du système
exemple de procédure de lecture 4x4
Code:// initialiser les pins dans le setup // A0 - A3 en entrée (résistance pull down) // et 2-4 en sortie les mettre à 0 int readKB(void); { int x,y; int r; int pin = 2; // pin de 2 à 5 y =0; for (x=0; x<3; x++) { digitalWrite(pin,HIGH); // sélectionner la colonne r = digitalRead(A0); digitalWrite(pin,LOW);// désélectionner la colonne pin++; // pin suivante if (r != 0) return(r+y); // touche trouvée y = y + 4; } return(-1); // rien lu }
On met le chiffre qu'on veut , mais les processeurs 8 bits peuvent lire 8 bits d'un coup donc le code asm sera plus optimisé, mais il est préférable pour le code d'utiliser des puissances de 2
exemple (2 4 8 16 etc...)
ok ok, donc c'est pour des raisons de vitesse uniquement?
Pour la raison qu'un octet c'est 8 bits comme il a été dit, donc plus efficace que 9... où il faudra 2 octets ou bricoler salement
Par exemple si tu fais un clavier pour coder 16 touches tu utilises un octet avec par exemple pour le quartet haut les 4 lignes et pour le quartet bas les 4 colonnes.
Plus qu'à filtrer avec des masques pour savoir quelle ligne et quelle colonne correspondent au bouton appuyé.
Pour la détection il y a 2 méthodes (en fait il y en a plus)
Soit on scanne chaque entrée (en lisant le port cycliquement) soit on utilise les interruptions par changement d'état. Ca évite de perdre du temps comme dans le cas du scan, voir de rater l'appui d'une touche.
Je corrige mon exemple en C Arduino.
(sur Arduino les pins ne correspondent pas forcément à 1 port entier)
La question du post#1 ne spécifie pas le µp, mon exemple n'était peut être pas utile, mais bon ...
De toute façon la logique est la même.
Le code serait plus rapide en asm qui permettrait de lire un octet complet.
La fonction digitalRead lit un bit pas un octet
Le test se fera donc bit par bit sur le X
Code:// initialiser les pins dans le setup // A0 - A3 en entrée (résistance pull down) // et 2-4 en sortie les mettre à 0 int readKB(void); { int x,y; int r; int pin = 2; // pin de 2 à 5 // met à 0 les fils Y for (x=0; x<3; x++) digitalWrite(pin++,LOW);// désélectionner la colonne pin=2; y =0; for (x=0; x<3; x++) { digitalWrite(pin,HIGH); // sélectionner la colonne if (digitalRead(A0) != LOW) return(y); // touche trouvée if (digitalRead(A1) != LOW) return(1+y); // touche trouvée if (digitalRead(A2) != LOW) return(2+y); // touche trouvée if (digitalRead(A3) != LOW) return(3+y); // touche trouvée digitalWrite(pin,LOW);// désélectionner la colonne pin++; // pin suivante y = y + 4; } return(-1); // rien lu }
bonsoir
en effet en assembleur cela serait plus rapide et en plus on pourrait supprimer les rebonds.
la bonne solution c'est d'utiliser une interruption Timer et de faire donc un balayage cyclique, s'il est assez rapide, mais n’exagérons rien un truc à 50Hz est plus que suffisant, on aura les valeurs attendues.
JR
l'électronique c'est pas du vaudou!
Même avec un code "bourrin" Arduino , un seul passage ne doit prendre que quelques µs.
50 fois par seconde c est luxueux LOL
Après le reste dépend de l'application.
bonjour,
en effet 50Hz cela peut être jugé un peu rapide mais cela permet de ventiler l'analyse du clavier sur plusieurs cycle sans pour autant être trop lent au niveau réactivité.
JR
l'électronique c'est pas du vaudou!
Wouah! J'ignorais complètement la présence de pins d'interruption sur les µc (je suis un adepte de l'Arduino, et ducoup j'ai cru que je n'avais pas besoin de lire la datasheet du 328P... honte à moi!)!
C'est une fonctionnalité super intéressante voire primordiale je trouve, nan? ducoup j'ai potassé la section interrupt de la datasheet, et j'ai une tonne de questions qui me sont venues,
un peu trop sûrement, j'ai peur de vous en demander trop...
Mais si on reprend l'exemple de HULK23, avec une matrice de 4x4 (16 touches donc), le déroulement du code donnerait quoi?
J'ai essayé de pondre quelque chose, c'est pas fou, et j'ai pas encore l'habitude des opérateurs bit à bit, mais ça vous prouvera mon intérêt pour la chose
Code:#define NB_LIGNES 4 #define NB_COLONNES 4 volatile byte state = 0; void setup() { DDRB = B11110000; // 4 entrées et 4 sorties PORTB = B00000000; // Tout en LOW (pull-ups en hardware) PCMSK0 = B00001111; // PCMSK0 contient les pins 0..7 du portB. // On traite uniquement les entrées PCICR = B00000001; // PCIE Pin Change Interrupt Enable sur banque 0 (pins 0 à 7 en prenant en compte le masque // donc PCINT3..0) PCIFR = B00000001; // PCIF0 Pin Change Interrupt Flag 0. Je ne suis pas certain de devoir activer les Flags, // j'ai cru comprendre qu'ils s'activent si une des entrées PCINT7..0 change? } void loop() { for(int i=0; i<NB_LIGNES; i++) { PORTB = B0001000 << i; // J'allume ligne par ligne delay(50); // les interrupts s'activent durant les delays j'imagine? } // ... Des Trucs ... } void sousRoutine() { // J'ai pas compris comment entrer dans l'ISR... state != state; // J'ai pas encore réfléchi à cette partie-là // mais si j'ai bien compris, c'est ici que je trouve la touche qui a été enfoncée ou relachée // colonne = PINB & B11110000; // ligne = PINB & B00001111; }
Je me rends compte que j'ai pas mal dévié du sujet initial, est -ce qu'il faut déplacer le sujet dans la rubrique "Programmation",
voire ouvrir un nouveau fil sur les interrupteurs là-bas?
Dernière modification par Janosch ; 16/01/2020 à 16h12.
Pas très cohérent...
Il faudrait savoir ce qu'on veut exactement.
S'agit il d'un Arduino ou d'une carte autre ?
Pourquoi utiliser l'interruption qui va compliquer dans ce cas ?
Car la lecture se fait avec le pulse Y.
Si l'on a un codeur externe à diode par exemple , l'interruption serait utile la lecture se ferait en 1 instruction, pas nécessaire de mettre un pulse, resterait à décodé la valeur lu , ou carrément une table de sauts.
Si l'on a seulement 8 fils et 8 boutons , pareil l'interruption serait utile.
Sinon le site arduino est vraiment bien fait une recherche et on trouve beaucoup de chose.
Et le net regorge d'exemple aussi, en étant méfiant tout de même pas mal d'erreur ou maladresse circulent.
J'imagine... Peut-être j'attaque des choses trop difficiles pour l'instant.Pas très cohérent...
Et puis il est vrai que je n'ai pas été très clair sur ce que je voulais, c'est parce que en fait je ne veux rien de précis, si ce n'est comprendre.
En fait multiplexer en Arduino, je sais faire, je bosse justement sur un projet avec 42 fourches optiques multiplexée sur un arduino nano (en 8x6), à coup de pinMode(), digitalRead(), delay() etc...
Mais comme tu l'as dis toi même, pas mal de maladresses circulent sur le net, et c'est avec ces maladresses-là que j'ai appris, et puis ça reste vaguement du copié-collé que je fais (très ré-adapté), et même si je comprends ce que je fais,
je ne comprends pas toujours ce que Arduino fait.
Mon projet était donc, d'abandonner petit à petit l'Arduino, pour apprendre l'asm, le C (j'ai des bases), les µc et l'élec en général (oui, c'est ambitieux)
Et je ne suis pas pressé, ma question à la base était juste de savoir d'où sortait ce fameux "8" que je rencontre partout dans les multiplexages des autres.
C'est là qu'on m'a parlé d'interruption , et je me suis emballé! dsl.
Merci en tout cas de ton aide, ma question initiale a été résolue, maintenant si quelqu'un veut m'aider à avancer sur les interruptions (surtout que sur le site d'arduino je ne trouve pas grand chose
sur les vecteurs d'interruption, uniquement les pin INT0 et INT1), je suis preneur, mais je peux effectivement trouver des ressources sur le net, ce qui n'était pas le cas pour ce fameux 8.
Merci en tout cas de m'avoir aidé jusque-là
bonsoir,
il faut lire la datasheet du µc et passer en assembleur ou c.
Utiliser les interruptions sur changement d’état des entrées n'est pas la bonne solution pour un clavier matricé sauf peut être à le faire précéder par un encodeur de priorité type 74xx148.
et là on retrouve les 8bits.
JR
l'électronique c'est pas du vaudou!
Sur l'arduino on utilise des numéros de pins qui ne correspondent pas a des ports entiers.
voir ci joint.
De plus certaines pins sont spécialisées comme Tx, Rx ou Mosi, Miso , ce qui limite l'utilisation du port complet.
Il faut donc prévoir son câblage avec toutes les fonctions avant de faire le soft !
ici la page pour l'int Arduino
https://www.arduino.cc/reference/en/...tachinterrupt/
On change l'état de la LED à chaque impulsion.
Pas d'anti rebond... Donc le test avec un simple fils pour contact de masse risque de faire des résultats aléatoires si le contact n est pas franc.
On peut aussi utiliser plusieurs pins .
Code:const byte ledPin = 13; const byte interruptPin = 2; volatile byte state = LOW; void setup() { pinMode(ledPin, OUTPUT); pinMode(interruptPin, INPUT_PULLUP); attachInterrupt(digitalPinToInterrupt(interruptPin), blink, CHANGE); } void loop() { digitalWrite(ledPin, state); } void blink() { state = !state; }
Vous pouvez utiliser des instructions assembler dans le code C.
A vos risque et périls !
https://ucexperiment.wordpress.com/2...ly-tutorial-1/
L'environnement IDE Arduino avec le Bootloader limite les fausses manips au pire le prog ne fonctionne pas.
Pour la programmation purement assembleur, il faudra passer par la prise JTAG pour programmer.
Avec AVRDUDE par exemple et un programmateur externe.
Au risque de bloquer le chip si on tripote un peu trop les bits de config...
Je trouve la version "Atmel Studio 4" bien.
La suivante se transformant en usine à gaz , opinion personnel.
J ai trouvé cette page avec exemple asm;
https://gist.github.com/mhitza/8a4608f4dfdec20d3879
Il faudra installer le "Tools chain" aussi.
Ca dépend du µC, il en faut nécessairement un ayant 4 entrées interruptives sur changement d'états, ça évite d'ajouter un circuit externe.Envoyé par jiherve
Une autre solution pour un clavier consiste à utiliser un ADC.
Lire cette note d'appli par exemple:
https://www.st.com/content/ccc/resou...CD00004024.pdf
bonjour
avec le µC ATMEL c'est possible mais il n'y en a que deux sur fronts dont la polarité puisse être choisie, les autres étant sur tout changement d’état on aura donc une IT à l'appui et une autre au relâchement ce qui complique pas mal le soft, la solution avec timer et donc une analyse cyclique fonctionne aussi bien pour un clavier.
JR
l'électronique c'est pas du vaudou!
