పిక్ మైక్రోకంట్రోలర్‌తో సెగ్మెంట్ డిస్ప్లే ఇంటర్‌ఫేసింగ్

MPLAB మరియు XC8 ఉపయోగించి PIC మైక్రోకంట్రోలర్‌లను నేర్చుకోవడం మా 8 వ ట్యుటోరియల్. MPLABX ని ఇన్‌స్టాల్ చేయడం నుండి PIC MCU తో LCD ని ఉపయోగించడం వరకు మేము అన్ని విధాలుగా ముందుకు వచ్చాము. మీరు ఇక్కడ కొత్తగా ఉంటే, మీరు టైమర్‌లు, మెరిసే ఎల్‌ఇడి, ఇంటర్‌ఫేసింగ్ ఎల్‌సిడి మొదలైనవి నేర్చుకోగల మునుపటి ట్యుటోరియల్‌లను చూడండి. మీరు మా పిఐసి ట్యుటోరియల్‌లను ఇక్కడ చూడవచ్చు. మా చివరి ట్యుటోరియల్‌లో మన 16 * 2 ఎల్‌సిడి డిస్‌ప్లేతో కస్టమ్ అక్షరాలను ఎలా ఉత్పత్తి చేయవచ్చో చూశాము, ఇప్పుడు 7-సెగ్మెంట్ డిస్ప్లే అని పిలువబడే మరొక రకమైన డిస్ప్లే మాడ్యూల్‌తో మన స్వీయతను సమకూర్చుకుందాం మరియు దానిని పిఐసి మైక్రోకంట్రోలర్‌తో ఇంటర్‌ఫేస్ చేద్దాం.

16x2 LCD 7-సెగ్మెంట్ డిస్ప్లే కంటే చాలా సౌకర్యవంతంగా ఉన్నప్పటికీ, 7-సెగ్మెంట్ డిస్ప్లే LCD డిస్ప్లే కంటే హ్యాండియర్‌లో వచ్చే కొన్ని దృశ్యాలు ఉన్నాయి. తక్కువ అక్షర పరిమాణాన్ని కలిగి ఉన్న లోపంతో LCD బాధపడుతోంది మరియు మీరు కొన్ని సంఖ్యా విలువలను ప్రదర్శించాలనుకుంటే మీ ప్రాజెక్ట్ కోసం ఓవర్ కిల్ అవుతుంది. 7-విభాగాలు పేలవమైన లైటింగ్ స్థితికి వ్యతిరేకంగా కూడా ప్రయోజనాన్ని కలిగి ఉన్నాయి మరియు సాధారణ ఎల్‌సిడి స్క్రీన్ కంటే లాగర్ కోణాల నుండి చూడవచ్చు. కాబట్టి, దానిని తెలుసుకోవడం ప్రారంభిద్దాం.

7-సెగ్మెంట్ మరియు 4-అంకెల 7-సెగ్మెంట్ డిస్ప్లే మాడ్యూల్:

7 సెగ్మెంట్ డిస్ప్లేలో ఏడు సెగ్మెంట్లు ఉన్నాయి మరియు ప్రతి సెగ్మెంట్ దానిలో ఒక ఎల్ఇడి కలిగి ఉంటుంది, సంబంధిత విభాగాలను వెలిగించడం ద్వారా సంఖ్యలను ప్రదర్శిస్తుంది. మీరు 7-సెగ్మెంట్ "5" సంఖ్యను ప్రదర్శించాలనుకుంటే, మీరు వాటి సంబంధిత పిన్‌లను అధికంగా చేయడం ద్వారా సెగ్మెంట్ a, f, g, c మరియు d ని గ్లో చేయాలి. 7-సెగ్మెంట్ డిస్ప్లేలలో రెండు రకాలు ఉన్నాయి: కామన్ కాథోడ్ మరియు కామన్ యానోడ్, ఇక్కడ మేము కామన్ కాథోడ్ ఏడు సెగ్మెంట్ డిస్ప్లేని ఉపయోగిస్తున్నాము. 7 సెగ్మెంట్ డిస్ప్లే గురించి ఇక్కడ మరింత తెలుసుకోండి.

