ఆర్డునో మల్టీ టాస్కింగ్ ట్యుటోరియల్

బహువిధి సామర్థ్యం, వశ్యత, స్వీకృతి మరియు ఉత్పాదకత పెంచే ఒకటి లేదా ఎక్కువ కార్యక్రమాలు ఏకకాలంలో అమలు చేయగల ఒక విప్లవం కంప్యూటర్లను దారితీసింది. ఎంబెడెడ్ సిస్టమ్స్‌లో, మైక్రోకంట్రోలర్‌లు మల్టీటాస్కింగ్‌ను కూడా నిర్వహించగలవు మరియు ప్రస్తుత సూచనలను ఆపకుండా ఒకేసారి రెండు లేదా అంతకంటే ఎక్కువ పనులను చేస్తాయి.

ఇక్కడ ఈ ట్యుటోరియల్ లో మేము నేర్చుకుంటారు Arduino బహువిధి అమలు ఎలా తో Arduino millis ఫంక్షన్. ఎల్‌ఈడీ బ్లింకింగ్ వంటి ఆవర్తన పని కోసం ఆర్డునోలో సాధారణంగా ఆలస్యం () ఫంక్షన్ ఉపయోగించబడుతుంది, అయితే ఈ ఆలస్యం () ఫంక్షన్ ప్రోగ్రామ్‌ను కొంత ఖచ్చితమైన సమయానికి ఆపివేస్తుంది మరియు ఇతర కార్యకలాపాలను నిర్వహించడానికి అనుమతించవద్దు. కాబట్టి ఈ వ్యాసం మేము ఆలస్యం () ఫంక్షన్‌ను ఉపయోగించడాన్ని ఎలా నివారించవచ్చో మరియు మిల్లీస్ () తో భర్తీ చేయటం ద్వారా ఒకేసారి ఒకటి కంటే ఎక్కువ పనులను చేయగలమని మరియు ఆర్డునోను మల్టీ టాస్కింగ్ కంట్రోలర్‌గా మార్చగలమని వివరిస్తుంది. వివరాల్లోకి వెళ్లేముందు మల్టీ టాస్కింగ్‌ను అర్థం చేసుకోవడం ప్రారంభిద్దాం.

మల్టీ టాస్కింగ్ అంటే ఏమిటి?

మల్టీ టాస్కింగ్ అంటే ఒకే సమయంలో ఒకటి కంటే ఎక్కువ టాస్క్‌లు లేదా ప్రోగ్రామ్‌లను ఒకేసారి అమలు చేయడం. దాదాపు అన్ని ఆపరేటింగ్ సిస్టమ్స్ మల్టీ టాస్కింగ్ కలిగి ఉంటాయి. ఈ రకమైన ఆపరేటింగ్ సిస్టమ్స్‌ను MOS (మల్టీ టాస్కింగ్ ఆపరేటింగ్ సిస్టమ్) అంటారు. MOS మొబైల్ లేదా డెస్క్‌టాప్ PC ఆపరేటింగ్ సిస్టమ్ కావచ్చు. కంప్యూటర్లలో మల్టీ టాస్కింగ్ యొక్క మంచి ఉదాహరణ ఏమిటంటే, వినియోగదారులు ఒకే సమయంలో ఇమెయిల్ అప్లికేషన్, ఇంటర్నెట్ బ్రౌజర్, మీడియా ప్లేయర్, ఆటలను నడుపుతున్నప్పుడు మరియు వినియోగదారులు అప్లికేషన్‌ను ఉపయోగించకూడదనుకుంటే అది మూసివేయబడకపోతే నేపథ్యంలో నడుస్తుంది. తుది వినియోగదారు ఈ అనువర్తనాలన్నింటినీ ఒకే సమయంలో ఉపయోగిస్తాడు, కాని OS ఈ భావనను కొంచెం భిన్నంగా తీసుకుంటుంది. OS మల్టీ టాస్కింగ్‌ను ఎలా నిర్వహిస్తుందో చర్చిద్దాం.

