7 Pag-interface ng display sa segment na may pic microcontroller

Ito ang aming ika-8 tutorial ng Pag- aaral ng mga microcontroller ng PIC gamit ang MPLAB at XC8. Nakarating kami lahat mula sa pag-install ng MPLABX hanggang sa paggamit ng isang LCD na may PIC MCU. Kung bago ka dito, tingnan ang mga nakaraang tutorial kung saan maaari kang matuto ng mga timer, kumukurap na LED, interfacing LCD atbp.. Mahahanap mo rito ang lahat ng aming Mga Tutorial sa PIC. Sa aming huling tutorial nakita namin kung paano makakalikha ng Mga pasadyang character sa aming 16 * 2 LCD display, ipaalam sa amin ngayon na bigyan ang aming sarili ng isa pang uri ng display module na tinatawag na 7-segment display at i-interface ito sa PIC Microcontroller.

Kahit na ang 16x2 LCD ay mas komportable kaysa sa 7-segment display ngunit may ilang mga sitwasyon kung saan ang isang 7-segment na display ay darating sa handier kaysa sa isang LCD display. Ang LCD ay naghihirap mula sa sagabal ng pagkakaroon ng mababang sukat ng character at magiging labis na labis para sa iyong proyekto kung nagpaplano ka lamang na ipakita ang ilang mga halagang bilang. Ang 7-mga segment ay mayroon ding kalamangan laban sa mahinang kundisyon ng pag-iilaw at maaaring matingnan mula sa mga anggulo ng lager kaysa sa isang normal na LCD screen. Kaya, magsimula tayong malaman ito.

7-Segment at 4-Digit 7-Segment na Modyul ng Pagpapakita:

Ang 7 Segment Display ay mayroong pitong mga segment dito at ang bawat segment ay may isang LED sa loob nito upang maipakita ang mga numero sa pamamagitan ng pag-iilaw ng mga kaukulang segment. Tulad ng kung nais mo ang 7-segment na ipakita ang bilang na "5" pagkatapos ay kailangan mong i-glow ang segment a, f, g, c, at d sa pamamagitan ng paggawa ng mataas na kaukulang mga pin. Mayroong dalawang uri ng mga pagpapakita ng 7-segment: Karaniwang Cathode at Karaniwang Anode, narito ginagamit namin ang pagpapakita ng Karaniwang Cathode pitong segment. Matuto nang higit pa tungkol sa 7 segment na pagpapakita dito.

Ngayon alam namin kung paano ipakita ang aming ninanais na character na pang-numero sa isang solong pagpapakita ng 7 segment. Ngunit, maliwanag na kakailanganin natin ng higit sa isang 7-segment na pagpapakita upang maiparating ang anumang impormasyon na higit sa isang digit. Kaya, sa tutorial na ito gagamit kami ng isang 4-digit na 7-Segment Display Module tulad ng ipinakita sa ibaba.

Tulad ng nakikita natin mayroong Apat na Pitong Mga Segment na Ipinapakita na konektado magkasama. Alam namin na ang bawat module na 7-segment ay magkakaroon ng 10 mga pin at para sa 4 na pitong segment na nagpapakita ay magkakaroon ng 40 mga pin sa kabuuan at magiging abala para sa sinuman na solder ang mga ito sa isang dot board, kaya masidhing inirerekumenda ko ang sinumang bumili ng isang module o gumawa ng iyong sariling PCB para sa paggamit ng isang 4-digit na 7-segment na display. Ang iskema ng koneksyon para sa pareho ay ipinapakita sa ibaba:

Upang maunawaan kung paano gumagana ang 4-digit na pitong segment na module kailangan nating tingnan ang mga iskemat sa itaas, tulad ng ipinapakita ang mga A pin ng lahat ng apat na display ay konektado upang makalikom bilang isang A at pareho para sa B, C…. hanggang sa DP. Kaya, karaniwang kung ang A ay nag-trigger, kung gayon ang lahat ng apat na A ay dapat na mataas di ba?