ఒకే 7-సెగ్మెంట్ డిస్ప్లేలో మనకు కావలసిన సంఖ్యా అక్షరాన్ని ఎలా ప్రదర్శించాలో ఇప్పుడు మనకు తెలుసు. కానీ, ఒకటి కంటే ఎక్కువ అంకెలు ఉన్న ఏదైనా సమాచారాన్ని తెలియజేయడానికి మాకు ఒకటి కంటే ఎక్కువ 7-సెగ్మెంట్ డిస్ప్లే అవసరమని స్పష్టంగా తెలుస్తుంది. కాబట్టి, ఈ ట్యుటోరియల్‌లో మనం క్రింద చూపిన విధంగా 4-అంకెల 7-సెగ్మెంట్ డిస్ప్లే మాడ్యూల్‌ని ఉపయోగిస్తాము.

మనం చూడగలిగినట్లుగా నాలుగు ఏడు సెగ్మెంట్ డిస్ప్లేలు కలిసి కనెక్ట్ చేయబడ్డాయి. ప్రతి 7-సెగ్మెంట్ మాడ్యూల్ 10 పిన్స్ కలిగి ఉంటుందని మరియు 4 ఏడు సెగ్మెంట్ డిస్ప్లేల కోసం మొత్తం 40 పిన్స్ ఉంటాయని మాకు తెలుసు మరియు ఎవరైనా వాటిని డాట్ బోర్డ్‌లో టంకం వేయడం చాలా తీవ్రంగా ఉంటుంది, కాబట్టి నేను మాడ్యూల్ కొనడానికి ఎవరినైనా బాగా సిఫార్సు చేస్తాను లేదా 4-అంకెల 7-సెగ్మెంట్ డిస్ప్లేని ఉపయోగించడం కోసం మీ స్వంత PCB ని తయారు చేయండి. దాని కోసం కనెక్షన్ స్కీమాటిక్ క్రింద చూపబడింది:

4-అంకెల ఏడు సెగ్మెంట్ మాడ్యూల్ ఎలా పనిచేస్తుందో అర్థం చేసుకోవడానికి, పైన పేర్కొన్న స్కీమాటిక్స్ గురించి మనం పరిశీలించాలి, నాలుగు డిస్ప్లేల యొక్క పిన్స్ ఒక A గా మరియు B, C…. డిపి వరకు సేకరించడానికి అనుసంధానించబడి ఉన్నట్లు చూపబడింది. కాబట్టి, ప్రాథమికంగా A ని ట్రిగ్గర్ చేస్తే, అప్పుడు నాలుగు A లు అధికంగా వెళ్ళాలి?

కానీ, అది జరగదు. మనకు D0 నుండి D3 (D0, D1, D2 మరియు D3) వరకు అదనపు నాలుగు పిన్‌లు ఉన్నాయి, వీటిని నాలుగు నుండి ఏ డిస్ప్లే అధికంగా ఉండాలో నియంత్రించడానికి ఉపయోగపడుతుంది. ఉదాహరణకు: నా అవుట్పుట్ రెండవ డిస్ప్లేలో మాత్రమే ఉండాలంటే, ఇతర పిన్నులను (D0, D2 మరియు D3) తక్కువగా ఉంచేటప్పుడు D1 మాత్రమే అధికంగా ఉండాలి. D0 నుండి D3 వరకు పిన్‌లను ఉపయోగించి ఏ డిస్ప్లే యాక్టివ్‌గా ఉండాలో మరియు A నుండి DP వరకు పిన్‌లను ఉపయోగించి ఏ పాత్రను ప్రదర్శించాలో ఎంచుకోవచ్చు.

PIC మైక్రోకంట్రోలర్‌తో 4-అంకెల ఏడు సెగ్మెంట్ మాడ్యూల్‌ను కనెక్ట్ చేస్తోంది:

ఇక్కడ మేము PIC మైక్రోకంట్రోలర్ PIC16F877A ను ఉపయోగించాము మరియు సర్క్యూట్ యొక్క స్కీమాటిక్ క్రింద చూపబడింది.

