Disons que nous devons donner des commandes à notre appareil. Le moyen le plus simple de procéder consiste à utiliser les boutons ordinaires attachés au port. Mais c’est une chose quand il y a deux ou trois boutons, et une autre quand il y en a vingt. Ne tuez pas vingt broches du contrôleur pour cela. Il existe une solution au problème - matriçage. Autrement dit, les boutons sont regroupés en lignes et en colonnes et la matrice résultante est interrogée séquentiellement par le microcontrôleur, ce qui vous permet de réduire considérablement le nombre de sorties requises au prix d'une complexité de l'algorithme d'interrogation.

Matrice de clavier.
Je l'ai dessiné pour vous sur la première photo. Comme vous pouvez le constater, il y a des lignes et des colonnes. Les cercles indiquent les boutons. Ils sont activés de sorte que lorsque vous cliquez dessus, le bouton ferme une ligne en colonne.

Le port de lecture est activé en mode d'entrée Pull-up, c'est-à-dire une entrée avec des résistances pull-up. Si le contrôleur ne le prend pas en charge, ces résistances doivent être suspendues à l'extérieur.

Le port de numérisation fonctionne en mode sortie et est connecté aux colonnes. Les colonnes doivent être reliées à l'alimentation par des résistances. Cependant, si un Push-Pull à part entière est utilisé, aucun ascenseur n'est nécessaire - la sortie elle-même élèvera la jambe au niveau souhaité.

Cela fonctionne comme suit.

Une valeur composée d'un zéro et d'un sur toutes les autres broches est envoyée au port de numérisation. Supposons, par exemple, que zéro soit sur la broche A. La présence de zéro appuie immédiatement sur le pull-up et la colonne entière tombe au sol.

Maintenant, nous lisons la valeur entière du port de lecture en une seule fois. Si aucun bouton n’est enfoncé sur la colonne A, alors tous seront dans le port. Mais si vous appuyez sur n’importe quel bouton de la colonne A, cela fermera immédiatement la ligne A vers cette broche de port. Dans la ligne A, nous avons actuellement 0, cela fournit un zéro à la sortie de scanning du contrôleur. Par conséquent, la broche du port correspondant sera également 0
Ainsi, si un bouton est enfoncé, par exemple 6, alors la ligne P1 sera 0.

Ensuite, le numéro dans le port de numérisation est décalé d'un bit vers la gauche (ou la droite) et la deuxième colonne est numérisée, et ainsi de suite en cercle. En conséquence, sachant quelle colonne nous scannons, après avoir reçu un zéro sur le port de lecture, nous comprendrons, comme par coordonnées, sur quel bouton de la matrice est enfoncé.

Vous pouvez détecter l'appui simultané sur plusieurs boutons - il vous suffit de vérifier non pas par octet, mais par un bit spécifique.

Augmenter la profondeur de bits
Mais que se passerait-il si nous n'avions pas seulement beaucoup de boutons, mais beaucoup d'entre eux. Que même le matriçage ne vous évite pas l'énorme consommation de lignes portuaires. Ici, vous devez soit sacrifier plusieurs ports, soit introduire une logique supplémentaire. Par exemple décodeur avec sortie inverse.

Décodeur, il s'agit d'un microcircuit qui accepte un code binaire en entrée et en sort un dans le chiffre sélectionné. Ceux. a soumis le numéro « 101 » - a reçu « 1 » sur la broche numéro 5. Eh bien, le décodeur inverse aura 0.

Vous pouvez aller encore plus loin et installer une puce de compteur, qui est pulsée depuis le port et la valeur du compteur est transmise via un décodeur. Ainsi, vous pouvez insérer autant de broches que vous le souhaitez, à condition que la capacité du décodeur soit suffisante. L'essentiel est de prendre en compte à quel cycle de compteur nous aurons quelle colonne.

Si un clavier ordinaire appuyé par une personne est en cours d'analyse, vous ne pouvez pas vous soucier de la vitesse d'interrogation et le faire en tant que sous-produit, en le suspendant à une interruption gauche. Il suffit que le clavier soit interrogé au moins 10 à 20 fois par seconde. C'est déjà suffisant pour un travail confortable.

Rebond de contact et comment y faire face.
Lorsque vous travaillez avec des boutons mécaniques, un problème se pose - rebond de contact. Son essence est que lors de la fermeture, le contact est déclenché plus d'une fois et au moment de la fermeture et de l'ouverture, il se produit plusieurs alarmes. Cela se produit parce que le contact idéal ne se produit pas immédiatement, mais après un certain temps, il produit des étincelles et grince, bien que cela ne soit pas visible. Il s’avère donc qu’au lieu d’une goutte, nous obtenons d’abord une série de rafales et ce n’est qu’alors qu’un état stable apparaît.

Mais le microcontrôleur fonctionne à une telle vitesse qu’il parvient à considérer ces pics comme des états stables. Ce problème peut être résolu matériellement, à l'aide d'un déclencheur RS, ou logiciellement - en créant un petit délai avant l'interrogation du bouton suivant. Le délai est sélectionné de telle sorte que le bavardage ait le temps de s'arrêter à la fin du délai.

Caractéristiques distinctives:

• Clavier 64 touches sous forme de matrice 8 x 8
• Aucun composant externe requis
• Quitter le mode veille en appuyant sur un bouton
• Intégration facile avec d'autres applications
• Faible consommation
• Algorithme logiciel anti-rebond
• Prise en charge de fonctions de boutons alternatives, qui peuvent être facilement supprimées pour réduire la taille du programme
• Le code du programme peut être utilisé par n'importe quel microcontrôleur AVR possédant au moins 17 lignes de ports d'entrée/sortie et disposant d'une interruption pour changer l'état des lignes (actuellement, il ne s'agit que des ATmega162 et ATmega169)
• Le code peut être facilement modifié pour être utilisé dans d'autres microcontrôleurs utilisant une interruption commune (voir exemple d'application "AVR240 : 4 x 4 Keypad - Wake-up on Keypress")

Introduction

Cet exemple d'application décrit le programme pilote d'interface matricielle de clavier 8 x 8. L'exemple d'application est conçu pour être utilisé dans des appareils auto-alimentés. Le microcontrôleur AVR passe la plupart de son temps en mode veille, s'activant uniquement lorsque les boutons du clavier sont enfoncés. Après cela, la matrice du clavier est analysée, les informations sont traitées et remises en mode basse consommation.

En outre, le périphérique décrit dans cet exemple d'application prend en charge d'autres fonctions programmables par l'utilisateur telles que Caps Lock, Ctrl-, Shift- et Alt-. L'application de test sert une matrice de clavier 4 x 4, chaque touche représentant un chiffre et trois symboles. Les boutons alternatifs vous permettent de sélectionner la fonction du bouton sur lequel vous appuyez.

Figure 1. Application de test

Cet appareil convient à toutes les applications utilisant un clavier matriciel, telles que les télécommandes, les téléphones portables et les systèmes d'alarme et de contrôle d'accès. Les mises à jour logicielles sont très faciles grâce à la famille de microcontrôleurs ATmega dotée de fonctions d'auto-programmation et de programmation dans le système. Ces fonctionnalités sont particulièrement utiles lors de l'utilisation de ces microcontrôleurs dans des télécommandes universelles.

Le dispositif décrit dans cet exemple d'application est basé sur le microcontrôleur ATmega162. Cependant, après des modifications mineures, le code du programme peut être utilisé dans le microcontrôleur ATmega169.

