Tastiera a matrice 4X4 interfacciabile con microcontrollore pic

Le tastiere sono dispositivi di input ampiamente utilizzati in vari progetti elettronici e integrati. Sono utilizzati per prendere input sotto forma di numeri e alfabeti e inserire gli stessi nel sistema per ulteriori elaborazioni. In questo tutorial interfacciamo una tastiera a matrice 4x4 con PIC16F877A.

Prima di entrare nella logica dei dettagli e imparare a usare la tastiera, avremo bisogno di sapere alcune cose.

Perché abbiamo bisogno della tastiera 4x4:

In genere utilizziamo un singolo pin I / O di un'unità microcontrollore per leggere il segnale digitale, come un ingresso di commutazione. In poche applicazioni in cui sono necessarie 9, 12, 16 chiavi per scopi di input, se aggiungiamo ciascuna chiave in una porta del microcontrollore, finiremo per utilizzare 16 porte I / O. Queste 16 porte I / O non sono solo per la lettura dei segnali I / O, ma possono essere utilizzate anche come connessioni periferiche, come i supporti ADC, I2C, le connessioni SPI sono supportate anche da quei pin I / O. Poiché questi pin sono collegati agli interruttori / tasti, non possiamo usarli ma solo come porte I / O. Questo non ha alcun senso. Quindi, come ridurre il numero di pin? La risposta è, utilizzando una tastiera esadecimale o una tastiera a matrice; possiamo ridurre il numero di pin, che associano chiavi matrice 4x4. Utilizzerà 8 pin di cui 4 collegati in righe e 4 collegati in colonne, risparmiando quindi 8 pin del microcontrollore.

Come funziona la tastiera a matrice 4x4:

Nell'immagine in alto a sinistra è mostrato un modulo tastiera a matrice. Sulla destra viene mostrata la connessione interna e la connessione della porta. Se vediamo la porta ci sono 8 pin, i primi 4 da sinistra a destra sono X1, X2, X3 e X4 sono le righe e gli ultimi 4 da sinistra a destra sono Y1, Y2, Y3, Y4 sono quattro colonne. Se creiamo 4 righe o il lato X come output e le rendiamo logiche basse o 0, e facciamo le 4 colonne come input e leggiamo i tasti, leggeremo l'interruttore premere quando il corrispondente Y ottiene 0.

La stessa cosa accadrà nella matrice nxn dove n è il numero. Può essere 3x3, 6x6 ecc.

Ora pensa solo che 1 è premuto. Quindi l' 1 si trova nella riga X1 e nella colonna Y1. Se X1 è 0, Y1 sarà 0. Allo stesso modo possiamo rilevare ogni tasto nella riga X1, rilevando le colonne Y1, Y2, Y3 e Y4. Questa cosa accade per ogni interruttore e leggeremo la posizione degli interruttori nella matrice.

Ogni cerchio verde è l'interruttore ed entrambi sono collegati insieme allo stesso modo.

In questo tutorial interfacciamo la tastiera con le seguenti specifiche:

Useremo pull up interni
Aggiungeremo l'opzione di rimbalzo della chiave

Ma quando gli interruttori non vengono premuti, dobbiamo rendere Y1, Y2, Y3 e Y4 più alti o 1. Altrimenti non possiamo rilevare i cambiamenti logici quando l'interruttore viene premuto. Ma non siamo riusciti a farlo tramite codici o programmi perché quei pin sono usati come input, non come output. Quindi, useremo un registro di funzionamento interno nel microcontrollore e utilizzeremo quei pin come modalità abilitata per pull up debole. Usando questo, ci sarà una modalità di abilitazione logica alta quando è nello stato predefinito.

Inoltre, quando si preme il tasto si verificano picchi o viene generato rumore con i contatti dell'interruttore e, a causa di questa pressione multipla dell'interruttore, si verifica una pressione non prevista. Quindi, per prima cosa rileveremo la pressione dell'interruttore, attendiamo alcuni millisecondi, controlliamo nuovamente se l'interruttore è ancora premuto o meno e se l'interruttore è ancora premuto accetteremo la pressione dell'interruttore alla fine altrimenti no. Questo è chiamato come de-rimbalzo degli interruttori.

Implementeremo tutto questo nel nostro codice e creeremo la connessione sulla breadboard.

