Arduino मल्टीटास्किंग ट्यूटोरियल

मल्टीटास्किंग एक क्रांति जहां एक या अधिक कार्यक्रमों को एक साथ चला सकते हैं जो बढ़ जाती है दक्षता, लचीलापन, अनुकूलनशीलता और उत्पादकता के लिए कंप्यूटर का नेतृत्व किया है। एम्बेडेड सिस्टम में, माइक्रोकंट्रोलर मल्टीटास्किंग को भी संभाल सकते हैं और वर्तमान निर्देशों को रोकने के बिना एक साथ दो या अधिक कार्य करते हैं।

यहाँ इस ट्यूटोरियल में हम सीखेंगे कि कैसे Arduino Arduino millis फ़ंक्शन के साथ मल्टीटास्किंग करता है । आम तौर पर एक विलंब कार्य () फ़ंक्शन का उपयोग एलईडी ब्लिंकिंग जैसे आवधिक कार्य के लिए किया जाता है, लेकिन यह विलंब () फ़ंक्शन कुछ निश्चित समय के लिए कार्यक्रम को रोक देता है और अन्य कार्यों को करने की अनुमति नहीं देता है। तो यह लेख बताता है कि हम देरी () फ़ंक्शन के उपयोग से कैसे बच सकते हैं और इसे एक साथ एक से अधिक कार्य करने के लिए मिलिस () के साथ बदल सकते हैं और Arduino को मल्टीटास्किंग नियंत्रक बना सकते हैं । विस्तार में जाने से पहले, मल्टीटास्किंग को समझने के साथ शुरू करते हैं।

मल्टीटास्किंग क्या है?

मल्टीटास्किंग का अर्थ है एक ही समय में एक साथ एक से अधिक कार्य या प्रोग्राम को निष्पादित करना। लगभग सभी ऑपरेटिंग सिस्टम में मल्टीटास्किंग की सुविधा है। इस तरह के ऑपरेटिंग सिस्टम को MOS (मल्टीटास्किंग ऑपरेटिंग सिस्टम) के रूप में जाना जाता है। MOS मोबाइल या डेस्कटॉप पीसी ऑपरेटिंग सिस्टम हो सकता है। कंप्यूटर में मल्टीटास्किंग का सबसे अच्छा उदाहरण है जब उपयोगकर्ता ईमेल एप्लिकेशन, इंटरनेट ब्राउज़र, मीडिया प्लेयर, गेम चलाते हैं, और यदि उपयोगकर्ता नहीं चाहते हैं कि एप्लिकेशन बंद होने पर पृष्ठभूमि में चलता है। अंतिम उपयोगकर्ता एक ही समय में इन सभी अनुप्रयोगों का उपयोग करता है लेकिन ओएस इस अवधारणा को थोड़ा अलग लेता है। आइए चर्चा करते हैं कि ओएस मल्टीटास्किंग का प्रबंधन कैसे करता है।

जैसा कि चित्र में देखा गया है, सीपीयू समय को तीन समान भागों में विभाजित करता है और प्रत्येक भाग को प्रत्येक कार्य / अनुप्रयोग में नियत करता है। इस तरह से अधिकांश सिस्टम में मल्टीटास्किंग की जाती है। Arduino मल्टीटास्किंग के लिए अवधारणा लगभग समान होगी, सिवाय समय वितरण के थोड़ा अलग होगा। चूंकि Arduino कम आवृत्ति में चलता है और RAM की तुलना Laptop / Mobile / PC से की जाती है, इसलिए प्रत्येक कार्य के लिए दिया गया समय भी अलग होगा। Arduino में एक देरी () फ़ंक्शन भी है जिसका व्यापक रूप से उपयोग किया जाता है। लेकिन शुरू करने से पहले आइए चर्चा करें कि हमें किसी भी परियोजना में देरी () फ़ंक्शन का उपयोग क्यों नहीं करना चाहिए ।

Arduino में देरी () क्यों छोड़ें?

