7 Segment display grænseflade med pic mikrocontroller

Dette er vores 8. tutorial af PIC-mikrocontrollere, der lærer MPLAB og XC8. Vi er kommet op hele vejen fra installation af MPLABX til brug af et LCD med PIC MCU. Hvis du er ny her, så se på tidligere tutorials, hvor du kan lære timere, blinkende LED, grænseflade mellem LCD osv. Du kan finde alle vores PIC-tutorials her. I vores sidste vejledning så vi, hvordan vi kan generere brugerdefinerede tegn med vores 16 * 2 LCD-skærm, lad os nu udstyre os med en anden type skærmmodul kaldet 7-segment display og interface det med PIC Microcontroller.

Selvom 16x2 LCD er meget mere behagelig end 7-segment display, men der er få scenarier, hvor en 7-segment skærm ville komme lettere end en LCD-skærm. LCD lider af ulempen ved at have lav karakterstørrelse og vil være overkill for dit projekt, hvis du bare planlægger at vise nogle numeriske værdier. 7-segmenter har også fordelen mod dårlig belysningstilstand og kan ses fra lagervinkler end en normal LCD-skærm. Så lad os begynde at vide det.

7-segment og 4-cifret 7-segment display modul:

7 Segment Display har syv segmenter i sig, og hvert segment har en LED indeni for at vise tallene ved at belyse de tilsvarende segmenter. Ligesom hvis du vil have 7-segmentet til at vise tallet "5", skal du gløde segment a, f, g, c og d ved at gøre deres tilsvarende stifter høje. Der er to typer 7-segment skærme: Common Cathode og Common Anode, her bruger vi Common Cathode syv segment display. Lær mere om 7-segmentvisning her.

Nu ved vi, hvordan vi viser vores ønskede numeriske tegn på et enkelt 7-segment display. Men det er ret tydeligt, at vi har brug for mere end et 7-segment display for at formidle information, der er mere end et ciffer. Så i denne vejledning bruger vi et 4-cifret 7-segment display modul som vist nedenfor.

Som vi kan se, er der fire syv segmentskærme forbundet sammen. Vi ved, at hvert 7-segment-modul vil have 10 ben og for 4 syv segment-skærme vil der være 40 ben i alt, og det ville være hektisk for alle at lodde dem på et prikbræt, så jeg vil meget anbefale nogen at købe et modul eller lav dit eget printkort til brug af et 4-cifret 7-segment display. Forbindelsesskemaet for det samme er vist nedenfor:

For at forstå hvordan 4-cifret syv segmentmodul fungerer, skal vi se på ovenstående skemaer, som vist er A-stifterne på alle fire skærme forbundet til at samles som en A og den samme for B, C…. op til DP. Så hvis udløseren A er slået til, så skal alle fire A'er gå højt, ikke?

Men det sker ikke. Vi har yderligere fire ben fra D0 til D3 (D0, D1, D2 og D3), som kan bruges til at kontrollere, hvilken skærm ud af de fire skal gå højt. For eksempel: Hvis jeg kun har brug for, at min output er til stede på det andet display, skal kun D1 gøres højt, mens andre ben (D0, D2 og D3) holdes så lave. Vi kan ganske enkelt vælge, hvilket display der skal gå aktivt ved hjælp af benene fra D0 til D3, og hvilket tegn der skal vises ved hjælp af benene fra A til DP.

Tilslutning af 4-cifret syv segmentmodul med PIC Microcontroller:

Her har vi brugt PIC-mikrocontroller PIC16F877A, og skematisk for kredsløbet er vist nedenfor.

Vi har 12 outputstifter fra modulet, hvoraf 8 bruges til at vise tegnene og fire bruges til at vælge en skærm ud af fire. Derfor tildeles alle de 8 tegnstifter til PORTD, og ​​visningsvalgstifterne tildeles de første fire stifter i PORTC.

