4X4 mátrix kezelő interfész a pic mikrovezérlővel

A kezelőegységek széles körben használt beviteli eszközök, amelyeket különféle elektronikai és beágyazott projektekben használnak. Arra szolgálnak, hogy számokat és ábécéket kapjanak az inputok, és ezeket tovább feldolgozzák a rendszerbe. Ebben az oktatóanyagban egy 4x4-es mátrix billentyűzetet fogunk összekapcsolni a PIC16F877A-val.

Mielőtt belemennénk a részletek logikájába és megtanulnánk a billentyűzet használatát, néhány dolgot tudnunk kell.

Miért van szükség 4x4-es kezelőre:

Általában egy mikrovezérlő egység egyetlen I / O tűjét használjuk a digitális jel leolvasásához, például egy kapcsoló bemenetéhez. Néhány alkalmazásban, ahol 9, 12, 16 kulcsra van szükség beviteli célokra, ha minden kulcsot hozzáadunk egy mikrovezérlő porthoz, végül 16 I / O portot használunk. Ez a 16 I / O port nem csak az I / O jelek olvasására szolgál, hanem perifériás kapcsolatokként is használhatók, mint például az ADC támogatások, az I2C, az SPI csatlakozásokat az I / O tűk is támogatják. Mivel ezek a csapok összekapcsolódnak a kapcsolókkal / gombokkal, nem használhatjuk őket, hanem csak I / O portként. Ennek semmi értelme. Szóval, hogyan lehet csökkenteni a PIN-kódot? A válasz egy hexa- vagy mátrix-billentyűzet használatával; csökkenthetjük a csapok számát, amelyek 4x4 mátrixkulcsokat társítanak. 8 tűt fog használni, amelyekből 4 sorban, 4 pedig oszlopokban csatlakozik, ezáltal megtakarítva a mikrovezérlő 8 érintkezőjét.

Hogyan működik a 4x4 Matrix kezelő:

A felső képen egy mátrix billentyűzet modul látható a bal oldalon. Jobb oldalon a belső kapcsolat, valamint a portkapcsolat látható. Ha azt látjuk, hogy a port 8 csap van, akkor az első 4 balról jobbra az X1, X2, X3 és X4 a sor, az utolsó 4 pedig balról jobbra az Y1, Y2, Y3, Y4 négy oszlop. Ha teszünk 4 sorok vagy X oldalon kiadási és azokat logikai alacsony vagy 0, és végezze el a 4 oszlop a bemeneti és olvassa el a kulcsokat fogjuk olvasni a kapcsolót nyomja meg, amikor levelező Y lesz 0.

Ugyanez fog történni az nxn mátrixban, ahol n a szám. Ez lehet 3x3, 6x6 stb.

Gondoljon csak arra, hogy az 1-et megnyomta. Ezután az 1 az X1 sornál és az Y1 oszlopnál helyezkedik el. Ha X1 értéke 0, akkor az Y1 értéke 0. Ugyanígy érzékelhetjük az X1 sor minden egyes kulcsát, az Y1, Y2, Y3 és Y4 oszlop érzékelésével. Ez a helyzet minden kapcsolónál előfordul, és kiolvassuk a kapcsolók helyzetét a mátrixban.

Minden zöld kör a kapcsoló, és mindkettő ugyanúgy kapcsolódik egymáshoz.

Ebben az oktatóanyagban a következő specifikációkkal fogjuk összekapcsolni a billentyűzetet:

Belső felhúzást fogunk használni
Hozzáadjuk a kulcs visszafordulási lehetőségét

De amikor a kapcsoló nincs lenyomva kell tennünk a Y1, Y2, Y3 és Y4 mint a magas vagy 1. Ellenkező esetben nem tudjuk felismerni a logika változásokat, amikor a kapcsoló le van nyomva. De nem tudtuk kódokkal vagy programmal elkészíteni, mivel ezeket a csapokat használják bemenetként, nem kimenetként. Tehát használunk egy belső műveleti regisztert a mikrovezérlőben, és ezeket a tűket gyengén felfelé engedélyezett módként működtetjük. Ennek használatával logikai magas engedélyezési mód lesz, amikor az alapértelmezett állapotban van.

