పిక్ మైక్రోకంట్రోలర్ ఉపయోగించి లెడ్ బ్లింకింగ్ సీక్వెన్స్

మా మునుపటి ట్యుటోరియల్‌లో, పిఐసి మైక్రోకంట్రోలర్‌ను ఉపయోగించి ఎల్‌ఇడిని బ్లింక్ చేయడం గురించి తెలుసుకున్నాము మరియు పెర్ఫ్ బోర్డులో అదే సర్క్యూట్‌ను నిర్మించాము. అప్పుడు మేము ప్రోగ్రామ్‌ను మా పెర్ఫ్ బోర్డులోకి డంప్ చేయడానికి PICKit 3, ICSP మరియు MPLAB IPE లను ఉపయోగించాము. ఇప్పుడు, ఈ ట్యుటోరియల్‌లో మనం పిఐసి మైక్రోకంట్రోలర్‌పై ఎక్కువ పిన్‌లను ఉపయోగించుకుంటాం. మేము 7 అవుట్‌పుట్‌లు (LED లు) మరియు ఒక ఇన్‌పుట్‌ను ఉపయోగిస్తాము. ఈ ట్యుటోరియల్ కోసం మేము పాత పెర్ఫ్ బోర్డ్‌ను ఉపయోగిస్తాము (క్రింద చూపబడింది) మరియు అవసరమైన పిన్‌లను రెండవ LED బోర్డులోకి లాగడానికి బెర్గ్ కర్రలను జోడిస్తాము. ఈ ట్యుటోరియల్ చివరలో మేము PIC మైక్రోకంట్రోలర్ PIC16F877A ని ఉపయోగించి మెరిసే LED ల యొక్క సీక్వెన్స్ను రూపొందిస్తాము మరియు బహుళ ఇన్పుట్లను మరియు అవుట్పుట్లను ఎలా ఉపయోగించాలో నేర్చుకుంటాము, 'ఫర్' లూప్ మరియు ఫంక్షన్ కాలింగ్ పై కొన్ని ప్రాథమికాలు.

LED బోర్డు మరొక పెర్ఫ్ బోర్డ్ తప్ప మరొకటి కాదు, దీనిపై మేము LED లను ప్రస్తుత పరిమితి నిరోధకంతో (క్రింద చూపించాం) టంకం చేస్తాము. LED మెరిసే క్రమాన్ని ప్రారంభించడానికి మేము పుష్బటన్‌ను కూడా జోడిస్తాము.

సర్క్యూట్ రేఖాచిత్రం:

PIC మైక్రోకంట్రోలర్ PIC16F877A LED బ్లింక్ సీక్వెన్స్ కోడ్ మరియు వర్కింగ్ వివరణ:

పూర్తి కోడ్ క్రింద ఇవ్వబడింది (చివరిలో తనిఖీ చేయండి), ఇక్కడ మనం దానిని లైన్ ద్వారా లైన్ ద్వారా పొందుతాము. పుష్ బటన్ నొక్కినప్పుడు ఈ కోడ్ వరుస పద్ధతిలో LED లను మెరుస్తుంది. సన్నివేశాలను అర్థం చేసుకోవడానికి దయచేసి ట్యుటోరియల్ చివరిలో వీడియో చూడండి. వీడియోలో చూపిన అవుట్‌పుట్‌ను ఈ క్రింది కోడ్‌తో పోల్చమని మరియు ప్రోగ్రామ్‌ను అర్థం చేసుకోవడానికి ప్రయత్నించమని నేను మీకు సిఫార్సు చేస్తున్నాను.

కోడ్ లైన్‌ను లైన్ ద్వారా చూద్దాం. మునుపటి ట్యుటోరియల్‌లో వివరించిన కాన్ఫిగరేషన్ బిట్‌లను సెటప్ చేయడం కోసం మొదటి కొన్ని పంక్తులు ఉన్నాయి కాబట్టి నేను ఇప్పుడే వాటిని దాటవేస్తున్నాను. ఏదైనా ప్రోగ్రామ్‌ను అర్థం చేసుకోవడానికి ఉత్తమ మార్గం ప్రధాన ( శూన్యమైన ప్రధాన () ) ఫంక్షన్ నుండి ప్రారంభించడం, కాబట్టి అలా చేద్దాం

