7 Grensesnitt for segmentskjerm med pic-mikrokontroller

Dette er vår 8. opplæring om å lære PIC-mikrokontrollere ved hjelp av MPLAB og XC8. Vi har kommet opp helt fra å installere MPLABX til å bruke en LCD med PIC MCU. Hvis du er ny her, så se på tidligere opplæringsprogrammer der du kan lære timere, blinkende LED, grensesnitt LCD osv. Du finner alle våre PIC-veiledninger her. I vår siste veiledning så vi hvordan vi kan generere egendefinerte tegn med vår 16 * 2 LCD-skjerm, la oss nå utstyre oss med en annen type skjermmodul kalt 7-segmentskjerm og grensesnitt den med PIC Microcontroller.

Selv om 16x2 LCD er mye mer behagelig enn 7-segment skjerm, men det er få scenarier der en 7-segment skjerm ville komme lettere enn en LCD-skjerm. LCD lider av ulempen med å ha lav tegnstørrelse og vil være for mye for prosjektet ditt hvis du bare planlegger å vise noen numeriske verdier. 7-segmenter har også fordelen mot dårlig lysforhold og kan sees fra lagervinkler enn en vanlig LCD-skjerm. Så la oss begynne å vite det.

7-segment og 4-sifret 7-segment skjermmodul:

7 Segment Display har syv segmenter i seg, og hvert segment har en LED inni for å vise tallene ved å lyse opp de tilsvarende segmentene. Som om du vil at 7-segmentet skal vise tallet "5", må du gløde segment a, f, g, c og d ved å gjøre de tilsvarende pinnene høye. Det er to typer 7-segment skjermer: Common Cathode og Common Anode, her bruker vi Common Cathode syv segment display. Lær mer om 7 segmentvisning her.

Nå vet vi hvordan vi kan vise ønsket numerisk tegn på en enkelt 7-segment skjerm. Men det er ganske tydelig at vi trenger mer enn ett 7-segment display for å formidle informasjon som er mer enn ett siffer. Så i denne opplæringen bruker vi en firesifret 7-segment displaymodul som vist nedenfor.

Som vi kan se er det Four Seven Segment Displays koblet sammen. Vi vet at hver 7-segmentmodul vil ha 10 pinner, og for 4 syv segmentdisplayer vil det være 40 pinner totalt, og det vil være hektisk for alle å lodde dem på et prikkbrett, så jeg vil anbefale alle å kjøpe en modul eller lag din egen PCB for å bruke en firesifret 7-segment skjerm. Tilkoblingsskjemaet for det samme er vist nedenfor:

For å forstå hvordan firesifret syv-segmentmodul fungerer, må vi se på skjemaene ovenfor, som vist er A-pinnene på alle fire skjermene koblet til for å samles som en A og den samme for B, C…. opp til DP. Så hvis utløser A er på, så burde alle fire Aene gå høyt, ikke sant?

Men det skjer ikke. Vi har ytterligere fire pinner fra D0 til D3 (D0, D1, D2 og D3) som kan brukes til å kontrollere hvilken skjerm av de fire som skal gå høyt. For eksempel: Hvis jeg trenger at utdataene mine bare er til stede på den andre skjermen, bør bare D1 gjøres høyt mens andre pinner (D0, D2 og D3) holdes så lave. Bare vi kan velge hvilken skjerm som skal gå aktiv ved hjelp av pinnene fra D0 til D3 og hvilket tegn som skal vises ved hjelp av pinnene fra A til DP.

Koble til 4-sifret syv segmentmodul med PIC-mikrokontroller:

Her har vi brukt PIC-mikrokontroller PIC16F877A og skjematisk for kretsen er vist nedenfor.

Vi har 12 utgangspinner fra modulen, hvorav 8 brukes til å vise tegnene og fire brukes til å velge en skjerm av fire. Derfor tildeles alle de 8 tegnpinnene til PORTD, og ​​visningsvalgpinnene tildeles de første fire pinnene i PORTC.

Merk: Jordpinnen på modulen skal også kobles til bakken på MCU som ikke er vist her.

