Interfície de visualització de 7 segments amb microcontrolador pic

Aquest és el nostre vuitè tutorial sobre l' aprenentatge de microcontroladors PIC mitjançant MPLAB i XC8. Hem arribat des de la instal·lació de MPLABX fins a l’ús d’una pantalla LCD amb PIC MCU. Si sou nou aquí, mireu tutorials anteriors on podeu aprendre temporitzadors, LED intermitent, interfície LCD, etc. Podeu trobar tots els nostres tutorials PIC aquí. En el nostre últim tutorial vam veure com podem generar caràcters personalitzats amb la nostra pantalla LCD de 16 * 2, ara anem a equipar als nostres un mateix amb un altre tipus de mòdul de visualització anomenat el display de 7 segments i la interfície amb microcontrolador PIC.

Tot i que la pantalla LCD de 16 x 2 és molt més còmoda que la pantalla de 7 segments, però hi ha pocs escenaris en què una pantalla de 7 segments sigui més útil que una pantalla LCD. La pantalla LCD té l’inconvenient de tenir una mida de caràcter baixa i serà excessiva per al vostre projecte si només teniu previst mostrar alguns valors numèrics. Els segments de 7 també tenen l'avantatge de no tenir un estat d'il·luminació deficient i es poden veure des d'un angle lager que una pantalla LCD normal. Comencem, doncs, a saber-ho.

Mòdul de visualització de 7 segments i 4 dígits de 7 segments:

La pantalla de 7 segments inclou set segments i cada segment té un LED al seu interior per mostrar els números il·luminant els segments corresponents. Igual que si voleu que el segment de 7 mostri el número "5", haureu de fer brillar el segment a, f, g, c i d fent que els pins corresponents siguin alts. Hi ha dos tipus de pantalles de 7 segments: càtode comú i ànode comú; aquí estem fent servir pantalles de càtode comú de set segments. Obteniu més informació sobre la visualització de 7 segments aquí.

Ara sabem com mostrar el caràcter numèric desitjat en una sola pantalla de 7 segments. Però, és bastant evident que necessitaríem més d’una pantalla de 7 segments per transmetre qualsevol informació que tingui més d’un dígit. Per tant, en aquest tutorial utilitzarem un mòdul de visualització de 7 segments de 4 dígits, tal com es mostra a continuació.

Com podem veure, hi ha quatre pantalles de set segments connectades entre si. Sabem que cada mòdul de 7 segments tindrà 10 pins i, per a 4 pantalles de 7 segments, hi hauria 40 pins en total i seria trepidant que qualsevol persona els soldés en un tauler de punts, així que recomanaria a qualsevol que comprés un mòdul o feu el vostre propi PCB per utilitzar una pantalla de 7 dígits de 4 dígits. A continuació es mostra l’esquema de connexió del mateix:

Per entendre com funciona el mòdul de quatre segments de quatre dígits, hem de mirar els esquemes anteriors, tal com es mostra, els pins A de les quatre pantalles estan connectats per reunir-se com un A i el mateix per a B, C… fins a DP. Per tant, bàsicament, si s’activa l’activador A, les quatre A haurien d’anar a dalt, oi?

Però això no passa. Tenim quatre pins addicionals de D0 a D3 (D0, D1, D2 i D3) que es poden utilitzar per controlar quina visualització de les quatre hauria de pujar. Per exemple: si necessito que la meva sortida només estigui present a la segona pantalla, només s'hauria de posar D1 alt mentre es mantindran altres pins (D0, D2 i D3) tan baixos. Simplement podem seleccionar quina pantalla ha d’estar activa mitjançant els pins de D0 a D3 i quin caràcter es mostrarà mitjançant els pins d’A a DP.

Connexió del mòdul de 7 segments de 4 dígits amb microcontrolador PIC:

Aquí hem utilitzat el microcontrolador PIC PIC16F877A i l’esquema del circuit es mostra a continuació.

Tenim 12 pins de sortida del mòdul, dels quals 8 s'utilitzen per mostrar els caràcters i quatre s'utilitzen per seleccionar una pantalla de quatre. Per tant, tots els pins de 8 caràcters s’assignen a PORTD i els pins de selecció de la pantalla s’assignen als quatre primers pins de PORTC.

Nota: El pin de terra del mòdul també s'hauria de connectar a la terra de l'MCU, que no es mostra aquí.

