7 Segmento ekrano sąsaja su „pic“ mikrovaldikliu

Tai yra mūsų 8-oji PIC mikrovaldiklių mokymosi naudojant MPLAB ir XC8 pamoka. Nuo MPLABX diegimo iki skystųjų kristalų su PIC MCU naudojimo mes atėjome. Jei čia esate naujas, tada peržiūrėkite ankstesnes mokymo programas, kuriose galite sužinoti laikmačius, mirksintį šviesos diodą, sąsajos skystųjų kristalų ekraną ir pan. Paskutinėje pamokoje pamatėme, kaip galime sukurti pasirinktus simbolius naudodami 16 * 2 skystųjų kristalų ekraną, dabar aprūpinkime save kito tipo ekrano moduliu, vadinamu 7 segmentų ekranu, ir susiekime jį su PIC mikrovaldikliu.

Nors 16x2 skystųjų kristalų ekranas yra daug patogesnis nei 7 segmentų ekranas, tačiau yra nedaug scenarijų, kai 7 segmentų ekranas būtų naudingesnis nei skystųjų kristalų ekranas. Skystųjų kristalų ekranas turi trūkumų dėl mažo simbolių dydžio ir bus per didelis jūsų projektui, jei tik planuojate rodyti keletą skaitinių verčių. 7 segmentai taip pat turi pranašumą prieš blogą apšvietimo būklę ir juos galima žiūrėti iš kampo kampų nei į įprastą LCD ekraną. Taigi pradėkime tai žinoti.

7 segmentų ir 4 skaitmenų 7 segmentų ekranas:

7 segmentų ekrane yra septyni segmentai, o kiekviename segmente yra vienas šviesos diodas, rodantis skaičius, apšviečiant atitinkamus segmentus. Panašiai kaip jei norite, kad 7 segmentai rodytų skaičių „5“, tada jums reikia švyti segmentus a, f, g, c ir d, padarydami aukštus jų kaiščius. Yra dviejų tipų 7 segmentų ekranai: bendrasis katodas ir bendrasis anodas, čia mes naudojame bendrojo katodo septynių segmentų ekraną. Sužinokite daugiau apie 7 segmentų rodymą čia.

Dabar mes žinome, kaip norimą skaitinį simbolį rodyti viename 7 segmentų ekrane. Tačiau akivaizdu, kad mums reikės daugiau nei vieno 7 segmentų ekrano, kad galėtume perduoti bet kokią informaciją, kuri yra daugiau nei vienas skaitmuo. Taigi, šioje pamokoje naudosime 4 skaitmenų 7 segmentų rodymo modulį, kaip parodyta žemiau.

Kaip matome, yra sujungti keturi septyni segmentų ekranai. Mes žinome, kad kiekvienas 7 segmentų modulis turės 10 smeigtukų, o keturiems septyniems segmentų ekranams iš viso būtų 40 smeigtukų, ir visiems būtų nemalonu juos lituoti ant taškinės lentos, todėl labai rekomenduočiau visiems įsigyti modulį arba pasidarykite savo PCB, kad galėtumėte naudoti 4 skaitmenų 7 segmentų ekraną. Toliau parodyta to paties ryšio schema:

Norėdami suprasti, kaip veikia 4 skaitmenų septynių segmentų modulis, turime panagrinėti aukščiau pateiktas schemas, kaip parodyta visų keturių ekranų A kaiščiai yra sujungti, kad būtų galima surinkti kaip vieną A ir tą patį B, C…. iki DP. Taigi, iš esmės, jei įjungiamas A, tada visi keturi A turėtų būti aukšti?