Bemærk: Jordstiften på modulet skal også forbindes til jorden på MCU'en, som ikke er vist her.

Programmering ved hjælp af PIC16F877A:

Nu hvor vi ved, hvordan dette modul rent faktisk fungerer, så lad os lære at programmere PIC16F877A for at få det til at vise et 4-cifret nummer. Lad os øge en variabel fra 0 til 1000 og udskrive den på 7-segment displayet. Start MPLABX-programmet og opret nyt projekt, lad os starte med konfigurationsbits.

#pragma config FOSC = HS // Oscillator Selection bits (HS oscillator) #pragma config WDTE = OFF // Watchdog Timer Enable bit (WDT deaktiveret) # 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 er digital I / O, HV til MCLR skal bruges til 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 program memory) kan skrives til af EECON-kontrol) #pragma config CP = OFF // Flash Program Memory Code Protection bit (Code protection off)

Som sædvanligt bruger vi indstillingsvinduet til at konfigurere disse bits. Hvis du ikke er sikker på, hvad de betyder, skal du besøge LED-blinkende tutorial her.

Lad os derefter definere outputstifterne til at skifte mellem hvert ciffer på skærmen.

// *** Definer signalstifterne på alle fire skærme *** // #define s1 RC0 #define s2 RC1 #define s3 RC2 #define s4 RC3 // *** End of definition ** ////

Her bruges benene RC0, RC1, RC2 og RC3 til at vælge mellem de fire cifre i vores 7-segment displaymodul. Disse ben er defineret som henholdsvis s1, s2, s3 og s4.

Lad os derefter hoppe ind i ugyldig main (), hvori vi har følgende variabeldeklaration:

int i = 0; // den firecifrede værdi, der skal vises int flag = 0; // til oprettelse af forsinkelse usigneret int a, b, c, d, e, f, g, h; // bare variabler usigneret int seg = {0X3F, // Hex-værdi for at få vist tallet 0 0X06, // Hex-værdi for at vise tallet 1 0X5B, // Hex-værdi for at vise tallet 2 0X4F, // Hex-værdi for at vise tallet 3 0X66, // Hex-værdi for at få vist tallet 4 0X6D, // Hex-værdi for at vise tallet 5 0X7C, // Hex-værdi for at få vist nummeret 6 0X07, // Hex-værdi for at vise tallet 7 0X7F, / / Hex-værdi for at få vist tallet 8 0X6F // Hex-værdi for at få vist tallet 9}; // End of Array for visning af numre fra 0 til 9

Her bruges variablerne i og flag til lagring af de værdier, der skal vises, og til at skabe en forsinkelse. De usignerede heltalsvariabler a til h bruges til at opdele de firecifrede tal i enkelt cifre og gemme dem (som forklares senere her).

En vigtig ting at bemærke her er "seg" array-erklæringen. I dette program bruger vi en ny datatype kaldet Array. Array er intet andet end en samling af lignende datatypeværdier. Her har vi brugt denne matrix til at gemme alle de tilsvarende hex-værdier til visning af et tal fra 0 til 9.

Adressen til arrayet starter altid fra nul. Så denne matrix vil have den hex-værdi af et numerisk tal (0-9) gemt i adressen, der er den samme som 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
Ligning Numerisk nummer:	0	1	2	3	4	5	6	7	8	9

Så simpelthen, hvis du vil vise nummeret 0 på dit 7-segment, kan du ringe til seg, ligesom hvis du vil vise nummeret 6, skal du bare bruge seg.

For at forstå, hvordan HEX-værdien faktisk blev opnået, lad os se på nedenstående tabel. Den ækvivalente HEX-værdi for hvert decimaltal er gemt i arrayet, så det kan kaldes til at vise et bestemt nummer.

Lad os nu gå videre til den næste del af koden, som er I / O-konfigurationen:

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

I / O-konfiguration er enkel, fordi alle stifterne på vores 7-segment er outputstifter, og forbindelserne er vist i kredsløbsdiagrammet ovenfor, så erklær dem simpelthen som output og initialiser dem til nul.

