4X4 matrix toetsenbord interface met pic microcontroller

Toetsenborden zijn veelgebruikte invoerapparaten die worden gebruikt in verschillende elektronica- en embedded projecten. Ze worden gebruikt om invoer in de vorm van cijfers en alfabetten op te nemen en deze in het systeem in te voeren voor verdere verwerking. In deze tutorial gaan we een 4x4 matrix toetsenbord koppelen aan PIC16F877A.

Voordat we ingaan op de detaillogica en leren hoe we het toetsenbord moeten gebruiken, zullen we enkele dingen moeten weten.

Waarom we een 4x4-toetsenbord nodig hebben:

Meestal gebruiken we een enkele I / O-pin van een microcontroller-eenheid om het digitale signaal te lezen, zoals een schakelingang. In enkele toepassingen waar 9, 12, 16 sleutels nodig zijn voor invoerdoeleinden, zullen we, als we elke sleutel in een microcontrollerpoort toevoegen, uiteindelijk 16 I / O-poorten gebruiken. Deze 16 I / O-poorten zijn niet alleen voor het lezen van I / O-signalen, maar ze kunnen ook worden gebruikt als randapparatuur, zoals ADC-ondersteuning, I2C, SPI-verbindingen worden ook ondersteund door die I / O-pinnen. Omdat die pinnen zijn verbonden met de schakelaars / toetsen, kunnen we ze niet gebruiken, maar alleen als I / O-poorten. Dit heeft helemaal geen zin. Dus, hoe het aantal pinnen te verminderen? Het antwoord is, met behulp van een hexadecimaal toetsenbord of een matrix toetsenbord; we kunnen het aantal pinnen verminderen, die 4x4-matrixtoetsen koppelen. Het zal 8 pinnen gebruiken, waarvan 4 in rijen en 4 in kolommen verbonden, waardoor 8 pinnen van de microcontroller worden bespaard.

Hoe 4x4 Matrix Keypad werkt:

In de bovenste afbeelding wordt links een matrix toetsenbordmodule getoond. Aan de rechterkant wordt zowel de interne verbinding als de poortverbinding weergegeven. Als we de poort zien, zijn er 8 pinnen, de eerste 4 van links naar rechts zijn X1, X2, X3 en X4 zijn de rijen, en de laatste 4 van links naar rechts zijn Y1, Y2, Y3, Y4 zijn vier kolommen. Als we 4 rijen of X-zijde als uitvoer maken en ze logisch laag of 0 maken, en de 4 kolommen als invoer maken en de toetsen lezen, zullen we de schakelaardruk lezen wanneer correspondent Y 0 krijgt.

Hetzelfde zal gebeuren in de nxn- matrix waar n het getal is. Dat kan 3x3, 6x6 etc. zijn

Denk nu eens dat 1 is ingedrukt. Dan bevindt de 1 zich op rij X1 en kolom Y1. Als X1 0 is, dan is Y1 0. Op dezelfde manier kunnen we elke toets in de X1-rij detecteren door kolom Y1, Y2, Y3 en Y4 te detecteren. Dit ding gebeurt voor elke schakelaar en we zullen de positie van de schakelaars in de matrix aflezen.

Elke groene cirkel is de schakelaar en ze zijn allebei op dezelfde manier met elkaar verbonden.

In deze tutorial zullen we het toetsenbord koppelen aan de volgende specificaties:

We zullen interne pull-up gebruiken
We zullen de sleutel de-bounce-optie toevoegen

Maar als de schakelaars niet worden ingedrukt, moeten we de Y1, Y2, Y3 en Y4 zo hoog of 1 maken. Anders kunnen we de logische veranderingen niet detecteren wanneer de schakelaar wordt ingedrukt. Maar we konden het niet halen met codes of programma omdat die pinnen als invoer worden gebruikt, niet als uitvoer. We zullen dus een intern operatieregister in de microcontroller gebruiken en die pinnen gebruiken als zwakke pull-up- modus. Door dit te gebruiken, zal er een logische hoge activeringsmodus zijn wanneer deze zich in de standaardstatus bevindt.

Ook als we op de toets drukken, zijn er pieken of wordt er ruis gegenereerd met schakelcontacten, en vanwege deze meervoudige schakelaar gebeurt het indrukken wat niet te verwachten is. Dus we zullen eerst de schakelaarpers detecteren, enkele milliseconden wachten, opnieuw controleren of de schakelaar nog steeds is ingedrukt of niet en als de schakelaar nog steeds is ingedrukt, accepteren we de schakelaarpers uiteindelijk anders niet. Dit wordt de-bouncing van de schakelaars genoemd.

