7 Szegmenskijelző interfész a pic mikrokontrollerrel

Ez a 8. oktatóanyagunk a PIC mikrokontrollerek megtanulásáról MPLAB és XC8 használatával. Az MPLABX telepítésétől az LCD PIC MCU-val történő használatáig egészen felmerültünk. Ha új vagy itt, akkor nézd meg a korábbi oktatóanyagokat, ahol megtanulhat időzítőket, villogó LED-et, illesztő LCD-t stb. Minden PIC oktatóanyagunkat itt találja. Utolsó bemutatónkban láttuk, hogyan tudunk egyedi karaktereket előállítani a 16 * 2-es LCD kijelzőnkkel, most pedig felszereljük önmagunkat egy másik típusú modulra, az úgynevezett 7-szegmenses kijelzőre, és csatlakoztassuk a PIC mikrovezérlőhöz.

Bár a 16x2 LCD sokkal kényelmesebb, mint a 7 szegmenses kijelző, de kevés olyan eset van, amikor egy 7 szegmenses kijelző hasznosabb lenne, mint egy LCD kijelző. Az LCD-nek az a hátránya, hogy alacsony a karaktermérete, és túlterheli a projektet, ha csak numerikus értékek megjelenítését tervezi. A 7 szegmens előnye a rossz megvilágítással szemben is, és lager szögből nézhető, mint egy normál LCD képernyő. Tehát kezdjük el tudni.

7 szegmenses és 4 számjegyű 7 szegmenses kijelzőmodul:

7 Szegmenskijelző hét szegmenssel rendelkezik, és mindegyik szegmensben egy LED található, amely a megfelelő szegmensek megvilágításával jeleníti meg a számokat. Például, ha azt szeretné, hogy a 7 szegmens az "5" számot jelenítse meg, akkor az a, f, g, c és d szegmenseket kell világítania azáltal, hogy a megfelelő csapokat magasra teszi. A 7 szegmenses kijelzőknek kétféle típusa van: Közös katód és Közös anód, itt hét közös szegmens kijelzőt használunk. Tudjon meg többet a 7 szegmenses kijelzőről itt.

Most már tudjuk, hogyan jelenítsük meg a kívánt numerikus karakterünket egyetlen 7 szegmenses kijelzőn. De elég nyilvánvaló, hogy több mint egy 7-szegmenses kijelzőre lenne szükségünk, ha bármilyen információt át akarunk adni, amely egynél több számjegyű. Tehát ebben az oktatóanyagban egy négyjegyű, 7 szegmenses kijelző modult fogunk használni, az alábbiak szerint.

Mint láthatjuk, négy hét szegmens kijelző van összekapcsolva. Tudjuk, hogy minden 7 szegmenses modulnak 10 érintkezõje lesz, és négy hét szegmenses kijelzõnél összesen 40 érintkezõ lenne, és hektikus lenne, ha bárki forrasztaná õket egy táblán, ezért nagyon ajánlom mindenkinek, hogy vásároljon modult vagy készítsen saját NYÁK-t egy négyjegyű 7 szegmenses kijelző használatához. Az alábbiakban a csatlakozási vázlatot mutatjuk be:

Ahhoz, hogy megértsük, hogyan működik a négyjegyű hét szegmens modul, meg kell vizsgálnunk a fenti sémákat, amint az látható, mind a négy kijelző A-csapjai össze vannak kötve, hogy egy A-ként gyűljenek össze, és ugyanazok B, C…. -ig DP-ig. Szóval, alapvetően, ha az A bekapcsol, akkor mind a négy A-nak magasra kell mennie?

De ez nem történik meg. További négy csapunk van D0-tól D3-ig (D0, D1, D2 és D3), amelyek segítségével szabályozható, hogy a négy közül melyik kijelző legyen magas. Például: Ha azt akarom, hogy a kimenetem csak a második kijelzőn legyen, akkor csak a D1-et kell magasra tenni, miközben a többi csapot (D0, D2 és D3) alacsonyan tartom. Egyszerűen kiválaszthatjuk, hogy melyik kijelző legyen aktív, a D0-tól D3-ig terjedő csapok segítségével, és milyen karaktert jelenítsen meg az A-tól DP-ig.

4 számjegyű, hét szegmenses modul csatlakoztatása PIC mikrovezérlővel:

Itt PIC16F877A PIC mikrovezérlőt használtunk, és az áramkör vázlata az alábbiakban látható.

A modulból 12 kimeneti tüske van, amelyek közül 8-at használunk a karakterek megjelenítésére, négy-et pedig egy-egy kijelzésre a négyből. Ennélfogva mind a 8 karaktertű a PORTD-hoz van rendelve, és a kijelző választó csapok a PORTC első négy érintkezőjéhez vannak rendelve.

Megjegyzés: A modul földelt csapját is csatlakoztatni kell az MCU földjéhez, amely itt nem látható.

Programozás a PIC16F877A használatával:

Most, hogy tudjuk, hogyan működik ez a modul, megtanuljuk, hogyan programozzuk a PIC16F877A-t úgy, hogy 4 számjegyű szám jelenjen meg. Növeljünk egy változót 0 és 1000 között, és nyomtassuk ki a 7 szegmenses kijelzőre. Indítsa el az MPLABX programot, és hozzon létre új projektet, kezdjük a konfigurációs bitekkel.

#pragma config FOSC = HS // Oszcillátor választóbitek (HS oszcillátor) #pragma config WDTE = KI // Watchdog Timer Engedélyezés bit (WDT letiltva) #pragma config PWRTE = BE // Bekapcsolási időzítő bit engedélyezése (PWRT engedélyezve) # pragma config BOREN = BE // Brown-out Reset bit engedélyezése (BOR engedélyezve) #pragma config LVP = OFF // Kisfeszültségű (egyszeres tápellátás) Áramkörben soros programozás Engedélyező bit (RB3 digitális I / O, HV be MCLR-t kell használni a programozáshoz) #pragma config CPD = OFF // Data EEPROM memóriakód védelmi bit (Data EEPROM kód védelem ki van kapcsolva) #pragma config WRT = OFF // Flash program memória írása Bitek engedélyezése (Írásvédelem kikapcsolva; az összes program memória az EECON vezérléssel írható) #pragma config CP = OFF // Flash program memória kód védelmi bit (kód védelem ki)

Szokásunkhoz a beállítási bitek beállítása ablakot használjuk ezek beállítása. Ha nem tudja biztosan, mit jelentenek, látogasson el ide a LED villogó bemutatójára.

Ezután határozzuk meg a kimeneti csapokat a kijelző egyes számjegyei közötti váltáshoz.

// *** Határozza meg mind a négy kijelző jeltűit *** // #define s1 RC0 #define s2 RC1 #define s3 RC2 #define s4 RC3 // *** Definíció vége ** ////

Itt az RC0, RC1, RC2 és RC3 csapok segítségével választhatunk a 7 szegmenses kijelzőmodul négy számjegye közül. Ezeket a csapokat s1, s2, s3 és s4 definiálja.

Ezután ugorjunk be a void main () -ba , amelyen belül a következő változó deklarációval rendelkezünk:

int i = 0; // az int flag = 0 megjelenítendő négyjegyű érték; // késleltetés létrehozásához előjel nélküli int a, b, c, d, e, f, g, h; // csak változók nem aláírt int seg = {0X3F, // Hex érték a 0 0X06 szám megjelenítéséhez, // Hex érték az 1 0X5B szám megjelenítéséhez, // Hex érték a 2 0XXF szám megjelenítéséhez, // Hex érték a megjelenítéshez a 3-as szám 0X66, // Hex-érték a 4-es szám megjelenítéséhez 0X6D, // Hex-érték az 5-ös szám megjelenítéséhez 0X7C, // Hex-érték a 6-os szám megjelenítéséhez 0/06, // Hex-érték a 7 0X7F szám megjelenítéséhez, / / Hex érték a 8 szám megjelenítéséhez 0X6F // Hex érték a 9 szám megjelenítéséhez}; // A tömb vége a 0 és 9 közötti számok megjelenítéséhez

Itt az i és a flag változókat használják a megjelenítendő értékek tárolására és késleltetés létrehozására. Az a-h, előjel nélküli egész változóval a négyjegyű számokat egyjegyűre bontjuk és tároljuk (ezt később itt magyarázzuk el).

Az egyik legfontosabb dolog, amit meg kell jegyezni, a "seg" tömb deklaráció. Ebben a programban új, Array nevű adattípust használunk. A tömb nem más, mint hasonló adattípusú értékek gyűjteménye. Itt ezt a tömböt használtuk az összes ekvivalens hexa érték tárolására 0 és 9 közötti szám megjelenítéséhez.

A tömb címe mindig nulláról indul. Tehát ennek a tömbnek egy numerikus szám (0–9) hexaértéke lesz tárolva a címben, amely megegyezik az alább látható száméval

Változó:	seg	seg	seg	seg	seg	seg	seg	seg	seg	seg
Hex kód:	0X3F	0X06	0X5B	0X4F	0X66	0X6D	0X7C	0X07	0X7F	0X6F
Egyenlő Numerikus szám:	0	1	2	3	4	5.	6.	7	8.	9.

Tehát egyszerűen, ha meg akarja jeleníteni a 0-os számot a 7-szegmensen, akkor hívhatja a seg-t, ugyanúgy, ha a 6-os számot akarja megjeleníteni, akkor csak a seg-t kell használnia .

Annak megértéséhez, hogy a HEX értéket hogyan kapták meg, nézzük meg az alábbi táblázatot. Az egyes decimális számok egyenértékű HEX-értéke tárolódik a tömbben, így felhívható egy adott szám megjelenítésére.

