Display a 7 segmenti che si interfaccia con il microcontrollore pic

Questo è il nostro ottavo tutorial sull'apprendimento dei microcontrollori PIC utilizzando MPLAB e XC8. Siamo passati dall'installazione di MPLABX all'utilizzo di un LCD con PIC MCU. Se sei nuovo qui, guarda i tutorial precedenti dove puoi imparare timer, LED lampeggianti, interfacciamento LCD ecc. Puoi trovare tutti i nostri tutorial PIC qui. Nel nostro ultimo tutorial abbiamo visto come possiamo generare caratteri personalizzati con il nostro display LCD 16 * 2, ora dotiamoci di un altro tipo di modulo display chiamato display a 7 segmenti e interfacciatelo con il microcontrollore PIC.

Sebbene l'LCD 16x2 sia molto più comodo del display a 7 segmenti, ma ci sono pochi scenari in cui un display a 7 segmenti sarebbe più comodo di un display LCD. L'LCD soffre dello svantaggio di avere una dimensione dei caratteri bassa e sarà eccessivo per il tuo progetto se hai solo intenzione di visualizzare alcuni valori numerici. I 7 segmenti hanno anche il vantaggio in condizioni di scarsa illuminazione e possono essere visualizzati da angolazioni maggiori rispetto a un normale schermo LCD. Quindi, iniziamo a conoscerlo.

Modulo display a 7 segmenti a 7 segmenti e 4 cifre:

Il display a 7 segmenti ha sette segmenti e ogni segmento ha un LED al suo interno per visualizzare i numeri illuminando i segmenti corrispondenti. Ad esempio, se si desidera che i 7 segmenti mostrino il numero "5", è necessario illuminare i segmenti a, f, g, ce d rendendo alti i pin corrispondenti. Ci sono due tipi di display a 7 segmenti: Common Cathode e Common Anode, qui stiamo usando il display Common Cathode a sette segmenti. Ulteriori informazioni sul display a 7 segmenti qui.

Ora sappiamo come visualizzare il nostro carattere numerico desiderato su un singolo display a 7 segmenti. Ma è abbastanza evidente che avremmo bisogno di più di un display a 7 segmenti per trasmettere qualsiasi informazione che sia più di una cifra. Quindi, in questo tutorial utilizzeremo un modulo di visualizzazione a 7 segmenti a 4 cifre come mostrato di seguito.

Come possiamo vedere, ci sono quattro display a sette segmenti collegati insieme. Sappiamo che ogni modulo a 7 segmenti avrà 10 pin e per 4 display a sette segmenti ci sarebbero 40 pin in totale e sarebbe frenetico per chiunque saldarli su una scheda a punti, quindi consiglio vivamente a chiunque di acquistare un modulo oppure crea il tuo PCB per utilizzare un display a 7 segmenti a 4 cifre. Lo schema di connessione per lo stesso è mostrato di seguito:

Per capire come funziona il modulo a sette segmenti a 4 cifre, dobbiamo esaminare gli schemi sopra, come mostrato, i pin A di tutti e quattro i display sono collegati per riunirsi come uno A e lo stesso per B, C… Quindi, fondamentalmente se il trigger A è attivato, tutte e quattro le A dovrebbero andare alte, giusto?

Ma questo non accade. Abbiamo quattro pin aggiuntivi da D0 a D3 (D0, D1, D2 e ​​D3) che possono essere utilizzati per controllare quale display dei quattro dovrebbe andare in alto. Ad esempio: se ho bisogno che il mio output sia presente solo sul secondo display, solo D1 dovrebbe essere alto mantenendo gli altri pin (D0, D2 e ​​D3) più bassi. Semplicemente possiamo selezionare quale display deve diventare attivo utilizzando i pin da D0 a D3 e quale carattere visualizzare utilizzando i pin da A a DP.

Collegamento del modulo a sette segmenti a 4 cifre con il microcontrollore PIC:

Qui abbiamo usato il microcontrollore PIC PIC16F877A e lo schema del circuito è mostrato sotto.

Abbiamo 12 pin di uscita dal modulo di cui 8 vengono utilizzati per visualizzare i caratteri e quattro per selezionare un display su quattro. Quindi tutti gli 8 pin di caratteri vengono assegnati a PORTD e i pin di selezione del display vengono assegnati ai primi quattro pin di PORTC.

Nota: anche il pin di terra del modulo deve essere collegato alla massa dell'MCU che non è mostrata qui.

Programmazione utilizzando PIC16F877A:

Ora che sappiamo come funziona effettivamente questo modulo, impariamo come programmare PIC16F877A in modo che visualizzi un numero di 4 cifre. Incrementiamo una variabile da 0 a 1000 e stampiamola sul display a 7 segmenti. Avvia il programma MPLABX e crea un nuovo progetto, iniziamo con i bit di configurazione.

#pragma config FOSC = HS // Bit di selezione dell'oscillatore (oscillatore HS) #pragma config WDTE = OFF // Bit di abilitazione del timer watchdog (WDT disabilitato) #pragma config PWRTE = ON // Bit di abilitazione del timer di accensione (PWRT abilitato) # pragma config BOREN = ON // Bit di abilitazione reset brown-out (BOR abilitato) #pragma config LVP = OFF // Bit di abilitazione programmazione seriale in-circuit a bassa tensione (alimentazione singola) (RB3 è I / O digitale, HV on MCLR deve essere utilizzato per la programmazione) #pragma config CPD = OFF // Bit di protezione codice memoria EEPROM dati (protezione codice EEPROM dati disattivata) #pragma config WRT = OFF // Bit di abilitazione scrittura memoria programma flash (protezione da scrittura disattivata; tutta la memoria programma può essere scritto dal controllo EECON) #pragma config CP = OFF // Bit di protezione del codice della memoria del programma Flash (protezione del codice disattivata)

Come al solito usiamo la finestra set configuration bits per impostare questi bit. Se non sei sicuro di cosa significano, visita il tutorial sul lampeggiamento dei LED qui.

Definiamo quindi i pin di uscita per passare da una cifra all'altra del display.

// *** Definisci i pin del segnale di tutti e quattro i display *** // #define s1 RC0 #define s2 RC1 #define s3 RC2 #define s4 RC3 // *** Fine della definizione ** ////

Qui i pin RC0, RC1, RC2 e RC3 vengono utilizzati per selezionare tra le quattro cifre del nostro modulo display a 7 segmenti. Questi pin sono definiti rispettivamente come s1, s2, s3 e s4.

Passiamo quindi a void main (), all'interno del quale abbiamo la seguente dichiarazione di variabile:

int i = 0; // il valore a 4 cifre che deve essere visualizzato int flag = 0; // per creare un ritardo senza segno int a, b, c, d, e, f, g, h; // solo variabili unsigned int seg = {0X3F, // valore esadecimale per visualizzare il numero 0 0X06, // valore esadecimale per visualizzare il numero 1 0X5B, // valore esadecimale per visualizzare il numero 2 0X4F, // valore esadecimale da visualizzare il numero 3 0X66, // Valore esadecimale per visualizzare il numero 4 0X6D, // Valore esadecimale per visualizzare il numero 5 0X7C, // Valore esadecimale per visualizzare il numero 6 0X07, // Valore esadecimale per visualizzare il numero 7 0X7F, / / Valore esadecimale per visualizzare il numero 8 0X6F // Valore esadecimale per visualizzare il numero 9}; // End of Array per visualizzare i numeri da 0 a 9

Qui le variabili i e bandiera vengono utilizzate per memorizzare i valori da visualizzare e creare un ritardo rispettivamente. Le variabili intere senza segno da a ad h vengono utilizzate per suddividere i numeri a quattro cifre in singole cifre e memorizzarli (che verrà spiegato più avanti qui).

Una cosa fondamentale da notare qui è la dichiarazione dell'array "seg" . In questo programma stiamo usando un nuovo tipo di dati chiamato Array. Array non è altro che una raccolta di valori di tipi di dati simili. Qui, abbiamo usato questo array per memorizzare tutti i valori esadecimali equivalenti per la visualizzazione di un numero da 0 a 9.

L'indirizzo dell'array inizia sempre da zero. Quindi questo array avrà il valore esadecimale di un numero numerico (0-9) memorizzato nell'indirizzo che è uguale a quello del numero come mostrato di seguito

Variabile:	seg	seg	seg	seg	seg	seg	seg	seg	seg	seg
Codice esadecimale:	0X3F	0X06	0X5B	0X4F	0X66	0X6D	0X7C	0X07	0X7F	0X6F
Eq. Numero numerico:	0	1	2	3	4	5	6	7	8	9

Quindi, semplicemente, se vuoi mostrare il numero 0 sul tuo 7 segmenti puoi chiamare seg, allo stesso modo se vuoi mostrare il numero 6 devi solo usare seg.