Programmering ved bruk av PIC16F877A:

Nå som vi vet hvordan denne modulen faktisk fungerer, la oss lære hvordan vi programmerer PIC16F877A slik at den viser et firesifret nummer. La oss øke en variabel fra 0 til 1000 og skrive den ut på 7-segmentet. Start MPLABX-programmet og opprett et nytt prosjekt, la oss starte med konfigurasjonsbitene.

#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 is digital I / O, HV on MCLR må brukes for programmering) #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 (Write protection off; all programm memory) kan skrives til av EECON-kontroll) #pragma config CP = OFF // Flash Program Memory Code Protection bit (Code protection off)

Som vanlig bruker vi vinduet angitt konfigurasjonsbiter for å stille disse bitene. Hvis du ikke er sikker på hva de mener, kan du gå til LED-blinkende opplæringen her.

La oss deretter definere utgangspinnene for å veksle mellom hvert siffer på skjermen.

// *** Definer signalpinnene til alle fire skjermer *** // #define s1 RC0 #define s2 RC1 #define s3 RC2 #define s4 RC3 // *** End of definition ** ////

Her brukes pinnene RC0, RC1, RC2 og RC3 til å velge mellom de fire sifrene i vår 7-segment displaymodul. Disse pinnene er definert som henholdsvis s1, s2, s3 og s4.

La oss deretter hoppe inn i ugyldig hoved (), der vi har følgende variabelerklæring:

int i = 0; // den firesifrede verdien som skal vises int flag = 0; // for å lage forsinkelse usignert int a, b, c, d, e, f, g, h; // bare variabler usignert int seg = {0X3F, // Hex-verdi for å vise tallet 0 0X06, // Hex-verdi for å vise tallet 1 0X5B, // Hex-verdi for å vise tallet 2 0X4F, // Hex-verdi for å vise tallet 3 0X66, // Hex-verdi for å vise tallet 4 0X6D, // Hex-verdi for å vise tallet 5 0X7C, // Hex-verdi for å vise tallet 6 0X07, // Hex-verdi for å vise tallet 7 0X7F, / / Hex-verdi for å vise tallet 8 0X6F // Hex-verdi for å vise tallet 9}; // End of Array for visning av tall fra 0 til 9

Her brukes variablene i og flagg for å lagre verdiene som skal vises og skape henholdsvis en forsinkelse. De usignerte heltallvariablene a til h brukes til å dele de firesifrede tallene i enkle sifre og lagre dem (som vil bli forklart senere her).

En viktig ting å merke seg her er "seg" array-erklæringen. I dette programmet bruker vi en ny datatype kalt Array. Array er bare en samling av lignende datatypeverdier. Her har vi brukt denne matrisen til å lagre alle tilsvarende hexverdier for å vise et tall fra 0 til 9.

Adressen til matrisen starter alltid fra null. Så denne matrisen vil ha hexverdien til et numerisk tall (0-9) lagret i adressen som er den samme som for tallet som vist nedenfor

Variabel:	seg	seg	seg	seg	seg	seg	seg	seg	seg	seg
Hex-kode:	0X3F	0X06	0X5B	0X4F	0X66	0X6D	0X7C	0X07	0X7F	0X6F
Ekv. Numerisk nummer:	0	1	2	3	4	5	6	7	8	9

Så rett og slett, hvis du vil vise nummeret 0 på 7-segmentet ditt, kan du ringe seg, og hvis du vil vise nummeret 6, må du bare bruke seg.

For å forstå hvordan HEX-verdien faktisk ble oppnådd, la oss se på tabellen nedenfor. Den ekvivalente HEX-verdien for hvert desimaltall lagres i matrisen slik at den kan kalles til å vise ett bestemt tall.

La oss nå gå videre til neste del av koden som er I / O-konfigurasjonen:

// ***** I / O-konfigurasjon **** // TRISC = 0X00; PORTC = 0X00; TRISD = 0x00; PORTD = 0X00; // *** Slutt på I / O-konfigurasjon ** ///

