Clavier matriciel 4X4 s'interfaçant avec le microcontrôleur pic

Les claviers sont des périphériques d'entrée largement utilisés dans divers projets électroniques et intégrés. Ils sont utilisés pour prendre des entrées sous forme de nombres et d'alphabets, et les alimentent dans le système pour un traitement ultérieur. Dans ce tutoriel, nous allons interfacer un clavier matriciel 4x4 avec PIC16F877A.

Avant d'entrer dans la logique de détail et d'apprendre à utiliser le clavier, nous aurons besoin de savoir peu de choses.

Pourquoi nous avons besoin d'un clavier 4x4:

En général, nous utilisons une seule broche d'E / S d'une unité de microcontrôleur pour lire le signal numérique, comme une entrée de commutateur. Dans quelques applications où 9, 12, 16 touches sont nécessaires à des fins d'entrée, si nous ajoutons chaque clé dans un port de microcontrôleur, nous finirons par utiliser 16 ports d'E / S. Ces 16 ports d'E / S ne servent pas seulement à lire les signaux d'E / S, mais ils peuvent également être utilisés comme connexions périphériques, comme les prises en charge ADC, les connexions I2C et SPI sont également prises en charge par ces broches d'E / S. Comme ces broches sont connectées aux commutateurs / touches, nous ne pouvons pas les utiliser mais uniquement comme ports d'E / S. Cela n'a aucun sens. Alors, comment réduire le nombre de broches? La réponse est, en utilisant un clavier hexadécimal ou un clavier matriciel; nous pouvons réduire le nombre de broches, qui associent des clés matricielles 4x4. Il utilisera 8 broches dont 4 connectées en rangées et 4 connectées en colonnes, économisant ainsi 8 broches du microcontrôleur.

Comment fonctionne le clavier matriciel 4x4:

Dans l'image supérieure, un module de clavier matriciel est illustré à gauche. Sur la droite, la connexion interne est affichée ainsi que la connexion du port. Si nous voyons le port il y a 8 broches, les 4 premières de gauche à droite sont X1, X2, X3 et X4 sont les lignes, et les 4 dernières de gauche à droite sont Y1, Y2, Y3, Y4 sont quatre colonnes. Si nous créons 4 lignes ou côté X en sortie et les rendons logiques bas ou 0, et faisons les 4 colonnes en entrée et lisons les touches, nous lirons l'interrupteur pressé lorsque le correspondant Y obtient 0.

La même chose se produira dans la matrice nxn où n est le nombre. Cela peut être 3x3, 6x6 etc.

Maintenant, pensez simplement que 1 est pressé. Ensuite, le 1 est situé à la ligne X1 et à la colonne Y1. Si X1 est 0, alors Y1 sera 0. De la même manière, nous pouvons détecter chaque clé de la ligne X1, en détectant les colonnes Y1, Y2, Y3 et Y4. Cette chose se produit pour chaque interrupteur et nous lirons la position des interrupteurs dans la matrice.

Chaque cercle vert est le commutateur et ils sont tous deux connectés ensemble de la même manière.

Dans ce tutoriel, nous allons interfacer le clavier avec les spécifications suivantes:

Nous utiliserons le pull up interne
Nous ajouterons une option de dé-rebond de clé

Mais lorsque les commutateurs ne sont pas enfoncés, nous devons rendre Y1, Y2, Y3 et Y4 aussi hauts ou 1. Sinon, nous ne pouvons pas détecter les changements de logique lorsque le commutateur est enfoncé. Mais nous ne pouvions pas le faire avec des codes ou un programme car ces broches sont utilisées comme entrée et non comme sortie. Ainsi, nous utiliserons un registre de fonctionnement interne dans le microcontrôleur et utiliserons ces broches en tant que mode activé pour le pull up faible. En utilisant cela, il y aura un mode d'activation logique haut lorsqu'il est dans l'état par défaut.

De plus, lorsque nous appuyons sur la touche, des pointes ou du bruit sont générés avec les contacts du commutateur, et en raison de cette pression multiple, il se produit ce qui n'est pas prévu. Donc, nous allons d'abord détecter la pression de l'interrupteur, attendre quelques millisecondes, vérifier à nouveau si l'interrupteur est toujours enfoncé ou non et si l'interrupteur est toujours enfoncé, nous accepterons enfin la pression de l'interrupteur, sinon non. C'est ce qu'on appelle le rebond des commutateurs.

Nous allons implémenter tout cela dans notre code et établir la connexion sur la maquette.

Vérifiez également comment interfacer le clavier 4x4 avec d'autres microcontrôleurs:

Interfaçage du clavier avec Arduino Uno
Interfaçage du clavier matriciel 4x4 avec le microcontrôleur 8051
Interfaçage du clavier 4x4 avec le microcontrôleur ATmega32
Verrouillage à code numérique Raspberry Pi sur la planche à pain

Matériel requis:

Planche à pain
Pic-kit 3 et environnement de développement sur votre PC, c'est-à-dire MPLABX
Fils et connecteurs
LCD à caractères 16x2
Cristal 20Mhz
2 capuchons de disque en céramique 33pF.
Résistance 4,7k
Préréglage 10k (résistance variable)
Clavier matriciel 4x4
Un adaptateur 5 V

Schéma:

Nous allons connecter les cristaux et la résistance dans les broches associées. De plus, nous connecterons l'écran LCD en mode 4 bits sur PORTD. Nous avons connecté le clavier hexadécimal ou le clavier matriciel sur le port RB4.

Si vous êtes nouveau sur PIC, commencez par Premiers pas avec PIC Microcontroller: Introduction à PIC et MPLABX

