Ang 4X4 matrix keypad na interfacing sa pic microcontroller

Ang mga Keypad ay malawakang ginagamit na mga aparato ng pag-input na ginagamit sa iba't ibang mga electronics at naka-embed na proyekto. Ginagamit ang mga ito upang kumuha ng mga input sa anyo ng mga numero at alpabeto, at feed ang pareho sa system para sa karagdagang pagproseso. Sa tutorial na ito pupunta kami sa isang 4x4 matrix keypad sa PIC16F877A.

Bago pumunta sa detalye ng lohika at alamin kung paano gamitin ang keypad, kakailanganin nating malaman ang ilang mga bagay.

Bakit kailangan namin ng 4x4 Keypad:

Kadalasan gumagamit kami ng solong I / O pin ng isang yunit ng microcontroller upang mabasa ang digital signal, tulad ng isang switch input. Sa ilang mga application kung saan kinakailangan ang 9, 12, 16 na mga key para sa mga layunin ng pag-input, kung idaragdag namin ang bawat key sa isang port ng microcontroller, magtatapos kami gamit ang 16 I / O port. Ang 16 I / O port na ito ay hindi lamang para sa pagbabasa ng mga signal ng I / O, ngunit maaari silang magamit bilang mga peripheral na koneksyon din, tulad ng mga suporta ng ADC, I2C, ang mga koneksyon sa SPI ay sinusuportahan din ng mga I / O na pin. Tulad ng mga pin na konektado sa mga switch / key, hindi namin magagamit ang mga ito ngunit bilang I / O port lamang. Ito ay walang katuturan. Kaya, paano mabawasan ang bilang ng pin? Ang sagot ay, gamit ang isang hex keypad o matrix keypad; maaari nating bawasan ang mga bilang ng pin, na nag-uugnay ng 4x4 matrix keys. Gumagamit ito ng 8 mga pin mula sa kung saan 4 na konektado sa mga hilera at 4 na konektado sa mga haligi, samakatuwid ay nagse-save ng 8 mga pin ng microcontroller.

Paano gumagana ang 4x4 Matrix Keypad:

Sa itaas na imahe ang isang module ng keypad ng matrix ay ipinapakita sa kaliwa. Sa kanan ang panloob na koneksyon ay ipinapakita pati na rin ang koneksyon sa port. Kung nakikita natin ang port may 8 mga pin, unang 4 mula kaliwa hanggang kanan ang X1, X2, X3, at X4 ang mga hilera, at ang huling 4 mula kaliwa hanggang kanan ay Y1, Y2, Y3, Y4 ay apat na haligi. Kung gumawa kami ng 4 mga hilera o X side bilang output at gawin silang logic mababa o 0, at gawin ang 4 mga haligi bilang input at basahin ang mga susi kami ay basahin ang switch press kapag correspondent Y nakakakuha 0.

Parehong bagay ang mangyayari sa nxn matrix kung saan n ang numero. Maaari itong maging 3x3, 6x6 atbp.

Ngayon isipin lamang na ang 1 ay pinindot. Pagkatapos ang 1 ay matatagpuan sa X1 row at Y1 na haligi. Kung ang X1 ay 0, kung gayon ang Y1 ay magiging 0. Sa pamamagitan ng parehong paraan maaari nating maunawaan ang bawat key sa hilera X1, sa pamamagitan ng pag-sensing ng haligi Y1, Y2, Y3 at Y4. Nangyayari ang bagay na ito para sa bawat switch at babasahin namin ang posisyon ng mga switch sa matrix.

Ang bawat berdeng bilog ay ang switch at pareho silang konektado magkasama sa parehong paraan.

Sa tutorial na ito mai-interface namin ang key board na may mga sumusunod na pagtutukoy-

Gumagamit kami ng panloob na pull up
Magdaragdag kami ng pangunahing pagpipiliang de-bounce