यदि Arduino के संदर्भ प्रलेखन पर विचार किया जाता है, तो दो प्रकार के विलंब कार्य हैं, पहला है देरी () और दूसरा है देरीमाइक्रोसेकंड () । देरी उत्पन्न करने के मामले में दोनों कार्य समान हैं। अंतर केवल इतना है कि, देरी () फ़ंक्शन में, पारित किया गया पूर्णांक मिलीसेकंड में होता है अर्थात यदि हम देरी (1000) लिखते हैं तो विलंब 1000 मिलीसेकंड यानी 1 सेकंड का होगा। इसी तरह देरीमाइक्रोसेकंड () फ़ंक्शन में, पारित पैरामीटर माइक्रोसेकंड में होता है अर्थात यदि हम देरी को लिखते हैं (1000), तो देरी 1000 माइक्रोसेकंड यानी 1 मिलीसेकंड की होगी।

यहाँ बिंदु आता है, दोनों फ़ंक्शन विलंब फ़ंक्शन में पारित समय की मात्रा के लिए कार्यक्रम को रोकते हैं। इसलिए यदि हम 1 सेकंड की देरी दे रहे हैं तो प्रोसेसर अगले निर्देश तक नहीं जा सकता है जब तक कि 1 सेकंड न बीत जाए। इसी तरह अगर देरी 10 सेकंड है तो प्रोग्राम 10 सेकंड के लिए बंद हो जाएगा और प्रोसेसर 10 सेकंड बीतने तक अगले निर्देशों के लिए जाने की अनुमति नहीं देगा। यह गति और निर्देशों को निष्पादित करने के संदर्भ में माइक्रोकंट्रोलर के प्रदर्शन को बाधित करता है।

विलंब फ़ंक्शन की खामी को समझाने के लिए सबसे अच्छा उदाहरण दो पुश बटन का उपयोग करना है। विचार करें कि हम दो पुश बटन का उपयोग करके दो एल ई डी टॉगल करना चाहते हैं। इसलिए यदि एक पुश बटन को धक्का दिया जाता है, तो संबंधित एलईडी को 2 सेकंड के लिए चमकना चाहिए, इसी तरह यदि दूसरा धक्का दिया जाता है तो एलईडी को 4 सेकंड के लिए चमकना चाहिए। लेकिन जब हम देरी का उपयोग करते हैं (), यदि उपयोगकर्ता पहला बटन दबा रहा है तो कार्यक्रम 2 सेकंड के लिए बंद हो जाएगा और यदि उपयोगकर्ता 2 सेकंड देरी से पहले दूसरा बटन दबाता है, तो माइक्रोकंट्रोलर इनपुट को स्वीकार नहीं करेगा जैसा कि कार्यक्रम है पड़ाव अवस्था में।

Arduino के आधिकारिक दस्तावेज़ीकरण में इसके नोट्स और चेतावनियों में देरी () फ़ंक्शन विवरण का स्पष्ट रूप से उल्लेख है। आप इसे और अधिक स्पष्ट करने के लिए इसे देख सकते हैं और देख सकते हैं।

चक्की () का उपयोग क्यों करें?

देरी का उपयोग करने के कारण होने वाली समस्या को दूर करने के लिए, एक डेवलपर को मिलिस () फ़ंक्शन का उपयोग करना चाहिए जो एक बार उपयोग करने के बाद आसान हो जाता है और निर्देशों को निष्पादित करने में कोई देरी किए बिना यह 100% सीपीयू प्रदर्शन का उपयोग करेगा। मिलिस () एक ऐसा कार्य है जो सिर्फ अरुडिनो बोर्ड द्वारा कार्यक्रम को फ्रीज किए बिना चालू कार्यक्रम को शुरू करने के बाद से मिली हुई राशि को लौटा देता है। लगभग 50 दिनों के बाद इस बार संख्या ओवरफ्लो हो जाएगी (यानी शून्य पर वापस जाएगी)।