Ngunit, hindi iyon nangyari. Mayroon kaming karagdagang apat na pin mula sa D0 hanggang D3 (D0, D1, D2 at D3) na maaaring magamit upang makontrol kung aling display sa apat ang dapat na mataas. Halimbawa: Kung kailangan ko ang aking output na naroroon lamang sa pangalawang display pagkatapos ay ang D1 lamang ang dapat gawing mataas habang pinapanatili ang iba pang mga pin (D0, D2, at D3) na mababa. Maaari lamang nating piliin kung aling display ang dapat na aktibo gamit ang mga pin mula sa D0 hanggang D3 at kung anong character ang ipapakita gamit ang mga pin mula A hanggang DP.

Pagkonekta ng 4-Digit Seven Segment Module sa PIC Microcontroller:

Dito ginamit namin ang PIC microcontroller PIC16F877A at ang eskematiko para sa circuit ay ipinapakita sa ibaba.

Mayroon kaming 12 output pin mula sa module kung saan 8 ang ginagamit upang ipakita ang mga character at apat ang ginagamit upang pumili ng isang display sa apat. Samakatuwid ang lahat ng mga 8 character pin ay itinalaga sa PORTD at ang mga pin na pagpipilian ng pagpili ay itinalaga sa unang apat na pin ng PORTC.

Tandaan: Ang ground pin ng module ay dapat ding konektado sa lupa ng MCU na hindi ipinakita dito.

Programming gamit ang PIC16F877A:

Ngayon, na alam natin kung paano talaga gumagana ang modyul na ito, alamin natin kung paano i-program ang PIC16F877A upang maipakita ito ng isang 4 na numero ng numero. Palakihin natin ang isang variable mula 0 hanggang 1000 at i-print ito sa display na 7-segment. Ilunsad ang programa ng MPLABX at lumikha ng bagong proyekto, magsimula tayo sa mga config bit.

#pragma config FOSC = HS // Oscillator Selection bits (HS oscillator) #pragma config WDTE = OFF // Watchdog Timer Paganahin ang bit (hindi pinagana ang WDT) #pragma config PWRTE = ON // Power-up Timer Paganahin ang bit (pinagana ang PWRT) # pragma config BOREN = ON // Brown-out Reset Paganahin ang bit (pinagana ang BOR) #pragma config LVP = OFF // Mababang Boltahe (Single-Supply) In-Circuit Serial Programming Paganahin ang bit (ang RB3 ay digital I / O, HV sa Dapat gamitin ang MCLR para sa pagprograma) #pragma config CPD = OFF // Data EEPROM Memory Code Protection bit (Proteksyon ang Data EEPROM code) #pragma config WRT = OFF // Flash Program Memory Sumulat Paganahin ang mga bits (Isulat ang proteksyon; lahat ng memorya ng programa maaaring nakasulat sa pamamagitan ng kontrol ng EECON) #pragma config CP = OFF // Flash Program Memory Code Protection bit (Proteksyon ang code)

Tulad ng dati ginagamit namin ang itinakda na window ng mga setting ng bits upang maitakda ang mga bits na ito. Kung hindi ka sigurado kung ano ang ibig sabihin nito bisitahin ang LED blinking tutorial dito.

Susunod na tukuyin namin ang mga output pin para sa pag-toggle sa pagitan ng bawat digit ng display.

// *** Tukuyin ang mga signal pin ng lahat ng apat na display *** // #define s1 RC0 #define s2 RC1 #define s3 RC2 #define s4 RC3 // *** End of kahulugan ** ////

Dito ang mga pin na RC0, RC1, RC2 at RC3 ay ginagamit para sa pagpili sa pagitan ng apat na digit ng aming 7-segment na module ng pagpapakita. Ang mga pin na ito ay tinukoy bilang s1, s2, s3 at s4 ayon sa pagkakabanggit.

Susunod na tumalon tayo sa void main (), sa loob kung saan mayroon kaming sumusunod na deklarasyong variable:

int i = 0; // ang 4-digit na halaga na ipapakita sa int flag = 0; // para sa paglikha ng pagkaantala ng unsigned int a, b, c, d, e, f, g, h; // variable lang unsigned int seg = {0X3F, // Hex na halaga upang maipakita ang bilang na 0 0X06, // Hex na halaga upang ipakita ang bilang 1 0X5B, // Hex na halaga upang ipakita ang bilang 2 0X4F, // Hex na halaga upang ipakita ang bilang 3 0X66, // Hex halaga upang ipakita ang numero 4 0X6D, // Hex halaga upang ipakita ang bilang 5 0X7C, // Hex halaga upang ipakita ang bilang 6 0X07, // Hex halaga upang ipakita ang bilang 7 0X7F, / / Hex na halaga upang maipakita ang bilang 8 0X6F // Hex na halaga upang ipakita ang bilang 9}; // End of Array para sa pagpapakita ng mga numero mula 0 hanggang 9

Dito ginagamit ang mga variable na i at flag para sa pagtatago ng mga halagang maipapakita at lumilikha ng pagkaantala ayon sa pagkakabanggit. Ang mga unsigned integer variable na a hanggang h ay ginagamit upang masira ang apat na digit na numero sa iisang mga digit at iimbak ang mga ito (na ipapaliwanag dito mamaya).

Ang isang pangunahing bagay na dapat tandaan dito ay ang "seg" na deklarasyon ng array. Sa program na ito gumagamit kami ng isang bagong uri ng data na tinatawag na Array. Ang Array ay walang iba kundi isang koleksyon ng mga katulad na halaga ng uri ng data. Dito, ginamit namin ang array na ito upang maiimbak ang lahat ng katumbas na halaga ng hex para sa pagpapakita ng isang numero mula 0 hanggang 9.

Ang address ng array ay laging nagsisimula mula sa zero. Kaya't ang array na ito ay magkakaroon ng hex na halaga ng isang numerong numero (0-9) na nakaimbak sa address na kapareho ng bilang ng bilang tulad ng ipinakita sa ibaba

Variable:	seg	seg	seg	seg	seg	seg	seg	seg	seg	seg
Hex Code:	0X3F	0X06	0X5B	0X4F	0X66	0X6D	0X7C	0X07	0X7F	0X6F
Eq Numero ng numero:	0	1	2	3	4	5	6	7	8	9

Kaya't simple, kung nais mong ipakita ang numero 0 sa iyong 7-segment maaari kang tumawag sa seg, gayun din kung nais mong ipakita ang numero 6 kailangan mo lamang gamitin seg.

Upang maunawaan kung paano talagang nakuha ang halagang HEX tingnan natin sa talahanayan sa ibaba. Ang katumbas na halagang HEX para sa bawat decimal number ay nakaimbak sa array upang maaari itong tawagan upang ipakita ang isang partikular na numero.

Ngayon, magpatuloy tayo sa susunod na bahagi ng code na kung saan ay ang pagsasaayos ng I / O:

// ***** I / O Configuration **** // TRISC = 0X00; PORTC = 0X00; TRISD = 0x00; PORTD = 0X00; // *** Wakas ng pagsasaayos ng I / O ** ///

Ang pagsasaayos ng I / O ay simple sapagkat ang lahat ng mga pin sa aming 7-segment ay mga output pin, at ang mga koneksyon ay ipinapakita sa circuit diagram sa itaas, kaya ideklara lamang ang mga ito bilang mga output at simulan ang mga ito sa zero.

Tumalon tayo ngayon sa aming walang katapusang loop (habang (1)). Narito kailangan nating hatiin ang halaga ng "i" sa apat na digit at ipakita ang mga ito sa 7-segment. Magsimula muna tayo sa pamamagitan ng paghahati ng halaga sa "i"

// *** Hinahati ang "i" sa apat na digit *** // a = i% 10; // 4th digit ay nai-save dito b = i / 10; c = b% 10; // Ang ika-3 na digit ay nai-save dito d = b / 10; e = d% 10; // 2nd digit ay nai-save dito f = d / 10; g = f% 10; // 1st digit ay nai-save dito h = f / 10; // *** Pagtatapos ng paghahati *** //