Programació mitjançant PIC16F877A:

Ara, ja que sabem com funciona aquest mòdul, aprenem a programar PIC16F877A perquè mostri un número de 4 dígits. Incrementem una variable de 0 a 1000 i imprimim-la a la pantalla de 7 segments. Inicieu el programa MPLABX i creeu un projecte nou, comencem amb els bits de configuració.

#pragma config FOSC = HS // Oscillator Selection bits (HS oscillator) #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 enabled) #pragma config LVP = OFF // Low Voltage (Single-Supply) In-Circuit Serial Programming Enable Bit (RB3 és E / S digital, HV activat S'ha d'utilitzar MCLR per a la programació) #pragma config CPD = OFF // Data EEPROM Memory Code Protection bit (Data EEPROM code protection off) #pragma config WRT = OFF // Flash Program Memory Write Enable bits (Protecció contra escriptura desactivada; tota la memòria del programa) pot ser escrit pel control EECON) #pragma config CP = OFF // Bit de protecció del codi de memòria del programa Flash (protecció del codi desactivada)

Com és habitual, fem servir la finestra de configuració de bits per configurar aquests bits. Si no esteu segur de què volen dir, visiteu el tutorial de parpelleig LED aquí.

A continuació, definim els pins de sortida per alternar entre cada dígit de la pantalla.

// *** Definiu els pins de senyal de les quatre pantalles *** // #define s1 RC0 #define s2 RC1 #define s3 RC2 #define s4 RC3 // *** Final de la definició ** ////

Aquí s’utilitzen els pins RC0, RC1, RC2 i RC3 per seleccionar entre els quatre dígits del nostre mòdul de visualització de 7 segments. Aquests pins es defineixen com s1, s2, s3 i s4 respectivament.

A continuació, saltem a void main (), dins del qual tenim la següent declaració de variable:

int i = 0; // el valor de 4 dígits que s'ha de mostrar int flag = 0; // per crear retard sense signar int a, b, c, d, e, f, g, h; // només variables sense signar int seg = {0X3F, // Valor hexadecimal per mostrar el número 0 0X06, // Valor hexadecimal per mostrar el número 1 0X5B, // Valor hexadecimal per mostrar el número 2 0X4F, // Valor hexadecimal per mostrar el número 3 0X66, // Valor hexagonal per mostrar el número 4 0X6D, // Valor hexagonal per mostrar el número 5 0X7C, // Valor hexagonal per mostrar el número 6 0X07, // Valor hexagonal per mostrar el número 7 0X7F, / / Valor hexadecimal per mostrar el número 8 0X6F // Valor hexadecimal per mostrar el número 9}; // Fi de la matriu per mostrar números del 0 al 9

Aquí les variables i i flag s’utilitzen per emmagatzemar els valors que es mostraran i crear un retard respectivament. Les variables enteres sense signar de a a h s'utilitzen per dividir els números de quatre dígits en dígits simples i emmagatzemar-los (cosa que s'explicarà més endavant aquí).

Una cosa clau a tenir en compte aquí és la declaració de matriu "seg" . En aquest programa estem utilitzant un nou tipus de dades anomenat Array. Array no és res més que una col·lecció de valors de tipus de dades similars. Aquí hem utilitzat aquesta matriu per emmagatzemar tots els valors hexadecimals equivalents per mostrar un número del 0 al 9.

L'adreça de la matriu sempre comença des de zero. Per tant, aquesta matriu tindrà el valor hexadecimal d’un número numèric (0-9) emmagatzemat a l’adreça que és el mateix que el número que es mostra a continuació.

Variable:	seg	seg	seg	seg	seg	seg	seg	seg	seg	seg
Codi hexadecimal:	0X3F	0X06	0X5B	0X4F	0X66	0X6D	0X7C	0X07	0X7F	0X6F
Eq. Número numèric:	0	1	2	3	4	5	6	7	8	9

De manera senzilla, si voleu mostrar el número 0 al vostre segment de 7, podeu trucar a seg, de la mateixa manera que si voleu mostrar el número 6, només heu d’utilitzar seg.

Per entendre com es va obtenir realment el valor HEX, examinem la taula següent. El valor HEX equivalent per a cada nombre decimal s'emmagatzema a la matriu de manera que es pot cridar per mostrar un número concret.