We zullen dit allemaal in onze code implementeren en de verbinding maken op breadboard.

Controleer ook hoe u het 4x4-toetsenbord verbindt met andere microcontrollers:

Toetsenbordinterface met Arduino Uno
4x4 Matrix-toetsenbordinterface met 8051 Microcontroller
4x4 toetsenbordinterface met ATmega32-microcontroller
Raspberry Pi digitaal codeslot op breadboard

Materiaal vereist:

Breadboard
Pic-kit 3 en ontwikkelomgeving op uw pc, dwz MPLABX
Draden en connectoren
Karakter LCD 16x2
20Mhz kristal
2 stuks 33pF keramische schijfdop.
4.7k weerstand
10k preset (variabele weerstand)
4x4 Matrix-toetsenbord
Een 5 V adapter

Schakelschema:

We verbinden de kristallen en de weerstand in de bijbehorende pinnen. We zullen ook de LCD in 4 bit-modus via PORTD verbinden. We hebben het hex-toetsenbord of matrix-toetsenbord aangesloten op de poort RB4.

Als je nieuw bent bij PIC, begin dan met Aan de slag met PIC Microcontroller: Inleiding tot PIC en MPLABX

Programmering Toelichting:

De volledige code voor het koppelen van Matrix-toetsenbord met PIC-microcontroller wordt aan het einde gegeven. Code is eenvoudig en spreekt voor zich. Toetsenbordbibliotheek is het enige dat in de code moet worden begrepen. Hier hebben we keypad.h en lcd.h Library gebruikt om het keypad en 16x2 LCD te koppelen. Dus laten we eens kijken wat er binnenin gebeurt.

In het keypad.h zullen we zien dat we de xc.h- header hebben gebruikt die de standaard registerbibliotheek is, de kristalfrequentie is gedefinieerd voor het gebruik voor het gebruik van de vertraging die wordt gebruikt in het kepad.c- bestand. We hebben de toetsenbordpoorten gedefinieerd in het PORTRB- register en individuele pinnen gedefinieerd als rij (X) en kolommen (Y).

We hebben ook twee functies gebruikt: één voor de initialisatie van het toetsenbord, die de poort als uitvoer en invoer zal omleiden, en een scan voor het indrukken van de schakelaar die de status van de schakelaar weer zal geven wanneer deze wordt gebeld.

# omvatten #define _XTAL_FREQ 200000000 // Crystal Frequency, gebruikt in de vertraging #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 ongeldig InitKeypad (ongeldig); char switch_press_scan (leegte);

In het keypad.c zullen we zien dat de onderstaande functie de toetsaanslag teruggeeft wanneer de toetsenbordscannerfunctie niet 'n' retourneert.

char switch_press_scan (void) // Haal sleutel op van gebruiker { char key = 'n'; // Veronderstel dat er geen toets is ingedrukt terwijl (key == 'n') // Wacht tot een toets wordt ingedrukt key = keypad_scanner (); // Scan de toetsen keer op keer return-toets; // wanneer de toets wordt ingedrukt, retourneert u de waarde ervan }

Hieronder vindt u de leesfunctie van het toetsenbord. In elke stap maken we de rij X1, X2, X3 en X4 als 0 en lezen we de status Y1, Y2, Y3 en Y4. De vertraging wordt gebruikt voor het debounce-effect, wanneer de schakelaar nog steeds wordt ingedrukt, retourneren we de bijbehorende waarde. Als er geen schakelaar wordt ingedrukt, keren we terug naar 'n'.

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

We zullen ook de zwakke pull-up op de laatste vier bits instellen en ook de richting van de poorten instellen als laatste 4 invoer en eerste 4 als uitvoer. De OPTION_REG & = 0x7F; wordt gebruikt om de zwakke pull-up-modus op de laatste pinnen in te stellen.

void InitKeypad (void) { Keypad_PORT = 0x00; // Stel de pin-waarden van de toetsenbordpoort in op nul Keypad_PORT_Direction = 0xF0; // Laatste 4 pinnen input, eerste 4 pinnen output OPTION_REG & = 0x7F; }

In het hoofd-PIC-programma (hieronder weergegeven) hebben we eerst de configuratiebits ingesteld en enkele benodigde bibliotheken toegevoegd. Vervolgens initialiseren we in ongeldige system_init-functies het toetsenbord en het LCD-scherm. En tot slot hebben we in de hoofdfunctie het toetsenbord gelezen door de functie switch_press_scan () aan te roepen en de waarde terug te sturen naar lcd.

Download de volledige code met headerbestanden van hier en bekijk de demonstratievideo hieronder.