Interfície de teclat matricial 4X4 amb microcontrolador pic

Els teclats són dispositius d’entrada molt utilitzats que s’utilitzen en diversos projectes electrònics i incrustats. S'utilitzen per prendre entrades en forma de nombres i alfabets, i alimenten el mateix en el sistema per al seu posterior processament. En aquest tutorial farem una interfície d'un teclat de matriu 4x4 amb PIC16F877A.

Abans d’entrar en la lògica de detalls i aprendre a utilitzar el teclat, haurem de saber poques coses.

Per què necessitem el teclat 4x4:

Normalment utilitzem un pin d'E / S d'una unitat de microcontrolador per llegir el senyal digital, com una entrada de commutador. En poques aplicacions on es necessiten 9, 12, 16 claus per a finalitats d'entrada, si afegim cada clau en un port de microcontrolador, acabarem utilitzant 16 ports d'E / S. Aquests 16 ports d'E / S no només serveixen per llegir senyals d'E / S, sinó que també es poden utilitzar com a connexions perifèriques, com ara els suports ADC, les connexions I2C i SPI també són compatibles amb aquests pins d'E / S. Com que aquests pins estan connectats amb els commutadors / tecles, no els podem utilitzar sinó només com a ports d'E / S. Això no té cap sentit. Llavors, com reduir el recompte de pins? La resposta és, mitjançant un teclat hexagonal o un teclat matricial; podem reduir el recompte de pins, que associen claus de matriu 4x4. Utilitzarà 8 pins dels quals 4 connectats en files i 4 connectats en columnes, per tant, estalviaran 8 pins del microcontrolador.

Com funciona el teclat Matrix 4x4:

A la imatge superior es mostra un mòdul de teclat matricial a l'esquerra. A la dreta es mostra la connexió interna i la connexió de port. Si veiem el port hi ha 8 pins, els primers 4 d’esquerra a dreta són X1, X2, X3 i X4 són les files, i els darrers 4 d’esquerra a dreta són Y1, Y2, Y3, Y4 són quatre columnes. Si fem 4 files o costat X com a sortida i les fem lògiques baixes o 0, i fem les 4 columnes com a entrada i llegim les tecles, llegirem el polsador de commutació quan el corresponsal Y obtingui 0.

El mateix passarà a la matriu nxn on n és el nombre. Pot ser 3x3, 6x6, etc.

Ara només cal que premeu 1. A continuació, l' 1 es troba a la fila X1 i a la columna Y1. Si X1 és 0, llavors Y1 serà 0. De la mateixa manera, podem detectar cada tecla de la fila X1 detectant les columnes Y1, Y2, Y3 i Y4. Això passa per a cada commutador i llegirem la posició dels commutadors a la matriu.

Tots els cercles verds són el commutador i tots dos estan connectats de la mateixa manera.

En aquest tutorial relacionarem el teclat amb les següents especificacions:

Utilitzarem el pull up intern
Afegirem l’opció clau de rebot

Però quan no es premen els commutadors, hem de fer que els Y1, Y2, Y3 i Y4 siguin alts o 1. En cas contrari, no podem detectar els canvis lògics quan es pressiona l’interruptor. Però no ho hem pogut fer per codis o programes, ja que aquests pins s'utilitzen com a entrada, no com a sortida. Per tant, utilitzarem un registre d’operacions intern al microcontrolador i utilitzarem aquests pins com a mode habilitat de pull up feble. En utilitzar-ho, hi haurà un mode d'activació lògica alta quan estigui a l'estat per defecte.

A més, quan premem la tecla hi ha pics o es genera soroll amb els contactes del commutador, i a causa d’aquest commutador múltiple es produeix una pressió que no s’espera. Per tant, primer detectarem l’interruptor premut, esperarem uns quants mil·lisegons, tornarem a comprovar si l’interruptor encara està premut o no i, si l’interruptor encara està premut, acceptarem l’interruptor finalment, en cas contrari, no. Això es diu com a rebot dels commutadors.

Ho implementarem tot al nostre codi i establirem la connexió a la taula de proves.

Comproveu també com es relaciona el teclat 4x4 amb altres microcontroladors:

Interfície de teclat amb Arduino Uno
Interfície de teclat Matrix 4x4 amb microcontrolador 8051
Interfície de teclat 4x4 amb microcontrolador ATmega32
Bloqueig de codi digital Raspberry Pi a la taula de pa

Material requerit:

Taula de pa
Pic-kit 3 i entorn de desenvolupament al vostre PC, és a dir, MPLABX
Cables i connectors
LCD de caràcters 16x2
Cristall de 20Mhz
2 taps de disc ceràmic 33pF.
Resistència de 4,7 k
10k predefinit (resistència variable)
Teclat Matrix 4x4
Un adaptador de 5 V.

Esquema de connexions:

Connectarem els cristalls i la resistència als pins associats. A més, connectarem la pantalla LCD en mode de 4 bits a través de PORTD. Hem connectat el teclat hexagonal o el teclat matricial al port RB4.

Si no coneixeu PIC, comenceu per Introducció al microcontrolador PIC: Introducció a PIC i MPLABX

Explicació de la programació:

Al final es dóna un codi complet per a la interfície del teclat Matrix amb el microcontrolador PIC. El codi és fàcil i s’explica per si mateix. La biblioteca de teclats només s’ha d’entendre al codi. Aquí hem utilitzat la biblioteca keypad.h i lcd.h per connectar el teclat i el LCD 16x2. Així doncs, vegem què passa dins d’això.

Dins del teclat.h veurem que hem utilitzat la capçalera xc.h que és la biblioteca de registres per defecte, la freqüència de cristall es defineix per a l'ús del retard utilitzat al fitxer kepad.c. Hem definit els ports del teclat al registre PORTRB i hem definit els pins individuals com a fila (X) i columnes (Y).

També hem utilitzat dues funcions, una per a la inicialització del teclat, que redirigirà el port com a sortida i entrada, i un escaneig de premsa de commutador que retornarà l'estat de premuda de commutador quan es cridi.

#incloure #define _XTAL_FREQ 200000000 // vidre de freqüència, que s'utilitza en la demora #define X_1 RB0 #define X_2 RB1 #define X_3 RB2 #define X_4 RB3 #define Y_1 RB4 #define i_2 RB5 #define Y_3 RB6 #define Y_4 RB7 #define Keypad_PORT PORTB #define Keypad_PORT_Direction TRISB void InitKeypad (buit); char switch_press_scan (void);

Al teclat.c veurem que la funció següent tornarà a prémer la tecla quan la funció de l'escàner del teclat no retorni 'n'.

char switch_press_scan (void) // Obtén la clau de l'usuari { char key = 'n'; // Suposem que no es prem cap tecla mentre (tecla == 'n') // Espereu fins que es prem una tecla tecla = teclat_escàner (); // Escaneja les tecles una i altra vegada la tecla de retorn; // quan es prem la tecla, torna el seu valor }

A continuació es mostra la funció de lectura del teclat. A cada pas farem que la fila X1, X2, X3 i X4 sigui 0 i llegim els estats Y1, Y2, Y3 i Y4. El retard s'utilitza per a l'efecte rebounce, quan es continua prement l'interruptor, retornarem el valor associat. Quan no es prem cap interruptor, tornarem 'n'.

char keypad_scanner (void) { X_1 = 0; X_2 = 1; X_3 = 1; X_4 = 1; if (Y_1 == 0) {__delay_ms (100); mentre que (Y_1 == 0); torna '1'; } if (Y_2 == 0) {__delay_ms (100); mentre que (Y_2 == 0); torna '2'; } if (Y_3 == 0) {__delay_ms (100); mentre que (Y_3 == 0); torna '3'; } if (Y_4 == 0) {__delay_ms (100); mentre que (Y_4 == 0); torna 'A'; } X_1 = 1; X_2 = 0; X_3 = 1; X_4 = 1; if (Y_1 == 0) {__delay_ms (100); mentre que (Y_1 == 0); torna '4'; } if (Y_2 == 0) {__delay_ms (100); mentre que (Y_2 == 0); torna '5'; } if (Y_3 == 0) {__delay_ms (100); mentre que (Y_3 == 0); torna '6'; } if (Y_4 == 0) {__delay_ms (100); mentre que (Y_4 == 0); torna 'B'; } X_1 = 1; X_2 = 1; X_3 = 0; X_4 = 1; if (Y_1 == 0) {__delay_ms (100); mentre que (Y_1 == 0); torna '7'; } if (Y_2 == 0) {__delay_ms (100); mentre que (Y_2 == 0); torna '8'; } if (Y_3 == 0) {__delay_ms (100); mentre que (Y_3 == 0); torna '9'; } if (Y_4 == 0) {__delay_ms (100); mentre que (Y_4 == 0); torna 'C'; } X_1 = 1; X_2 = 1; X_3 = 1; X_4 = 0; if (Y_1 == 0) {__delay_ms (100); mentre que (Y_1 == 0); torna '*'; } if (Y_2 == 0) {__delay_ms (100); mentre que (Y_2 == 0); retorna '0'; } if (Y_3 == 0) {__delay_ms (100); mentre que (Y_3 == 0); torna '#'; } if (Y_4 == 0) {__delay_ms (100); mentre que (Y_4 == 0); torna "D"; } retornar 'n'; }

També establirem la tracció feble cap amunt en els darrers quatre bits i també definirem la direcció dels ports com a darrers 4 entrades i 4 primers com a sortida. El OPTION_REG & = 0x7F; s’utilitza per configurar el mode d’estirada feble als darrers pins.

void InitKeypad (void) { Teclat_PORT = 0x00; // Estableix els valors del pin de port del teclat zero Teclat_PORT_Direcció = 0xF0; // Entrada dels darrers 4 pins, sortida dels primers 4 pins OPTION_REG & = 0x7F; }

Al programa PIC principal (que es mostra a continuació) primer vam establir els bits de configuració i vam incloure poques biblioteques necessàries. A continuació, a les funcions void system_init inicialitzem el teclat i la pantalla LCD. I, finalment, a la funció principal , hem llegit el teclat trucant a la funció switch_press_scan () i retornant el valor a lcd.

Baixeu-vos el codi complet amb fitxers de capçalera i consulteu el vídeo de demostració següent.