చిత్రంలో చూసినట్లుగా, CPU సమయాన్ని మూడు సమాన భాగాలుగా విభజిస్తుంది మరియు ప్రతి పనిని ప్రతి పనికి / అనువర్తనానికి కేటాయించండి. చాలా వ్యవస్థల్లో మల్టీ టాస్కింగ్ ఈ విధంగా జరుగుతుంది. ఆర్డునో మల్టీ టాస్కింగ్ కోసం ఈ భావన దాదాపు ఒకే విధంగా ఉంటుంది, సమయం పంపిణీ కొంచెం భిన్నంగా ఉంటుంది తప్ప. ఆర్డునో తక్కువ పౌన frequency పున్యంలో నడుస్తుంది కాబట్టి ర్యామ్ ల్యాప్‌టాప్ / మొబైల్ / పిసితో పోల్చబడుతుంది కాబట్టి ప్రతి పనికి ఇచ్చిన సమయం కూడా భిన్నంగా ఉంటుంది. Arduino కూడా ఆలస్యం () ఫంక్షన్‌ను కలిగి ఉంది, ఇది విస్తృతంగా ఉపయోగించబడుతుంది. కానీ ప్రారంభించే ముందు మనం ఏ ప్రాజెక్ట్‌లోనైనా ఆలస్యం () ఫంక్షన్‌ను ఎందుకు ఉపయోగించకూడదో చర్చించుకుందాం .

Arduino లో ఆలస్యం () ను ఎందుకు దాటవేయాలి?

ఆర్డునో యొక్క రిఫరెన్స్ డాక్యుమెంటేషన్ పరిగణించబడితే రెండు రకాల ఆలస్యం విధులు ఉన్నాయి, మొదటిది ఆలస్యం () మరియు రెండవది ఆలస్యం మైక్రోసెకన్లు (). ఆలస్యాన్ని ఉత్పత్తి చేసే విషయంలో రెండు విధులు ఒకేలా ఉంటాయి. ఒకే తేడా ఏమిటంటే, ఆలస్యం () ఫంక్షన్‌లో, పరామితి పూర్ణాంకం మిల్లీసెకన్లలో ఉంటుంది, అంటే మనం ఆలస్యం (1000) వ్రాస్తే ఆలస్యం 1000 మిల్లీసెకన్లు, అంటే 1 సెకను. అదేవిధంగా ఆలస్యం మైక్రోసెకండ్లు () ఫంక్షన్‌లో, ఆమోదించిన పరామితి మైక్రోసెకన్లలో ఉంటుంది, అంటే మనం ఆలస్యం మైక్రోసెకన్లు (1000) వ్రాస్తే, ఆలస్యం 1000 మైక్రోసెకన్లు అంటే 1 మిల్లీసెకన్లు.

ఇక్కడ పాయింట్ వస్తుంది, రెండు ఫంక్షన్లు ఆలస్యం ఫంక్షన్‌లో గడిచిన సమయానికి ప్రోగ్రామ్‌ను పాజ్ చేస్తాయి. కాబట్టి మేము 1 సెకన్ల ఆలస్యం ఇస్తుంటే, 1 సెకను గడిచే వరకు ప్రాసెసర్ తదుపరి సూచనలకు వెళ్ళదు. అదేవిధంగా ఆలస్యం 10 సెకన్లు అయితే ప్రోగ్రామ్ 10 సెకన్ల పాటు ఆగిపోతుంది మరియు 10 సెకన్లు గడిచే వరకు ప్రాసెసర్ తదుపరి సూచనల కోసం వెళ్ళడానికి అనుమతించదు. ఇది మైక్రోకంట్రోలర్ యొక్క పనితీరును వేగం మరియు సూచనలను అమలు చేయడంలో ఆటంకం కలిగిస్తుంది.

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

ఆర్డునో యొక్క అధికారిక డాక్యుమెంటేషన్ దాని నోట్స్ మరియు హెచ్చరికల ఆలస్యం () ఫంక్షన్ వివరణలో స్పష్టంగా పేర్కొంది. మరింత స్పష్టంగా చెప్పడానికి మీరు దీన్ని పరిశీలించవచ్చు.