Principe de fonctionnement

La connexion des boutons matriciels du clavier 8 x 8 est illustrée à la figure 2. Lorsque vous appuyez sur un bouton, les lignes et colonnes correspondantes sont connectées. Lorsque vous cliquez sur le bouton en haut à gauche, la colonne la plus à gauche et la ligne la plus haute sont fermées.

Figure 2. Connexion de la matrice du clavier

Les matrices de clavier peuvent être numérisées de plusieurs manières. Si un seul bouton peut être enfoncé, la méthode d'analyse rapide est sélectionnée, qui sélectionne simultanément (définie au niveau bas) toutes les lignes et lit l'état des colonnes. Après cela, toutes les colonnes sont sélectionnées et les états des lignes sont lus. Les valeurs de colonne et de ligne renvoyées sont combinées dans un code qui identifie le bouton enfoncé. C'est la méthode utilisée dans cet exemple d'application.

S'il est nécessaire de réparer un clavier permettant d'appuyer simultanément sur des boutons, la méthode décrite ci-dessus ne peut pas être utilisée. Dans ce cas, les lignes doivent être numérisées séparément. Les lignes doivent être sélectionnées (définies à un niveau bas) séquentiellement, effaçant l'état de toutes les colonnes. Cela détectera tous les boutons enfoncés. Cependant, dans ce cas, des interconnexions apparaissent. La figure 3 montre le résultat de l'appui sur trois touches, dans lequel il semble que le bouton marqué d'un X soit également enfoncé. Cela entraîne une erreur de décodage.

Figure 3. Faux décodage en appuyant simultanément sur les boutons

Pour détecter les pressions sur les boutons et sortir du mode veille, l'interruption de changement de broche disponible sur le microcontrôleur AVR utilisé est utilisée. Avant d'entrer en mode veille, toutes les broches de ligne sont réglées au niveau bas, ce qui provoque l'apparition d'un signal faible aux entrées de colonne lorsque les boutons sont enfoncés. Cela entraînera une interruption.

Lors de l'utilisation d'une interruption de changement d'entrée, un seul clic est traité. Dans ce cas, la répétition automatique de l'appui lors du maintien du bouton n'est pas générée. La simulation de pressions répétées doit être implémentée par un sous-programme distinct.

Boutons alternatifs

De nombreuses interfaces clavier utilisent des fonctions de boutons auxiliaires. Cela peut être mis en œuvre de plusieurs manières. L'une des méthodes les plus courantes consiste à attribuer plusieurs boutons auxquels des fonctions alternatives sont attribuées. Lorsque ces boutons et les boutons ordinaires sont enfoncés simultanément, un code de numérisation secondaire est généré. Il existe également des options lorsque le bouton alternatif est enfoncé immédiatement avant d'appuyer sur le bouton principal. Cela élimine le besoin de suivre les renversements.

Les boutons alternatifs ne sont pris en compte que lorsque les boutons principaux sont enfoncés. Dans ce cas, les boutons alternatifs sont dits « one-shot ».

Il est également possible d'implémenter des boutons « déclencheurs » qui, lorsqu'ils sont enfoncés pour la première fois, activent des fonctions alternatives et, lorsqu'ils sont enfoncés à nouveau, les désactivent. Dans ce cas, des fonctions alternatives sont utilisées pour tous les boutons actionnés ultérieurement. Le bouton Caps Lock d’un clavier d’ordinateur standard possède ces fonctions. Cet exemple d'application utilise à la fois des boutons à déclenchement unique et des boutons de déclenchement.

L'utilisation du principe d'appuis séquentiels plutôt que simultanés sur les boutons évite les problèmes liés à un décodage erroné. Si plusieurs boutons sont enfoncés en même temps, l'application l'ignorera simplement.

Rebond de contact

La figure 4 montre le rebond du contact lorsque vous appuyez sur le bouton. Comme vous pouvez le constater, plusieurs clics sont simulés. Afin d'éviter un décodage incorrect, le code de balayage est lu quelque temps après que l'interruption de changement d'état se soit produite. Aussi, cet algorithme, appelé anti-rebond, permet d’éviter les fausses alarmes lorsqu’il est exposé au bruit. L'anti-rebond des contacts peut également être obtenu à l'aide d'un filtre matériel ou numérique, mais la méthode utilisée dans cet exemple d'application est la moins coûteuse.

Figure 4. Rebond de contact

Mise en œuvre

Cette implémentation utilise le microcontrôleur ATmega162. Les recommandations pour la mise à niveau vers le microcontrôleur ATmega169 sont répertoriées à la fin de ce document.

Le clavier se connecte à deux ports 8 bits du microcontrôleur AVR. Un port (port D) est configuré pour faire fonctionner toutes les lignes comme sorties et est connecté aux lignes de la matrice du clavier. L'autre port (Port C) est configuré pour faire fonctionner toutes les lignes comme entrées et est connecté aux colonnes de la matrice du clavier. Cela peut être vu plus en détail dans la figure 2. Lors de l'analyse de la matrice du clavier, le port utilisé comme sortie doit maintenir les sorties à un niveau bas, et le port utilisé comme entrée doit avoir des résistances de rappel de puissance intégrées.

Le dispositif décrit utilise la première ligne du port E pour générer un code série correspondant au code du bouton enfoncé. Les données sont transmises à l'aide de l'UART intégré, dont l'utilisation est décrite dans l'exemple d'application AVR306.

Lorsqu'il est enfoncé normalement, un code de numérisation est généré dont la valeur est comprise entre 0 et 63 (8 lignes * 8 colonnes). Appuyer sur le bouton pour appeler une fonction alternative génère également un code de balayage régulier, mais en plus, les drapeaux correspondants des fonctions alternatives sont définis. Ces indicateurs d'état sont stockés dans une variable globale.

Trois boutons permettant d'appeler des fonctions alternatives sont configurés pour fonctionner comme des boutons de déclenchement, et quatre sont configurés comme des boutons à un coup. Lorsque vous cliquez sur ces boutons, un code d'analyse régulier est généré, ce qui permet à l'application de les traiter comme des boutons normaux.

Une autre variable globale est utilisée pour transmettre le code d'analyse ainsi que les indicateurs à l'application. Les six bits de poids faible sont utilisés pour transmettre le code (de 0 à 63), et le bit de poids fort (MSB) indique un changement d'état. Le pilote du clavier définit ce bit lorsqu'un bouton est enfoncé. L'application interroge ce bit et le réinitialise après avoir lu le code de numérisation. L'octet global et le scanword sont illustrés à la figure 5.

Figure 5. Code d'analyse avancé

Le programme pilote de clavier est implémenté en tant que programme de gestion d'interruptions. Le programme principal met le microprocesseur en mode veille. Lorsque le bouton est enfoncé, le pilote du clavier réveille le microcontrôleur AVR, reçoit le code de numérisation et met à jour les octets globaux. Après avoir exécuté les fonctions des boutons enfoncés, le programme principal remet à nouveau le microcontrôleur en mode veille.

Module d'initiation et programme principal

La figure 6 montre le module d'initialisation et le programme principal. La réinitialisation des indicateurs de fonctions alternatives et des variables globales, ainsi que l'initialisation des ports sont décrites ci-dessus. Si aucun traitement n'est requis, le mode veille inactif est sélectionné.

Figure 6. Module d'initiation et programme principal

