Afișare cu 7 segmente de interfață cu microcontroler pic

Acesta este al 8-lea tutorial de învățare a microcontrolerelor PIC folosind MPLAB și XC8. Am venit până la instalarea MPLABX până la utilizarea unui LCD cu PIC MCU. Dacă sunteți nou aici, uitați-vă la tutoriale anterioare în care puteți învăța temporizatoare, LED-uri intermitente, interfață LCD etc. Puteți găsi toate tutorialele noastre PIC aici. În ultimul nostru tutorial am văzut cum putem genera caractere personalizate cu ecranul nostru LCD de 16 * 2, acum permiteți-ne să ne echipăm cu un alt tip de modul de afișare numit afișaj cu 7 segmente și să îl interfațăm cu microcontrolerul PIC.

Deși ecranul LCD 16x2 este mult mai confortabil decât afișajul cu 7 segmente, însă există puține scenarii în care un afișaj cu 7 segmente ar fi mai util decât un afișaj LCD. Ecranul LCD suferă de dezavantajul de a avea dimensiuni reduse ale caracterelor și va fi exagerat pentru proiectul dvs. dacă intenționați doar să afișați câteva valori numerice. 7 segmente au, de asemenea, avantajul împotriva unei condiții de iluminare slabe și pot fi vizualizate din unghiuri lager decât un ecran LCD normal. Deci, să începem să știm.

Modul de afișare cu 7 segmente și 4 cifre cu 7 segmente:

7 Segment Display conține șapte segmente și fiecare segment are un LED în interior pentru a afișa numerele iluminând segmentele corespunzătoare. De exemplu, dacă doriți ca segmentul cu 7 să afișeze numărul „5”, atunci trebuie să străluciți segmentele a, f, g, c și d, făcând pinii lor înalți. Există două tipuri de afișaje pe 7 segmente: catod comun și anod comun, aici folosim afișaj cu șapte segmente pentru catod comun. Aflați mai multe despre afișajul pe 7 segmente aici.

Acum știm cum să afișăm caracterul nostru numeric dorit pe un singur ecran cu 7 segmente. Dar, este destul de evident că am avea nevoie de mai mult de un afișaj pe 7 segmente pentru a transmite orice informație care are mai mult de o cifră. Deci, în acest tutorial vom folosi un modul de afișare cu 7 segmente din 4 cifre, așa cum se arată mai jos.

După cum putem vedea, există patru afișaje cu șapte segmente conectate împreună. Știm că fiecare modul cu 7 segmente va avea 10 pini și pentru 4 afișaje cu șapte segmente ar exista 40 de pini în total și ar fi agitat pentru oricine să le lipească pe o placă de puncte, așa că aș recomanda cu toată încrederea oricui să cumpere un modul sau creați-vă propriul PCB pentru utilizarea unui afișaj cu 4 cifre, cu 7 segmente. Schema conexiunii pentru același lucru este prezentată mai jos:

Pentru a înțelege modul în care funcționează modulul de șapte segmente din 4 cifre, trebuie să ne uităm la schemele de mai sus, așa cum se arată pinii A ai tuturor celor patru afișaje sunt conectați pentru a aduna ca unul A și același lucru pentru B, C…. până la DP. Deci, practic, dacă declanșatorul A este activat, atunci toate cele patru A ar trebui să meargă la înălțime, nu?

Dar asta nu se întâmplă. Avem patru pini suplimentari de la D0 la D3 (D0, D1, D2 și D3), care pot fi folosiți pentru a controla care afișaj din cei patru ar trebui să fie ridicat. De exemplu: Dacă am nevoie ca ieșirea mea să fie prezentă doar pe al doilea afișaj, atunci doar D1 ar trebui să fie ridicat, păstrând în același timp alți pini (D0, D2 și D3) la un nivel scăzut. Pur și simplu putem selecta care afișaj trebuie să fie activ folosind pinii de la D0 la D3 și ce caracter să fie afișat folosind pinii de la A la DP.

Conectarea modulului cu șapte segmente din 4 cifre cu microcontroler PIC:

Aici am folosit microcontrolerul PIC PIC16F877A și schema pentru circuit este prezentată mai jos.

Avem 12 pini de ieșire din modul, dintre care 8 sunt folosiți pentru afișarea caracterelor și patru sunt folosiți pentru a selecta un afișaj din patru. Prin urmare, toți pinii de 8 caractere sunt atribuiți PORTD, iar pinii de selecție a afișajului sunt atribuiți primilor patru pini ai PORTC.

Notă: Știftul de masă al modulului ar trebui, de asemenea, să fie conectat la solul MCU, care nu este prezentat aici.