Bet taip neatsitinka. Mes turime papildomus keturis kaiščius nuo D0 iki D3 (D0, D1, D2 ir D3), kuriais galima valdyti, kuris ekranas iš keturių turėtų būti aukštas. Pvz.: Jei man reikia, kad mano išvestis būtų rodoma tik antrame ekrane, tik D1 turėtų būti padaryta aukšta, o kiti kaiščiai (D0, D2 ir D3) turėtų būti kuo mažesni. Paprasčiausiai mes galime pasirinkti, kuris ekranas turi būti aktyvus, naudojant kaiščius nuo D0 iki D3, ir kokį simbolį rodyti, naudojant kaiščius nuo A iki DP.

4 skaitmenų septynių segmentų modulio prijungimas prie PIC mikrovaldiklio:

Čia mes panaudojome PIC mikrovaldiklį PIC16F877A, o schemos schema parodyta žemiau.

Mes turime 12 modulio išvesties kaiščių, iš kurių 8 naudojami simboliams rodyti, o keturi naudojami vienam iš keturių rodyti. Taigi visi 8 simbolių kaiščiai priskiriami PORTD, o ekrano pasirinkimo kaiščiai priskiriami pirmiems keturiems PORTC kaiščiams.

Pastaba: Modulio įžeminimo kaištis taip pat turėtų būti prijungtas prie MCU įžeminimo, kuris čia neparodytas.

Programavimas naudojant PIC16F877A:

Dabar, kai žinome, kaip šis modulis iš tikrųjų veikia, sužinokime, kaip užprogramuoti PIC16F877A, kad jis rodytų 4 skaitmenų skaičių. Padidinkime kintamąjį nuo 0 iki 1000 ir atspausdinkime jį 7 segmentų ekrane. Paleiskite „MPLABX“ programą ir sukurkite naują projektą. Pradėkime nuo konfigūracijos bitų.

#pragma config FOSC = HS // Oscilatoriaus pasirinkimo bitai (HS osciliatorius) #pragma config WDTE = OFF // Watchdog Timer Enable bit (WDT išjungtas) #pragma config PWRTE = ON // Power-up Timer Enable bit (įjungtas PWRT) # pragmos konfigūracija BOREN = ĮJUNGTA // Išjungta iš naujo Įgalinti bitą (įjungta BOR) #pragma konfigūracija LVP = IŠJUNGTA // Žemos įtampos (vieno maitinimo) grandinės nuosekliojo programavimo įgalinimo bitas (RB3 yra skaitmeninis įvesties / išvesties įjungimas, įjungtas HV Programavimui reikia naudoti MCLR) #pragma config CPD = OFF // duomenų EEPROM atminties kodo apsaugos bitas (duomenų EEPROM kodo apsauga išjungta) #pragma config WRT = OFF // „Flash“ programos atminties įrašymas Įgalinti bitus (nurašymo apsauga; visa programos atmintis gali būti parašyta EECON valdymu) #pragma config CP = OFF // „Flash“ programos atminties kodo apsaugos bitas (kodo apsauga išjungta)

Kaip įprasta, šiems bitams nustatyti naudojame nustatytų konfigūracijos bitų langą. Jei nesate tikri, ką jie reiškia, apsilankykite LED mirksi pamoka čia.

Toliau apibrėžkime išvesties kaiščius, perjungiamus tarp kiekvieno ekrano skaitmens.

// *** Apibrėžkite visų keturių ekranų signalo kaiščius *** // #define s1 RC0 #define s2 RC1 #define s3 RC2 #define s4 RC3 // *** Apibrėžimo pabaiga ** ////

Čia kaiščiai RC0, RC1, RC2 ir RC3 naudojami pasirinkti iš keturių mūsų 7 segmentų rodymo modulio skaitmenų. Šie kaiščiai apibrėžiami kaip atitinkamai s1, s2, s3 ir s4.

Tada pereikime į negaliojančią main (), kurios viduje turime tokią kintamojo deklaraciją:

int i = 0; // 4 skaitmenų reikšmė, kuri turi būti rodoma int flag = 0; // uždelsimo sukūrimui nepasirašytas int a, b, c, d, e, f, g, h; // tik kintamieji nepasirašyti int seg = {0X3F, // Hex reikšmė rodyti skaičių 0 0X06, // Hex reikšmė rodyti skaičių 1 0X5B, // Hex reikšmė rodyti skaičių 2 0X4F, // Hex vertė rodyti skaičius 3 0X66, // Hex value - skaičius 4 0X6D, // Hex value - skaičius 5 0X7C, // Hex value - skaičius 6 0X07, // Hex value - skaičius 7 0X7F, / / Hex value - rodyti skaičių 8 0X6F // Hex value - rodyti skaičių 9}; // Masyvo pabaiga rodyti skaičius nuo 0 iki 9

Čia kintamieji i ir flag naudojami rodomoms reikšmėms saugoti ir vėlavimui sukurti. Į unsigned integer kintamieji a iki h yra naudojami sulaužyti keturių skaitmenų numerius į vieną skaitmenimis ir laikyti juos (kuri bus paaiškinta vėliau čia).

Vienas svarbiausias dalykas, kurį reikia atkreipti dėmesį į tai, yra masyvo „seg“ deklaracija. Šioje programoje mes naudojame naują duomenų tipą, vadinamą masyvu. Masyvas yra ne kas kita, kaip panašių duomenų tipo reikšmių rinkinys. Čia mes naudojome šį masyvą, kad išsaugotume visas lygiavertes šešiakampes reikšmes, kad būtų rodomas skaičius nuo 0 iki 9.

Masyvo adresas visada prasideda nuo nulio. Taigi šio masyvo skaitmeninio skaičiaus (0–9) šešioliktainė vertė bus išsaugota adresu, kuri yra tokia pati kaip ir skaičiaus, kaip parodyta žemiau

Kintamasis:	seg	seg	seg	seg	seg	seg	seg	seg	seg	seg
Hex kodas:	0X3F	0X06	0X5B	0X4F	0X66	0X6D	0X7C	0X07	0X7F	0X6F
Eq. Skaitinis numeris:	0	1	2	3	4	5	6	7	8	9

Taigi, jei norite rodyti skaičių 7 savo 7 segmentuose, galite skambinti seg, taip pat, jei norite rodyti skaičių 6, tiesiog turite naudoti seg.

Norėdami suprasti, kaip iš tikrųjų buvo gauta HEX vertė, pažvelkime į toliau pateiktą lentelę. Ekvivalentas HEX vertė kiekvienai dešimtainis skaičius yra saugomi masyve, kad jis gali būti vadinamas rodyti vieną konkretų skaičių.

Dabar pereikime prie kitos kodo dalies, kuri yra įvesties / išvesties konfigūracija:

***** Įvesties / išvesties konfigūracija **** // TRISC = 0X00; PORTC = 0X00; TRISD = 0x00; PORTD = 0X00; *** *** I / O konfigūracijos pabaiga ** ///

Įvesties / išvesties konfigūracija yra paprasta, nes visi mūsų 7 segmentų kaiščiai yra išvesties kaiščiai, o jungtys parodytos pirmiau pateiktoje grandinės schemoje, todėl tiesiog deklaruokite juos kaip išvestis ir inicializuokite į nulį.

Dabar peršokime į savo begalinę kilpą (o (1)). Čia mes turime padalinti „i“ vertę į keturis skaitmenis ir parodyti juos 7 segmentuose. Pirmiausia pradėkime nuo vertės „i“ padalijimo

// *** „i“ padalijimas į keturis skaitmenis *** // a = i% 10; // čia išsaugomas 4 skaitmuo b = i / 10; c = b% 10; // čia įrašomas 3 skaitmuo d = b / 10; e = d% 10; // čia išsaugotas 2 skaitmuo f = d / 10; g = f% 10; // čia išsaugotas 1 skaitmuo h = f / 10; *** Skilimo pabaiga *** //