Module principal du décodeur de clavier Le décodeur de clavier est un sous-programme de traitement d'interruption permettant de modifier l'état des ports. Tout d'abord, le mode veille inactif est sélectionné, permettant au microcontrôleur AVR de se réveiller lorsque la minuterie déborde, ce qui est impossible lorsque le microcontrôleur est en mode veille hors tension. La minuterie est réglée pour générer une interruption après 5 ms, ce qui est largement suffisant pour mettre fin aux processus transitoires des signaux au niveau des broches. Pendant ce temps de retard, le programme principal reprend le contrôle et peut activer le mode veille. A la fin de la temporisation, la procédure de traitement d'appui sur le bouton est appelée. Cette fonction complète la détermination du code du bouton enfoncé. À la fin de celui-ci, les lignes de port de toutes les lignes sont réglées à un niveau bas et le mode veille hors tension est activé, qui peut être quitté en appuyant sur un bouton. Le schéma fonctionnel de ce module logiciel est présenté à la figure 7.

Figure 7. Schéma fonctionnel du module logiciel principal du décodeur de clavier

Balayage du clavier (traitement des pressions sur les touches) La figure 8 montre un schéma fonctionnel de la routine de balayage du clavier. Tout d’abord, le résultat est analysé colonne par colonne. Les trois bits les moins significatifs du code d'analyse (colonnes) sont incrémentés jusqu'à ce qu'un niveau bas soit trouvé sur la ligne de colonne. Après cela, la directionnalité des lignes portuaires est inversée et le balayage est répété. Dans ce cas, une recherche de bas niveau est effectuée sur les lignes de lignes. Après cela, le sous-programme de traitement du code de numérisation est appelé.

Figure 8. Schéma fonctionnel de la routine de numérisation du clavier

Tout d'abord, la fonction de traitement du code de numérisation copie le code de numérisation généré dans une variable globale. Après cela, le code de balayage est comparé aux codes des boutons des fonctions alternatives et les drapeaux correspondants des fonctions alternatives sont générés. Ces indicateurs sont copiés dans une variable globale. Si le bouton enfoncé n'est pas un bouton alternatif, alors les drapeaux de toutes les fonctions alternatives ponctuelles sont réinitialisés. Enfin, de nouveaux drapeaux sont posés. Le schéma fonctionnel de cette fonction est présenté à la figure 9.

Figure 9. Schéma fonctionnel de la fonction de traitement du code de numérisation

Cas de test de l'application myCellPhone

Il existe un scénario de test qui implémente une matrice de clavier qui ressemble à un clavier de téléphone portable. Les caractères finaux qu'il contient sont transmis via l'interface USART. À l'aide d'une matrice de clavier 4 x 4, vous pouvez former tous les chiffres et symboles pouvant être fournis à l'aide de quatre boutons de fonction alternatifs supplémentaires. Trois boutons sont utilisés pour sélectionner une fonction alternative pour chaque bouton principal, et le quatrième agit comme un bouton de verrouillage des majuscules (basculement entre les majuscules et les minuscules).

Une table de conversion permet de convertir les codes scan en combinaisons de codes correspondant aux codes des boutons enfoncés, en tenant compte des boutons de fonctions alternatives. Le code de numérisation peut également être utilisé pour scanner une matrice de clavier 8 x 8. Ainsi, le tableau aurait 8 entrées par ligne, tout en n'utilisant que 4 boutons par ligne. Ainsi, si le nombre de colonnes de la matrice du clavier augmente, la taille du programme ne changera pas.

Taille et timing du code d’application

Les tailles de code des sous-programmes pour diverses fonctions de traitement matriciel du clavier sont indiquées dans le tableau 1.

Tableau 1. Tailles des codes de sous-programmes pour diverses fonctions de traitement matriciel du clavier

Le tableau 2 montre la durée des différentes actions effectuées par le microcontrôleur ATmega162 fonctionnant à une fréquence de 8 MHz. Voici les séquences d'actions depuis le réveil lorsqu'une pression sur un bouton est détectée jusqu'à l'entrée en mode veille après le traitement des boutons enfoncés.

Tableau 2. Durée des séquences d'actions effectuées

Si vous ne tenez pas compte du mode veille hors tension, vous pouvez constater que la plupart du temps le microcontrôleur fonctionne en mode veille inactif. Le microcontrôleur est en mode actif pendant seulement 0,3 ms, soit environ 0,5 % du temps total. Le temps relatif passé dans les différents modes de fonctionnement est indiqué dans le tableau 3.

Tableau 3. Consommation et temps relatif passé par le microcontrôleur dans différents modes de fonctionnement

Si nous supposons que les boutons sont enfoncés une fois toutes les 10 minutes, alors la consommation moyenne ne sera que de 2 µA.

Discussions sur l'utilisation d'autres microcontrôleurs

La seule différence lors de l'utilisation des microcontrôleurs ATmega162 et ATmega169 est qu'ils doivent utiliser des ports différents pour connecter la matrice du clavier. L'ATmega162 utilise le port C, tandis que l'ATmega169 doit utiliser le port E. En effet, différents ports ont des interruptions d'état de ligne. ATmega162 a pour fonction de générer une interruption lorsque l'état des lignes du port C change, et ATmega169 - lorsque l'état des lignes du port E change. Si vous devez utiliser d'autres fonctions alternatives de ces ports, vous devez modifier l'application de cette manière. manière d'utiliser un autre port doté d'une fonction de génération pour connecter les interruptions de la matrice du clavier pour les changements d'état de ligne.

Notez également que l'ATmega169 utilise le registre SMCR pour activer le mode veille.

Si vous utilisez d'autres microcontrôleurs, des composants externes supplémentaires et une modification de l'interruption utilisée seront nécessaires. L'utilisation de tels microcontrôleurs pour traiter une matrice de clavier 4x4 est décrite dans l'exemple d'application AVR240. Il n'est pas nécessaire de modifier les autres fonctions de l'exemple d'application décrit.

Souvent, il n'y a pas assez de broches libres du microcontrôleur pour connecter le nombre requis de boutons. Lors d'une connexion directe pour n boutons, vous devez allouer le même nombre de lignes d'entrée/sortie, ce qui n'est pas toujours possible. Pour une utilisation plus rationnelle des lignes portuaires, vous pouvez utiliser le schéma de connexion matricielle de la Fig. 1. Dans ce cas, la matrice connectée au port D a une taille de 4 * 4 = 16 boutons (4 lignes r0...r3 et 4 colonnes c0...c3). Les lignes PD0...PD3, qui sont les lignes r0...r3, sont toujours configurées pour l'entrée et sont tirées vers le bus d'alimentation par des résistances R (valeur typique 4,7...10 kOhm). À partir d'eux, l'état des boutons SB1-SB16 est lu. Un signal zéro logique est généré alternativement sur les lignes PD4…PD7 (colonnes c0…c3). Initialement, le niveau bas est défini sur la colonne c0 et sur toutes les autres colonnes, l'état Z est défini. Désormais, seulement lorsque les boutons de cette colonne (SB1...SB4) sont enfoncés, un niveau logique bas peut se produire sur les lignes de ligne r0...r3. Ensuite, le 0 logique est défini dans la colonne c1 et le groupe de boutons SB5...SB8, etc. est scanné. Exactement le même algorithme d'interrogation des boutons est utilisé pour tout autre clavier matriciel, quel que soit le nombre de lignes et de colonnes. En général, le nombre de boutons n est le produit du nombre de lignes et de colonnes. Ainsi, par exemple, une matrice 2*2 (4 lignes) contiendra 4 boutons. Mais d’un autre côté, il faudra le même nombre de lignes d’E/S pour connecter directement le même nombre de boutons. Ainsi, les économies de sorties commencent à apparaître lorsque le nombre de boutons dépasse 4...6, et deviennent d'autant plus importantes que leur nombre augmente.