Programare folosind PIC16F877A:

Acum, că știm cum funcționează de fapt acest modul, să învățăm cum să programăm PIC16F877A pentru a-l face să afișeze un număr din 4 cifre. Să incrementăm o variabilă de la 0 la 1000 și să o imprimăm pe afișajul cu 7 segmente. Lansați programul MPLABX și creați un proiect nou, să începem cu biții de configurare.

#pragma config FOSC = HS // Oscillator Selection bits (HS oscilator) #pragma config WDTE = OFF // Watchdog Timer Enable bit (WDT disabled) #pragma config PWRTE = ON // Power-up Timer Enable bit (PWRT enabled) # pragma config BOREN = ON // Brown-out Reset Enable bit (BOR activat) #pragma config LVP = OFF // Low-Voltage (Single-Supply) In-Circuit Serial Programming Enable bit (RB3 este I / O digital, HV activat MCLR trebuie utilizat pentru programare) #pragma config CPD = OFF // Data EEPROM Memory Code Protection bit (Data EEPROM code protection protection off) #pragma config WRT = OFF // Flash Program Memory Write Enable bits (Protecție la scriere dezactivată; toată memoria programului) poate fi scris către controlul EECON) #pragma config CP = OFF // Programul Flash Memorie Cod de protecție bit (Protecție cod dezactivată)

Ca de obicei, folosim fereastra de biți de configurare pentru a seta acești biți. Dacă nu sunteți sigur ce înseamnă, accesați aici tutorialul LED intermitent.

În continuare, să definim pinii de ieșire pentru a comuta între fiecare cifră a afișajului.

// *** Definiți pinii de semnal pentru toate cele patru afișaje *** // #define s1 RC0 #define s2 RC1 #define s3 RC2 #define s4 RC3 // *** Sfârșitul definiției ** ////

Aici pinii RC0, RC1, RC2 și RC3 sunt utilizați pentru selectarea dintre cele patru cifre ale modulului nostru de afișare pe 7 segmente. Acești pini sunt definiți ca s1, s2, s3 și respectiv s4.

În continuare, să trecem în void main (), în interiorul căruia avem următoarea declarație de variabilă:

int i = 0; // valoarea din 4 cifre care urmează să fie afișată int flag = 0; // pentru crearea întârzierii nesemnate int a, b, c, d, e, f, g, h; // doar variabile nesemnate int seg = {0X3F, // Hex valoare pentru a afișa numărul 0 0X06, // Hex valoare pentru a afișa numărul 1 0X5B, // Hex valoare pentru a afișa numărul 2 0X4F, // Hex valoare pentru a afișa numărul 3 0X66, // Valoare hexagonală pentru afișarea numărului 4 0X6D, // Valoare hexagonală pentru afișarea numărului 5 0X7C, // Valoare hexagonală pentru afișarea numărului 6 0X07, // Valoare hexagonală pentru afișarea numărului 7 0X7F, / / Valoare hexagonală pentru afișarea numărului 8 0X6F // Valoare hexagonală pentru afișarea numărului 9}; // End of Array pentru afișarea numerelor de la 0 la 9

Aici variabilele i și flag sunt folosite pentru stocarea valorilor care trebuie afișate și respectiv pentru crearea unei întârzieri. De variabile nesemnate întregi la o oră sunt folosite pentru a rupe cele patru numere de cifre în cifre unice și a le stoca (care va fi explicat mai târziu aici).

Un lucru cheie de remarcat aici este declarația matricei „seg” . În acest program folosim un nou tip de date numit Array. Array nu este altceva decât o colecție de valori similare de tip date. Aici, am folosit această matrice pentru a stoca toate valorile hexagonale echivalente pentru afișarea unui număr de la 0 la 9.

Adresa matricei începe întotdeauna de la zero. Deci, această matrice va avea valoarea hexagonală a unui număr numeric (0-9) stocat în adresa care este aceeași cu cea a numărului așa cum se arată mai jos

Variabil:	seg	seg	seg	seg	seg	seg	seg	seg	seg	seg
Cod hexagonal:	0X3F	0X06	0X5B	0X4F	0X66	0X6D	0X7C	0X07	0X7F	0X6F
Eq. Numărul numeric:	0	1	2	3	4	5	6	7	8	9

Deci, pur și simplu, dacă doriți să afișați numărul 0 pe segmentul dvs. 7, puteți apela seg, la fel dacă doriți să afișați numărul 6, trebuie doar să utilizați seg.

Pentru a înțelege cum s-a obținut efectiv valoarea HEX, să ne uităm în tabelul de mai jos. Valoarea HEX echivalentă pentru fiecare număr zecimal este stocată în matrice astfel încât să poată fi apelată pentru a afișa un anumit număr.

