Interfață cu tastatură matricială 4X4 cu microcontroler pic

Tastaturile sunt dispozitive de intrare utilizate pe scară largă, fiind utilizate în diverse proiecte electronice și încorporate. Acestea sunt folosite pentru a prelua intrări sub formă de numere și alfabete și le alimentează în sistem pentru procesare ulterioară. În acest tutorial vom interfața o tastatură matricială 4x4 cu PIC16F877A.

Înainte de a intra în logica detaliilor și de a învăța cum să folosim tastatura, va trebui să știm câteva lucruri.

De ce avem nevoie de tastatură 4x4:

De obicei, folosim un singur pin I / O al unei unități de microcontroler pentru a citi semnalul digital, ca o intrare de comutare. În puține aplicații în care sunt necesare 9, 12, 16 taste pentru introducere, dacă adăugăm fiecare cheie într-un port de microcontroler, vom ajunge să folosim 16 porturi I / O. Aceste 16 porturi I / O nu sunt doar pentru citirea semnalelor I / O, dar pot fi utilizate și ca conexiuni periferice, cum ar fi suporturile ADC, conexiunile I2C, SPI sunt, de asemenea, acceptate de acei pini I / O. Deoarece acei pini sunt conectați cu comutatoare / taste, nu le putem folosi, ci doar ca porturi I / O. Acest lucru nu are deloc sens. Deci, cum se reduce numărul de pini? Răspunsul este, folosind o tastatură hexagonală sau o tastatură matricială; putem reduce numărul de pini, care asociază chei matriciale 4x4. Acesta va utiliza 8 pini, dintre care 4 conectați în rânduri și 4 conectați în coloane, salvând astfel 8 pini ai microcontrolerului.

Cum funcționează tastatura 4x4 Matrix:

În imaginea superioară, un modul cu tastatură matricială este afișat în stânga. În dreapta este afișată conexiunea internă, precum și conexiunea la port. Dacă vedem portul sunt 8 pini, primele 4 de la stânga la dreapta sunt X1, X2, X3 și X4 sunt rândurile, iar ultimele 4 de la stânga la dreapta sunt Y1, Y2, Y3, Y4 sunt patru coloane. Dacă facem 4 rânduri sau partea X ca ieșire și le facem logice scăzute sau 0 și facem cele 4 coloane ca intrare și citim tastele, vom citi comutatorul apăsați când corespondentul Y obține 0.

Același lucru se va întâmpla în matricea nxn unde n este numărul. Poate fi 3x3, 6x6 etc.

Acum doar gândiți-vă că 1 este apăsat. Apoi 1 este situat la rândul X1 și coloana Y1. Dacă X1 este 0, atunci Y1 va fi 0. În același mod, putem detecta fiecare tastă din rândul X1, prin detectarea coloanelor Y1, Y2, Y3 și Y4. Acest lucru se întâmplă pentru fiecare comutator și vom citi poziția comutatoarelor în matrice.

Fiecare cerc verde este comutatorul și ambele sunt conectate împreună în același mod.

În acest tutorial vom interfața tastatura cu următoarele specificații-

Vom folosi pull up intern
Vom adăuga opțiunea cheie de-rebounce

Dar când comutatoarele nu sunt apăsate, trebuie să facem ca Y1, Y2, Y3 și Y4 să fie mari sau 1. În caz contrar, nu putem detecta modificările logice atunci când comutatorul este apăsat. Dar nu am putut face acest lucru prin coduri sau programe, deoarece acei pini sunt folosiți ca intrare, nu ca ieșire. Deci, vom folosi un registru de funcționare intern în microcontroler și vom opera acei pini ca mod slab activat în sus. Folosind aceasta, va exista un mod de activare logică ridicată atunci când se află în starea implicită.

De asemenea, atunci când apăsăm tasta există vârfuri sau se generează zgomot la contactele comutatorului și, datorită acestui comutator multiplu, se întâmplă apăsarea care nu este de așteptat. Deci, vom detecta mai întâi apăsarea comutatorului, așteptăm câteva milisecunde, verificăm din nou dacă comutatorul este încă apăsat sau nu și dacă comutatorul este încă apăsat, vom accepta apăsarea comutatorului în caz contrar, nu. Acest lucru se numește ca deconectare a comutatoarelor.

Vom implementa toate acestea în codul nostru și vom face conexiunea pe panoul de verificare.

De asemenea, verificați cum să interfațați tastatura 4x4 cu alte microcontrolere:

Interfața tastaturii cu Arduino Uno
Interfațare cu tastatură matricială 4x4 cu microcontroler 8051
Interfațare cu tastatură 4x4 cu microcontroler ATmega32
Blocare cod digital Raspberry Pi pe Breadboard

Material necesar:

Breadboard
Pic-kit 3 și mediul de dezvoltare în computerul dvs., adică MPLABX
Sârme și conectori
Caracter LCD 16x2
Cristal de 20Mhz
2 buc capac de disc ceramic 33pF.
Rezistor de 4.7k
10k presetat (rezistor variabil)
Tastatură 4x4 Matrix
Un adaptor de 5 V.

Diagrama circuitului:

Vom conecta cristalele și rezistorul în pinii asociați. De asemenea, vom conecta LCD-ul în modul 4 biți pe PORTD. Am conectat tastatura hex sau tastatura matricială prin portul RB4.