Sa pamamagitan ng paggamit ng simpleng pagpapatakbo ng modulus at dibisyon ng 4 na numero ng (i) ay pinaghiwalay sa mga indibidwal na numero. Sa aming kaso kumuha tayo ng isang halimbawa kung saan ang halaga ng "i" ay 4578. Pagkatapos sa pagtatapos ng prosesong ito ang variable g = 4, e = 5, c = 7, at a = 8. Kaya ngayon madali itong ipapakita ang bawat digit sa pamamagitan lamang ng paggamit ng variable na iyon.

PORTD = seg; s1 = 1; // ON ON display 1 and print 4th digit __delay_ms (5); s1 = 0; // Turn OFF display 1 pagkatapos ng 5ms pagkaantala sa PORTD = seg; s2 = 1; // ON ON display 2 at i-print ang 3rd digit __delay_ms (5); s2 = 0; // OFF OFF display 2 pagkatapos ng pagkaantala ng 5ms PORTD = seg; s3 = 1; // ON ON display 3 at i-print ang ika-2 digit na __delay_ms (5); s3 = 0; // OFF OFF display 3 pagkatapos maantala ang 5ms PORTD = seg; s4 = 1; // ON ON display 4 at i-print ang 1st digit __delay_ms (5); s4 = 0; // OFF OFF display 4 pagkatapos ng pagkaantala ng 5ms

Ito ang aktwal na lugar kung saan nakikipag-usap ang MCU sa 7-segment. Tulad ng alam naming maaari lamang kaming magpakita ng isang digit nang paisa-isa, ngunit mayroon kaming apat na digit na ipapakita at kung ang lahat ng apat na digit ay Sa kumpletong numero ng apat na digit ay makikita para sa gumagamit.

Kaya, paano tayo makakasama dito?

Masuwerte para sa amin ang aming MCU ay napakabilis kaysa sa isang mata ng tao, kaya kung ano talaga ang ginagawa namin: nagpapakita kami ng isang digit nang paisa-isa ngunit ginagawa namin ito nang napakabilis tulad ng ipinakita sa itaas.

Pinipili namin ang isang digit na display na ito maghintay para sa 5ms upang ang MCU at 7-segment ay maaaring maproseso ito at pagkatapos ay i-off ang digit na iyon at magpatuloy sa susunod na digit at gawin ang pareho hanggang maabot namin ang huling digit. Ang pagkaantala ng 5ms na ito ay hindi maaaring sundin ng isang mata ng tao at ang lahat ng apat na digit ay lilitaw na On nang sabay.

Iyon lang, sa wakas ay nadaragdagan lamang natin ang halaga ng ipinakitang digit gamit ang isang pagkaantala tulad ng ipinakita sa ibaba

kung (flag> = 100) // maghintay hanggang sa umabot ang bandila sa 100 {i ++; flag = 0; // kung ang flag ay daang "i" ay madadagdagan} flag ++; // increment flag para sa bawat flash

Ginagamit ang pagkaantala upang ang oras na ginugol para sa pagbabago mula sa isang numero patungo sa isa pa ay sapat na katagalan upang mapansin namin ang pagbabago.

Ang kumpletong code ay ibinibigay sa ibaba at ang proseso ay ipinaliwanag din sa Video sa dulo.

Pag-setup at Pagsubok ng Hardware:

Tulad ng lagi ay ipaalam sa amin na gayahin ang programa gamit ang Proteus bago talaga kami pumunta sa aming hardware. Kung ang simulation ay matagumpay dapat mong makita ang isang bagay tulad nito

Ang proyektong ito ay walang anumang kumplikadong pag-setup ng hardware, muling gumagamit kami ng parehong board ng PIC Microcontroller na nilikha namin sa LED blinking Tutorial. Ikonekta lamang ang 7-segment na Modyul sa iyong PIC Microcontroller board ayon sa diagram ng koneksyon. Kapag tapos ka na sa mga koneksyon, itapon lamang ang code gamit ang iyong PicKit 3 programmer at iyon ang nasisiyahan sa iyong output.