మాడ్యూల్ నుండి మనకు 12 అవుట్పుట్ పిన్స్ ఉన్నాయి, వీటిలో 8 అక్షరాలను ప్రదర్శించడానికి ఉపయోగించబడతాయి మరియు నాలుగు నాలుగు వాటిలో ఒక ప్రదర్శనను ఎంచుకోవడానికి ఉపయోగించబడతాయి. అందువల్ల మొత్తం 8 అక్షర పిన్‌లు PORTD కి కేటాయించబడతాయి మరియు ప్రదర్శన ఎంపిక పిన్‌లు PORTC యొక్క మొదటి నాలుగు పిన్‌లకు కేటాయించబడతాయి.

గమనిక: మాడ్యూల్ యొక్క గ్రౌండ్ పిన్ ఇక్కడ చూపబడని MCU యొక్క భూమికి అనుసంధానించబడి ఉండాలి.

PIC16F877A ఉపయోగించి ప్రోగ్రామింగ్:

ఇప్పుడు, ఈ మాడ్యూల్ వాస్తవానికి ఎలా పనిచేస్తుందో మాకు తెలుసు, PIC16F877A ను 4 అంకెల సంఖ్యను ప్రదర్శించేలా ఎలా ప్రోగ్రామ్ చేయాలో నేర్చుకుందాం. వేరియబుల్‌ను 0 నుండి 1000 కి పెంచండి మరియు దానిని 7-సెగ్మెంట్ డిస్ప్లేలో ప్రింట్ చేద్దాం. MPLABX ప్రోగ్రామ్‌ను ప్రారంభించి, క్రొత్త ప్రాజెక్ట్‌ను సృష్టించండి, కాన్ఫిగరేషన్ బిట్‌లతో ప్రారంభిద్దాం.

#pragma config FOSC = HS // ఓసిలేటర్ ఎంపిక బిట్స్ (HS ఓసిలేటర్) #pragma config WDTE = OFF // వాచ్‌డాగ్ టైమర్ బిట్‌ను ప్రారంభించండి (WDT నిలిపివేయబడింది) #pragma config PWRTE = ON // పవర్-అప్ టైమర్ ఎనేబుల్ బిట్ (PWRT ప్రారంభించబడింది) # ప్రాగ్మా కాన్ఫిగర్ BOREN = ON // బ్రౌన్-అవుట్ రీసెట్ ఎనేబుల్ బిట్ (BOR ఎనేబుల్) ప్రోగ్రామింగ్ కోసం MCLR తప్పక ఉపయోగించాలి) # ప్రాగ్మా కాన్ఫిగర్ CPD = OFF // డేటా EEPROM మెమరీ కోడ్ ప్రొటెక్షన్ బిట్ (డేటా EEPROM కోడ్ ప్రొటెక్షన్ ఆఫ్) EECON నియంత్రణ ద్వారా వ్రాయబడవచ్చు) # ప్రాగ్మా కాన్ఫిగర్ CP = OFF // ఫ్లాష్ ప్రోగ్రామ్ మెమరీ కోడ్ ప్రొటెక్షన్ బిట్ (కోడ్ ప్రొటెక్షన్ ఆఫ్)

ఎప్పటిలాగే మేము ఈ బిట్లను సెట్ చేయడానికి సెట్ కాన్ఫిగరేషన్ బిట్స్ విండోను ఉపయోగిస్తాము. అవి ఏమిటో మీకు తెలియకపోతే ఇక్కడ LED బ్లింక్ ట్యుటోరియల్‌ని సందర్శించండి.

తరువాత డిస్ప్లే యొక్క ప్రతి అంకెల మధ్య టోగుల్ చేయడానికి అవుట్పుట్ పిన్నులను నిర్వచించండి.

// *** నాలుగు డిస్ప్లేల సిగ్నల్ పిన్‌లను నిర్వచించండి *** // # s1 RC0 ని నిర్వచించండి # s2 RC1 ని నిర్వచించండి # s3 RC2 ని నిర్వచించండి # s4 RC3 ని నిర్వచించండి // *** నిర్వచనం ముగింపు ** ////

ఇక్కడ మా 7-సెగ్మెంట్ డిస్ప్లే మాడ్యూల్ యొక్క నాలుగు అంకెల మధ్య ఎంచుకోవడానికి పిన్స్ RC0, RC1, RC2 మరియు RC3 ఉపయోగించబడతాయి. ఈ పిన్‌లను వరుసగా s1, s2, s3 మరియు s4 గా నిర్వచించారు.