Ngunit kapag ang mga switch ay hindi pinindot kailangan nating gawin ang Y1, Y2, Y3 at Y4 na taas o 1. Kung hindi man ay hindi natin matutukoy ang mga pagbabago sa lohika kapag ang switch ay pinindot. Ngunit hindi namin ito magawa sa pamamagitan ng mga code o programa dahil sa mga pin na iyon ay ginagamit bilang input, hindi output. Sa gayon, gagamitin namin ang isang panloob na pagrehistro sa operasyon sa microcontroller at patakbuhin ang mga pin na iyon bilang mahinang pull up mode na pinagana. Sa pamamagitan ng paggamit nito, magkakaroon ng mode na mataas na paganahin ang lohika kapag nasa default na estado ito.

Gayundin, kapag pinindot namin ang key mayroong mga spike o ingay ay nabuo gamit ang mga contact sa switch, at dahil sa maraming switch press na ito ang nangyayari na hindi inaasahan. Kaya, una naming matutukoy ang switch ng switch, maghintay para sa ilang milliseconds, muli suriin kung ang switch ay pinindot pa rin o hindi at kung ang switch ay pinindot pa rin tatanggapin namin ang switch press sa wakas kung hindi man. Ito ay tinatawag na de-bouncing ng mga switch.

Ipatupad namin ang lahat sa aming code, at gagawin ang koneksyon sa breadboard.

Suriin din kung paano i- interface ang 4x4 keypad sa iba pang mga Microcontroller:

Ang Keypad Interfacing kasama si Arduino Uno
4x4 Matrix Keypad Interfacing na may 8051 Microcontroller
4x4 Keypad Interfacing sa ATmega32 Microcontroller
Raspberry Pi Digital Code Lock sa Breadboard

Kinakailangan na Materyal:

Breadboard
Ang Pic-kit 3 at ang kapaligiran sa pag-unlad sa iyong PC, ibig sabihin, MPLABX
Mga wire at konektor
Karakter na LCD 16x2
20Mhz Crystal
2 pcs 33pF ceramic disc cap.
4.7k risistor
10k preset (variable risistor)
4x4 Matrix keypad
Isang 5 V adapter

Diagram ng Circuit:

Ikonekta namin ang mga kristal at ang risistor sa mga nauugnay na mga pin. Gayundin, ikonekta namin ang LCD sa 4 bit mode sa buong PORTD. Ikinonekta namin ang hex keypad o matrix keypad sa buong port RB4.

Kung bago ka sa PIC pagkatapos magsimula sa Pagsisimula sa PIC Microcontroller: Panimula sa PIC at MPLABX

Paliwanag sa Programming:

Kumpletuhin ang code para sa interfacing Matrix Keypad sa PIC Microcontroller ay ibinibigay sa dulo. Ang code ay madali at nagpapaliwanag sa sarili. Ang Keypad library ay isang bagay lamang na mauunawaan sa code. Dito ginamit namin ang keypad.h at lcd.h Library upang i-interface ang keypad at 16x2 LCD. Tingnan natin kung ano ang nangyayari sa loob nito.

Sa loob ng keypad.h makikita natin na gumamit kami ng xc.h header na default na library ng rehistro, ang dalas ng kristal ay tinukoy para sa paggamit para sa paggamit ng pagkaantala na ginamit sa file ng kepad.c. Tinukoy namin ang mga port ng keypad sa rehistro ng PORTRB at tinukoy ang mga indibidwal na pin bilang hilera (X) at mga haligi (Y).

Gumamit din kami ng dalawang pagpapaandar isa para sa inisyal na keypad na magre-redirect sa port bilang output at input, at isang switch ng pindutin ang pag-scan na ibabalik ang katayuan ng switch press kapag tinawag.

# isama #define _XTAL_FREQ 200000000 // Crystal Dalas, ginagamit sa pagkaantala #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 walang bisa InitKeypad (walang bisa); char switch_press_scan (walang bisa);

Sa keypad.c makikita natin na ang pag-andar sa ibaba ay ibabalik ang key press kapag ang pag-andar ng keypad scanner ay hindi bumalik 'n'.

