Arduino पर टाइमर और मल्टीटास्किंग

आज हम Arduino पर टाइमर और मल्टीटास्किंग जैसे प्रासंगिक विषय के बारे में बात करेंगे। इस लेख को लिखने का कारण सैमसंग IoT अकादमी के ढांचे में MIREA के छात्रों के लिए ओलेग आर्टामोनोव @olartamonov द्वारा व्याख्यान था, या इसके बजाय, ओलेग का कथन, उद्धरण (दूसरा व्याख्यान, 1:13:08):

"उदाहरण के लिए, ऐसे कार्य हैं, जिनके लिए अधिकांश arduino ड्राइवरों, विशेष रूप से शुरुआती, को तोड़ा जा सकता है, उन्हें अलग-अलग आवृत्तियों और अवधि के साथ पांच अलग-अलग एलईडी के साथ पलक झपकने के लिए कहें, और ताकि प्रत्येक एलईडी के लिए एक और अवधि को व्यक्तिगत रूप से बदला जा सके ..."

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

चलो यह पता लगाते हैं कि एक साथ Arduino पर मल्टीटास्किंग को कैसे व्यवस्थित किया जाए, और साथ ही साथ MIREA के छात्रों को हमारे समय की Arduino नामक सामाजिक-सांस्कृतिक और तकनीकी घटना के संबंध में उन पर लगाई गई धारणा की रूढ़ियों से छुटकारा पाने में मदद करें।

ओलेग Artamonov द्वारा व्याख्यान

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

विशेष रूप से, पूरे व्याख्यान के दौरान ओलेग ने जटिल मल्टी-टास्किंग सिस्टम के निर्माण के लिए अरुडिनो की अनैच्छिकता के बारे में लंबित बयान दिए, जो केवल सच्चाई और वास्तविक अभ्यास का विरोध करता है।

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

हम उदाहरणों के लिए दूर नहीं जाएंगे। यहाँ विंटर गार्डन ("स्मार्ट ग्रीनहाउस") की परियोजना है जिसमें निम्नलिखित संस्थाएँ मल्टीटास्किंग मोड में वास्तविक समय में काम करती हैं:



एक वितरित nRF24 नियंत्रक की टोपोलॉजी बड़ी संख्या में जुड़े और वास्तविक समय के उपकरण के साथ। उपयोगकर्ता केवल "आधार" से संबंधित है, nRF24 साथी का कार्य उसके लिए पूरी तरह से पारदर्शी है। और, हाँ, यह Arduino है।

"आधार" पर:

- 7 सर्वोस
- 9 स्टेपर मोटरें
- 6 रिले
- 3 मिट्टी नमी सेंसर
- 2 लाइट सेंसर
- जल स्तर सेंसर
- आर्द्रता और हवा का तापमान सेंसर

दूरस्थ भाग के nRF24 पर:

- 12 मिट्टी नमी सेंसर
- 12 रिले
- 3 स्टेपर मोटर्स
- 2 लाइट सेंसर
- जल स्तर सेंसर

इसके अलावा, वास्तविक समय में, nRF24 सिस्टम के दो वितरित भागों और सर्वर के ईथरनेट इंटरफेस और सर्वर इंजन के बीच संचालित होता है, जो सिस्टम का एक वेब उपयोगकर्ता इंटरफ़ेस प्रदान करता है।

कुल मिलाकर, वास्तविक समय में, मल्टीटास्किंग मोड में, कम से कम 60 इकाइयां 8-बिट मेगा पर काम कर रही हैं (और यह स्वयं एएमएस ऑपरेटिंग सिस्टम की कई सेवाओं की गिनती नहीं कर रहा है, उनके साथ संस्थाओं की संख्या एक सौ तक पहुंच जाएगी)। जो स्पष्ट रूप से इस कथन से सहमत नहीं है कि "Arduino पर वास्तविक मल्टीटास्किंग असंभव है और इस पर पांच एल ई डी के साथ भी झपकी लेने की समस्याग्रस्त है"।