తరువాత మనం శూన్యమైన ప్రధాన () లోకి దూకుదాం, దాని లోపల మనకు ఈ క్రింది వేరియబుల్ డిక్లరేషన్ ఉంది:

int i = 0; // ప్రదర్శించాల్సిన 4-అంకెల విలువ int ఫ్లాగ్ = 0; // ఆలస్యం సంతకం చేయని పూర్ణాంకం a, b, c, d, e, f, g, h; // కేవలం వేరియబుల్స్ సంతకం చేయని Int seg = X 0X3F, // సంఖ్యను ప్రదర్శించడానికి హెక్స్ విలువ 0 0X06, // సంఖ్యను ప్రదర్శించడానికి హెక్స్ విలువ 0 0X5B, // సంఖ్యను ప్రదర్శించడానికి హెక్స్ విలువ 2 0X4F, // ప్రదర్శించడానికి హెక్స్ విలువ సంఖ్య 3 0X66, // సంఖ్యను ప్రదర్శించడానికి హెక్స్ విలువ 0X6D, // సంఖ్యను ప్రదర్శించడానికి హెక్స్ విలువ 0 0X7C, // సంఖ్యను ప్రదర్శించడానికి హెక్స్ విలువ 0 0X07, // సంఖ్యను ప్రదర్శించడానికి హెక్స్ విలువ 0 0X7F, / / సంఖ్యను ప్రదర్శించడానికి హెక్స్ విలువ 0 0X6F // సంఖ్య 9 display ను ప్రదర్శించడానికి హెక్స్ విలువ; 0 నుండి 9 వరకు సంఖ్యలను ప్రదర్శించడానికి అర్రే ముగింపు

ఇక్కడ ప్రదర్శించవలసిన విలువలను నిల్వ చేయడానికి మరియు ఆలస్యాన్ని సృష్టించడానికి i మరియు ఫ్లాగ్ అనే వేరియబుల్స్ ఉపయోగించబడతాయి. సైన్ చేయని పూర్ణ వేరియబుల్స్ ఒక h వరకు నాలుగు అంకెల సంఖ్యలో బ్రేక్ ఒకే అంకెలు లోకి మరియు (తరువాత ఇక్కడ వివరించడం జరుగుతుంది ఇది) వాటిని నిల్వ ఉపయోగిస్తారు.

ఇక్కడ గమనించవలసిన ఒక ముఖ్యమైన విషయం ఏమిటంటే "సెగ్" అర్రే డిక్లరేషన్. ఈ ప్రోగ్రామ్‌లో మేము అర్రే అనే కొత్త డేటా రకాన్ని ఉపయోగిస్తున్నాము. అర్రే అనేది సారూప్య డేటా-రకం విలువల సమాహారం తప్ప మరొకటి కాదు. ఇక్కడ, 0 నుండి 9 వరకు సంఖ్యను ప్రదర్శించడానికి అన్ని సమానమైన హెక్స్ విలువలను నిల్వ చేయడానికి మేము ఈ శ్రేణిని ఉపయోగించాము.

శ్రేణి యొక్క చిరునామా ఎల్లప్పుడూ సున్నా నుండి మొదలవుతుంది. కాబట్టి ఈ శ్రేణి చిరునామాలో నిల్వ చేయబడిన సంఖ్యా సంఖ్య (0-9) యొక్క హెక్స్ విలువను కలిగి ఉంటుంది, ఇది క్రింద చూపిన విధంగా సంఖ్యకు సమానం

వేరియబుల్:	సెగ్	సెగ్	సెగ్	సెగ్	సెగ్	సెగ్	సెగ్	సెగ్	సెగ్	సెగ్
హెక్స్ కోడ్:	0X3F	0X06	0 ఎక్స్ 5 బి	0 ఎక్స్ 4 ఎఫ్	0X66	0X6D	0 ఎక్స్ 7 సి	0X07	0X7F	0X6F
Eq. సంఖ్యా సంఖ్య:	0	1	2	3	4	5	6	7	8	9