మిల్లీస్ () ను ఎందుకు ఉపయోగించాలి?

ఆలస్యాన్ని ఉపయోగించడం వల్ల కలిగే సమస్యను అధిగమించడానికి, డెవలపర్ మిల్లిస్ () ఫంక్షన్‌ను ఉపయోగించాలి, ఇది మీరు అలవాటు అయిన తర్వాత ఉపయోగించడం సులభం మరియు ఇది సూచనలను అమలు చేయడంలో ఆలస్యం చేయకుండా 100% CPU పనితీరును ఉపయోగిస్తుంది. మిల్లిస్ () అనేది ఒక ఫంక్షన్, ఇది ఆర్డునో బోర్డు ప్రస్తుత ప్రోగ్రామ్‌ను స్తంభింపజేయకుండా అమలు చేయడం ప్రారంభించినప్పటి నుండి గడిచిన మిల్లీసెకన్ల మొత్తాన్ని తిరిగి ఇస్తుంది. ఈ సమయం సంఖ్య సుమారు 50 రోజుల తరువాత పొంగిపోతుంది (అనగా సున్నాకి తిరిగి వెళ్ళు).

ఆర్డునోకు ఆలస్యం మైక్రోసెకన్లు () ఉన్నట్లే, దీనికి మిల్లిస్ () యొక్క మైక్రో వెర్షన్ కూడా మైక్రో () గా ఉంటుంది . మైక్రోలు మరియు మిల్లీస్ మధ్య వ్యత్యాసం ఏమిటంటే, మైక్రోస్ () సుమారు 70 నిమిషాల తర్వాత పొంగిపోతుంది, మిల్లీస్ () తో పోలిస్తే ఇది 50 రోజులు. కాబట్టి అనువర్తనాన్ని బట్టి మీరు మిల్లీస్ () లేదా మైక్రో () ను ఉపయోగించవచ్చు.

ఆలస్యం () కు బదులుగా మిల్లీస్ () ను ఉపయోగించడం:

సమయం మరియు ఆలస్యం కోసం మిల్లీస్ () ను ఉపయోగించడానికి, మీరు సమయం ప్రారంభించడానికి చర్య జరిగిన సమయాన్ని రికార్డ్ చేసి నిల్వ చేయాలి మరియు నిర్వచించిన సమయం గడిచిందో లేదో విరామాలలో తనిఖీ చేయాలి. కాబట్టి చెప్పినట్లుగా, ప్రస్తుత సమయాన్ని వేరియబుల్‌లో నిల్వ చేయండి.

సంతకం చేయని దీర్ఘ కరెంట్మిల్లిస్ = మిల్లిస్ ();

అవసరమైన సమయం గడిచిందో లేదో తెలుసుకోవడానికి మాకు మరో రెండు వేరియబుల్స్ అవసరం. మేము ప్రస్తుత సమయాన్ని కరెంట్‌మిల్లిస్ వేరియబుల్‌లో నిల్వ చేసాము, కాని టైమింగ్ పీరియడ్ ఎప్పుడు ప్రారంభమైంది మరియు కాలం ఎంత అని కూడా తెలుసుకోవాలి. కాబట్టి ఇంటర్వెల్ మరియు మునుపటి మిల్లిస్ ప్రకటించబడ్డాయి. విరామం సమయం ఆలస్యాన్ని మాకు తెలియజేస్తుంది మరియు ఈవెంట్ జరిగిన చివరిసారి ప్రివియోస్మిల్లిస్ నిల్వ చేస్తుంది.

సంతకం చేయని దీర్ఘ మునుపటి మిల్లిస్; సంతకం చేయని దీర్ఘ కాలం = 1000;

దీన్ని అర్థం చేసుకోవడానికి, సరళమైన మెరిసే LED కి ఉదాహరణ తీసుకుందాం. కాలం = 1000 ఎల్‌ఈడీ 1 సెకను లేదా 1000 ఎంఎస్‌ల వరకు మెరిసిపోతుందని మాకు తెలియజేస్తుంది.