Lad os nu springe ind i vores uendelige løkke (mens (1)). Her skal vi opdele værdien af ​​"i" i fire cifre og vise dem på 7-segmentet. Lad os først starte med at opdele værdien på "i"

// *** Opdeling af "i" i fire cifre *** // a = i% 10; // 4. ciffer gemmes her b = i / 10; c = b% 10; // 3. ciffer gemmes her d = b / 10; e = d% 10; // 2. ciffer gemmes her f = d / 10; g = f% 10; // 1. ciffer gemmes her h = f / 10; // *** Afslutning af opdeling *** //

Ved at bruge enkel modul og opdeling er det 4-cifrede nummer (i) adskilt i individuelle tal. Lad os i vores tilfælde tage et eksempel, hvor værdien af ​​"i" er 4578. Derefter i slutningen af ​​denne proces er variablen g = 4, e = 5, c = 7 og a = 8. Så nu vil det være let at vise hvert ciffer ved blot at bruge den variabel.

PORTD = seg; s1 = 1; // Tænd display 1 og udskriv 4. cifret __forsink_ms (5); s1 = 0; // Sluk display 1 efter 5 ms forsinkelse PORTD = seg; s2 = 1; // Tænd display 2 og udskriv 3. ciffer __forsink_ms (5); s2 = 0; // Sluk for display 2 efter 5 ms forsinkelse PORTD = seg; s3 = 1; // Tænd display 3 og udskriv 2. ciffer __forsink_ms (5); s3 = 0; // Sluk display 3 efter 5ms forsinkelse PORTD = seg; s4 = 1; // Tænd display 4 og udskriv 1. ciffer __forsink_ms (5); s4 = 0; // Sluk display 4 efter 5 ms forsinkelse

Dette er det faktiske sted, hvor MCU taler med 7-segmentet. Som vi ved, kan vi kun vise et ciffer ad gangen, men vi har fire cifre, der skal vises, og kun hvis alle de fire cifre er på, vil det komplette firecifrede nummer være synligt for brugeren.

Så hvordan går vi med dette?

Heldig for os er vores MCU meget hurtigere end et menneskeligt øje, så hvad vi faktisk gør: vi viser et ciffer ad gangen, men vi gør det meget hurtigt som vist ovenfor.

Vi vælger et cifret display, det venter i 5 ms, så MCU og 7-segmentet kan behandle det og derefter slukke for dette ciffer og gå videre til det næste ciffer og gøre det samme, indtil vi når det sidste ciffer. Denne forsinkelse på 5 ms kan ikke observeres af et menneskeligt øje, og alle de fire cifre syntes at være On på samme tid.

Det er det, endelig øger vi bare værdien af ​​det viste ciffer ved hjælp af en forsinkelse som vist nedenfor

hvis (flag> = 100) // vent indtil flag når 100 {i ++; flag = 0; // kun hvis flag er hundrede vil "i" blive forøget} flag ++; // inkrementflag for hver flash

Forsinkelsen bruges, så den tid det tager at skifte fra et nummer til et andet er lang nok til, at vi kan lægge mærke til ændringen.

Den komplette kode er angivet nedenfor, og processen forklares også i videoen i slutningen.

Opsætning og test af hardware:

Lad os som altid simulere programmet ved hjælp af Proteus, før vi rent faktisk går med vores hardware. Hvis simuleringen er vellykket, skal du se noget lignende

Dette projekt har ingen kompliceret hardwareopsætning, vi bruger igen det samme PIC Microcontroller-kort, som vi har oprettet i LED blinkende vejledning. Tilslut simpelthen 7-segmentmodulet med dit PIC Microcontroller-kort i henhold til tilslutningsdiagrammet. Når du er færdig med forbindelserne, skal du blot dumpe koden ved hjælp af din PicKit 3-programmør, og det er det, nyd din output.