Naudojant paprastą modulio ir dalijimo operaciją, 4 skaitmenų skaičius (i) yra atskirtas į atskirus skaičius. Mūsų atveju imkime pavyzdį, kai „i“ reikšmė yra 4578. Tada šio proceso pabaigoje kintamasis g = 4, e = 5, c = 7 ir a = 8. Taigi dabar bus lengva parodyti kiekvieną skaitmenį paprasčiausiai naudojant tą kintamąjį.

PORTD = seg; s1 = 1; // Įjunkite 1 ekraną ir atspausdinkite 4 skaitmenį __delay_ms (5); s1 = 0; // Išjunkite 1 ekraną po 5ms vėlavimo PORTD = seg; s2 = 1; // Įjunkite 2 ekraną ir atspausdinkite 3 skaitmenį __delay_ms (5); s2 = 0; // Išjunkite 2 ekraną po 5ms vėlavimo PORTD = seg; s3 = 1; // Įjunkite 3 ekraną ir atspausdinkite 2 skaitmenų __delay_ms (5); s3 = 0; // Išjunkite 3 ekraną po 5ms vėlavimo PORTD = seg; s4 = 1; // Įjunkite 4 ekraną ir atspausdinkite 1 skaitmenį __delay_ms (5); s4 = 0; // Po 5 ms vėlavimo išjunkite 4 ekraną

Tai yra tikroji vieta, kur MCU kalba su 7 segmentais. Kaip žinome, vienu metu galime rodyti tik vieną skaitmenį, tačiau turime rodyti keturis skaitmenis ir tik tuo atveju, jei visi keturi skaitmenys yra įjungti, vartotojui bus matomas visas keturių skaitmenų skaičius.

Taigi, kaip mums tai padaryti?

Mums pasisekė, kad mūsų MCU yra daug greitesnis nei žmogaus akis, todėl tai, ką mes iš tikrųjų darome: rodome po vieną skaitmenį, bet tai darome labai greitai, kaip parodyta aukščiau.

Mes pasirenkame vieno skaitmens ekraną, kurį reikia palaukti 5 ms, kad MCU ir 7 segmentai galėtų jį apdoroti, tada išjungti tą skaitmenį ir pereiti prie kito skaitmens ir daryti tą patį, kol pasieksime paskutinį skaitmenį. Šio 5ms vėlavimo negalima pastebėti žmogaus akimi, ir visi keturi skaitmenys tuo pačiu metu buvo įjungti.

Tai viskas, pagaliau mes tiesiog padidiname rodomo skaitmens vertę naudodami vėlavimą, kaip parodyta žemiau

if (flag> = 100) // palaukite, kol vėliava pasieks 100 {i ++; flag = 0; // tik jei vėliava yra šimtas „i“ bus padidinta} vėliava ++; // kiekvienos blykstės padidėjimo vėliava

Vėlavimas naudojamas taip, kad laikas, per kurį reikia pereiti iš vieno numerio į kitą, yra pakankamai ilgas, kad pastebėtume pasikeitimą.

Visas kodas pateikiamas žemiau, o procesas taip pat paaiškinamas vaizdo įraše pabaigoje.

Aparatūros nustatymas ir testavimas:

Kaip visada, imituokime programą naudodami „Proteus“, kol iš tikrųjų eisime su savo aparatine įranga. Jei modeliavimas yra sėkmingas, turėtumėte pamatyti kažką panašaus

Šiame projekte nėra sudėtingos aparatinės įrangos sąrankos, mes vėl naudojame tą pačią PIC mikrovaldiklio plokštę, kurią sukūrėme „LED“ mirksi pamoka. Paprasčiausiai prijunkite 7 segmentų modulį prie savo PIC mikrovaldiklio plokštės pagal prijungimo schemą. Baigę ryšius, paprasčiausiai perkelkite kodą naudodami „PicKit 3“ programuotoją ir tai mėgaukitės savo išvestimi.