जैसे अरुडिनो में देरीमाइक्रोसेकंड () है, इसमें माइक्रो (माइक्रो) के रूप में मिली () का माइक्रो संस्करण भी है । माइक्रो और मिलिस के बीच का अंतर यह है कि, मिलिस () जो कि 50 दिनों का है, की तुलना में लगभग 70 मिनट बाद माइक्रो () ओवरफ्लो हो जाएगा। तो आवेदन के आधार पर आप मिलिस () या माइक्रो () का उपयोग कर सकते हैं।

देरी के बजाय मिलिस () का उपयोग करना:

समय और देरी के लिए मिलिस () का उपयोग करने के लिए, आपको उस समय को रिकॉर्ड करने और संग्रहीत करने की आवश्यकता होती है जिस पर कार्रवाई समय शुरू करने के लिए हुई थी और फिर अंतराल पर जांच करें कि क्या परिभाषित समय बीत चुका है। जैसा कि कहा गया है, एक चर में वर्तमान समय को संग्रहीत करें।

अहस्ताक्षरित लंबी currentMillis = मिली ();

हमें यह जानने के लिए दो और चर की आवश्यकता है कि क्या आवश्यक समय बीत चुका है । हमने वर्तमान समय को करंटमिलिस वैरिएबल में संग्रहित किया है, लेकिन हमें यह भी जानना होगा कि समय अवधि कब शुरू हुई और यह अवधि कब तक है। तो अंतराल और previousMillis घोषित किया जाता है। अंतराल हमें समय की देरी के बारे में बताएगा और प्रीवियोमिलिस अंतिम बार जब घटना हुई है, तो उसे स्टोर करेगा।

अहस्ताक्षरित लंबी पिछली मिलिस; अहस्ताक्षरित लंबी अवधि = 1000;

इसे समझने के लिए, आइए एक साधारण ब्लिंकिंग एलईडी का उदाहरण लें। अवधि = 1000 हमें बताएगी कि एलईडी 1 सेकंड या 1000ms के लिए ब्लिंक करेगा।

const int ledPin = 4; // एलईडी पिन नंबर जुड़ा हुआ int ledState = LOW; // एलईडी राज्य को लंबे समय तक चलने के लिए इस्तेमाल किया गया है // पिछली बार स्टोर करेगा एलईडी कांस्टेड कास्ट लंबी अवधि = 1000 थी; // अवधि जिसमें एमएस शून्य सेटअप () { पिनमोड (ledPin, OUTPUT) में पलक झपकने के लिए; // सेट ledpin आउटपुट के रूप में } शून्य लूप () { अहस्ताक्षरित लंबी currentMillis = मिली (); // वर्तमान समय को स्टोर करें यदि (currentMillis - lastMillis> = period) {// चेक करें कि क्या 1000 मी पिछला मेमिलिस = currentMillis पास हुआ है; // पिछली बार जब आपने एलईडी को ब्लिंक किया है तो उसे सेव करें (ledState == LOW) {// अगर LED ऑफ है तो उसे ऑन करें और इसके विपरीत- ledState = HIGH; } और { ledState = LOW; } digitalWrite (ledPin, ledState); // फिर से पलक झपकने के लिए ledState के साथ LED सेट करें } }

यहाँ, बयान = अवधि)> 1000ms पारित कर दिया है, तो जाँच करता है। यदि 1000ms बीत चुके हैं, तो एलईडी झपकी और फिर से उसी स्थिति में आता है। और यही चलता है। यही है, हमने देरी के बजाय मिलिस का उपयोग करना सीख लिया है। इस तरह से यह विशेष अंतराल के लिए कार्यक्रम को रोक नहीं पाएगा।

Arduino में व्यवधान अन्य माइक्रोकंट्रोलर की तरह ही काम करता है। Arduino UNO बोर्ड में GPIO पिन 2 और 3 पर इंटरप्ट को संलग्न करने के लिए दो अलग-अलग पिन हैं। हमने इसे Arduino Interrupts Tutorial में विस्तार से कवर किया है, जहां आप इंटरप्ट के बारे में अधिक जान सकते हैं और उनका उपयोग कैसे करें।