const int ledPin = 4; // LED పిన్ నంబర్ కనెక్ట్ చేయబడిన int ledState = LOW; // LED స్థితిని సంతకం చేయడానికి ఉపయోగించని దీర్ఘ మునుపటి మిల్లిస్ = 0; // చివరిసారిగా ఎల్‌ఈడీ రెప్పపాటులో నిల్వ చేయబడుతుంది const long period = 1000; // శూన్య సెటప్ () { పిన్‌మోడ్ (లెడ్‌పిన్, U ట్‌పుట్ ) లో మెరిసే కాలం; // లెడ్‌పిన్‌ను అవుట్‌పుట్‌గా సెట్ చేయండి } శూన్య లూప్ () { సంతకం చేయని లాంగ్ కరెంట్మిల్లిస్ = మిల్లిస్ (); // ప్రస్తుత సమయాన్ని నిల్వ చేస్తే (కరెంట్‌మిల్లిస్ - మునుపటి మిల్లిస్> = కాలం) {// 1000 మి.మి.లు మునుపటి మిల్లిస్ = కరెంట్‌మిల్లిస్ దాటిందో లేదో తనిఖీ చేయండి ; // మీరు ఎల్‌ఈడీని బ్లింక్ చేసిన చివరిసారి సేవ్ చేస్తే (ledState == LOW) {// LED ఆఫ్‌లో ఉంటే దాన్ని ఆన్ చేసి, దీనికి విరుద్ధంగా ledState = HIGH; } else { ledState = తక్కువ; } డిజిటల్ రైట్ (లెడ్‌పిన్, లెడ్‌స్టేట్); // మళ్లీ రెప్పపాటుకు లెడ్‌స్టేట్‌తో LED సెట్ చేయండి } }

ఇక్కడ, ప్రకటన = కాలం)> 1000ms గడిచిందో లేదో తనిఖీ చేస్తుంది. 1000ms దాటితే, అప్పుడు LED బ్లింక్ మరియు మళ్ళీ అదే స్థితికి వస్తుంది. మరియు ఇది కొనసాగుతుంది. అంతే, ఆలస్యం కాకుండా మిల్లీస్ వాడటం నేర్చుకున్నాం. ఈ విధంగా ఇది నిర్దిష్ట విరామం కోసం ప్రోగ్రామ్‌ను ఆపదు.

ఆర్డునోలో అంతరాయాలు ఇతర మైక్రోకంట్రోలర్‌ల మాదిరిగానే పనిచేస్తాయి. GPIO పిన్ 2 మరియు 3 లలో అంతరాయాలను అటాచ్ చేయడానికి Arduino UNO బోర్డు రెండు వేర్వేరు పిన్‌లను కలిగి ఉంది. మేము దీనిని Arduino Interrupts Tutorial లో వివరంగా కవర్ చేసాము, ఇక్కడ మీరు అంతరాయాల గురించి మరియు వాటిని ఎలా ఉపయోగించాలో తెలుసుకోవచ్చు.

ఇక్కడ మేము ఒకేసారి రెండు పనులను నిర్వహించడం ద్వారా ఆర్డునో మల్టీ టాస్కింగ్ చూపిస్తాము . ఎల్‌ఈడీ ఆన్ / ఆఫ్ స్థితిని నియంత్రించడానికి ఉపయోగపడే పుష్ బటన్‌తో పాటు వేర్వేరు సమయ ఆలస్యంలో రెండు ఎల్‌ఈడీలను మెరిసే పనులు ఉంటాయి. కాబట్టి ఒకేసారి మూడు పనులు నిర్వహించబడతాయి.

భాగాలు అవసరం

• ఆర్డునో UNO
• మూడు LED లు (ఏదైనా రంగు)
• ప్రతిఘటనలు (470, 10 కే)
• జంపర్స్
• బ్రెడ్‌బోర్డ్

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