Fig.1 Schéma matriciel pour connecter les boutons

Les éléments VD1...VD4 et R1...R4 sont facultatifs dans le diagramme. Les diodes servent à protéger contre les courts-circuits entre les lignes de lignes et de colonnes. Si, par exemple, lorsque vous appuyez sur le bouton SB1 (au moment de scanner la colonne c0), la ligne de ligne r0 s'avère soudainement configurée pour la sortie et qu'elle contient un niveau logique élevé, alors un courant inacceptablement élevé commencera pour circuler dans le circuit c0r0. Bien que la logique du programme ne permette pas ce mode de fonctionnement, cela peut néanmoins se produire pour diverses raisons. Par conséquent, au moins lors du débogage d'un programme, les diodes ne seront pas superflues. Si la capacité de montage référencée aux broches PD3...PD0 n'est pas trop grande, alors la résistance de rappel vers le bus d'alimentation peut être remplacée par des résistances de rappel internes. Pour ce faire, vous devez définir les bits appropriés dans le registre PORTD lorsque les lignes sont configurées pour l'entrée.

Exemple de routine de numérisation de clavier matriciel

Def bouton = R16 ;s'inscrire avec le code du bouton enfoncé.def temp = R17 ;s'inscrire pour les opérations intermédiaires ldi temp,high(RAMEND) ;initialisation de la pile out SPH,temp ldi temp,low(RAMEND) out SPL,temp . clr temp ; configurer les lignes du port D pour entrer DDRD, temp ldi temp, (1<< PD0)|(1 << PD1)|(1 << PD2)|(1 << PD3) out PORTD,temp . rcall btn_pol . ; Подпрограмма опроса матричной клавиатуры; R16 – номер нажатой кнопки на выходе из подпрограммы, ; если ни одна кнопка не нажата, то R16=0; ; если нажаты две и более кнопок, то R16=0xFF ; R17 – регистр для определения номера строки; R18 – регистр для задания номера столбца; R19 – счётчик столбцов; R20 – регистр для промежуточных операций btn_pol: clr R16 ;обнуляем регистры с кодом нажатой clr R19 ;кнопки и номером столбца ldi R18,0x0F ;очищаем регистр данных PORTD порта D out PORTD,R18 ldi R18,0x00010000 bp1: out DDRD,R18 ;настраиваем на вывод линию соответствующего nop ;столбца через регистр DDRD порта D in R17,PIND ;считываем состояние строк из регистра PIND com R17 andi R17,0x0F ;выделяем значение 4-х строк ldi R20,0 ;если ни одна кнопка в столбце не нажата, breq bp5 ;перемещаемся на следующий столбец cpi R17,0x01 ;если нажата кнопка в строке c0, ldi R20,1 ;то вычисляем её номер breq bp2 cpi R17,0x02 ;если нажата кнопка в строке c1, ldi R20,2 ;то вычисляем её номер breq bp2 cpi R17,0x04 ;если нажата кнопка в строке c2, ldi R20,3 ;то вычисляем её номер breq bp2 cpi R17,0x08 ;если нажата кнопка в строке c3, ldi R20,4 ;то вычисляем её номер brne bp3 ;если нажато более одной кнопки, завершаем опрос bp2: tst R16 ;если в предыдущих столбцах были нажаты breq bp4 bp3: ldi R16,0xFF ;кнопки, то завершаем опрос с кодом 0xFF ret bp4: push R19 ;иначе вычисляем номер кнопки, как lsl R19 ;N = 4*column + row + 1 = 4*R19 + R20 + 1 lsl R19 add R20,R19 mov R16,R20 pop R19 bp5: inc R19 lsl R18 cpi R19,4 ;повторяем цикл опроса пока не будут brne bp1 ;опрошены все 4 столбца ret

Malgré tous ses avantages, le schéma de connexion matricielle présente également un inconvénient. Avec son aide, il est difficile de mettre en œuvre des combinaisons de boutons de lecture. Si trois boutons formant un angle droit les uns avec les autres (par exemple, SB1, SB2, SB5) sont enfoncés sur un tel clavier, le programme d'interrogation enregistrera une fausse pression sur le bouton situé dans le coin libre du rectangle (en ce cas, SB6). Dans une certaine situation, un tel bouton « fantôme » peut être n'importe quel bouton du clavier.

Liste des radioéléments

Désignation	Taper	Dénomination	Quantité	Note	Boutique	Mon bloc-notes
DD1	MK-AVR 8 bits	ATmega8	1			Vers le bloc-notes
VD1-VD4	Diode		4			Vers le bloc-notes
R, R, R, R	Résistance		4

Alors, comment allons-nous faire la matrice ? Et surtout, pourquoi est-ce nécessaire ? Eh bien, cela est principalement dû aux limitations physiques des microcontrôleurs sur lesquels les claviers sont construits. Le fait est qu'avec l'augmentation du nombre de broches dans les microcontrôleurs et les puces logiques programmables, leur taille augmente également, ce qui entraîne une augmentation de la consommation d'énergie, des capacités, mais surtout des prix. De ce fait, vous pouvez choisir soit une puce bon marché et peu performante (qui vous convient assez bien), mais avec un petit nombre d'entrées et de sorties, soit une puce plus puissante, dont les performances dépassent cependant largement vos exigences. Mais seule cette puce puissante disposera de suffisamment de broches pour connecter chaque bouton du clavier.

Au fil des décennies, l’électronique a développé une pratique utilisant diverses astuces pour étendre artificiellement les capacités de communication intégrées des processeurs et des contrôleurs. Une de ces méthodes, bien adaptée aux contacts mécaniques (boutons), est la création d'une matrice. Comprendre son fonctionnement nécessite quelques connaissances de base. Avant de continuer, veuillez réviser la loi d'Ohm.

Un peu de théorie

Pour comprendre le fonctionnement de l’électronique numérique, vous devez comprendre deux principes de base.

Premier principe déclare que le processus de communication au sein d’un circuit ne consiste pas à y transmettre ou à y recevoir quelque chose. Pour permettre la communication entre deux appareils, il vous suffit de connecter leurs bornes avec un matériau électriquement conducteur. Après cela, on suppose que l’état du matériau (tension et courant) aux deux extrémités sera le même. En réalité, ce n’est bien sûr pas le cas, mais pour les communications lentes et les conducteurs courts, notre hypothèse fonctionne parfaitement. Il s’avère que l’envoi et la réception d’informations consistent en fait à les partager.

Côté émetteur, vous changez simplement l'état électrique du conducteur (en y faisant passer un courant continu, modifiant son potentiel), en espérant que le récepteur sera capable de détecter ce changement et de le comprendre correctement.

Il résulte également de ce principe qu'il n'y a aucune relation entre le sens de la communication et le sens du courant électrique. Beaucoup de gens pensent à tort le contraire, ce qui les empêche de comprendre le fonctionnement de l’électronique.