Explication de la programmation:

Le code complet pour l'interfaçage du clavier matriciel avec le microcontrôleur PIC est donné à la fin. Le code est simple et explicite. La bibliothèque de clavier est la seule chose à comprendre dans le code. Ici, nous avons utilisé keypad.h et lcd.h Library pour interfacer le clavier et l'écran LCD 16x2. Voyons donc ce qui se passe à l'intérieur.

Dans le keypad.h, nous verrons que nous avons utilisé l'en - tête xc.h qui est la bibliothèque de registres par défaut, la fréquence du cristal est définie pour l'utilisation du délai utilisé dans le fichier kepad.c. Nous avons défini les ports du clavier au registre PORTRB et défini les broches individuelles comme ligne (X) et colonnes (Y).

Nous avons également utilisé deux fonctions, une pour l'initialisation du clavier qui redirigera le port en tant que sortie et entrée, et un balayage de la presse du commutateur qui retournera l'état de la presse du commutateur lorsqu'il est appelé.

#comprendre #define _XTAL_FREQ 200000000 // Fréquence de cristal, utilisée dans le délai #define X_1 RB0 #define X_2 RB1 #define X_3 RB2 #define X_4 RB3 #define Y_1 RB4 #define Y_2 RB5 #define Y_3 RB6 #define Y_4 RB7 #define Y_3 RB6 #define Y_4 RB7 #define Y_3 RB6 #define Y_4 RB7 #define Keypad_PORT_Direction TRISB void InitKeypad (void); char switch_press_scan (void);

Dans le keypad.c, nous verrons que la fonction ci-dessous renverra la pression sur la touche lorsque la fonction scanner du clavier ne retournera pas 'n'.

char switch_press_scan (void) // Récupère la clé de l'utilisateur { char key = 'n'; // Suppose qu'aucune touche n'est enfoncée pendant que (key == 'n') // Attendez jusqu'à ce qu'une touche soit enfoncée key = keypad_scanner (); // Scannez les clés encore et encore return key; // lorsque la touche est enfoncée puis renvoie sa valeur }

Voici la fonction de lecture du clavier. Dans chaque étape, nous allons rendre la ligne X1, X2, X3 et X4 à 0 et lire l'état Y1, Y2, Y3 et Y4. Le délai est utilisé pour l'effet anti-rebond, lorsque l'interrupteur est toujours enfoncé, nous retournerons la valeur qui lui est associée. Lorsqu'aucun interrupteur n'est enfoncé, nous retournons «n».

char keypad_scanner (void) { X_1 = 0; X_2 = 1; X_3 = 1; X_4 = 1; si (Y_1 == 0) {__delay_ms (100); tandis que (Y_1 == 0); retourne «1»; } si (Y_2 == 0) {__delay_ms (100); tandis que (Y_2 == 0); retourne «2»; } si (Y_3 == 0) {__delay_ms (100); tandis que (Y_3 == 0); retourne «3»; } si (Y_4 == 0) {__delay_ms (100); tandis que (Y_4 == 0); retourne «A»; } X_1 = 1; X_2 = 0; X_3 = 1; X_4 = 1; si (Y_1 == 0) {__delay_ms (100); tandis que (Y_1 == 0); retourne «4»; } si (Y_2 == 0) {__delay_ms (100); tandis que (Y_2 == 0); retourne «5»; } si (Y_3 == 0) {__delay_ms (100); tandis que (Y_3 == 0); retourne «6»; } si (Y_4 == 0) {__delay_ms (100); tandis que (Y_4 == 0); retourne «B»; } X_1 = 1; X_2 = 1; X_3 = 0; X_4 = 1; si (Y_1 == 0) {__delay_ms (100); tandis que (Y_1 == 0); retourne «7»; } si (Y_2 == 0) {__delay_ms (100); tandis que (Y_2 == 0); retourne «8»; } si (Y_3 == 0) {__delay_ms (100); tandis que (Y_3 == 0); retourne «9»; } si (Y_4 == 0) {__delay_ms (100); tandis que (Y_4 == 0); retourne «C»; } X_1 = 1; X_2 = 1; X_3 = 1; X_4 = 0; si (Y_1 == 0) {__delay_ms (100); tandis que (Y_1 == 0); revenir '*'; } si (Y_2 == 0) {__delay_ms (100); tandis que (Y_2 == 0); renvoie «0»; } si (Y_3 == 0) {__delay_ms (100); tandis que (Y_3 == 0); revenir '#'; } si (Y_4 == 0) {__delay_ms (100); tandis que (Y_4 == 0); retourne «D»; } retourne 'n'; }

Nous définirons également le tirage faible sur les quatre derniers bits, et définirons également la direction des ports comme 4 dernières entrées et 4 premières comme sorties. Le OPTION_REG & = 0x7F; est utilisé pour définir le mode pull up faible sur les dernières broches.

void InitKeypad (void) { Keypad_PORT = 0x00; // Définit les valeurs des broches du port du clavier zéro Keypad_PORT_Direction = 0xF0; // Dernière entrée 4 broches, première sortie 4 broches OPTION_REG & = 0x7F; }

Dans le programme PIC principal (donné ci-dessous), nous avons d'abord défini les bits de configuration et inclus quelques bibliothèques nécessaires. Ensuite, dans les fonctions void system_init, nous initialisons le clavier et l'écran LCD. Et enfin dans la fonction principale , nous avons lu le clavier en appelant la fonction switch_press_scan () et en renvoyant la valeur à lcd.

Téléchargez le code complet avec les fichiers d'en-tête à partir d'ici et regardez la vidéo de démonstration ci-dessous.