ఆర్డునో మిల్లిస్ () ఫక్షన్ వాడకాన్ని ప్రదర్శించడానికి సర్క్యూట్ రేఖాచిత్రం చాలా సులభం మరియు క్రింద చూపిన విధంగా అటాచ్ చేయడానికి ఎక్కువ భాగాలు లేవు.

మల్టీటాస్కింగ్ కోసం ప్రోగ్రామింగ్ Arduino UNO

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

LED లు మరియు పుష్ బటన్ అనుసంధానించబడిన పిన్ నంబర్లను ప్రకటించడంతో ప్రోగ్రామింగ్ ప్రారంభమవుతుంది.

int led1 = 6; int led2 = 7; int టోగుల్లేడ్ = 5; int pushButton = 2;

భవిష్యత్తులో ఉపయోగం కోసం LED ల యొక్క స్థితిని నిల్వ చేయడానికి మేము వేరియబుల్ వ్రాస్తాము.

int ledState1 = తక్కువ; int ledState2 = తక్కువ;

బ్లింక్ ఉదాహరణలో పైన వివరించినట్లుగా, పీరియడ్ మరియు మునుపటి మిల్లిస్ యొక్క వేరియబుల్స్ LED లను పోల్చడానికి మరియు ఆలస్యాన్ని ఉత్పత్తి చేయడానికి ప్రకటించబడ్డాయి. మొదటి ఎల్‌ఈడీ ప్రతి 1 సెకను తర్వాత మెరిసిపోతుంది మరియు మరొక ఎల్‌ఇడి 200 ఎంఎస్‌ల తర్వాత మెరిసిపోతుంది.

సంతకం చేయని దీర్ఘ మునుపటిమిల్లిస్ 1 = 0; const long period1 = 1000; సంతకం చేయని దీర్ఘ మునుపటిమిల్లిస్ 2 = 0; const long period2 = 200;

పుష్ బటన్ యొక్క బహుళ ప్రెస్‌లను నివారించడానికి డీబౌన్స్ ఆలస్యాన్ని రూపొందించడానికి మరొక మిల్లీస్ ఫంక్షన్ ఉపయోగించబడుతుంది. పైన చెప్పిన విధంగానే ఉంటుంది.

int debouncePeriod = 20; int debounceMillis = 0;

మూడు వేరియబుల్స్ ఆటంకం వంటి పుష్ బటన్ స్థితి నిల్వ ఉపయోగించబడుతుంది టోగుల్ LED మరియు పుష్ బటన్ రాష్ట్ర.

bool buttonPush = తప్పుడు; int ledChange = తక్కువ; int lastState = HIGH;

పిన్ యొక్క చర్యను నిర్వచించండి, ఏ పిన్ INPUT లేదా OUTPUT గా పని చేస్తుంది.

పిన్‌మోడ్ (led1, OUTPUT); పిన్‌మోడ్ (led2, OUTPUT); పిన్‌మోడ్ (టోగుల్‌లేడ్, U ట్పుట్); పిన్ మోడ్ (పుష్బటన్, INPUT);

ISR యొక్క నిర్వచనం మరియు అంతరాయ మోడ్‌తో అంతరాయాన్ని అటాచ్ చేయడం ద్వారా ఇప్పుడు అంతరాయ పిన్ను నిర్వచించండి. వాస్తవ డిజిటల్ పిన్ను నిర్దిష్ట అంతరాయ సంఖ్యకు అనువదించడానికి అటాచ్ఇంటరప్ట్ () ఫంక్షన్‌ను ప్రకటించేటప్పుడు డిజిటల్ పిన్‌టోఇంటరప్ట్ (పిన్_నంబర్) ను ఉపయోగించమని సిఫార్సు చేయబడింది.

అటాచ్ఇంటరప్ట్ (డిజిటల్ పిన్టోఇంటరప్ట్ (పుష్బటన్), పుష్బటన్_ఐఎస్ఆర్, మార్పు);