TRISB0 = 1; // PORTB పిన్ 0 బటన్ కోసం ఇన్‌పుట్‌గా ఉపయోగించబడుతుందని MCU కి సూచించండి. TRISD = 0x00; // అన్ని పిన్స్ అవుట్పుట్ PORTD = 0x00 అని MCU కి సూచించండి; // అన్ని పిన్‌లను 0 కి ప్రారంభించండి

పిన్ ఇన్పుట్ / అవుట్పుట్గా ఉపయోగించబడుతుందో లేదో నిర్వచించడానికి TRIS అనే పదాన్ని ఉపయోగిస్తారు మరియు పిన్ హై / తక్కువ చేయడానికి PORT అనే పదాన్ని ఉపయోగిస్తారు. TRISB0 = 1 పంక్తి PORT B ​​యొక్క 0 వ పిన్ను ఇన్‌పుట్‌గా చేస్తుంది. ఇది మా పుష్బటన్ అవుతుంది. పంక్తులు TRISD = 0x00; PORTD = 0x00; పోర్ట్ D యొక్క అన్ని పిన్‌లను అవుట్‌పుట్‌గా చేస్తుంది మరియు ఆ పిన్‌లకు తక్కువ యొక్క ప్రారంభ విలువను కేటాయిస్తుంది.

B0 ను ఇన్‌పుట్‌గా ఉపయోగిస్తామని మేము చెప్పినందున, మేము పుష్బటన్ యొక్క ఒక చివరను పిన్ B0 కి మరియు మరొక చివరను భూమికి కలుపుతాము. అప్పటికి మనం బటన్ నొక్కినప్పుడు పై కనెక్షన్ రేఖాచిత్రంలో చూపిన విధంగా పిన్ నేలమీద ఉంటుంది. ఇది జరగడానికి మనం పుల్ అప్ రెసిస్టర్‌ను ఉపయోగించాలి, తద్వారా బటన్ నొక్కినప్పుడు పిన్ అధికంగా ఉంటుంది. పుల్ అప్ రెసిస్టర్ ఇలాంటిది.

కానీ మా PIC MCU లో అంతర్గత బలహీనమైన పుల్ అప్ రెసిస్టర్ ఉంది, ఇది సాఫ్ట్‌వేర్ ద్వారా సక్రియం చేయగలదు, తద్వారా చాలా ఇబ్బందిని ఆదా చేస్తుంది (ఎక్కువ బటన్లు కనెక్ట్ అయినప్పుడు).

బలహీనమైన పుల్ అప్ రెసిస్టర్ అంటే ఏమిటి?

పుల్ అప్ రెసిస్టర్‌లో రెండు రకాలు ఉన్నాయి, ఒకటి బలహీనమైన పుల్ అప్ మరియు మరొకటి స్ట్రాంగ్ పుల్ అప్. బలహీనమైన పుల్ అప్ రెసిస్టర్లు అధిక విలువను కలిగి ఉంటాయి మరియు తద్వారా బలహీనమైన కరెంట్ ద్వారా ప్రవహించటానికి వీలు కల్పిస్తుంది మరియు బలమైన పుల్ అప్ రెసిస్టర్లు తక్కువ విలువను కలిగి ఉంటాయి, తద్వారా బలమైన ప్రవాహం ప్రవహిస్తుంది. అన్ని MCU ఎక్కువగా బలహీనమైన పుల్ అప్ రెసిస్టర్‌లను ఉపయోగిస్తాయి. మా PIC MCU లో దీన్ని సక్రియం చేయడానికి, దిగువ స్నాప్‌షాట్‌లో చూపిన విధంగా OPTION_REG (ఆప్షన్ రిజిస్టర్) కోసం మా డేటా షీట్‌ను పరిశీలించాలి.