Ara anem a la següent part del codi que és la configuració d'E / S:

// ***** Configuració d'E / S **** // TRISC = 0X00; PORTC = 0X00; TRISD = 0x00; PORTD = 0X00; // *** Fi de la configuració d'E / S ** ///

La configuració d'E / S és senzilla perquè tots els pins dels nostres 7 segments són pins de sortida i les connexions es mostren al diagrama del circuit anterior, de manera que només cal declarar-les com a sortides i inicialitzar-les a zero.

Ara saltem al nostre bucle infinit (mentre que (1)). Aquí hem de dividir el valor de "i" en quatre dígits i mostrar-los al segment de 7. Primer comencem dividint el valor a "i"

// *** Es divideix "i" en quatre dígits *** // a = i% 10; // el 4t dígit es desa aquí b = i / 10; c = b% 10; // aquí es desa el tercer dígit d = b / 10; e = d% 10; // Aquí es desa el 2n dígit f = d / 10; g = f% 10; // Aquí es desa el primer dígit h = f / 10; // *** Fi de la divisió *** //

En utilitzar un mòdul i una operació de divisió simples, el número de 4 dígits (i) es separa en nombres individuals. En el nostre cas, prenem un exemple en què el valor de "i" és 4578. Al final d'aquest procés, la variable g = 4, e = 5, c = 7 i a = 8. Per tant, ara serà fàcil mostrar cada dígit simplement utilitzant aquesta variable.

PORTD = seg; s1 = 1; // Activeu la pantalla 1 i imprimiu el 4t dígit __delay_ms (5); s1 = 0; // Apagueu la pantalla 1 després de 5 ms de retard PORTD = seg; s2 = 1; // Activeu la pantalla 2 i imprimiu el tercer dígit __delay_ms (5); s2 = 0; // Apagueu la pantalla 2 després de 5 ms de retard PORTD = seg; s3 = 1; // Activeu la pantalla 3 i imprimiu el segon dígit __delay_ms (5); s3 = 0; // Apagueu la pantalla 3 després de 5 ms de retard PORTD = seg; s4 = 1; // Activeu la pantalla 4 i imprimiu el primer dígit __delay_ms (5); s4 = 0; // Apagueu la pantalla 4 després del retard de 5 ms

Aquest és el lloc real on la MCU parla amb el segment de 7. Com sabem , només podem mostrar un dígit a la vegada, però tenim quatre dígits per mostrar i només si els quatre dígits estan activats, el número de quatre dígits complet serà visible per a l'usuari.

Llavors, com anem amb això?

Per sort, per a nosaltres, la nostra MCU és molt més ràpida que un ull humà, així que fem el que realment fem: mostrem un dígit a la vegada, però ho fem molt ràpidament, tal com es mostra més amunt.

Seleccionem una pantalla d'un dígit que esperi 5 ms perquè l'MCU i el segment de 7 puguin processar-lo i, a continuació, apaguem aquest dígit i passem al següent dígit i fem el mateix fins a arribar a l'últim dígit. Aquest retard de 5 ms no pot ser observat per un ull humà i els quatre dígits semblaven estar activats al mateix temps.

És a dir, per fi, acabem d’incrementar el valor del dígit mostrat utilitzant un retard, tal com es mostra a continuació

if (flag> = 100) // espereu fins que la bandera arribi a 100 {i ++; flag = 0; // només si la bandera és cent "i" s'incrementarà} flag ++; // senyal d’increment per a cada flaix

El retard s’utilitza perquè el temps que es triga a canviar d’un número a un altre sigui prou llarg perquè notem el canvi.

A continuació es dóna el codi complet i el procés també s’explica al vídeo al final.

Configuració i proves de maquinari:

Com sempre, anem a simular el programa amb Proteus abans d’anar realment amb el nostre maquinari. Si la simulació té èxit, hauríeu de veure alguna cosa així

Aquest projecte no té cap configuració de maquinari complicada, tornem a utilitzar la mateixa placa de microcontrolador PIC que hem creat al Tutorial de parpelleig de LED. Simplement connecteu el mòdul de 7 segments amb la vostra placa de microcontrolador PIC segons el diagrama de connexió. Un cop hàgiu acabat les connexions, només heu de bolcar el codi amb el vostre programador PicKit 3 i això és gaudir de la vostra sortida.