Arduino की रक्षा में कुछ शब्द

(हालांकि यह स्पष्ट है कि Arduino एक सामाजिक-सांस्कृतिक और तकनीकी घटना के रूप में प्रशंसकों की एक बहु-मिलियन सेना के साथ है और कई हजारों अद्भुत परियोजनाओं को संरक्षण की आवश्यकता नहीं है।)

मैंने कई बार कहा है और एक बार फिर से दोहराऊंगा कि Arduino अपने सॉफ़्टवेयर घटक में है, वास्तव में, अपने स्वयं के फायदे और नुकसान के साथ अमूर्तता (किसी भी अन्य की तरह) के संभावित स्तरों में से एक है। और सिलिकॉन के अपने छोटे टुकड़े के अंदर "कताई" करने वाले उपयोगकर्ता के लिए बिल्कुल कोई अंतर नहीं है - "शुद्ध" Arduino, RTOS, RIOT OS, AMS या नियंत्रक के लौह संसाधनों के प्रतिनिधित्व और प्रबंधन के कुछ अन्य गणितीय अमूर्त।

उपयोगकर्ता के लिए अपनी समस्याओं को हल करना महत्वपूर्ण है - नियंत्रक के लिए पौधों को पानी देने के लिए, प्रकाश चालू करें, पर्दे को नियंत्रित करें, आदि। और मुख्य समस्या विकास में उपयोग किए जाने वाले साधनों में नहीं है, लेकिन उन्हें और का उपयोग करने की क्षमता में, स्वयं डेवलपर की कल्पना और इंजीनियरिंग दृष्टि में।

यह कैसे काम करता है?

अपने आप से, माइक्रोकंट्रोलर पर मल्टीटास्किंग को अलग-अलग तरीकों से आयोजित किया जा सकता है, इस मामले में हम सबसे सरल एक के बारे में बात करेंगे - प्रक्रियाएं नियंत्रण में बदल जाती हैं और स्वेच्छा से अपने समय की मात्रा का उपयोग करने के बाद इसे दूर कर देती हैं। यह विधि, ज़ाहिर है, स्पष्ट कमियों के बिना नहीं है, लेकिन, जैसा कि वे कहते हैं, अभ्यास सच्चाई की एक कसौटी है और यह वास्तविक परिस्थितियों में खुद को साबित कर चुका है: इसका उपयोग मानक Arduino मेगा सर्वर वितरण और AMS प्रो पर कई परियोजनाओं में दोनों किया जाता है। और ये सिस्टम 24/7 काम करता है और कई महीनों के परेशानी-मुक्त ऑपरेशन में अपटाइम की पुष्टि करता है।



यह वितरित nRF24 प्रणाली की लगभग सौ संस्थाओं का एक संकेत है, वास्तविक समय में स्वतंत्र रूप से प्रबंधित। पिछले दो सीपीयू संकेतकों पर ध्यान दें - यहां तक ​​कि 8-बिट मेगा पर प्रोसेसर लोड शून्य है (अर्थात, सिस्टम पूरी तरह से मुक्त है)।

टाइमर के बारे में थोड़ा सा

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

जो फिर से सीधे बयान का खंडन करता है: "3 एल ई डी के लिए पर्याप्त लोहे की टाइमर होंगे, तब से, arduinists को समस्या होगी।" शुरू न करें। किसी भी प्रकार के टाइमर किसी भी मात्रा में हमारे लिए उपलब्ध हैं। और, यदि वांछित है, तो हम खुद को और अधिक नए और मनमाने ढंग से विदेशी बना सकते हैं।

मुख्य मामला

इस प्रकार के मल्टीटास्किंग संगठन के लिए मुख्य मामला तथाकथित "गैर-अवरोधक" कोड बनाना है, अर्थात्, कोड जो देरी () फ़ंक्शन का उपयोग नहीं करता है, जो बस एक निश्चित समय के लिए कार्यक्रम को रोक देता है।