Si vous souhaitez envoyer un niveau logique de "0", la tension à la sortie de l'émetteur est généralement réduite à 0 V et le courant commence à circuler du récepteur à l'émetteur afin que le récepteur puisse déterminer que le niveau logique correspond à "0". (Alors que le sens inverse du courant signifierait qu'il y a un potentiel négatif quelque part dans le circuit - et cela, en règle générale, ne se produit pas dans l'électronique numérique.) D'autre part, pour transmettre un niveau logique "1" un une tension égale à la tension d'alimentation est appliquée, et comme il s'agit le plus souvent de la tension la plus élevée du circuit, le courant électrique n'aura d'autre choix que de circuler de l'émetteur vers le récepteur.

Principe numéro deux est qu'il est impossible de déterminer l'état d'un conducteur sans changer cet état. Peu importe que vous mesuriez une tension ou un courant, cela nécessite que des électrons circulent à travers votre compteur. Le flux d'électrons est un courant électrique, et puisqu'il circule, cela signifie que dans le nœud auquel vous êtes connecté pour la mesure, les courants et la tension ont déjà changé (voir les lois de Kirchhoff). Il s'ensuit que si l'on a besoin de « transmettre » une information en changeant l'état d'une broche connectée électriquement à une autre broche, alors cela nécessite de maintenir cet état, et donc de respecter toutes les exigences imposées par le récepteur.

Bouton

Un bouton mécanique (et dans ce contexte le mot « mécanique » n'est pas lié à l'expression « clavier mécanique ») est simplement une paire de contacts métalliques qui, lorsqu'ils sont en contact, connectent électriquement deux bornes. Bien sûr, il existe d'autres types de commutateurs, de conception plus complexe et dotés d'un plus grand nombre de broches, mais ils ne nous intéressent pas car ils ne sont pas utilisés dans les claviers.

Eh bien, comment allons-nous connecter le bouton à l'entrée du microcontrôleur ? Fondamentalement, toute entrée peut fonctionner avec deux niveaux logiques possibles : « 0 » et « 1 ». Une pratique courante consiste à prendre des tensions proches de 0 V comme zéro logique et des tensions proches de la tension d'alimentation (généralement 5 V ou 3,3 V) comme zéro logique. Mais le problème est que le bouton mécanique lui-même ne peut pas contrôler la tension. Il contrôle le courant - c'est-à-dire que si nous connectons deux nœuds avec des potentiels électriques différents via un bouton, alors le courant circulera entre ces nœuds si et seulement si le bouton est enfoncé.

Mais si nous ajoutons une résistance, nous pouvons très facilement convertir le courant en tension.

Bouton d'extraction

Jetez un œil à ce schéma. Lorsque le bouton n'est pas enfoncé (le circuit est ouvert), aucun courant ne le traverse, donc la tension au nœud « A » sera proche de la tension d'alimentation VCC (en fait, inférieure à VCC par la quantité de chute de tension aux bornes du résistance égale à R I). Lorsque le bouton est enfoncé (le circuit est fermé), le courant traverse la résistance jusqu'à la masse. Compte tenu du fait que la résistance du bouton fermé est très faible (de l'ordre de centaines de milliohms), la tension au nœud « A » sera proche de « 0 ».

Dans cette configuration, la résistance est appelée pull-up car elle « fait monter la tension » jusqu'au niveau VCC. Et sans connexion à l'alimentation via une résistance, il n'y aurait aucune tension dans le nœud «A» (dans ce cas, la sortie du microcircuit est appelée «suspendue dans l'air» ou étant dans un état de haute impédance) .

Il convient de noter que la plupart des microcontrôleurs modernes contiennent déjà des résistances de rappel, qui peuvent être rapidement connectées ou désactivées à l'aide d'un programme. Ainsi, la principale manière de connecter un bouton à un microcontrôleur est la suivante : une broche du bouton est à l'entrée du microcontrôleur, l'autre broche du bouton est à la masse. Dans ce cas, si le bouton n'est pas enfoncé, alors « 1 » est envoyé au microcontrôleur, et s'il est enfoncé, alors « 0 ». Cela peut paraître contre-intuitif, mais cette méthode de connexion est la plus populaire.

Veuillez noter que si nous laissons l'une des broches du bouton pendre en l'air, c'est-à-dire si nous ne la connectons nulle part, alors ce bouton ne fonctionnera pas du tout : peu importe combien vous appuyez dessus, cela n'affectera pas l'alimentation électrique. état de la broche du microcontrôleur de quelque manière que ce soit. Nous utiliserons à nouveau cette propriété lorsque nous composerons la matrice.

Principe matriciel

Le principe de base de la matrice du clavier est la possibilité de connecter plusieurs boutons à une entrée du microcontrôleur.

Utiliser des transistors ou correctement configurés sorties microcontrôleur, nous pouvons faire en sorte que les boutons soient connectés à la terre un par un, tandis que le reste sera suspendu en l'air. Les broches restantes de chaque bouton sont combinées en un seul nœud et connectées à entrée microcontrôleur. J'ai omis la résistance pull-up car on sait qu'elle est déjà présente à l'intérieur du microcontrôleur, dans son étage d'entrée. Nous « allumons » chaque bouton à tour de rôle, en connectant sa broche numéro 1 à la masse via la sortie correspondante du microcontrôleur, après quoi nous pouvons lire l'état du bouton à l'entrée en supprimant la tension de sa broche numéro 2. Autres boutons connectés à la même entrée n'ont aucun effet sur son état, car leurs conclusions numéro 1 sont en suspens à ce moment-là. Le diagramme suivant illustre cette idée.

Plusieurs boutons, une entrée (nœud « A »)

"A" est la seule entrée du microcontrôleur et "C1"..."Cn" sont ses sorties. L'une des sorties est réglée sur un « 0 » logique, c'est-à-dire qu'à l'intérieur du microcircuit, ce contact est en quelque sorte connecté à la terre - par conséquent, le courant circulera toujours vers ce contact (conformément au premier principe de base). Désormais, lorsque le bouton connecté à cette sortie est enfoncé, l'entrée « A » sera immédiatement « appuyée » sur la terre à travers elle, et elle sera réglée sur « 0 ». Appuyer sur d’autres boutons ne changera rien, car leurs broches de masse ne sont connectées nulle part pour le moment. Lorsque nous devons interroger le bouton suivant, nous supprimons le « 0 » logique de la sortie actuelle et réglons ce niveau sur la sortie suivante, de sorte qu'une seule des sorties du microcontrôleur soit utilisée à tout moment.

Cette configuration (où la sortie est soit connectée à la terre, soit complètement déconnectée) est appelée sortie à drain ouvert (OC) (historiquement - collecteur ouvert (OC)). Ici, j'ai fait quelques simplifications : en fait, un contact ne peut être complètement déconnecté du circuit que s'il en est physiquement coupé. Mais pour de simples E/S numériques, cette simplification est tout à fait adaptée. La plupart des microcontrôleurs offrent la possibilité de configurer par programme leurs broches de sortie pour fonctionner en mode OS. Mais que se passe-t-il si nous n’avons pas cette option ? Il existe une autre configuration - le mode push-pull ; Aujourd'hui, cette option est l'une des plus populaires. Cette configuration fonctionne un peu différemment. Dans l'état « 0 », la sortie est toujours fixée à la terre, mais lorsque l'état « 1 » se produit, elle est tirée jusqu'à la tension d'alimentation VCC, de sorte que la sortie ne soit plus suspendue dans les airs, elle peut maintenant devenir une source de courant elle-même.