Továbbá, amikor megnyomjuk a gombot, tüskék keletkeznek, vagy a kapcsoló érintkezőivel zaj keletkezik, és emiatt a többszörös kapcsoló megnyomása nem várható. Tehát először észleljük a kapcsolóprést, várunk néhány ezredmásodpercet, újra ellenőrizzük, hogy a kapcsolót még mindig megnyomjuk-e vagy sem, és ha a kapcsolót még mindig megnyomjuk, akkor elfogadjuk a kapcsolót, végül nem. Ezt nevezzük a kapcsolók visszapattanásának.

Mindezt megvalósítjuk a kódunkban, és a kapcsolatot a kenyérlapon hozzuk létre.

Ellenőrizze azt is, hogy hogyan lehet a 4x4 kezelőt összekapcsolni más mikrovezérlőkkel:

Kezelő interfész az Arduino Uno-val
4x4-es mátrix kezelő interfész a 8051 mikrokontrollerrel
4x4 kezelő interfész az ATmega32 mikrokontrollerrel
Raspberry Pi digitális kódzár a kenyérlapon

Szükséges anyag:

Kenyérlemez
Pic-kit 3 és fejlesztői környezet a számítógépen, azaz MPLABX
Vezetékek és csatlakozók
Karakter LCD 16x2
20Mhz kristály
2 db 33pF kerámia korongsapka.
4.7k ellenállás
10k előre beállított (változtatható ellenállás)
4x4 Mátrix kezelő
5 V-os adapter

Kördiagramm:

Csatlakoztatjuk a kristályokat és az ellenállást a hozzájuk tartozó csapokban. Továbbá, mi fog kapcsolódni az LCD 4 bites módban egész PORTD. Csatlakoztattuk a hatlapú vagy a mátrix kezelőt az RB4 porton keresztül.

Ha még nem ismeri a PIC alkalmazást, akkor kezdje el a PIC mikrokontroller használatának megkezdésével: Bevezetés a PIC-be és az MPLABX-be

Programozási magyarázat:

A végén megadjuk a Matrix Keypad és a PIC mikrovezérlő összekapcsolásának teljes kódját. A kód egyszerű és magától értetődő. A kezelő könyvtár csak a kódban érthető dolog. Itt már használják keypad.h és lcd.h Library interfész a billentyűzet és 16x2 LCD. Lássuk, mi történik ezen belül.

A billentyűzet.h belsejében látni fogjuk, hogy az xc.h fejlécet használtuk, amely az alapértelmezett regiszterkönyvtár, a kristály frekvenciát a kepad.c fájlban használt késleltetés használatára definiáljuk. Meghatároztuk a billentyűzet portjait a PORTRB regiszterben, és meghatároztuk az egyes csapokat sorként (X) és oszlopként (Y).

Két funkciót is használtunk a billentyűzet inicializálásához, amely átirányítja a portot kimenetként és bemenetként, és egy kapcsolóprés-szkennelést, amely visszaadja a kapcsolóprés állapotát, amikor hívják.

#include #define _XTAL_FREQ 200000000 // késleltetésben használt kristályfrekvencia #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 #define #define Kezelő_PORT_irány TRISB void InitKeypad (érvénytelen); char switch_press_scan (érvénytelen);

A billentyűzeten.c látni fogjuk, hogy az alábbi funkció visszaadja a gombnyomást, ha a billentyűzetolvasó funkció nem adja vissza az 'n' értéket.

char switch_press_scan (void) // Kulcs beolvasása a { char key = 'n' felhasználótól; // Feltételezzük, hogy egyetlen billentyűt sem nyomunk meg, amíg (key == 'n') // Várjon, amíg egy gombot megnyomnak key = keypad_scanner (); // Vizsgálja újra és újra a kulcsokat return key; // amikor megnyomja a gombot, adja vissza az értékét }