वास्तविक समय

मल्टीटास्किंग को लागू करने के लिए वर्णित विधि को "सॉफ्ट-रियलटाइम" के रूप में वर्णित किया जा सकता है, सिस्टम में विशिष्ट विलंब समय 10 एमएस है (लेकिन पीक विलंब बहुत लंबा और मानकीकृत नहीं हो सकता है)। यह इस समाधान के आवेदन के स्पेक्ट्रम पर अच्छी तरह से ज्ञात सीमाएं लगाता है, लेकिन अधिकांश "घरेलू" कार्यों के लिए (और न केवल) यह पूरी तरह से उपयुक्त है, ऊपर दिए गए उदाहरण देखें।

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

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

साइकिल का समय

सरलतम चक्रीय टाइमर के कार्यान्वयन पर विचार करें। ये टाइमर (एएमएस "चक्र" की शब्दावली में) हैं, जो निश्चित, पूर्वनिर्धारित समय अंतराल पर सक्रिय होते हैं और चक्रीय प्रक्रियाओं को सक्रिय करने के लिए उपयोग किए जाते हैं।

सामान्य तौर पर, प्रोग्रामर को ऑब्जेक्ट के रूप में डिज़ाइन करना बेहतर होता है, लेकिन Arduino Mega Server की मानक डिलीवरी में इन टाइमर को फ़ंक्शंस के रूप में लागू किया जाता है, इसलिए, शुरुआत के लिए, हम उन्हें इस हाइपोस्टैसिस में विचार करेंगे।

चक्रीय टाइमर का उपयोग करना बहुत ही सरल है: बस उस कोड को डालें जिसे समय-समय पर स्टेटमेंट के कोष्ठक के बीच निष्पादित किया जाना चाहिए। यदि आपको एक अलग ट्रिगर अंतराल का उपयोग करने की आवश्यकता है, तो साइकिल 1 के बजाय वांछित चर का उपयोग करें। आप जितने चाहें उतने अलग-अलग चक्र बना सकते हैं - 8-बिट मेगा पर भी एक सिस्टम आसानी से सैकड़ों ऐसे टाइमर को आसानी से संभाल सकता है (केवल, निश्चित रूप से, आपको यह याद रखने की आवश्यकता है कि बुलाया कोड अवरुद्ध नहीं है)।

  if (cycle1s) {
    // ,   , ,  
  }

. :

// Cycles
bool cycle1s  = false;
bool cycle5s  = false;
bool cycle20s = false;
bool cycle30s = false;
bool cycle1m  = false;
bool cycle3m  = false;
bool cycle5m  = false;

.

«Timers»:

/*
  Module Timers
  part of Arduino Mega Server project
*/

// Cycles
unsigned long timeSec;
unsigned long timer1s;
unsigned long timer5s;
unsigned long timer20s;
unsigned long timer30s;
unsigned long timer1m;
unsigned long timer3m;
unsigned long timer5m;

void timersInit() {
  unsigned long uptimeSec = millis() / 1000;
  timeSec  = uptimeSec;
  timer1s  = uptimeSec;  
  timer5s  = uptimeSec; 
  timer20s = uptimeSec;
  timer30s = uptimeSec;
  timer1m  = uptimeSec;
  timer3m  = uptimeSec;
  timer5m  = uptimeSec;
}

void timersWorks() {
  timeSec = millis() / 1000;
    if (timeSec - timer1s  >=  1)  {
                                    timer1s  = timeSec; cycle1s  = true;
    if (timeSec - timer5s  >=  5)  {timer5s  = timeSec; cycle5s  = true;}
    if (timeSec - timer20s >= 20)  {timer20s = timeSec; cycle20s = true;}
    if (timeSec - timer30s >= 30)  {timer30s = timeSec; cycle30s = true;}
    if (timeSec - timer1m  >= 60)  {timer1m  = timeSec; cycle1m  = true;}
    if (timeSec - timer3m  >= 180) {timer3m  = timeSec; cycle3m  = true;}
    if (timeSec - timer5m  >= 300) {timer5m  = timeSec; cycle5m  = true;}
  }
}