Quels changements cela entraînera-t-il dans la conception de la matrice ? Si nous n’appuyons pas sur plusieurs boutons en même temps, alors aucun. Mais si nous y allons, jetez un œil au dessin et imaginez une seconde ce qui se passera alors. En appuyant sur deux boutons, nous connectons les deux sorties inférieures en boucle fermée. Si l'un d'eux est à l'état « 0 » et l'autre à l'état « 1 », alors un courant électrique circulera de la sortie réglée sur « 1 » vers la sortie réglée sur « 0 ». Et comme ce courant n'est limité par rien (il n'y a pas de résistances), non seulement le circuit deviendra instable, mais la puce risque également de s'envoler. Bien sûr, il est peu probable que vous puissiez calculer l’état logique normalement.

Ajout de lignes

Vous pouvez considérer l’exemple précédent comme une matrice à une ligne. Augmentons-le maintenant en ajoutant des lignes supplémentaires. En fait, si nous pouvons accrocher une ligne entière sur une entrée, alors pourquoi ne pouvons-nous pas accrocher une colonne entière de boutons sur une sortie ? Certes, il existe une condition préalable : chaque bouton de la colonne doit être connecté à une entrée distincte du microcontrôleur.

Si nous disposons les boutons sous la forme d’une matrice régulière, alors cette condition sera remplie automatiquement. Et la figure suivante montre à quoi ressemblera une matrice de boutons, composée de n colonnes et m lignes ( Ne faites pas attention aux chiffres verts pour l'instant.).

Matrice de clavier simple

La lecture de cette matrice est très simple. Nous interrogeons une colonne à la fois. La colonne à lire est sélectionnée en connectant l'une des sorties « C1 ».. « Cn » à la masse (la sortie est mise à « 0 » en mode OS). Maintenant, en interrogeant les lignes « R1 » .. « Rm » une à une, on peut déterminer l'état de chaque bouton de la colonne sélectionnée. Les boutons des autres colonnes n'ont aucun effet, même s'ils sont enfoncés, car pour le moment leurs broches de masse flottent dans les airs (ou, comme on dit en électronique, sont à l'état Hi-Z).

Une fois que toute la colonne a été interrogée, nous passons à la suivante, libérant la sortie actuelle et mettant la suivante à zéro. L'analyse matricielle est considérée comme terminée lorsque toutes les colonnes ont été analysées. Si vous faites tout assez rapidement, même le dactylo le plus rapide ne remarquera pas les intervalles entre les sondages des colonnes. Même avec un microcontrôleur de 16 MHz, nous pouvons facilement scanner toute la matrice des milliers de fois par seconde, tandis que le dactylographe le plus rapide du test sur hi-games.net a atteint une vitesse de 203 mots par minute (wpm) - soit un peu moins 17 frappes par clavier, donnez-moi une seconde.

En concevant un clavier à l'aide d'une matrice, nous réduisons le nombre de broches nécessaires pour connecter toutes les touches. Mais afin de réduire le nombre de sorties au minimum possible, nous devons composer la matrice de manière à ce que le nombre de colonnes soit aussi proche que possible du nombre de lignes. Dans une situation idéale, si le nombre de boutons est égal n², alors le mieux que nous puissions obtenir en utilisant la matrice est 2n broches du microcontrôleur occupées. Cependant, aujourd'hui, lors de la compilation de matrices, on s'efforce rarement de minimiser le nombre de jambes impliquées, car les microcontrôleurs modernes ont généralement un nombre suffisant de broches libres. De plus, une optimisation maximale de la matrice peut par la suite entraîner des inconvénients - la disposition de la carte ou la répartition des fils dans l'appareil final deviendra sensiblement plus compliquée. Par conséquent, il vaut la peine d'emprunter une voie plus pratique : lors de la compilation d'une matrice, essayez de suivre la disposition physique des boutons. Dans ce cas, pour un clavier d'ordinateur standard, la matrice la plus simple ne comportera que 6 lignes et un certain nombre de colonnes, selon la disposition souhaitée. Bien entendu, du point de vue du nombre de broches impliquées, cette solution n'est pas la plus optimale, mais à l'avenir le câblage sera au moins simplifié.

Et si nous n’avons pas de sorties d’évacuation ouvertes ?

Vous vous demandez peut-être : que devons-nous faire si le microcontrôleur sélectionné n'a toujours pas de mode OS ? Eh bien, nous avons déjà établi quel genre de problème peut survenir, et que tirer les sorties vers VCC (c'est-à-dire les "connecter" à l'alimentation) n'est pas une bonne idée. Il existe de nombreuses façons de résoudre ce problème ; parmi eux, il existe non seulement des tampons de sortie spéciaux du système d'exploitation, mais même des registres à décalage avec des sorties du système d'exploitation - pour minimiser davantage le nombre de jambes impliquées. Mais il existe une autre technique très populaire qui est assez souvent utilisée dans la conception de claviers d'ordinateur (en fait, elle était largement utilisée autrefois).

Le problème des colonnes connectées aux sorties push-pull se manifeste au moment où deux boutons situés dans la même rangée sont enfoncés ensemble, et simultanément à cet appui, la colonne dans laquelle se trouve l'un des boutons est interrogée.

Problème push-pull

À partir de la sortie, qui est tirée à « 1 » (et ne reste pas suspendue à l'état Hi-Z), le courant commence à circuler. Il passe par le bouton fermé le plus proche, puis par le bouton fermé de la colonne interrogée, et enfin directement dans la sortie réglée à « 0 ». Cela peut conduire à n'importe quoi - de l'incapacité de lire de manière fiable l'état du clavier à la panne du microcontrôleur lui-même.

Mais puisque nous devons résoudre ce problème d’une manière ou d’une autre, nous pouvons utiliser une astuce astucieuse : transformer la sortie push-pull en quelque chose comme une sortie à drain ouvert. J'ai souvent vu cette solution dans les anciennes conceptions de clavier. Considérant que le courant ne doit circuler que dans les sorties (connectées aux colonnes) mais jamais en sortir, on peut limiter le sens du courant à l'aide de diodes. Une diode est un dispositif simple qui permet au courant de circuler dans une seule direction. A l’image d’une diode sur un schéma électrique, le triangle symbolise la flèche qui pointe dans cette direction. Si nous plaçons une diode entre chaque sortie du microcontrôleur et le conducteur de la colonne correspondante de la matrice, alors nous atteindrons notre objectif - désormais le courant ne peut circuler que dans les sorties, car les conducteurs spécifiés atteignent chaque bouton de leur colonne. Il s'avère qu'aucun courant ne circulera d'une sortie réglée sur « 1 », ce qui la transforme presque en une sortie à drain ouvert. Bien sûr, cela n'atteint pas le niveau d'un véritable système d'exploitation, mais cela résout notre problème de boucle de courant fermée dans la matrice du clavier. Revenons à l'avant-dernier dessin matriciel, mais cette fois notez les diodes vertes pour comprendre comment fonctionne cette astuce.

Naturellement, il est logique de minimiser le nombre de diodes. Pour ce faire, vous pouvez réduire le nombre de colonnes en augmentant le nombre de lignes. Et si le résultat obtenu ne correspond pas bien à la disposition réelle du clavier, vous pouvez alors « étendre » la matrice de 90° (intervertir les lignes et les colonnes). Les possibilités sont infinies. Mais ces jours-ci, un grand nombre de microcontrôleurs sont apparus, faciles à utiliser et pratiques pour les amateurs, de sorte qu'aujourd'hui la technique décrite n'est pratiquement plus utilisée dans les projets de clavier locaux. Heureusement.

Clics fantômes (Ghosting)

Si vous êtes intéressé par les claviers, vous devez déjà avoir rencontré ce terme. Malheureusement, il est souvent mal interprété dans le monde du clavier.

On connaît déjà la situation où des appuis simultanés sur plusieurs boutons situés sur une même ligne peuvent gêner la lecture normale de la matrice. Et ce problème, on peut le dire, a été résolu. Voyons maintenant ce qui se passe si vous appuyez sur plusieurs boutons qui se trouvent simultanément dans la même ligne et dans la même colonne.

Exemple de clic fantôme

Sur la figure, trois boutons sont enfoncés simultanément. Deux d’entre eux se trouvent dans la colonne « C2 » et deux dans la ligne « Rm ». Cela signifie que l'un des boutons enfoncés partage une ligne avec un autre bouton enfoncé et une colonne avec un troisième bouton enfoncé. C'est exactement ce qui se passe dans cette situation clic fantôme. Imaginez que nous interrogeons actuellement la colonne « C1 » (c'est-à-dire qu'elle est appuyée au sol - elle est à l'état « 0 »). Cet accord caractéristique des boutons enfoncés conduit à ce qui suit : même si le bouton en haut à gauche n'est pas enfoncé, la ligne "R2" est à l'état "0" car elle est épinglée au sol par la colonne "C1" (qui est à l'état "0"). "0") grâce à trois boutons enfoncés. En conséquence, le contrôleur du clavier lit le bouton en haut à gauche comme « appuyé », qu'il soit réellement enfoncé ou non. La situation décrite est appelée pressage fantôme (fantôme), car certaines combinaisons de boutons enfoncés simultanément provoquent une activation fantôme d'autres boutons (pressions de touches fantômes), bien que ces autres boutons ne soient pas physiquement enfoncés.

Bien entendu, il existe des moyens de protéger les dactylographes et les joueurs contre les opérations fantômes, et ces méthodes sont largement utilisées sur les claviers d’ordinateurs modernes. Vous pouvez détecter le moment où un clic fantôme se produit et le bloquer. La personne moyenne est incapable d’appuyer ou de relâcher simultanément deux touches avec une précision parfaite. Ainsi, en parcourant la matrice assez rapidement, on peut supposer qu'entre deux passages dans la matrice pas plus d'un bouton ne peut changer d'état. Dans ce cas, le contrôleur accepte les clics simples et surveille les situations lorsque deux boutons ou plus sont enfoncés entre les passages de la matrice. Considérant que la matrice est analysée à une vitesse à laquelle l'apparition normale de telles situations est extrêmement improbable, nous pouvons conclure que l'un des boutons qui viennent d'être enfoncés est un fantôme. Par conséquent, le contrôleur doit ignorer tous ces clics. De plus, il est plus sûr de ne pas informer immédiatement l'ordinateur des changements dans l'état du clavier - il est d'abord logique d'attendre que toutes ces alarmes disparaissent.

Il existe une autre approche. Vous pouvez identifier une situation dans laquelle le « troisième » bouton est déclenché et bloquer à la fois cette pression et toutes les suivantes. Ne retirez pas le verrou jusqu'à ce que le déclenchement fantôme disparaisse et que la situation redevienne normale. Pour mettre en œuvre cette approche, le programme doit se souvenir des boutons actuellement enfoncés (et il s'en souvient généralement de toute façon) afin de rejeter les activations ultérieures des boutons dans les lignes et les colonnes dont des pressions simultanées ont déjà été enregistrées. Si vous écrivez le programme judicieusement, seules les réponses problématiques seront bloquées et toutes les réponses suivantes seront acceptées comme d'habitude - à l'exception de celles qui enfreignent à nouveau les règles. Étant donné que le contrôleur rejette l'appui sur chaque bouton ayant déjà des activations simultanées dans sa ligne et sa colonne, il s'avère que, en fonction de l'état de certains boutons, d'autres peuvent ne pas être enregistrés du tout. Cette situation est communément appelée blocage (brouillage). C'est-à-dire que les boutons qui empêchent le fonctionnement simultané d'autres boutons « bloquent » une partie du clavier.

Du point de vue de l'utilisateur, il est possible d'appuyer simultanément sur tous les boutons d'une colonne (sans appuyer sur les boutons d'une autre), mais l'appui simultané sur tous les boutons d'une rangée n'est possible que si chacun de ces boutons n'a pas plus d'une opération enregistrée dans la colonne. Il en va de même pour les boutons de la même colonne - les clics supplémentaires ne sont enregistrés que si les boutons se trouvent dans des lignes « non occupées ».

Les gens confondent souvent " déclenchement fantôme" Et " opération de blocage» (« fantôme" Et " brouillage"), ce qui est un mystère pour moi personnellement - à mon avis, ces termes sont assez intuitifs.