కాబట్టి, మీరు మీ 7-సెగ్మెంట్లో 0 సంఖ్యను ప్రదర్శించాలనుకుంటే మీరు సెగ్ అని పిలుస్తారు, అదేవిధంగా మీరు 6 సంఖ్యను ప్రదర్శించాలనుకుంటే మీరు సెగ్ ఉపయోగించాలి .

HEX విలువ వాస్తవానికి ఎలా పొందబడిందో అర్థం చేసుకోవడానికి ఈ క్రింది పట్టికను పరిశీలిద్దాం. ప్రతి దశాంశ సంఖ్య సమానార్ధాన్నిచ్చే హెక్స్ విలువ శ్రేణి లో నిల్వ చేయబడుతుంది అది ఒక ప్రత్యేక సంఖ్య ప్రదర్శించడానికి అని చేయవచ్చు కాబట్టి.

ఇప్పుడు, I / O కాన్ఫిగరేషన్ అయిన కోడ్ యొక్క తరువాతి భాగానికి వెళ్దాం:

// ***** I / O కాన్ఫిగరేషన్ **** // TRISC = 0X00; PORTC = 0X00; TRISD = 0x00; PORTD = 0X00; // *** I / O కాన్ఫిగరేషన్ ముగింపు ** ///

I / O కాన్ఫిగరేషన్ చాలా సులభం ఎందుకంటే మా 7-సెగ్మెంట్‌లోని అన్ని పిన్‌లు అవుట్పుట్ పిన్‌లు, మరియు కనెక్షన్లు పై సర్క్యూట్ రేఖాచిత్రంలో చూపించబడ్డాయి, కాబట్టి వాటిని అవుట్‌పుట్‌లుగా ప్రకటించి వాటిని సున్నాకి ప్రారంభించండి.

ఇప్పుడు మన అనంతమైన లూప్‌లోకి దూకుదాం (అయితే (1)). ఇక్కడ మనం "i" విలువను నాలుగు అంకెలుగా విభజించి వాటిని 7-విభాగంలో ప్రదర్శించాలి. మొదట "i" పై విలువను విభజించడం ద్వారా ప్రారంభిద్దాం

// *** "i" ను నాలుగు అంకెలుగా విభజించడం *** // a = i% 10; // 4 వ అంకె ఇక్కడ సేవ్ చేయబడింది b = i / 10; c = b% 10; // 3 వ అంకె ఇక్కడ సేవ్ చేయబడింది d = b / 10; e = d% 10; // 2 వ అంకె ఇక్కడ సేవ్ చేయబడింది f = d / 10; g = f% 10; // 1 వ అంకె ఇక్కడ సేవ్ చేయబడింది h = f / 10; // *** విభజన ముగింపు *** //

సాధారణ మాడ్యులస్ మరియు డివిజన్ ఆపరేషన్ ఉపయోగించడం ద్వారా 4 అంకెల సంఖ్య (i) వ్యక్తిగత సంఖ్యలుగా విభజించబడింది. మన విషయంలో "i" విలువ 4578 ఉన్న ఒక ఉదాహరణ తీసుకుందాం. అప్పుడు ఈ ప్రక్రియ చివరిలో వేరియబుల్ g = 4, e = 5, c = 7 మరియు a = 8. కాబట్టి ఇప్పుడు ఆ వేరియబుల్ ఉపయోగించి ప్రతి అంకెను ప్రదర్శించడం సులభం అవుతుంది.

PORTD = సెగ్; s1 = 1; // డిస్ప్లే 1 ను ఆన్ చేసి 4 వ అంకె __delay_ms (5); s1 = 0; // 5ms ఆలస్యం తర్వాత OFF డిస్ప్లే 1 ని తిప్పండి PORTD = seg; s2 = 1; // డిస్ప్లే 2 ను ఆన్ చేసి 3 వ అంకె __delay_ms (5); s2 = 0; // 5ms ఆలస్యం తర్వాత OFF డిస్ప్లే 2 ని తిప్పండి PORTD = seg; s3 = 1; // డిస్ప్లే 3 ను ఆన్ చేసి 2 వ అంకె __delay_ms (5); s3 = 0; // 5ms ఆలస్యం తర్వాత OFF డిస్ప్లే 3 ని తిప్పండి PORTD = seg; s4 = 1; // డిస్ప్లే 4 ను ఆన్ చేసి, 1 వ అంకె __delay_ms (5); s4 = 0; // 5ms ఆలస్యం తర్వాత డిస్ప్లే 4 ఆఫ్ చేయండి