Most térjünk át a kód következő részére, amely az I / O konfiguráció:

// ***** I / O konfiguráció **** // TRISC = 0X00; PORTC = 0X00; TRISD = 0x00; PORTD = 0X00; *** *** I / O konfiguráció vége ** ///

Az I / O konfiguráció egyszerű, mert a 7 szegmensünk összes csapja kimeneti tű, és a csatlakozásokat a fenti kapcsolási rajz mutatja, ezért egyszerűen deklarálja kimenetként és inicializálja nullára.

Most ugorjunk a végtelen hurkunkba (míg (1)). Itt négy számjegyre kell felosztanunk az "i" értékét, és meg kell jelenítenünk a 7 szegmensen. Először kezdjük azzal, hogy felosztjuk az "i" értéket

// *** Az "i" négy számjegyre osztása *** // a = i% 10; // A 4. számjegyet itt menti b = i / 10; c = b% 10; // ide kerül a 3. számjegy d = b / 10; e = d% 10; // ide kerül a 2. számjegy f = d / 10; g = f% 10; // az 1. számjegyet itt menti h = f / 10; *** A felosztás vége *** //

Egyszerű modulus és osztási művelet alkalmazásával a négyjegyű számot (i) külön számokra választjuk el. Esetünkben vegyünk egy példát, ahol az "i" értéke 4578. Ezután a folyamat végén a g = 4, e = 5, c = 7 és a = 8 változó. Tehát most könnyű lesz minden számjegyet megjeleníteni a változó egyszerű használatával.

PORTD = seg; s1 = 1; // Kapcsolja be az 1. kijelzőt, és nyomtassa ki a 4. számjegyet __delay_ms (5); s1 = 0; // 5 ms késleltetés után kapcsolja ki az 1. kijelzőt PORTD = seg; s2 = 1; // Kapcsolja be a 2. kijelzőt, és nyomtassa ki a 3. számjegyet __delay_ms (5); s2 = 0; // 5 ms késleltetés után kapcsolja ki a 2. kijelzőt PORTD = seg; s3 = 1; // Kapcsolja be a 3. kijelzőt, és nyomtassa ki a 2. számjegyet __delay_ms (5); s3 = 0; // 5 ms késleltetés után kapcsolja ki a 3 kijelzőt PORTD = seg; s4 = 1; // Kapcsolja be a 4. kijelzőt, és nyomtassa ki az 1. számjegyet __delay_ms (5); s4 = 0; // 5 ms késleltetés után kapcsolja ki a 4 kijelzőt

Ez az a tényleges hely, ahol az MCU tárgyal a 7 szegmenssel. Mint tudjuk, egyszerre csak egy számjegyet tudunk megjeleníteni, de négy számjegyet kell megjelenítenünk, és csak akkor, ha mind a négy számjegy be van kapcsolva. A teljes négyjegyű szám látható lesz a felhasználó számára.

Szóval, hogy megyünk ezzel?

Számunkra szerencsés, hogy MCU-junk sokkal gyorsabb, mint egy emberi szem, tehát amit valójában csinálunk: egy számjegyet jelenítünk meg egyszerre, de nagyon gyorsan, ahogy fentebb látható.

Kiválasztunk egy számjegyű kijelzőt, amely 5 ms-ot vár, hogy az MCU és a 7-szegmens feldolgozhassa, majd kikapcsolja ezt a számot, és továbblépjen a következő számjegyre, és ugyanezt tegye, amíg el nem érjük az utolsó számjegyet. Ezt az 5 ms késést emberi szemmel nem lehet megfigyelni, és mind a négy számjegy egyszerre volt bekapcsolva.

Ez az, végül csak növeljük a megjelenített számjegy értékét az alább látható késleltetés segítségével

if (zászló> = 100) // várjon, amíg a zászló eléri a 100-at {i ++; zászló = 0; // csak akkor, ha a zászló száz "i", akkor növekszik} zászló ++; // növekményes jelző minden egyes villanáshoz

A késleltetést arra használjuk, hogy az egyik számról a másikra váltáshoz szükséges idő elég hosszú legyen, hogy észrevegyük a változást.

A teljes kódot az alábbiakban adjuk meg, és a folyamatot a végén található videó is elmagyarázza.

Hardver beállítása és tesztelése:

Mint mindig, most is szimuláljuk a programot a Proteus segítségével, mielőtt a hardverünkhöz mennénk. Ha a szimuláció sikeres, valami ilyesmit kell látnia

Ennek a projektnek nincs bonyolult hardverbeállítása, ismét ugyanazt a PIC mikrokontroller kártyát használjuk, amelyet a LED villogó bemutatójában hoztunk létre. Egyszerűen csatlakoztassa a 7 szegmensű modult a PIC mikrokontroller kártyához a kapcsolási rajz szerint. Miután elkészült a kapcsolatokkal, egyszerűen dobja ki a kódot a PicKit 3 programozójával, és élvezze a kimenetet.