void eraseCycles() {
  cycle1s  = false;
  cycle5s  = false;
  cycle20s = false;
  cycle30s = false;
  cycle1m  = false;
  cycle3m  = false;
  cycle5m  = false;
}

. - , . , , .

void loop() {
  timersWorks();

  //   

  eraseCycles();
}

, , . myCycle.

, :

/*
  myCycle Library
  part of Arduino Mega Server project
*/

#ifndef _MYCYCLE_H
#define _MYCYCLE_H

#define MS_500       500
#define MS_01S      1000
#define MS_02S      2000
#define MS_05S      5000
#define MS_10S     10000
#define MS_13S     13000
#define MS_17S     17000
#define MS_20S     20000
#define MS_30S     30000
#define MS_01M     60000
#define MS_03M    180000
#define MS_05M    300000
#define MS_01H   3600000
#define MS_06H  21600000
#define MS_12H  43200000
#define MS_01D  86400000

class myCycle {
  private:
    bool          _go;
    bool          _active;
    unsigned long _start;
    unsigned long _period;
  
  public:
    myCycle(unsigned long per, bool act);
    void reInit(unsigned long per, bool act);
    void reStart();
    bool check();
    bool go();
    void clear();
    
    // active
    bool active();
    void setActive(bool act);
    // period
    unsigned long period();
    void setPeriod(unsigned long per);
}; // class myCycle

#endif // _MYCYCLE_H

:

/*
  myCycle Library
  part of Arduino Mega Server project
*/

#include "myCycle.h"
#include <Arduino.h>

myCycle::myCycle(unsigned long per, bool act) {
  _go     = false;
  _active = act;
  _period = per;
  _start  = millis();
}

// Methods

void myCycle::reInit(unsigned long per, bool act) {
  _go     = false;
  _active = act;
  _period = per;
  _start  = millis();
}

void myCycle::reStart() {
  _start = millis();
}

bool myCycle::check() {
  if (millis() - _start >= _period) {
    _start = millis();
    if (_active) {
      _go = true;
    }
  }
  return _go;
}

bool myCycle::go() {
  return _go;
}

void myCycle::clear() {
  _go = false;
}

// Active

bool myCycle::active() {
  return _active;
}

void myCycle::setActive(bool act) {
  _active = act;
}

// Period

unsigned long myCycle::period() {
  return _period;
}

void myCycle::setPeriod(unsigned long per) {
  _period = per;
}

«» : « ».

:

:

#include "myCycle.h"

:

// Cycles
myCycle cycle500(MS_500, true);
myCycle cycle2s(MS_02S, true);
myCycle cycle5s(MS_05S, true);

:

void timersWorks() {
  cycle500.check();
  cycle2s.check();
  cycle5s.check();
}

void eraseCycles() {
  cycle500.clear();
  cycle2s.clear();
  cycle5s.clear();
}

:

void loop() {
  timersWorks();

  //   

  if (cycle5s.go()) {
    Serial.println(F("cycle5s!"));
  }

  eraseCycles();
}

, , . , / , , , .

Arduino

, — . , . , AMS .

()

, . , 3 nRF24. 3 .

/ . .

«», - - .

- , , .

, , . , , , 20 , «», «» , . , «» .

, . — Arduino Mega Server .

, , / , « » . .

— , 8- .

, , Arduino - — — , .

, Arduino Mega Server .

, , Arduino , , , Arduino () .

, , .

P.S.
, 0.17 Arduino Mega Server Arduino Mega, Due, 101 M0, . , , .