MCU 7-విభాగాలతో మాట్లాడే అసలు ప్రదేశం ఇదే. మనకు తెలిసినట్లుగా, మేము ఒకేసారి ఒక అంకెను మాత్రమే ప్రదర్శించగలము, కాని మనకు నాలుగు అంకెలు ప్రదర్శించబడతాయి మరియు నాలుగు అంకెలు ఉంటే మాత్రమే పూర్తి నాలుగు అంకెల సంఖ్య వినియోగదారుకు కనిపిస్తుంది.

కాబట్టి, దీనితో మనం ఎలా వెళ్తాము?

మన MCU మానవ కన్ను కంటే చాలా వేగంగా ఉంది, కాబట్టి మనం నిజంగా ఏమి చేస్తాము: మేము ఒక సమయంలో ఒక అంకెను ప్రదర్శిస్తాము కాని పైన చూపిన విధంగా మేము చాలా వేగంగా చేస్తాము.

MCU మరియు 7-సెగ్మెంట్ దీన్ని ప్రాసెస్ చేసి, ఆ అంకెను ఆపివేసి, తదుపరి అంకెకు వెళ్లి, చివరి అంకెకు చేరుకునే వరకు అదే విధంగా చేయటానికి 5ms వేచి ఉండే ఒక అంకెల ప్రదర్శనను మేము ఎంచుకుంటాము. 5ms యొక్క ఈ ఆలస్యాన్ని మానవ కన్ను గమనించలేము మరియు నాలుగు అంకెలు ఒకే సమయంలో ఉన్నట్లు కనిపిస్తాయి.

అంటే, చివరకు మేము క్రింద చూపిన విధంగా ఆలస్యాన్ని ఉపయోగించి ప్రదర్శించిన అంకె విలువను పెంచుతాము

if (ఫ్లాగ్> = 100) // జెండా 100 {i ++; ఫ్లాగ్ = 0; // జెండా వంద "ఐ" ఉంటే మాత్రమే పెంచబడుతుంది} జెండా ++; ప్రతి ఫ్లాష్‌కు // ఇంక్రిమెంట్ ఫ్లాగ్

ఆలస్యం ఉపయోగించబడుతుంది, తద్వారా మార్పును గమనించడానికి మాకు ఒక సంఖ్య నుండి మరొకదానికి మార్చడానికి ఎక్కువ సమయం పడుతుంది.

పూర్తి కోడ్ క్రింద ఇచ్చిన మరియు ప్రక్రియ కూడా వివరించబడింది వీడియో చివరిలో.

హార్డ్వేర్ సెటప్ మరియు పరీక్ష:

వాస్తవానికి మా హార్డ్‌వేర్‌తో వెళ్లేముందు ప్రోటీస్‌ను ఉపయోగించి ప్రోగ్రామ్‌ను అనుకరించండి. అనుకరణ విజయవంతమైతే మీరు ఇలాంటిదే చూడాలి

ఈ ప్రాజెక్ట్‌లో సంక్లిష్టమైన హార్డ్‌వేర్ సెటప్ లేదు, మేము మళ్ళీ LED మెరిసే ట్యుటోరియల్‌లో సృష్టించిన అదే PIC మైక్రోకంట్రోలర్ బోర్డ్‌ను ఉపయోగిస్తున్నాము. కనెక్షన్ రేఖాచిత్రం ప్రకారం మీ PIC మైక్రోకంట్రోలర్ బోర్డ్‌తో 7-సెగ్మెంట్ మాడ్యూల్‌ను కనెక్ట్ చేయండి. మీరు కనెక్షన్‌లను పూర్తి చేసిన తర్వాత, మీ పిక్‌కిట్ 3 ప్రోగ్రామర్‌ను ఉపయోగించి కోడ్‌ను డంప్ చేయండి మరియు అది మీ అవుట్‌పుట్‌ను ఆస్వాదించండి.