అంతరాయ సబ్‌ట్రౌటిన్ వ్రాయబడింది మరియు ఇది బటన్ పుష్డ్ ఫ్లాగ్‌ను మాత్రమే మారుస్తుంది. గమనించండి, అంతరాయం కలిగించే సబ్‌ట్రౌటిన్ సాధ్యమైనంత తక్కువగా ఉండాలి, కాబట్టి దీన్ని వ్రాయడానికి ప్రయత్నించండి మరియు అదనపు సూచనలను తగ్గించండి.

void pushButton_ISR () { buttonPush = true; }

కరెంట్ మిల్లిస్ వేరియబుల్‌లో మిల్లీస్ విలువను నిల్వ చేయడం ద్వారా లూప్ మొదలవుతుంది, ఇది లూప్ పునరావృతమయ్యే ప్రతిసారీ గడిచిన సమయం విలువను నిల్వ చేస్తుంది.

సంతకం చేయని దీర్ఘ కరెంట్మిల్లిస్ = మిల్లిస్ ();

మల్టీటాస్కింగ్‌లో మొత్తం మూడు ఫంక్షన్లు ఉన్నాయి, 1 సెకనుకు ఒక ఎల్‌ఇడి, 200 ఎమ్‌ల వద్ద బ్లింక్ సెకండ్ ఎల్‌ఇడి మరియు పుష్ బటన్ నొక్కితే ఆఫ్ / ఆన్ ఎల్‌ఇడి మారండి. కాబట్టి ఈ పని చేయడానికి మేము మూడు భాగాలు వ్రాస్తాము.

మొదటి millis పోల్చడం ద్వారా ప్రతి 1 రెండవ తర్వాత LED రాష్ట్ర toggles గతించిన ఉంది.

if (currentMillis - previousMillis1> = period1) { previousMillis1 = currentMillis; if (ledState1 == LOW) { ledState1 = HIGH; } else { ledState1 = తక్కువ; } డిజిటల్ రైట్ (led1, ledState1); }

అదేవిధంగా రెండవది గడిచిన మిల్లీస్‌ను పోల్చడం ద్వారా ప్రతి 200ms తర్వాత LED ని టోగుల్ చేస్తుంది. వివరణ ఇప్పటికే ఈ వ్యాసంలో వివరించబడింది.

if (currentMillis - previousMillis2> = period2) { previousMillis2 = currentMillis; if (ledState2 == LOW) { ledState2 = HIGH; } else { ledState2 = తక్కువ; } డిజిటల్ రైట్ (led2, ledState2); }

చివరగా, బటన్‌పష్డ్ జెండా పర్యవేక్షించబడుతుంది మరియు 20ms డీబౌన్స్ ఆలస్యాన్ని సృష్టించిన తర్వాత అది LED స్థితిని టోగుల్ చేస్తుంది.

if (buttonPush = true) // ISR అని పిలువబడిందో లేదో తనిఖీ చేయండి { if ((currentMillis - debounceMillis)> debouncePeriod && buttonPush) // బహుళ ప్రెస్‌లను నివారించడానికి 20ms డీబౌన్స్ ఆలస్యాన్ని ఉత్పత్తి చేస్తుంది { debounceMillis = currentMillis; (డిజిటల్ రీడ్ (పుష్బటన్) == తక్కువ && లాస్ట్‌స్టేట్ == హై) // పుష్ బటన్ నొక్కిన తర్వాత లీడ్‌ను మార్చినట్లయితే చివరి డీబౌన్స్ ఆలస్యం సమయాన్ని ఆదా చేయండి { ledChange =! ledChange; డిజిటల్ రైట్ (టోగుల్ లెడ్, లెడ్ చేంజ్); lastState = తక్కువ; } else if (DigitalRead (pushButton) == HIGH && lastState == LOW) { lastState = HIGH; } buttonPush = తప్పుడు; } }

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

Arduino లో మిల్లీస్ ఫంక్షన్ యొక్క ఉపయోగాన్ని ప్రదర్శించడానికి పూర్తి కోడ్ మరియు వీడియో క్రింద ఇవ్వబడింది.