Per capire come è stato effettivamente ottenuto il valore HEX, esaminiamo la tabella sottostante. Il valore HEX equivalente per ogni numero decimale viene memorizzato nella matrice in modo che possa essere chiamato per visualizzare un numero particolare.

Ora, passiamo alla parte successiva del codice che è la configurazione I / O:

// ***** Configurazione I / O **** // TRISC = 0X00; PORTC = 0X00; TRISD = 0x00; PORTD = 0X00; // *** Fine della configurazione I / O ** ///

La configurazione I / O è semplice perché tutti i pin sui nostri 7 segmenti sono pin di uscita e le connessioni sono mostrate nello schema circuitale sopra, quindi è sufficiente dichiararle come uscite e inizializzarle a zero.

Ora saltiamo nel nostro ciclo infinito (while (1)). Qui dobbiamo dividere il valore di "i" in quattro cifre e visualizzarle sui 7 segmenti. Per prima cosa iniziamo dividendo il valore su "i"

// *** Dividere la "i" in quattro cifre *** // a = i% 10; // la quarta cifra viene salvata qui b = i / 10; c = b% 10; // la terza cifra viene salvata qui d = b / 10; e = d% 10; // La seconda cifra viene salvata qui f = d / 10; g = f% 10; // la prima cifra viene salvata qui h = f / 10; // *** Fine della divisione *** //

Utilizzando il modulo semplice e l'operazione di divisione, il numero a 4 cifre (i) viene separato in numeri individuali. Nel nostro caso prendiamo un esempio in cui il valore di "i" è 4578. Quindi alla fine di questo processo la variabile g = 4, e = 5, c = 7 e a = 8. Quindi ora sarà facile visualizzare ogni cifra semplicemente usando quella variabile.

PORTD = seg; s1 = 1; // Accende il display 1 e stampa la 4a cifra __delay_ms (5); s1 = 0; // Spegne il display 1 dopo 5 ms di ritardo PORTD = seg; s2 = 1; // Accende il display 2 e stampa la terza cifra __delay_ms (5); s2 = 0; // Spegne il display 2 dopo 5 ms di ritardo PORTD = seg; s3 = 1; // Accende il display 3 e stampa la seconda cifra __delay_ms (5); s3 = 0; // Spegne il display 3 dopo 5 ms di ritardo PORTD = seg; s4 = 1; // Accende il display 4 e stampa la prima cifra __delay_ms (5); s4 = 0; // Spegne il display 4 dopo 5 ms di ritardo

Questo è il luogo effettivo in cui l'MCU parla con il 7-segmento. Come sappiamo possiamo visualizzare solo una cifra alla volta, ma abbiamo quattro cifre da visualizzare e solo se tutte e quattro le cifre sono On il numero completo di quattro cifre sarà visibile all'utente.

Allora, come andiamo con questo?

Fortunatamente per noi il nostro MCU è molto più veloce di un occhio umano, quindi quello che facciamo effettivamente: mostriamo una cifra alla volta ma lo facciamo molto velocemente come mostrato sopra.

Selezioniamo una cifra visualizzata per attendere 5 ms in modo che l'MCU e il segmento 7 possano elaborarla, quindi disattivare quella cifra e passare alla cifra successiva e fare lo stesso fino a raggiungere l'ultima cifra. Questo ritardo di 5 ms non può essere osservato da un occhio umano e tutte e quattro le cifre sembrano essere attive contemporaneamente.

Questo è tutto, finalmente incrementiamo semplicemente il valore della cifra visualizzata usando un ritardo come mostrato di seguito

if (flag> = 100) // aspetta che il flag raggiunga 100 {i ++; flag = 0; // solo se il flag è cento "i" verrà incrementato} flag ++; // incrementa il flag per ogni flash

Il ritardo viene utilizzato in modo che il tempo impiegato per passare da un numero all'altro sia abbastanza lungo da farci notare il cambiamento.

Il codice completo è fornito di seguito e il processo è spiegato anche nel video alla fine.

Configurazione e test hardware:

Come sempre, simuliamo il programma usando Proteus prima di andare effettivamente con il nostro hardware. Se la simulazione ha successo dovresti vedere qualcosa di simile

Questo progetto non ha alcuna configurazione hardware complicata, stiamo nuovamente utilizzando la stessa scheda microcontrollore PIC che abbiamo creato nel Tutorial lampeggiante LED. Basta collegare il modulo a 7 segmenti con la scheda microcontrollore PIC secondo lo schema di collegamento. Una volta che hai finito con le connessioni, scarica semplicemente il codice usando il tuo programmatore PicKit 3 e goditi il ​​tuo output.