char switch_press_scan (walang bisa) // Kumuha ng susi mula sa gumagamit na { char key = 'n'; // Ipagpalagay walang pinindot na key habang (key == 'n') // Maghintay hanggang ang isang key ay pinindot key = keypad_scanner (); // I-scan muli ang mga susi at muling ibalik ang key; // kapag pinindot ang key pagkatapos ay ibalik ang halaga nito }

Nasa ibaba ang pagpapaandar ng pagbabasa ng keypad. Sa bawat hakbang ay gagawin namin ang hilera X1, X2, X3, at X4 bilang 0 at binabasa ang katayuang Y1, Y2, Y3 at Y4. Ginagamit ang pagkaantala para sa epekto ng pag-debounce, kapag pinindot pa rin ang switch ibabalik namin ang halagang nauugnay dito. Kapag walang pinindot na switch ay babalik kami 'n'.

char keypad_scanner (walang bisa) { X_1 = 0; X_2 = 1; X_3 = 1; X_4 = 1; kung (Y_1 == 0) {__delay_ms (100); habang (Y_1 == 0); ibalik ang '1'; } kung (Y_2 == 0) {__delay_ms (100); habang (Y_2 == 0); ibalik ang '2'; } kung (Y_3 == 0) {__delay_ms (100); habang (Y_3 == 0); ibalik ang '3'; } kung (Y_4 == 0) {__delay_ms (100); habang (Y_4 == 0); ibalik ang 'A'; } X_1 = 1; X_2 = 0; X_3 = 1; X_4 = 1; kung (Y_1 == 0) {__delay_ms (100); habang (Y_1 == 0); ibalik ang '4'; } kung (Y_2 == 0) {__delay_ms (100); habang (Y_2 == 0); ibalik ang '5'; } kung (Y_3 == 0) {__delay_ms (100); habang (Y_3 == 0); ibalik ang '6'; } kung (Y_4 == 0) {__delay_ms (100); habang (Y_4 == 0); ibalik ang 'B'; } X_1 = 1; X_2 = 1; X_3 = 0; X_4 = 1; kung (Y_1 == 0) {__delay_ms (100); habang (Y_1 == 0); ibalik ang '7'; } kung (Y_2 == 0) {__delay_ms (100); habang (Y_2 == 0); ibalik ang '8'; } kung (Y_3 == 0) {__delay_ms (100); habang (Y_3 == 0); ibalik ang '9'; } kung (Y_4 == 0) {__delay_ms (100); habang (Y_4 == 0); ibalik ang 'C'; } X_1 = 1; X_2 = 1; X_3 = 1; X_4 = 0; kung (Y_1 == 0) {__delay_ms (100); habang (Y_1 == 0); ibalik '*'; } kung (Y_2 == 0) {__delay_ms (100); habang (Y_2 == 0); ibalik ang '0'; } kung (Y_3 == 0) {__delay_ms (100); habang (Y_3 == 0); ibalik ang '#'; } kung (Y_4 == 0) {__delay_ms (100); habang (Y_4 == 0); ibalik ang 'D'; } ibalik ang 'n'; }

Itatakda din namin ang mahina na pull up sa huling apat na piraso, at itatakda din ang direksyon ng mga port bilang huling 4 na input at unang 4 bilang output. Ang OPTION_REG & = 0x7F; ay ginagamit upang itakda ang mahinang pull up mode sa huling mga pin.

walang bisa ang InitKeypad (walang bisa) { Keypad_PORT = 0x00; // Itakda ang mga halagang pin ng port ng Keypad ng zero Keypad_PORT_Direction = 0xF0; // Huling 4 na pag-input ng input, Una 4 na pin na output OPTION_REG & = 0x7F; }

Sa pangunahing programa ng PIC (ibinigay sa ibaba) unang itinakda namin ang mga config bit at isinama ang ilang mga kinakailangang aklatan. Pagkatapos sa mga walang bisa na pag-andar ng system_init isinisimula namin ang keypad at LCD. At sa wakas sa sa pangunahing pag-andar nabasa namin ang keypad pamamagitan ng pagtawag ng switch_press_scan () function at bumabalik na ang mga halaga sa LCD.

I-download ang kumpletong code na may mga file ng header mula dito at suriin ang Demonstration video sa ibaba.