Dans les claviers utilisant des matrices telles que celles que nous venons de voir, il est impossible d'éviter ni l'activation fantôme ni le blocage. Étant donné que les activations fantômes sont inacceptables dans le travail quotidien, pour les combattre, presque tous les fabricants de claviers à dôme en caoutchouc utilisent diverses astuces, et le blocage entre en jeu. Question : comment créer une matrice de manière à ce que le blocage se produise le plus rarement possible et ne soit pas provoqué par des combinaisons de touches courantes ? En fait, c’est un bon sujet pour un livre entier ; C'est pourquoi les matrices des claviers grand public sont si déroutantes et bloquent toujours la bonne humeur (jeu de mots).

Diodes pour tous les boutons - une solution radicale

Si vous regardez à nouveau l'image des clics fantômes, vous remarquerez que le bouton en bas à droite est à blâmer.
Mais ce bouton est le seul par lequel le courant circule « vers le haut » dans cette situation. Donc, si nous ne voulons pas que les courants « montants » nous empêchent de lire la matrice normalement, introduisons des diodes afin que le courant puisse circuler dans les colonnes strictement de haut en bas, circulant dans les sorties du microcontrôleur.

Malheureusement, vous ne pourrez pas économiser d'argent ici - vous devrez installer une diode sur chaque bouton. Si nous parlons de polarité, vous devriez déjà avoir compris que dans ce cas particulier, les diodes doivent faire passer le courant « de haut en bas », c'est-à-dire que leurs cathodes (« pointes de flèches ») doivent regarder les sorties du microcontrôleur (colonnes ), tandis que les anodes doivent faire face aux entrées (rangées).

Matrice finale

Peu importe de quel côté du bouton la diode est placée ; l'essentiel est de maintenir la bonne polarité. N'oubliez pas que dans ce cas, le courant circulera toujours des entrées vers les sorties. À propos, si les entrées sont connectées à l'alimentation et que les sorties sont en mode OS, cela se produira toujours.

Avec cette approche, il s'avère que le courant circulera toujours « vers la droite », ce qui élimine l'apparition de boucles de courant fermées lorsque plusieurs boutons sont enfoncés simultanément. De plus, cette conception est la seule à pouvoir fournir un NKRO complet au clavier. De plus, il convient de mentionner (même si cela semble évident) que le problème des sorties du microcontrôleur ne disposant pas de mode OS est désormais résolu automatiquement. Les diodes installées en série avec chaque bouton n'empêchent pas les sorties de court-circuiter, pas plus que l'option précédemment envisagée, où il était censé installer en plus une diode sur chaque colonne.

