- 7-segmentni in 4-mestni 7-segmentni prikazovalni modul:
- Povezava 4-mestnega sedemsegmentnega modula z mikrokrmilnikom PIC:
- Programiranje z uporabo PIC16F877A:
- Namestitev in testiranje strojne opreme:
To je naša 8. vadnica učenja mikrokrmilnikov PIC z uporabo MPLAB in XC8. Prešli smo vse od namestitve MPLABX do uporabe LCD-ja s PIC MCU. Če ste tu novi, si oglejte prejšnje vadnice, kjer se lahko naučite merilnikov časa, utripajoče LED, povezave LCD itd. Vse naše vadnice za PIC najdete tukaj. V naši zadnji vadnici smo videli, kako lahko z našim 16 * 2 LCD zaslonom ustvarimo znake po meri, zdaj pa se opremi z drugo vrsto prikazovalnega modula, imenovanega 7-segmentni zaslon, in ga povežite z mikrokrmilnikom PIC.
Čeprav je LCD 16x2 veliko bolj udoben kot 7-segmentni zaslon, je malo primerov, ko bi 7-segmentni zaslon prišel bolj kot LCD zaslon. LCD ima pomanjkljivost majhne velikosti znakov in bo za vaš projekt pretiran, če nameravate prikazati nekatere številčne vrednosti. 7-segmenti imajo tudi prednost pred slabimi svetlobnimi razmerami in jih je mogoče gledati iz večjih kotov kot običajni LCD zaslon. Torej, začnimo vedeti.
7-segmentni in 4-mestni 7-segmentni prikazovalni modul:
7-segmentni zaslon ima sedem segmentov, vsak segment pa ima v sebi eno LED, ki prikazuje številke z osvetlitvijo ustreznih segmentov. Če želite, da 7-segment prikazuje številko "5", potem morate svetleti segmente a, f, g, c in d tako, da so njihovi ustrezni zatiči visoki. Obstajata dve vrsti 7-segmentnih zaslonov: Common Cathode in Common Anode, tu uporabljamo sedemsegmentni prikaz Common Cathode. Več o 7-segmentnem prikazu lahko preberete tukaj.
Zdaj vemo, kako prikazati želeni številski znak na enem samem 7-segmentnem zaslonu. Jasno pa je, da bi potrebovali več kot en 7-segmentni zaslon, da bi posredovali kakršne koli informacije, ki imajo več kot eno števko. Torej, v tej vadnici bomo uporabili 4-mestni 7-segmentni prikazni modul, kot je prikazano spodaj.
Kot lahko vidimo, so med seboj povezani štirje sedem segmentni prikazi. Vemo, da bo imel vsak 7-segmentni modul 10 zatičev, za 4 sedemsegmentne prikazovalnike pa bi bilo skupno 40 zatičev in težko bi bilo, da bi jih kdo spajkal na pikčasto ploščo, zato toplo priporočam, da vsak kupi modul ali pa si izdelajte lastno tiskano vezje za uporabo 4-mestnega 7-segmentnega zaslona. Shema povezav za isto je prikazana spodaj:
Da bi razumeli, kako deluje 4-mestni sedemsegmentni modul, moramo preučiti zgornje sheme, kot je prikazano, zatiči A vseh štirih zaslonov so povezani, da se zberejo kot ena A in enaka za B, C…. do DP. Torej, v bistvu, če je sprožilec A vklopljen, bi morali iti vsi štirje A visoko, ne?
Toda to se ne zgodi. Na voljo imamo dodatne štiri zatiči od D0 do D3 (D0, D1, D2 in D3), s katerimi lahko nadzorujemo, kateri prikaz od štirih naj bo visok. Na primer: Če moram, da je moj izhod prisoten samo na drugem zaslonu, naj bo le D1 postavljen visoko, drugi zatiči (D0, D2 in D3) pa naj bodo nizki. Preprosto lahko izberemo, kateri zaslon mora biti aktiven s pomočjo zatičev od D0 do D3 in kateri znak naj bo prikazan z zatiči od A do DP.
Povezava 4-mestnega sedemsegmentnega modula z mikrokrmilnikom PIC:
Tu smo uporabili PIC mikrokrmilnik PIC16F877A in shema vezja je prikazana spodaj.
Iz modula imamo 12 izhodnih zatičev, od katerih 8 služi za prikaz znakov, štirje pa za izbiro enega od štirih zaslonov. Zato je vseh 8 znakovnih zatičev dodeljenih PORTD, zatiči za izbiro zaslona pa prvim štirim zatičem PORTC.
Opomba: Ozemljitveni zatič modula mora biti povezan tudi z maso MCU, ki tukaj ni prikazana.
Programiranje z uporabo PIC16F877A:
Zdaj, ko vemo, kako ta modul dejansko deluje, se naučimo, kako programirati PIC16F877A, da bo prikazal 4-mestno številko. Povečajmo spremenljivko od 0 do 1000 in jo natisnimo na 7-segmentni zaslon. Zaženite program MPLABX in ustvarite nov projekt, začnimo s konfiguracijskimi biti.
#pragma config FOSC = HS // Oscilator bitov za izbiro (HS oscilator) #pragma config WDTE = OFF // Bit Watchg Enable bit (WDT disabled) #pragma config PWRTE = ON // Power-up Timer Enable bit (PWRT enabled) # pragma config BOREN = ON // Rit-out Reset Enable bit (BOR enabled) #pragma config LVP = OFF // Nizkonapetostni (enojni napajalnik) vklopni serijski programirni bit (RB3 je digitalni I / O, HV vklopljen) Za programiranje je treba uporabiti MCLR) #pragma config CPD = OFF // Bit EEPROM Data Protection Protection bit (Data EEPROM code protection off) #pragma config WRT = OFF // Flash Program Memory Write Enable bit (Write protection off; all programski pomnilnik lahko se zapiše v nadzornik EECON) #pragma config CP = OFF // Flash Program Flash Code Protection bit (Code protection off)
Kot običajno za nastavitev teh bitov uporabljamo okno nastavljenih nastavitvenih bitov. Če niste prepričani, kaj pomenijo, obiščite vadnico za utripanje LED tukaj.
Nato določimo izhodne nožice za preklapljanje med vsako številko zaslona.
// *** Določite signalne nožice vseh štirih zaslonov *** // #define s1 RC0 #define s2 RC1 #define s3 RC2 #define s4 RC3 // *** Konec definicije ** ////
Tu so zatiči RC0, RC1, RC2 in RC3 uporabljeni za izbiro med štirimi števkami našega 7-segmentnega prikazovalnega modula. Ti zatiči so definirani kot s1, s2, s3 in s4.
Nato skočimo v void main (), znotraj katerega imamo naslednjo deklaracijo spremenljivke:
int i = 0; // 4-mestna vrednost, ki bo prikazana int flag = 0; // za ustvarjanje zamude unsigned int a, b, c, d, e, f, g, h; // samo spremenljivke unsigned int seg = {0X3F, // Hex vrednost za prikaz številke 0 0X06, // Hex vrednost za prikaz številke 1 0X5B, // Hex vrednost za prikaz številke 2 0X4F, // Hex vrednost za prikaz številka 3 0X66, // šestnajstiška vrednost za prikaz številke 4 0X6D, // šestnajstiška vrednost za prikaz številke 5 0X7C, // šestnajstiška vrednost za prikaz številke 6 0X07, // šestnajstiška vrednost za prikaz številke 7 0X7F, / / Hex vrednost za prikaz številke 8 0X6F // Hex vrednost za prikaz številke 9}; // Konec polja za prikaz številk od 0 do 9
Tu se spremenljivki i in zastava uporabljata za shranjevanje vrednosti, ki jih je treba prikazati, in ustvarjanje zakasnitve. V cela spremenljivke nepodpisane A do H se uporabljajo za prekinitev štiri mestno število v posameznih številk in jih shranite (kar bo pojasnjeno kasneje tukaj).
Tu je treba opozoriti na ključno deklaracijo matrike "seg" . V tem programu uporabljamo nov podatkovni tip, imenovan Array. Matrika ni nič drugega kot zbirka podobnih vrednosti podatkovnega tipa. Tu smo to matriko uporabili za shranjevanje vseh enakovrednih šestnajstiških vrednosti za prikaz števila od 0 do 9.
Naslov matrike se vedno začne od nič. Torej bo imela ta matrica šestnajstiško vrednost številskega števila (0-9), shranjenega na naslovu, ki je enak številu, kot je prikazano spodaj
Spremenljivka: |
seg |
seg |
seg |
seg |
seg |
seg |
seg |
seg |
seg |
seg |
Šestnajstiška koda: |
0X3F |
0X06 |
0X5B |
0X4F |
0X66 |
0X6D |
0X7C |
0X07 |
0X7F |
0X6F |
Enačba Številčna številka: |
0 |
1. |
2. |
3. |
4. |
5. |
6. |
7. |
8. |
9. |
Torej, če želite prikazati številko 0 na svojem 7-segmentu, lahko pokličete seg, prav tako pa, če želite prikazati številko 6, morate le uporabiti seg.
Da bi razumeli, kako je bila dejansko pridobljena vrednost HEX, si oglejmo spodnjo tabelo. Ekvivalent HEX vrednost za vsako decimalno število je shranjena v matriki, tako da se lahko imenuje za prikaz eno posebno številko.
Zdaj pa pojdimo na naslednji del kode, ki je V / I konfiguracija:
// ***** I / O konfiguracija **** // TRISC = 0X00; PORTC = 0X00; TRISD = 0x00; PORTD = 0X00; // *** Konec I / O konfiguracije ** ///
I / O konfiguracija je preprosta, ker so vsi zatiči na našem 7-segmentu izhodni zatiči, povezave pa so prikazane v zgornjem vezju, zato jih preprosto prijavite kot izhode in jih inicializirajte na nič.
Zdaj pa skočimo v našo neskončno zanko (while (1)). Tu moramo vrednost "i" razdeliti na štiri številke in jih prikazati na 7-segmentu. Najprej začnimo z delitvijo vrednosti na "i"
// *** Razdelitev "i" na štiri številke *** // a = i% 10; // tu je shranjena 4. številka b = i / 10; c = b% 10; // tu se shrani 3. številka d = b / 10; e = d% 10; // tu je shranjena 2. številka f = d / 10; g = f% 10; // tu je shranjena 1. številka h = f / 10; // *** Konec cepitve *** //
Z uporabo enostavnega modula in deljenja se 4-mestno število (i) loči na posamezna števila. V našem primeru vzemimo primer, kjer je vrednost "i" 4578. Nato na koncu tega postopka spremenljivka g = 4, e = 5, c = 7 in a = 8. Zdaj bo enostavno prikazati vsako številko s preprosto uporabo te spremenljivke.
PORTD = seg; s1 = 1; // VKLOPI zaslon 1 in natisni 4. številko __delay_ms (5); s1 = 0; // Izklopite zaslon 1 po 5ms zakasnitvi PORTD = seg; s2 = 1; // VKLOPI zaslon 2 in natisni 3. številko __delay_ms (5); s2 = 0; // Izklopite zaslon 2 po 5ms zakasnitvi PORTD = seg; s3 = 1; // VKLOPI zaslon 3 in natisni 2. številko __delay_ms (5); s3 = 0; // Izklopite zaslon 3 po 5ms zakasnitvi PORTD = seg; s4 = 1; // VKLOPI zaslon 4 in natisni 1. številko __delay_ms (5); s4 = 0; // Izklopite zaslon 4 po 5ms zakasnitvi
Tu se dejansko MCU pogovarja s 7-segmentom. Kot vemo, lahko naenkrat prikažemo samo eno števko, vendar imamo na voljo štiri števke in le, če so vse štiri številke vklopljene, bo uporabniku vidna celotna štirimestna številka.
Torej, kako naj gremo s tem?
Sreča za nas je, da je naš MCU veliko hitrejši od človeškega očesa, zato to, kar dejansko počnemo: prikažemo eno številko naenkrat, vendar to storimo zelo hitro, kot je prikazano zgoraj.
Izberemo enomestni prikaz, ki počaka 5 ms, da ga MCU in 7-segment lahko obdelata, nato pa to številko izklopi in premakne na naslednjo številko ter stori enako, dokler ne pridemo do zadnje številke. Te zakasnitve 5ms človeško oko ne more opaziti in vse štiri številke so bile videti vklopljene hkrati.
To je to, končno le prištejemo vrednost prikazane številke z zamikom, kot je prikazano spodaj
if (flag> = 100) // počakamo, da zastavica doseže 100 {i ++; flag = 0; // samo, če je zastavica sto "i", se bo povečala} flag ++; // zastavica prirastka za vsako bliskavico
Zamuda se uporablja tako, da je čas, potreben za prehod z ene številke na drugo, dovolj dolg, da opazimo spremembo.
Popolna koda je navedeno v nadaljevanju, in proces je pojasnjeno tudi v video na koncu.
Namestitev in testiranje strojne opreme:
Kot vedno simulirajte program s pomočjo Proteusa, preden se dejansko odločimo za svojo strojno opremo. Če je simulacija uspešna, bi morali videti kaj takega
Ta projekt nima nobene zapletene nastavitve strojne opreme, ponovno uporabljamo isto ploščo PIC Microcontroller, ki smo jo ustvarili v Vadnici za utripanje LED. Preprosto povežite 7-segmentni modul s ploščo mikrokrmilnika PIC v skladu s shemo povezav. Ko končate s povezavami, preprosto spustite kodo s programatorjem PicKit 3 in to je, da bo uživala v rezultatih.