यहां हम एक ही समय में दो कार्यों को संभालकर Arduino Multitasking दिखाएंगे । कार्यों में एक पुश बटन के साथ अलग-अलग समय की देरी में दो एलईडी को ब्लिंक करना शामिल होगा जो कि एलईडी की चालू / बंद स्थिति को नियंत्रित करने के लिए उपयोग किया जाएगा। तो तीन कार्य एक साथ किए जाएंगे।

अवयव आवश्यक

• Arduino UNO
• तीन एल ई डी (कोई भी रंग)
• प्रतिरोध (470, 10k)
• जम्परों
• ब्रेड बोर्ड

सर्किट आरेख

Arduino Millis () फ़्यूज़न के उपयोग को प्रदर्शित करने के लिए सर्किट आरेख बहुत आसान है और इसमें नीचे दिखाए गए अनुसार बहुत सारे घटक नहीं हैं।

मल्टीटास्किंग के लिए Arduino UNO प्रोग्रामिंग

मल्टीटास्किंग के लिए Arduino UNO प्रोग्रामिंग केवल मिलिस () काम के पीछे तर्क की आवश्यकता होगी जो ऊपर बताया गया है। मल्टीटास्किंग के लिए Arduino UNO को शुरू करने से पहले तर्क को स्पष्ट करने और मिलिस () के साथ खुद को सहज बनाने के लिए बार-बार मिलिस का उपयोग करके पलक एलईडी का अभ्यास करने की सिफारिश की जाती है । इस ट्यूटोरियल में मल्टीटास्किंग के लिए एक साथ मिलिस () के साथ इंटरप्ट का भी उपयोग किया जाता है। बटन एक व्यवधान होगा । इसलिए जब भी कोई बाधा उत्पन्न होती है यानी पुश बटन दबाया जाता है, तो एलईडी चालू या बंद अवस्था में आ जाएगी।

प्रोग्रामिंग की शुरुआत पिन नंबर घोषित करने से होती है, जहां एलईडी और पुश बटन जुड़े होते हैं।

int led1 = 6; int led2 = 7; int toggleLed = 5; int pushButton = 2;

आगे हम भविष्य के उपयोग के लिए एलईडी की स्थिति को संग्रहीत करने के लिए एक चर लिखते हैं।

int ledState1 = कम; int ledState2 = कम;

जैसा कि ब्लिंक उदाहरण में ऊपर बताया गया है, एलईड्स के लिए देरी और तुलना करने के लिए अवधि और पूर्वमिलिस के लिए चर घोषित किए जाते हैं । पहला LED हर 1 सेकंड के बाद पलक झपकता है और दूसरा LED 200ms के बाद झपकाता है।

अहस्ताक्षरित लंबे समय तक पिछलाMillis1 = 0; const लंबी अवधि 1 = 1000; अहस्ताक्षरित लंबे समय तक चली पिछला 2 = 0; const लंबी अवधि 2 = 200;

एक और मिलिस फ़ंक्शन का उपयोग पुश बटन के कई प्रेस से बचने के लिए बहस में देरी उत्पन्न करने के लिए किया जाएगा । ऊपर के समान दृष्टिकोण होगा।

int debouncePeriod = 20; int debounceMillis = 0;

तीन चर बाधा के रूप में पुश बटन की स्थिति स्टोर करने के लिए इस्तेमाल किया जाएगा, एलईडी और पुश बटन राज्य टॉगल।

बूल बटनPushed = false; int ledChange = LOW; int lastState = उच्च;

पिन की क्रिया को परिभाषित करें कि कौन सा पिन INPUT या OUTPUT के रूप में काम करेगा।

पिनमोड (led1, OUTPUT); पिनमोड (led2, OUTPUT); पिनमोड (टॉगल लेड, आउटपूट); पिनमोड (पुशबटन, INPUT);