Acum, să trecem la următoarea parte a codului, care este configurația I / O:

// ***** Configurare I / O **** // TRISC = 0X00; PORTC = 0X00; TRISD = 0x00; PORTD = 0X00; // *** Sfârșitul configurării I / O ** ///

Configurarea I / O este simplă, deoarece toți pinii de pe segmentul nostru de 7 sunt pin de ieșire, iar conexiunile sunt prezentate în schema de circuit de mai sus, deci pur și simplu le declarați ca ieșiri și inițializați-le la zero.

Acum să ne aruncăm în bucla noastră infinită (while (1)). Aici trebuie să împărțim valoarea „i” în patru cifre și să le afișăm pe segmentul 7. Mai întâi să începem prin împărțirea valorii pe „i”

// *** Împărțirea „i” în patru cifre *** // a = i% 10; // A patra cifră este salvată aici b = i / 10; c = b% 10; // A treia cifră este salvată aici d = b / 10; e = d% 10; // a doua cifră este salvată aici f = d / 10; g = f% 10; // prima cifră este salvată aici h = f / 10; // *** Sfârșitul divizării *** //

Utilizând modulul simplu și operația de divizare, numărul de 4 cifre (i) este separat în numere individuale. În cazul nostru, să luăm un exemplu în care valoarea lui "i" este 4578. Apoi, la sfârșitul acestui proces, variabila g = 4, e = 5, c = 7 și a = 8. Deci, acum va fi ușor să afișați fiecare cifră prin simpla utilizare a variabilei.

PORTD = seg; s1 = 1; // Porniți afișajul 1 și tipăriți a 4-a cifră __delay_ms (5); s1 = 0; // Opriți afișajul 1 după o întârziere de 5 ms PORTD = seg; s2 = 1; // Porniți afișajul 2 și tipăriți a treia cifră __delay_ms (5); s2 = 0; // Opriți afișajul 2 după o întârziere de 5 ms PORTD = seg; s3 = 1; // Porniți afișajul 3 și tipăriți a doua cifră __delay_ms (5); s3 = 0; // Opriți afișajul 3 după o întârziere de 5 ms PORTD = seg; s4 = 1; // Porniți afișajul 4 și tipăriți prima cifră __delay_ms (5); s4 = 0; // Opriți afișajul 4 după o întârziere de 5 ms

Acesta este locul real în care MCU vorbește cu segmentul 7. După cum știm , putem afișa o singură cifră la un moment dat, dar avem patru cifre de afișat și numai dacă toate cele patru cifre sunt pe numărul complet de patru cifre va fi vizibil pentru utilizator.

Deci, cum mergem cu asta?

Din fericire pentru noi MCU-ul nostru este mult mai rapid decât un ochi uman, deci ceea ce facem de fapt: afișăm câte o cifră odată, dar o facem foarte repede, așa cum se arată mai sus.

Selectăm afișarea cu o cifră, așteaptă 5 ms, astfel încât MCU și segmentul 7 să o poată procesa, apoi oprim cifra respectivă și trecem la următoarea cifră și facem același lucru până când ajungem la ultima cifră. Această întârziere de 5 ms nu poate fi observată de un ochi uman și toate cele patru cifre păreau să fie activate în același timp.

Asta este, în cele din urmă, doar incrementăm valoarea cifrei afișate folosind o întârziere așa cum se arată mai jos

if (flag> = 100) // așteptați până când flagul ajunge la 100 {i ++; flag = 0; // numai dacă pavilionul este sută „i” va fi incrementat} flag ++; // semnalizare increment pentru fiecare bliț

Întârzierea este utilizată astfel încât timpul necesar pentru schimbarea de la un număr la altul să fie suficient de lung pentru ca noi să observăm schimbarea.

Codul complet este prezentat mai jos, iar procesul este, de asemenea, explicat în Video la sfârșitul anului.

Configurare și testare hardware:

Ca întotdeauna, permiteți-ne să simulăm programul folosind Proteus înainte de a merge cu hardware-ul nostru. Dacă simularea are succes, ar trebui să vedeți așa ceva

Acest proiect nu are nicio configurare hardware complicată, folosim din nou aceeași placă de microcontroler PIC pe care am creat-o în Tutorialul intermitent cu LED-uri. Pur și simplu conectați modulul cu 7 segmente la placa de microcontroler PIC conform schemei de conectare. Odată ce ați terminat cu conexiunile, pur și simplu aruncați codul folosind programatorul PicKit 3 și asta este să vă bucurați de ieșirea dvs.