బిట్ 7 చూపిన విధంగా బలహీనమైన పుల్ అప్ రెసిస్టర్‌తో వ్యవహరిస్తుంది. దీన్ని సక్రియం చేయడానికి సున్నా చేయాలి. ఇది OPTION_REG <7> = 0 చేత చేయబడుతుంది. ఇది ప్రత్యేకంగా బిట్ 7 తో ఇతర బిట్లను దాని డిఫాల్ట్ విలువలకు వదిలివేస్తుంది. దీనితో మనం మన లూప్‌లోకి ప్రవేశిస్తాము, ఇక్కడ (RB0 == 0) ఉపయోగించి బటన్ నొక్కినట్లు తనిఖీ చేస్తుంది . పరిస్థితి సంతృప్తి చెందితే మన ఫంక్షన్‌ను 1, 3, 7 మరియు 15 పారామితులతో పిలుస్తాము.

sblink (1); // పారామితి 1 sblink (3) తో ఫంక్షన్ కాల్ 1; పరామితి 3 sblink (7) తో // ఫంక్షన్ కాల్ 3; // పారామితి 7 sblink (15) తో ఫంక్షన్ కాల్ 7; పారామితి 15 తో // ఫంక్షన్ కాల్ 4

మేము ఫంక్షన్లను ఎందుకు ఉపయోగిస్తాము?

మా కోడ్‌లోని పంక్తుల సంఖ్యను తగ్గించడానికి విధులు ఉపయోగించబడతాయి. మనలో చాలామందికి ఇది తెలిసి ఉంటుంది. అయితే మనం పంక్తుల సంఖ్యను ఎందుకు తగ్గించాలి, ముఖ్యంగా MCU ప్రోగ్రామింగ్ విషయానికి వస్తే. కారణం మా ప్రోగ్రామ్ మెమరీలో పరిమిత స్థలం. మేము కోడ్‌ను సరిగ్గా ఆప్టిమైజ్ చేయకపోతే, మనకు మెమరీ స్థలం అయిపోతుంది. మేము సంకేతాల దీర్ఘ పేజీలను వ్రాసేటప్పుడు ఇది ఉపయోగపడుతుంది.

ఏదైనా ఫంక్షన్ ఫంక్షన్ డెఫినిషన్ (మా విషయంలో sblink (int get) ) మరియు ఫంక్షన్ కాల్ (మా విషయంలో sblink (1) ) కలిగి ఉంటుంది. ఫంక్షన్ డిక్లరేషన్ కలిగి ఉండటం ఐచ్ఛికం, దానిని నివారించడానికి నేను ఫంక్షన్‌ను నా ప్రధాన ఫంక్షన్‌లోకి పిలిచే ముందు నా ఫంక్షన్ డెఫినిషన్‌ను ఉంచాను.

ఫంక్షన్ పారామితులు ఫంక్షన్ కాల్ నుండి ఫంక్షన్ నిర్వచనానికి పంపబడే విలువ. మా విషయంలో పూర్ణాంక విలువలు (1, 3, 7, 15) ఫంక్షన్ కాల్ నుండి పంపబడిన పారామితులు మరియు వేరియబుల్ "గెట్" పారామితుల విలువను వాటిని ప్రాసెస్ చేయడానికి ఫంక్షన్ డెఫినిషన్‌లోకి పొందుతుంది. ఒక ఫంక్షన్ ఒకటి కంటే ఎక్కువ పారామితులను కలిగి ఉంటుంది.

ఫంక్షన్ పిలువబడిన తర్వాత, ఫంక్షన్ డెఫినిషన్‌లోని క్రింది పంక్తులు అమలు చేయబడతాయి.

