7-segment display interface met pic microcontroller

Dit is onze 8e tutorial over het leren van PIC-microcontrollers met MPLAB en XC8. We zijn helemaal begonnen met het installeren van MPLABX tot het gebruik van een LCD met PIC MCU. Als je hier nieuw bent, bekijk dan eerdere tutorials waar je timers, knipperende LED's, interfacing LCD enz. Kunt leren. Je kunt al onze PIC Tutorials hier vinden. In onze laatste tutorial hebben we gezien hoe we aangepaste tekens kunnen genereren met ons 16 * 2 LCD-scherm, laten we ons nu uitrusten met een ander type weergavemodule, het 7-segment-display genaamd, en deze koppelen aan PIC Microcontroller.

Hoewel een 16x2 LCD-scherm veel comfortabeler is dan een 7-segmentbeeldscherm, zijn er maar weinig scenario's waarin een 7-segmentbeeldscherm handiger zou zijn dan een LCD-scherm. LCD heeft het nadeel dat het een lage tekengrootte heeft en zal overdreven zijn voor uw project als u alleen van plan bent om enkele numerieke waarden weer te geven. 7-segmenten hebben ook het voordeel bij slechte lichtomstandigheden en kunnen vanuit grotere hoeken worden bekeken dan een normaal LCD-scherm. Dus laten we het beginnen te weten.

7-segmenten en 4-cijferige 7-segmenten displaymodule:

7 Segment Display heeft zeven segmenten en elk segment heeft een LED erin om de cijfers weer te geven door de overeenkomstige segmenten op te lichten. Als je wilt dat het 7-segment het nummer "5" weergeeft, dan moet je segment a, f, g, c en d oplichten door hun corresponderende pinnen hoog te maken. Er zijn twee soorten 7-segment displays: Common Cathode en Common Anode, hier gebruiken we Common Cathode zeven segmenten display. Lees hier meer over 7-segmentweergave.

Nu weten we hoe we ons gewenste numerieke teken op een enkel 7-segment display kunnen weergeven. Maar het is vrij duidelijk dat we meer dan één 7-segmentendisplay nodig hebben om informatie over te brengen die uit meer dan één cijfer bestaat. In deze tutorial zullen we dus een 4-cijferige 7-segment displaymodule gebruiken, zoals hieronder getoond.

Zoals we kunnen zien, zijn er vier displays met zeven segmenten die met elkaar zijn verbonden. We weten dat elke 7-segmentmodule 10 pinnen zal hebben en voor 4 displays met zeven segmenten zouden er in totaal 40 pinnen zijn en het zou hectisch zijn voor iedereen om ze op een puntbord te solderen, dus ik zou iedereen ten zeerste aanbevelen om een ​​module te kopen of maak je eigen printplaat voor het gebruik van een 4-cijferig 7-segment display. Het aansluitschema voor hetzelfde wordt hieronder getoond:

Om te begrijpen hoe de 4-cijferige module met zeven segmenten werkt, moeten we het bovenstaande schema bekijken, zoals getoond, de A-pinnen van alle vier het display zijn verbonden om te verzamelen als één A en hetzelfde voor B, C…. t / m DP. Dus als trigger A aan staat, moeten alle vier A's hoog gaan, toch?

Maar dat gebeurt niet. We hebben vier extra pinnen van D0 tot D3 (D0, D1, D2 en D3) die kunnen worden gebruikt om te bepalen welke weergave van de vier hoog moet worden. Bijvoorbeeld: als ik wil dat mijn uitvoer alleen op het tweede scherm aanwezig is, moet alleen D1 hoog worden gemaakt terwijl andere pinnen (D0, D2 en D3) zo laag blijven. We kunnen eenvoudig selecteren welk display actief moet worden met behulp van de pinnen van D0 tot D3 en welk teken moet worden weergegeven met behulp van de pinnen van A tot DP.

4-cijferige zeven-segmentmodule verbinden met PIC-microcontroller:

Hier hebben we PIC-microcontroller PIC16F877A gebruikt en het schema voor de schakeling wordt hieronder weergegeven.

We hebben 12 uitgangspennen van de module waarvan er 8 worden gebruikt om de karakters weer te geven en vier worden gebruikt om een ​​van de vier displays te selecteren. Daarom zijn alle 8 karakterpinnen toegewezen aan PORTD en worden de display-selectiepennen toegewezen aan de eerste vier pinnen van PORTC.

Opmerking: de aardingspin van de module moet ook worden verbonden met de aarde van de MCU, die hier niet wordt weergegeven.

Programmeren met PIC16F877A:

Nu we weten hoe deze module werkelijk werkt, gaan we leren hoe we PIC16F877A kunnen programmeren om het een 4-cijferig nummer weer te geven. Laten we een variabele ophogen van 0 tot 1000 en deze afdrukken op het 7-segment display. Start het MPLABX-programma en maak een nieuw project, laten we beginnen met de configuratiebits.

#pragma config FOSC = HS // Oscillator Selectie bits (HS oscillator) #pragma config WDTE = OFF // Watchdog Timer Enable bit (WDT uitgeschakeld) #pragma config PWRTE = ON // Power-up Timer Enable bit (PWRT ingeschakeld) # pragma config BOREN = ON // Brown-out Reset Enable bit (BOR ingeschakeld) #pragma config LVP = OFF // Low-Voltage (Single-Supply) In-Circuit Serial Programming Enable bit (RB3 is digitale I / O, HV aan MCLR moet worden gebruikt voor het programmeren) #pragma config CPD = OFF // Data EEPROM-geheugencodebeschermingsbit (Data EEPROM-codebescherming uit) #pragma config WRT = OFF // Flash Programmageheugen Write Enable bits (schrijfbeveiliging uit; alle programmageheugen kan worden geschreven door EECON-besturing) #pragma config CP = OFF // Flash Program Memory Code Protection bit (Code bescherming uit)

Zoals gewoonlijk gebruiken we het set configuration bits-venster om deze bits in te stellen. Als je niet zeker weet wat ze betekenen, ga dan naar de LED-knipperende tutorial hier.

Laten we vervolgens de uitgangspennen definiëren voor het schakelen tussen elk cijfer van het display.

// *** Definieer de signaalpinnen van alle vier displays *** // #define s1 RC0 #define s2 RC1 #define s3 RC2 #define s4 RC3 // *** Einde definitie ** ////

Hier worden de pinnen RC0, RC1, RC2 en RC3 gebruikt om te kiezen tussen de vier cijfers van onze 7-segment display module. Deze pinnen zijn gedefinieerd als respectievelijk s1, s2, s3 en s4.

Laten we vervolgens naar void main () springen , waarbinnen we de volgende variabele declaratie hebben:

int i = 0; // de 4-cijferige waarde die moet worden weergegeven int flag = 0; // voor het creëren van vertraging zonder teken int a, b, c, d, e, f, g, h; // alleen variabelen unsigned int seg = {0X3F, // Hex-waarde om het nummer 0 0X06 weer te geven, // Hex-waarde om het nummer 1 0X5B weer te geven, // Hex-waarde om het nummer 2 0X4F weer te geven, // Hex-waarde om weer te geven het nummer 3 0X66, // Hex-waarde om het nummer 4 0X6D weer te geven, // Hex-waarde om het nummer 5 0X7C weer te geven, // Hex-waarde om het nummer 6 0X07 weer te geven, // Hex-waarde om het nummer 7 0X7F weer te geven, / / Hex-waarde om het nummer 8 0X6F weer te geven // Hex-waarde om het nummer 9} weer te geven; // Einde van matrix voor het weergeven van getallen van 0 tot 9

Hier worden de variabelen i en flag gebruikt om de weer te geven waarden op te slaan en een vertraging te creëren. De ongetekende integervariabelen a tot h worden gebruikt om de viercijferige getallen op te splitsen in enkele cijfers en deze op te slaan (wat later hier zal worden uitgelegd).

Een belangrijk ding om op te merken is de "seg" array-declaratie. In dit programma gebruiken we een nieuw datatype genaamd Array. Array is niets anders dan een verzameling vergelijkbare datatype-waarden. Hier hebben we deze array gebruikt om alle equivalente hexadecimale waarden op te slaan voor het weergeven van een getal van 0 tot 9.

Het adres van de array begint altijd vanaf nul. Dus deze array heeft de hexadecimale waarde van een numeriek nummer (0-9) opgeslagen in het adres dat hetzelfde is als dat van het nummer zoals hieronder weergegeven

Variabele:	seg	seg	seg	seg	seg	seg	seg	seg	seg	seg
Hex-code:	0X3F	0X06	0X5B	0X4F	0X66	0X6D	0X7C	0X07	0X7F	0X6F
Eq. Numeriek nummer:	0	1	2	3	4	5	6	7	8	9

Dus als u het nummer 0 op uw 7-segment wilt weergeven, kunt u seg bellen , en als u het nummer 6 wilt weergeven, hoeft u alleen seg te gebruiken .

Om te begrijpen hoe de HEX-waarde daadwerkelijk is verkregen, kijken we naar de onderstaande tabel. De equivalente HEX-waarde voor elk decimaal getal wordt in de array opgeslagen, zodat deze kan worden opgeroepen om een ​​bepaald getal weer te geven.

