7 Gränssnitt för skärmsegment med pic-mikrokontroller

Detta är vår åttonde handledning om inlärning av PIC-mikrokontroller med MPLAB och XC8. Vi har kommit upp hela vägen från att installera MPLABX till att använda en LCD med PIC MCU. Om du är ny här, titta på tidigare handledning där du kan lära dig timers, blinkande lysdiod, gränssnitt mellan LCD osv. Du hittar alla våra PIC-handledning här. I vår senaste handledning såg vi hur vi kan skapa anpassade tecken med vår 16 * 2 LCD-skärm, låt oss nu utrusta oss med en annan typ av skärmmodul som kallas 7-segmentsdisplayen och gränssnitt den med PIC Microcontroller.

Även om 16x2 LCD är mycket bekvämare än 7-segmentsdisplay, men det finns få scenarier där en 7-segmentsdisplay skulle komma bättre än en LCD-skärm. LCD lider av nackdelen med att ha låg karaktärsstorlek och kommer att vara överdriven för ditt projekt om du bara planerar att visa några numeriska värden. 7-segment har också fördelen mot dåligt ljusförhållande och kan ses från lagervinklar än en vanlig LCD-skärm. Så, låt oss börja veta det.

7-segment och 4-siffrig 7-segment displaymodul:

7 Segment Display har sju segment i sig och varje segment har en LED inuti för att visa siffrorna genom att lysa upp motsvarande segment. Som om du vill att 7-segmentet ska visa siffran "5" måste du lysa segment a, f, g, c och d genom att göra motsvarande stift höga. Det finns två typer av 7-segment skärmar: Common Cathode och Common Anode, här använder vi Common Cathode sju segment display. Läs mer om 7-segmentsvisning här.

Nu vet vi hur vi visar vår önskade numeriska karaktär på en enda 7-segmentskärm. Men det är ganska uppenbart att vi skulle behöva mer än en 7-segmentsdisplay för att förmedla all information som är mer än en siffra. Så i den här handledningen kommer vi att använda en fyrsiffrig 7-segment displaymodul som visas nedan.

Som vi kan se finns Four Seven Segment Displays kopplade ihop. Vi vet att varje 7-segmentsmodul kommer att ha 10 stift och för 4 sju segmentskärmar skulle det finnas totalt 40 stift och det skulle vara hektiskt för vem som helst att löda dem på ett prickbräda, så jag rekommenderar starkt någon att köpa en modul eller skapa ditt eget kretskort för att använda en fyrsiffrig 7-segmentsdisplay. Anslutningsschemat för detsamma visas nedan:

För att förstå hur fyrsiffrig sju segmentmodul fungerar måste vi titta på ovanstående scheman, som visas är A-stiften på alla fyra skärmarna anslutna för att samlas som en A och samma för B, C…. upp till DP. Så, i grund och botten om utlösare A är på, ska alla fyra A gå högt, eller hur?

Men det händer inte. Vi har ytterligare fyra stift från D0 till D3 (D0, D1, D2 och D3) som kan användas för att styra vilken bild av de fyra som ska gå högt. Till exempel: Om jag behöver att min utdata bara ska finnas på den andra skärmen, ska endast D1 göras högt medan andra stift (D0, D2 och D3) hålls så låga. Vi kan helt enkelt välja vilken skärm som ska gå aktivt med hjälp av stiften från D0 till D3 och vilket tecken som ska visas med stiften från A till DP.

Ansluter fyrsiffrig sju segmentmodul med PIC-mikrokontroller:

Här har vi använt PIC-mikrokontroller PIC16F877A och schemat för kretsen visas nedan.

Vi har 12 utgångsstift från modulen, varav 8 används för att visa tecknen och fyra används för att välja en bild av fyra. Följaktligen tilldelas alla de 8 teckennålarna till PORTD och visningsvalsnålarna tilldelas de första fyra stiften i PORTC.

Obs! Modulens jordstift ska också anslutas till MCU: s jord som inte visas här.

Programmering med PIC16F877A:

Nu när vi vet hur den här modulen faktiskt fungerar, låt oss lära oss hur man programmerar PIC16F877A så att den visar ett fyrsiffrigt nummer. Låt oss öka en variabel från 0 till 1000 och skriva ut den på 7-segmentet. Starta MPLABX-programmet och skapa ett nytt projekt, låt oss börja med konfigurationsbitarna.

#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 är digital I / O, HV på MCLR måste användas för 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 skrivas till av EECON-kontroll) #pragma config CP = OFF // Flash Program Memory Code Protection bit (Code protection off)

Som vanligt använder vi fönstret för inställning av konfigurationsbitar för att ställa in dessa bitar. Om du inte är säker på vad de menar, besök sedan LED-lampan som blinkar här.

Låt oss sedan definiera utgångsstiften för att växla mellan varje siffra på skärmen.

// *** Definiera signalstiftarna på alla fyra skärmarna *** // #define s1 RC0 #define s2 RC1 #define s3 RC2 #define s4 RC3 // *** Definitionens slut ** ////

Här används stiften RC0, RC1, RC2 och RC3 för att välja mellan de fyra siffrorna i vår 7-segment displaymodul. Dessa stift definieras som s1, s2, s3 respektive s4.

Låt oss sedan hoppa in i void main (), inom vilken vi har följande variabeldeklaration:

int i = 0; // det fyrsiffriga värdet som ska visas int flag = 0; // för att skapa fördröjning osignerad int a, b, c, d, e, f, g, h; // bara variabler osignerade int seg = {0X3F, // Hex-värde för att visa siffran 0 0X06, // Hex-värde för att visa numret 1 0X5B, // Hex-värde för att visa numret 2 0X4F, // Hex-värde för att visa siffran 3 0X66, // Hex-värde för att visa numret 4 0X6D, // Hex-värde för att visa numret 5 0X7C, // Hex-värde för att visa numret 6 0X07, // Hex-värde för att visa numret 7 0X7F, / / Hex-värde för att visa siffran 8 0X6F // Hex-värde för att visa numret 9}; // End of Array för att visa siffror från 0 till 9

Här används variablerna i och flaggan för att lagra värdena som ska visas och skapa en fördröjning. De osignerade heltalsvariablerna a till h används för att dela upp de fyrsiffriga siffrorna i enstaka siffror och lagra dem (vilket kommer att förklaras senare här).

En viktig sak att notera här är "seg" arraydeklarationen . I det här programmet använder vi en ny datatyp som heter Array. Array är inget annat än en samling av liknande datatypsvärden. Här har vi använt den här matrisen för att lagra alla motsvarande hex-värden för att visa ett tal från 0 till 9.

Adressen till matrisen börjar alltid från noll. Så den här matrisen kommer att ha hex-värdet för ett numeriskt nummer (0-9) lagrat i adressen som är samma som numret som visas nedan

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

Så enkelt, om du vill visa numret 0 på ditt 7-segment kan du ringa seg, om du också vill visa numret 6 måste du bara använda seg.

För att förstå hur HEX-värdet faktiskt erhölls, låt oss titta på tabellen nedan. Den ekvivalenta HEX värde för varje decimalnummer lagras i arrayen så att den kan kallas för att visa ett särskilt nummer.

Låt oss gå vidare till nästa del av koden som är I / O-konfigurationen:

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

I / O-konfigurationen är enkel eftersom alla stiften på vårt 7-segment är utgående stift, och anslutningarna visas i kopplingsschemat ovan, så deklarera dem helt enkelt som utgångar och initialisera dem till noll.

Låt oss nu hoppa in i vår oändliga slinga (medan (1)). Här måste vi dela upp värdet på "i" i fyra siffror och visa dem på 7-segmentet. Låt oss först börja med att dela upp värdet på "i"

// *** Dela "i" i fyra siffror *** // a = i% 10; // Fjärde siffran sparas här b = i / 10; c = b% 10; // 3: e siffran sparas här d = b / 10; e = d% 10; // 2: a siffran sparas här f = d / 10; g = f% 10; // 1: a siffran sparas här h = f / 10; // *** Delningens slut *** //

Genom att använda enkel modul och delning är det 4-siffriga numret (i) uppdelat i individuella nummer. Låt oss i vårt fall ta ett exempel där värdet "i" är 4578. Sedan i slutet av denna process är variabeln g = 4, e = 5, c = 7 och a = 8. Så nu blir det enkelt att visa varje siffra genom att helt enkelt använda den variabeln.

PORTD = seg; s1 = 1; // Slå PÅ display 1 och skriv ut 4: e siffran __delay_ms (5); s1 = 0; // Stäng av display 1 efter 5 ms fördröjning PORTD = seg; s2 = 1; // Slå PÅ display 2 och skriv ut 3: e siffran __delay_ms (5); s2 = 0; // Stäng AV display 2 efter 5 ms fördröjning PORTD = seg; s3 = 1; // Slå på display 3 och skriv ut andra siffran __fördröjning_ms (5); s3 = 0; // Stäng av display 3 efter 5 ms fördröjning PORTD = seg; s4 = 1; // Slå på display 4 och skriv ut 1: a siffran __fördröjning_ms (5); s4 = 0; // Stäng av display 4 efter 5 ms fördröjning

Detta är den faktiska platsen där MCU pratar med 7-segmentet. Som vi vet kan vi bara visa en siffra åt gången, men vi har fyra siffror som ska visas och bara om alla fyra siffrorna är på kommer hela fyrsiffriga numret att visas för användaren.

Så, hur går vi med det här?

Tur för oss att vår MCU är mycket snabbare än ett mänskligt öga, så vad vi faktiskt gör: vi visar en siffra i taget men vi gör det väldigt snabbt som visas ovan.

Vi väljer en siffra för att vänta i 5 ms så att MCU och 7-segmentet kan bearbeta den och sedan stänga av den siffran och gå vidare till nästa siffra och göra detsamma tills vi når den sista siffran. Denna fördröjning på 5 ms kan inte observeras av ett mänskligt öga och alla de fyra siffrorna verkade vara På samtidigt.

Det är det, äntligen ökar vi bara värdet på den visade siffran med en fördröjning som visas nedan

om (flagga> = 100) // vänta tills flaggan når 100 {i ++; flagga = 0; // endast om flaggan är hundra kommer "i" att ökas} flagga ++; // inkrementflagga för varje blixt

Förseningen används så att tiden det tar för att byta från ett nummer till ett annat är tillräckligt lång för att vi ska märka förändringen.

Den fullständiga koden ges nedan och processen förklaras också i videon i slutet.

Installation och testning av hårdvara:

Låt oss som alltid simulera programmet med Proteus innan vi faktiskt går med vår hårdvara. Om simuleringen lyckas borde du se något liknande

Detta projekt har ingen komplicerad hårdvaruinstallation, vi använder igen samma PIC Microcontroller-kort som vi har skapat i LED-blinkande handledning. Anslut helt enkelt 7-segmentmodulen till ditt PIC Microcontroller-kort enligt anslutningsdiagrammet. När du är klar med anslutningarna, dumpar du bara koden med din PicKit 3-programmerare och det är det som du njuter av din produktion.