अब ISR और इंटरप्ट मोड की परिभाषा के साथ इंटरप्ट संलग्न करके इंटरप्ट पिन को परिभाषित करें। ध्यान दें कि जब अटैचमेंट () फ़ंक्शन को वास्तविक डिजिटल पिन को विशिष्ट बीच की संख्या में बदलने के लिए फ़ंक्शन की घोषणा करते समय digitalPinToInterrupt (pin_number) का उपयोग करने की अनुशंसा की जाती है ।

संलग्न करें

इंटरप्रिट सबरूटीन लिखा गया है और यह केवल बटन को बदल देगा ध्वज। ध्यान दें कि, इंटरप्रिट सबरूटिन यथासंभव छोटा होना चाहिए, इसलिए इसे लिखने का प्रयास करें और अतिरिक्त निर्देशों को कम से कम करें।

शून्य पुशबटन_आईएसआर () { बटन दबाया = सच; }

लूप एक करंटमैलिस वैरिएबल में मिली वैल्यू को स्टोर करने के साथ शुरू होता है जो लूप के चलने पर हर बार गुजारे गए समय के मूल्य को स्टोर करेगा।

अहस्ताक्षरित लंबी currentMillis = मिली ();

मल्टीटास्किंग में कुल तीन कार्य होते हैं, 1 सेकंड में एक एलईडी को ब्लिंक करना, 200ms में दूसरी एलईडी को ब्लिंक करना और यदि पुश बटन को दबाया जाता है तो LED / ON को स्विच करें । इसलिए हम इस कार्य को करने के लिए तीन भाग लिखेंगे।

पहले मिली सेकंड की तुलना द्वारा हर 1 सेकंड के बाद एलईडी राज्य टॉगल गुजरे है।

if (currentMillis - lastMillis1> = period1) { पिछलेMillis1 = currentMillis; if (ledState1 == कम) { ledState1 = उच्च; } और { ledState1 = कम; } digitalWrite (led1, ledState1); }

इसी तरह दूसरी बार यह एलैपेड मिलिस की तुलना करके प्रत्येक 200ms के बाद एलईडी को टॉगल करता है। स्पष्टीकरण इस लेख में पहले ही समझाया जा चुका है।

if (currentMillis - lastMillis2> = period2) { पिछलेMillis2 = currentMillis; if (ledState2 == कम) { ledState2 = उच्च; } और { ledState2 = कम; } digitalWrite (led2, ledState2); }

अन्त में, buttonPushed झंडा नजर रखी जाती है और 20ms के एक debounce देरी पैदा करने के बाद यह सिर्फ पुश बटन के लिए एलईडी मेल खाती बाधा के रूप में संलग्न की स्थिति टॉगल करता है।

अगर (buttonPushed = true) // जांच अगर ISR कहा जाता है { अगर ((currentMillis - debounceMillis)> debouncePeriod && buttonPushed) // 20ms debounce देरी एकाधिक प्रेस से बचने के लिए उत्पन्न { debounceMillis = currentMillis; // अंतिम डिबेट में देरी का समय बचाएं अगर (digitalRead (pushButton) == LOW && lastState == HIGH) // पुश बटन दबाए जाने के बाद एलईडी को बदलें { ledChange =! ledChange; digitalWrite (toggleLed, ledChange); lastState = LOW; } और अगर (digitalRead (pushButton) == High && lastState == कम) { lastState = HIGH; } buttonPushed = false; } }

यह Arduino millis () ट्यूटोरियल को पूरा करता है । ध्यान दें कि मिलिस () के साथ अभ्यस्त होने के लिए , कुछ अन्य अनुप्रयोगों में इस तर्क को लागू करने के लिए बस अभ्यास करें। आप इसका विस्तार मोटर्स, इमदादी मोटर्स, सेंसर और अन्य बाह्य उपकरणों का उपयोग करने के लिए भी कर सकते हैं। किसी भी संदेह के मामले में, कृपया हमारे मंच पर लिखें या नीचे टिप्पणी करें।

Arduino में मिलिस फ़ंक्शन के उपयोग को प्रदर्शित करने के लिए पूरा कोड और वीडियो नीचे दिया गया है।