Laten we nu verder gaan met het volgende deel van de code, de I / O-configuratie:

// ***** I / O-configuratie **** // TRISC = 0X00; PORTC = 0X00; TRISD = 0x00; PORTD = 0X00; // *** Einde van I / O-configuratie ** ///

De I / O-configuratie is eenvoudig omdat alle pinnen op ons 7-segment uitgangspennen zijn en de verbindingen worden weergegeven in het bovenstaande schakelschema, dus declareer ze eenvoudig als uitgangen en initialiseer ze op nul.

Laten we nu in onze oneindige lus springen (while (1)). Hier moeten we de waarde van "i" in vier cijfers splitsen en deze op het 7-segment weergeven. Laten we eerst beginnen met het splitsen van de waarde op "i"

// *** Splitsen "i" in vier cijfers *** // a = i% 10; // 4e cijfer wordt hier opgeslagen b = i / 10; c = b% 10; // 3e cijfer wordt hier opgeslagen d = b / 10; e = d% 10; // 2e cijfer wordt hier opgeslagen f = d / 10; g = f% 10; // 1e cijfer wordt hier opgeslagen h = f / 10; // *** Einde splitsen *** //

Door gebruik te maken van een eenvoudige modulus- en deelbewerking wordt het 4-cijferige nummer (i) gescheiden in individuele nummers. Laten we in ons geval een voorbeeld nemen waarbij de waarde van "i" 4578 is. Aan het einde van dit proces is de variabele g = 4, e = 5, c = 7 en a = 8. Dus nu zal het gemakkelijk zijn om elk cijfer weer te geven door simpelweg die variabele te gebruiken.

PORTD = seg; s1 = 1; // Schakel display 1 in en print het 4e cijfer __delay_ms (5); s1 = 0; // Schakel display 1 uit na een vertraging van 5 ms PORTD = seg; s2 = 1; // Schakel display 2 in en print het 3e cijfer __delay_ms (5); s2 = 0; // Schakel display 2 uit na een vertraging van 5 ms PORTD = seg; s3 = 1; // Schakel display 3 in en print het 2e cijfer __delay_ms (5); s3 = 0; // Schakel display 3 uit na een vertraging van 5 ms PORTD = seg; s4 = 1; // Schakel display 4 in en print het eerste cijfer __delay_ms (5); s4 = 0; // Schakel display 4 uit na een vertraging van 5 ms

Dit is de daadwerkelijke plaats waar de MCU praat met het 7-segment. Zoals we weten , kunnen we slechts één cijfer tegelijk weergeven, maar we moeten vier cijfers weergeven en alleen als alle vier de cijfers Aan zijn, is het volledige viercijferige nummer zichtbaar voor de gebruiker.

Dus, hoe gaan we hiermee om?

Gelukkig voor ons is onze MCU veel sneller dan een menselijk oog, dus wat we eigenlijk doen: we geven één cijfer tegelijk weer, maar we doen het erg snel zoals hierboven weergegeven.

We selecteren een cijferweergave, het wacht 5 ms zodat de MCU en het 7-segment het kunnen verwerken en schakelen vervolgens dat cijfer uit en gaan verder met het volgende cijfer en doen hetzelfde tot we het laatste cijfer bereiken. Deze vertraging van 5 ms kan niet door het menselijk oog worden waargenomen en alle vier de cijfers bleken tegelijkertijd Aan te zijn.

Dat is het, tot slot verhogen we gewoon de waarde van het weergegeven cijfer met een vertraging zoals hieronder weergegeven

if (vlag> = 100) // wacht tot vlag 100 bereikt {i ++; vlag = 0; // alleen als vlag honderd is, wordt "i" opgehoogd} flag ++; // ophogingsvlag voor elke flits

De vertraging wordt gebruikt zodat de tijd die nodig is om van het ene nummer naar het andere over te schakelen lang genoeg is om de verandering op te merken.

De volledige code wordt hieronder gegeven en het proces wordt aan het einde ook uitgelegd in de video.

Hardware instellen en testen:

Laten we zoals altijd het programma simuleren met Proteus voordat we daadwerkelijk met onze hardware gaan werken. Als de simulatie succesvol is, zou u zoiets als dit moeten zien

Dit project heeft geen ingewikkelde hardware-instellingen, we gebruiken opnieuw hetzelfde PIC Microcontroller-bord dat we hebben gemaakt in de LED-knipperende zelfstudie. Verbind eenvoudig de 7-segment module met uw PIC Microcontroller board volgens het aansluitschema. Als je klaar bent met de verbindingen, dump je gewoon de code met je PicKit 3-programmeur en dat is het genieten van je output.