Dacă sunteți nou în PIC, începeți cu Noțiuni introductive despre microcontrolerul PIC: Introducere în PIC și MPLABX

Explicație de programare:

Codul complet pentru interfațarea tastaturii Matrix cu microcontrolerul PIC este dat la sfârșit. Codul este ușor și se explică de la sine. Biblioteca tastaturii este doar un lucru care trebuie înțeles în cod. Aici am folosit biblioteca keypad.h și lcd.h pentru a interfața tastatura și LCD 16x2. Deci, să vedem ce se întâmplă în interior.

În interiorul tastaturii.h vom vedea că am folosit antetul xc.h, care este biblioteca de registre implicită, frecvența cristalului este definită pentru utilizarea pentru utilizarea întârzierii utilizate în fișierul kepad.c. Am definit porturile tastaturii la registrul PORTRB și am definit pinii individuali ca rândul (X) și coloanele (Y).

De asemenea, am folosit două funcții, una pentru inițializarea tastaturii, care va redirecționa portul ca ieșire și intrare, și o scanare a apăsării comutatorului, care va reveni la starea apăsării comutatorului atunci când este apelat.

#include #define _XTAL_FREQ 200000000 // cristal de frecvență, utilizat în întârziere #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 (nul); char switch_press_scan (nul);

În tastatura.c vom vedea că funcția de mai jos va reveni la apăsarea tastei atunci când funcția de scanare a tastaturii nu returnează „n”.

char switch_press_scan (void) // Obține cheia de la utilizator { char key = 'n'; // Să nu presupunem că este apăsată nicio tastă în timp ce (tasta == 'n') // Așteptați până când o tasta este apăsată tasta = keypad_scanner (); // Scanați tastele din nou și din nou cheia de returnare; // când este apăsată tasta, returnează-i valoarea }

Mai jos este funcția de citire a tastaturii. În fiecare pas vom face rândul X1, X2, X3 și X4 ca 0 și citind starea Y1, Y2, Y3 și Y4. Întârzierea este utilizată pentru efectul debounce, când comutatorul este încă apăsat, vom returna valoarea asociată cu acesta. Când nu este apăsat nici un comutator, vom reveni la „n”.

char keypad_scanner (nul) { X_1 = 0; X_2 = 1; X_3 = 1; X_4 = 1; if (Y_1 == 0) {__delay_ms (100); while (Y_1 == 0); returnează „1”; } if (Y_2 == 0) {__delay_ms (100); while (Y_2 == 0); returnează „2”; } if (Y_3 == 0) {__delay_ms (100); while (Y_3 == 0); returnează „3”; } if (Y_4 == 0) {__delay_ms (100); while (Y_4 == 0); returnează „A”; } X_1 = 1; X_2 = 0; X_3 = 1; X_4 = 1; if (Y_1 == 0) {__delay_ms (100); while (Y_1 == 0); returnează „4”; } if (Y_2 == 0) {__delay_ms (100); while (Y_2 == 0); returnează „5”; } if (Y_3 == 0) {__delay_ms (100); while (Y_3 == 0); returnează „6”; } if (Y_4 == 0) {__delay_ms (100); while (Y_4 == 0); returnează „B”; } X_1 = 1; X_2 = 1; X_3 = 0; X_4 = 1; if (Y_1 == 0) {__delay_ms (100); while (Y_1 == 0); returnează „7”; } if (Y_2 == 0) {__delay_ms (100); while (Y_2 == 0); returnează „8”; } if (Y_3 == 0) {__delay_ms (100); while (Y_3 == 0); returnează „9”; } if (Y_4 == 0) {__delay_ms (100); while (Y_4 == 0); returnează „C”; } X_1 = 1; X_2 = 1; X_3 = 1; X_4 = 0; if (Y_1 == 0) {__delay_ms (100); while (Y_1 == 0); întoarcere '*'; } if (Y_2 == 0) {__delay_ms (100); while (Y_2 == 0); returnează '0'; } if (Y_3 == 0) {__delay_ms (100); while (Y_3 == 0); întoarcere '#'; } if (Y_4 == 0) {__delay_ms (100); while (Y_4 == 0); returnează „D”; } returnează 'n'; }

De asemenea, vom seta tragerea slabă pe ultimii patru biți și, de asemenea, vom seta direcția porturilor ca ultimele 4 intrări și primele 4 ca ieșire. OPTION_REG & = 0x7F; este folosit pentru a seta modul slab pull up pe ultimii pini.

void InitKeypad (nul) { Keypad_PORT = 0x00; // Setați valorile pinului portului tastaturii zero Keypad_PORT_Direction = 0xF0; // Ultimele 4 pini de intrare, Primii 4 pini de intrare OPTION_REG & = 0x7F; }

În programul principal PIC (prezentat mai jos) am setat mai întâi biții de configurare și am inclus câteva biblioteci necesare. Apoi, în funcțiile voite system_init inițializăm tastatura și ecranul LCD. Și, în sfârșit, în în principal funcția am citit tastatura prin apelarea switch_press_scan () funcția și revenirea valoarea la LCD.

Descărcați codul complet cu fișiere antet de aici și verificați videoclipul demonstrativ de mai jos.