Controlla anche come interfacciare la tastiera 4x4 con altri microcontrollori:

Interfacciamento della tastiera con Arduino Uno
Tastiera a matrice 4x4 interfacciata con microcontrollore 8051
Interfaccia tastiera 4x4 con microcontrollore ATmega32
Raspberry Pi Digital Code Lock su breadboard

Materiale richiesto:

Breadboard
Pic-kit 3 e ambiente di sviluppo nel tuo PC, cioè MPLABX
Fili e connettori
LCD a caratteri 16x2
Cristallo da 20 Mhz
Tappo disco ceramico 33pF 2 pz.
Resistenza da 4.7k
10k preset (resistenza variabile)
Tastiera Matrix 4x4
Un adattatore da 5 V.

Schema elettrico:

Collegheremo i cristalli e la resistenza nei pin associati. Inoltre, collegheremo l'LCD in modalità 4 bit su PORTD. Abbiamo collegato la tastiera esadecimale o la tastiera a matrice attraverso la porta RB4.

Se non conosci PIC, inizia con Introduzione a PIC Microcontroller: Introduzione a PIC e MPLABX

Spiegazione della programmazione:

Alla fine viene fornito il codice completo per l'interfacciamento della tastiera a matrice con il microcontrollore PIC. Il codice è semplice e intuitivo. La libreria della tastiera è l'unica cosa da comprendere nel codice. Qui abbiamo utilizzato la libreria keypad.h e lcd.h per interfacciare la tastiera e il display LCD 16x2. Quindi vediamo cosa sta succedendo al suo interno.

All'interno del keypad.h vedremo che abbiamo usato l' intestazione xc.h che è la libreria di registro predefinita, la frequenza del cristallo è definita per l'uso per l'uso del ritardo usato nel file kepad.c. Abbiamo definito le porte della tastiera nel registro PORTRB e definito i singoli pin come riga (X) e colonne (Y).

Abbiamo anche usato due funzioni, una per l'inizializzazione della tastiera che reindirizzerà la porta come output e input, e una scansione della pressa dello switch che restituirà lo stato della pressa dello switch quando viene chiamata.

#includere #define _XTAL_FREQ 200000000 // cristallo di frequenza, utilizzato in ritardo # 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 Keypad_PORT PORTB #define Keypad_PORT_Direction TRISB void InitKeypad (void); char switch_press_scan (void);

Nel keypad.c vedremo che la funzione di seguito restituirà la pressione del tasto quando la funzione scanner della tastiera non restituirà 'n'.

char switch_press_scan (void) // Ottiene la chiave dall'utente { char key = 'n'; // Assumi che nessun tasto sia premuto mentre (key == 'n') // Attendi finché non viene premuto un tasto key = keypad_scanner (); // Scansiona le chiavi ancora e ancora return key; // quando il tasto viene premuto, restituisce il suo valore }

Di seguito è riportata la funzione di lettura della tastiera. In ogni passaggio creeremo la riga X1, X2, X3 e X4 come 0 e leggeremo lo stato Y1, Y2, Y3 e Y4. Il ritardo viene utilizzato per l'effetto debounce, quando l'interruttore è ancora premuto restituiremo il valore ad esso associato. Quando non viene premuto alcun interruttore, restituiremo 'n'.

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

Imposteremo anche il pull up debole sugli ultimi quattro bit e imposteremo anche la direzione delle porte come gli ultimi 4 input e i primi 4 come output. L'OPTION_REG & = 0x7F; viene utilizzato per impostare la modalità di pull up debole sugli ultimi pin.

void InitKeypad (void) { Keypad_PORT = 0x00; // Imposta i valori del pin della porta del tastierino zero Keypad_PORT_Direction = 0xF0; // Ultimi 4 pin in ingresso, primi 4 pin in uscita OPTION_REG & = 0x7F; }

Nel programma PIC principale (indicato di seguito) abbiamo prima impostato i bit di configurazione e incluso alcune librerie necessarie. Quindi nelle funzioni void system_init inizializziamo la tastiera e il display LCD. E infine in nel principale funzione che abbiamo letto la tastiera chiamando il switch_press_scan () la funzione e restituire il valore a cristalli liquidi.

Scarica il codice completo con i file di intestazione da qui e guarda il video dimostrativo qui sotto.