(int i = 0; i <= 7 && RB0 == 0; i ++) {PORTD = get << i; // LED కదలిక ఎడమ సీక్వెన్స్ __delay_ms (50); } for (int i = 7; i> = 0 && RB0 == 0; i--) {PORTD = get << i; // LED కదలిక ఎడమ సీక్వెన్స్ __delay_ms (50); }

ఇప్పుడు ఈ పంక్తి బేసిగా ఉంది: PORTD = పొందండి << i . వాస్తవానికి ఇక్కడ ఏమి జరుగుతుందో నేను వివరిస్తాను.

"<<" అనేది ఎడమ షిఫ్ట్ ఆపరేటర్, ఇది అన్ని బిట్లను దాని ఎడమ స్థానానికి మారుస్తుంది. ఇప్పుడు మనం '1' పారామితితో sblink (int get) ఫంక్షన్‌ను sblink (1) గా పిలిచినప్పుడు, అది 'get' విలువను 1 గా చేస్తుంది, ఇది బైనరీలో 0b00000001. అందువల్ల ఈ పంక్తి PORTD = 0b00000001 << i లాగా ఉంటుంది.

(Int i = 0; i <= 7 && RB0 == 0; i ++) కోసం 'ఫర్ లూప్' ను ఉపయోగించినందున "i" విలువ 0 నుండి 7 వరకు మారుతుంది . 'I' యొక్క విలువ 0 నుండి 7 వరకు ఉండటం ఫలితాన్ని క్రింది విధంగా మారుస్తుంది:

మీరు చూడగలిగినట్లుగా, మిగిలిన వాటిని ఆఫ్‌లో ఉంచడం ద్వారా మేము ఒక సమయంలో (ఎడమ నుండి కుడికి) ఒక LED ని ఆన్ చేసాము. (Int i = 7; i> = 0 && RB0 == 0; i--) కోసం తదుపరి 'ఫర్ లూప్' కూడా అదే చేస్తుంది, అయితే ఈసారి LED ఒక క్రమంలో కుడి నుండి ఎడమకు ఆన్ చేయబడుతుంది, మేము 7 నుండి ప్రారంభించి 0 కి వెళ్తున్నాము. మేము 200ms ఆలస్యాన్ని ఉపయోగించాము, తద్వారా LED ఆన్ మరియు ఆఫ్ చేయబడుతుందని visual హించవచ్చు.

ఇప్పుడు మనం sblink (int get) ఫంక్షన్‌లో విలువ 3 ను దాటినప్పుడు , ఫంక్షన్ sblink (3) అమలు అవుతుంది, ఇది 'get' విలువను 0b00000011 గా చేస్తుంది, అందువల్ల PORTD పై ఫలితం ఉంటుంది:

కాబట్టి ఇప్పుడు ఈసారి రెండు ఎల్‌ఈడీలు ఏ సమయంలోనైనా ఎస్‌బిలింక్ (3) ఉపయోగించి ఆన్ చేయబడతాయి. అదేవిధంగా sblink (7) మరియు sblink (15) కొరకు, మూడు మరియు నాలుగు LED లు వరుసలో ఉంటాయి. ఇది పూర్తయిన తర్వాత మేము అన్ని LED లను PORTD = 0xFF పంక్తిని ఉపయోగించుకునేలా చేస్తాము . పూర్తి ప్రదర్శన కోసం క్రింది వీడియోను తనిఖీ చేయండి.

మీరు కోడ్‌ను అర్థం చేసుకున్నారని మరియు మీకు కావలసిన ఫలితాలను పొందడానికి 'కోసం' మరియు 'అయితే' లూప్‌ను ఎలా ఉపయోగించాలో నేర్చుకున్నారని ఆశిస్తున్నాము. ఎల్‌ఈడీ బ్లింకింగ్ యొక్క మీ విభిన్న క్రమాన్ని పొందడానికి ఇప్పుడు మీరు కోడ్ చుట్టూ సర్దుబాటు చేయవచ్చు. మీ కోడ్‌ను కంపైల్ చేసి, మీ MCU లో డంప్ చేసి, అవుట్‌పుట్‌ను ఆస్వాదించండి. మీరు ఎక్కడో ఇరుక్కుపోతే మీరు వ్యాఖ్య విభాగాన్ని ఉపయోగించవచ్చు. నేను ఇక్కడ అనుకరణ మరియు ప్రోగ్రామ్ ఫైళ్ళను కూడా అటాచ్ చేసాను.

ఇప్పుడే అది మా తదుపరి ట్యుటోరియల్‌లో ఆలస్యం ఫంక్షన్లను ఉపయోగించకుండా PIC16F877A టైమర్‌లను ఎలా ఉపయోగించాలో నేర్చుకుంటాము. మీరు అన్ని PIC మైక్రోకంట్రోలర్ ట్యుటోరియల్‌లను ఇక్కడ బ్రౌజ్ చేయవచ్చు.