I / O-konfigurasjon er enkel fordi alle pinnene på vårt 7-segment er utgangspinner, og tilkoblingene er vist i kretsskjemaet ovenfor, så bare erklær dem som utganger og initialiser dem til null.

La oss nå hoppe inn i vår uendelige løkke (mens (1)). Her må vi dele verdien på "i" i fire sifre og vise dem på 7-segmentet. La oss først starte med å dele verdien på "i"

// *** Deling av "i" i fire sifre *** // a = i% 10; // 4. siffer lagres her b = i / 10; c = b% 10; // 3. siffer lagres her d = b / 10; e = d% 10; // 2. siffer lagres her f = d / 10; g = f% 10; // 1. siffer lagres her h = f / 10; // *** Slutten av splitting *** //

Ved å bruke enkel modul og delingsoperasjon er det 4-sifrede tallet (i) skilt inn i individuelle tall. La oss i vårt tilfelle ta et eksempel der verdien av "i" er 4578. Så på slutten av denne prosessen er variabelen g = 4, e = 5, c = 7 og a = 8. Så nå vil det være enkelt å vise hvert siffer ved å bare bruke den variabelen.

PORTD = seg; s1 = 1; // Slå PÅ skjerm 1 og skriv ut 4. siffer __forsink_ms (5); s1 = 0; // Slå AV skjerm 1 etter 5 ms forsinkelse PORTD = seg; s2 = 1; // Slå PÅ skjerm 2 og skriv ut 3. siffer __forsink_ms (5); s2 = 0; // Slå AV skjerm 2 etter 5 ms forsinkelse PORTD = seg; s3 = 1; // Slå PÅ skjerm 3 og skriv ut andre siffer __forsink_ms (5); s3 = 0; // Slå AV display 3 etter 5 ms forsinkelse PORTD = seg; s4 = 1; // Slå PÅ skjerm 4 og skriv ut første siffer __forsink_ms (5); s4 = 0; // Slå AV skjermen 4 etter 5 ms forsinkelse

Dette er det faktiske stedet der MCU snakker med 7-segmentet. Som vi vet kan vi bare vise ett siffer om gangen, men vi har fire sifre som skal vises, og bare hvis alle de fire sifrene er på, vil hele firesifrede nummeret være synlig for brukeren.

Så hvordan går vi med dette?

Heldig for oss er vår MCU veldig raskere enn et menneskelig øye, så hva vi faktisk gjør: vi viser ett siffer om gangen, men vi gjør det veldig raskt som vist ovenfor.

Vi velger ett siffer for å vente på 5 ms, slik at MCU og 7-segmentet kan behandle det, og deretter slå av sifferet og gå videre til neste siffer og gjøre det samme til vi når det siste sifferet. Denne forsinkelsen på 5 ms kan ikke observeres av et menneskelig øye, og alle de fire sifrene så ut til å være På samtidig.

Det er det, til slutt øker vi bare verdien av det viste tallet ved hjelp av en forsinkelse som vist nedenfor

hvis (flagg> = 100) // vent til flagget når 100 {i ++; flag = 0; // bare hvis flagget er hundre, vil "jeg" økes} flagg ++; // økningsflagg for hver blits

Forsinkelsen brukes slik at tiden det tar å bytte fra ett nummer til et annet er lang nok til at vi merker endringen.

Den komplette koden er gitt nedenfor, og prosessen er også forklart i videoen til slutt.

Maskinvareoppsett og testing:

La oss som alltid simulere programmet ved hjelp av Proteus før vi faktisk går med maskinvaren vår. Hvis simuleringen er vellykket, bør du se noe slikt

Dette prosjektet har ikke noe komplisert maskinvareoppsett, vi bruker igjen det samme PIC Microcontroller-kortet som vi har laget i LED blinkende veiledning. Bare koble 7-segmentmodulen til PIC Microcontroller-kortet ditt i henhold til tilkoblingsskjemaet. Når du er ferdig med tilkoblingene, er det bare å dumpe koden ved hjelp av PicKit 3-programmereren, og det er det du kan glede deg over.