Az alábbiakban látható a kezelő olvasási funkciója. Minden lépésben az X1, X2, X3 és X4 sort 0-ként állítjuk be, és leolvassuk az Y1, Y2, Y3 és Y4 állapotot. A késleltetés a visszavonási effektusra szolgál, amikor a kapcsolót még mindig lenyomják, visszaadjuk a hozzá tartozó értéket. Ha egyetlen kapcsolót sem nyomnak meg, visszatérünk az 'n' értékre.

char billentyűzet_szkenner (void) { X_1 = 0; X_2 = 1; X_3 = 1; X_4 = 1; if (Y_1 == 0) {__késleltetési_ms (100); míg (Y_1 == 0); adja vissza „1”; } if (Y_2 == 0) {__késleltetési_ms (100); míg (Y_2 == 0); adja vissza a „2” -t; } if (Y_3 == 0) {__késleltetési_ms (100); míg (Y_3 == 0); adja vissza a „3” -t; } if (Y_4 == 0) {__késleltetési_ms (100); míg (Y_4 == 0); adja vissza az „A” szót; } X_1 = 1; X_2 = 0; X_3 = 1; X_4 = 1; if (Y_1 == 0) {__késleltetési_ms (100); míg (Y_1 == 0); adja vissza a „4” -t; } if (Y_2 == 0) {__késleltetési_ms (100); míg (Y_2 == 0); adja vissza az „5” -t; } if (Y_3 == 0) {__késleltetési_ms (100); míg (Y_3 == 0); adja vissza a „6” -t; } if (Y_4 == 0) {__késleltetési_ms (100); míg (Y_4 == 0); adja vissza a „B” szót; } X_1 = 1; X_2 = 1; X_3 = 0; X_4 = 1; if (Y_1 == 0) {__késleltetési_ms (100); míg (Y_1 == 0); adja vissza a „7” -t; } if (Y_2 == 0) {__késleltetési_ms (100); míg (Y_2 == 0); adja vissza a „8” -t; } if (Y_3 == 0) {__késleltetési_ms (100); míg (Y_3 == 0); adja vissza a „9” -t; } if (Y_4 == 0) {__késleltetési_ms (100); míg (Y_4 == 0); adja vissza a „C” -t; } X_1 = 1; X_2 = 1; X_3 = 1; X_4 = 0; if (Y_1 == 0) {__késleltetési_ms (100); míg (Y_1 == 0); Visszatérés '*'; } if (Y_2 == 0) {__késleltetési_ms (100); míg (Y_2 == 0); adja vissza a „0” értéket; } if (Y_3 == 0) {__késleltetési_ms (100); míg (Y_3 == 0); Visszatérés '#'; } if (Y_4 == 0) {__késleltetési_ms (100); míg (Y_4 == 0); adja vissza a „D” -t; } return 'n'; }

Beállítjuk az utolsó négy bit gyenge felhúzását, valamint a portok irányát utolsó 4 bemenetként és az első 4 kimenetként. Az OPTION_REG & = 0x7F; az utolsó csapok gyenge felhúzási módjának beállítására szolgál.

void InitKeypad (void) { Kezelő_PORT = 0x00; // Állítsa be a Kezelő port pin értékét nulla Kezelő_PORT_irány = 0xF0; // Az utolsó 4 érintkező bemenet, az első 4 érintkező kimenete OPTION_REG & = 0x7F; }

A fő PIC programban (amelyet alább adunk) először beállítottuk a konfigurációs biteket, és kevés szükséges könyvtárat vettünk fel. Ezután a void system_init függvényekben inicializáljuk a kezelőt és az LCD-t. És végül a fő funkcióban a billentyűzetet elolvastuk a switch_press_scan () függvény meghívásával és az érték visszaküldésével az lcd-re.

Töltse le a teljes kódot a fejlécfájlokkal innen, és ellenőrizze az alábbi demonstrációs videót.