Rouler sur

Oui, je sais que le texte est déjà trop long. Mais j’ajouterai quand même ce dernier chapitre, car, à mon avis, l’article serait incomplet sans lui. Ainsi, le rollover est la capacité du clavier à accepter plusieurs frappes en même temps.

xKRO

KRO signifie survol du clavier (roulement de clé), et généralement cette abréviation est précédée d'une sorte de chiffre. Par exemple, 2KRO signifie rollover à deux touches. Le clavier a X-key rollover si et seulement s'il est capable de s'enregistrer X pressions simultanées, et - quels que soient les boutons et dans quel ordre ont été utilisés. La plupart des claviers à dôme en caoutchouc modernes ont 2KRO. Il ne s'ensuit cependant pas que le nombre de frappes autorisé sur ces claviers sera toujours limité au nombre X. En réalité, cela signifie que le soutien X les presses simultanées sont garanties avec précision.

Selon la conception de la matrice et le type de contrôleur, deux claviers 2KRO de fabricants différents peuvent se comporter de manière complètement différente. L’un ne peut toujours gérer que deux clics simultanés, tandis que l’autre peut facilement en gérer davantage. Il semble que le dernier clavier ait été annoncé par 2KRO car certaines combinaisons de touches (très probablement, peu probables) l'empêcheront toujours d'appuyer sur d'autres boutons. Et comme cela signifie que lorsque vous travaillez avec ce clavier, certaines combinaisons de trois touches ou plus ne fonctionneront pas, la société l'a déclaré 2KRO.

NKRO

Le terme NKRO signifie Renversement de la touche N, et il est utilisé pour désigner des claviers qui prennent en charge, quoi qu'il en soit, n'importe quelle combinaison de touches enfoncées simultanément. Mais gardez à l’esprit que les matrices NKRO et les claviers NKRO sont deux choses très différentes. Par exemple, si l'implémentation finale de la matrice que nous avons examinée dans l'article prend en charge NKRO (en tenant compte du micrologiciel correctement écrit), il ne s'ensuit pas du tout que le clavier utilisant cette matrice prendra également en charge NKRO. Cela peut se produire en raison de restrictions imposées par les ports de communication auxquels le clavier est connecté ; Une autre raison peut être le caractère économe des fabricants, qui économisent toujours ici et là. Je vais essayer d'expliquer le problème de NKRO lors de la connexion à PS/2 et USB dans les parties suivantes.

Conclusion

Bien sûr, la fiche est assez grande, mais le concept n'est pas si simple - surtout pour le lecteur qui n'est pas ingénieur en électronique. J'espère avoir réussi à tout expliquer ; Quoi qu’il en soit, j’ai essayé d’écrire le plus clairement possible. Par conséquent, certains d’entre vous pourraient trouver cet article assez ennuyeux. Eh bien, si vous aimez l'électronique, vous n'auriez probablement pas dû le lire du tout ;)
Dans tous les cas, s'il vous plaît

Les pages de ce site ont déjà présenté des travaux de création et d'utilisation d'un clavier, mais celui-ci était tactile. Ceux qui ont besoin d'une option plus simple choisissent souvent des claviers à boutons-poussoirs standard, dans lesquels les boutons sont reliés par une matrice. Cette connexion de boutons permet de réduire le nombre de broches nécessaires pour se connecter au microcontrôleur.

Les claviers les plus courants sont les 3x4 et 4x4 avec respectivement 12 et 16 boutons. J'avais un clavier 4x4 entre les mains. Envisageons de travailler avec lui maintenant.

Il m'est arrivé d'avoir ce clavier avec des contacts à membrane. C'est bien car il n'a que 1 mm d'épaisseur et peut facilement adhérer aux surfaces souhaitées.

Après avoir fouillé les boutons, j'ai utilisé un multimètre pour déterminer comment les boutons à l'intérieur du clavier étaient connectés.

Il existe une fonction spéciale pour scanner les claviers matriciels dans Bascom-AVR Obtenirkbd() . Cette commande est conçue pour être utilisée avec des claviers 4x4, elle utilise donc les 8 broches d'un port du microcontrôleur. Et si vous utilisez des claviers avec moins de boutons, vous devez en tenir compte.

La configuration de la commande consiste à attribuer le port auquel le clavier sera connecté, le temps de rebond du contact et le délai après détection de la frappe.

par exemple, dans la ligne suivante :

Configuration Kbd = Portd, Anti-rebond= 20 , Retard= 100

la connexion du clavier au PortD est configurée, le temps de rebond est réglé à 20 ms, le temps de retard après appui est de 100 ms

Cette commande prend en charge tout le travail de numérisation des lignes du clavier et renvoie à une variable le numéro de la touche enfoncée de 0 à 15. Si l'appui sur le bouton n'est pas enregistré, alors la fonction renverra le numéro 16. De plus, selon la façon dont les boutons sont connectés, vous devrez peut-être connaître le symbole des boutons enfoncés.

Dans l'exemple ci-dessous, le balayage du clavier s'effectue à 10 Hz et se situe dans la boucle principale du programme. Le résultat de la pression est affiché sur l'écran LCD.

$fichierreg = "m8def.dat"
$cristal = 1000000

"configuration de l'affichage
Configuration Lcdpin = broche, Rs = port. 0, E = Portc. 1, Db4 = Portc. 2, Db5 = Portc. 3, Db6 = Portc. 4, Db7 = Portc. 5
Configuration Écran LCD= 20 * 4
Le curseur Désactivé
Cls

"configuration du clavier
Configuration Kbd = Portd, Anti-rebond= 20 , Retard= 100

"variables
Faible Clé_char CommeOctet"numéro de la touche enfoncée
Faible Clé_str CommeChaîne* 1 "symbole de la touche enfoncée sur le clavier
Faible Résultat CommeChaîne* 20 "le résultat d'une pression sur le clavier

Résultat= ""

"Boucle principale du programme
Faire

Clé_char= Obtenirkbd() "la touche n'est pas enfoncée et la fonction renvoie la valeur 16 à la variable

Si Clé_char<> 16 Alors"si la variable n'est pas égale à 16, alors le bouton a été enfoncé
Clé_str= Recherche(key_char, Keyboard_data) "retirez le symbole de la touche enfoncée
Résultat= Résultat + Key_str
Fin Si

Localiser 1 , 1

Écran LCD Résultat "nous affichons le résultat de l'appui sur

Attendez 100

Boucle

Fin

Données_clavier:
Données "1" , "4" , "7" , "*" , "2" , "5" , "8" , "0"
Données "3" , "6" , "9" , "#" , "A" , "B" , "C" , "D"

Et voici un circuit de test à l'aide duquel l'écran et le clavier sont connectés :

Cela ne ferait pas de mal non plus d'ajouter des résistances de limitation de courant au circuit sur la ligne du clavier, d'une valeur nominale de 100 à 150 Ohms. Au cas où, mais pour tester ça fera l'affaire (l'essentiel est de ne pas appuyer sur plusieurs boutons à la fois)

Nous nous connectons, clignotons, appuyons sur les boutons et voyons le résultat - les symboles des touches enfoncées sont affichés sur l'écran :

J'ajouterai une vidéo de démonstration plus tard, dès que j'aurai trouvé quelque chose à filmer avec une qualité décente.

En attendant, vous pouvez télécharger l'archive contenant le fichier pour la simulation dans Proteus et le firmware.