🏴‍☠️ 🕺🏻 😦 टाइमर और ट्रिगर CODESYS। क्लासिक पीएलसी की ओर एक और Arduino कदम Ⓜ️ 👊 ⬅️

यह CODESYS वातावरण में प्रोग्राम कंट्रोलर (PLCs) के लिए होता है। हर कोई जिसने इस प्रणाली से निपटा है, जानता है कि किसी भी परियोजना में एक Standard.lib पुस्तकालय है, जिसमें बुनियादी टाइमर, ट्रिगर, काउंटर और कई अन्य फ़ंक्शन और फ़ंक्शन ब्लॉक कार्यान्वित किए जाते हैं। इनमें से कई इकाइयां पीएलसी कार्यक्रमों में लगातार उपयोग की जाती हैं। और स्वयं पुस्तकालय, जैसे CODESYS प्रोग्रामिंग भाषा, IEC 61131-3 मानक का प्रतीक है, अर्थात। क्लासिक पीएलसी कार्यों की प्रोग्रामिंग के साथ मदद करने के लिए डिज़ाइन किया गया।

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

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

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

और अब याद रखें कि CODESYS से वही Standard.lib। यह सिर्फ आईईसी-एस गैर-अवरोधक टाइमर को लागू करता है। मैंने इसे एक आधार के रूप में लिया और Arduino लाइब्रेरी कोड (C ++) के लिए टाइमर और ट्रिगर के कार्यों को पोर्ट किया। यानी Arduino को क्लासिक पीएलसी के करीब लाने की कोशिश की।

नीचे मैं CODESYS के पोर्ट किए गए फ़ंक्शन ब्लॉकों (FB) और मेरे plcStandardLib लाइब्रेरी में उनके एनालॉग्स का संक्षिप्त विवरण दूंगा , सभी समय रेखाचित्र नए Arduino लाइब्रेरी के लिए सही हैं। स्रोत ब्लॉकों का अधिक विस्तृत विवरण पाया जा सकता है, उदाहरण के लिए, CODESYS पर रूसी-भाषा की मदद में।

TON - फ़ंक्शन ब्लॉक "टाइमर पर देरी के साथ"

TON(IN, PT, Q, ET)

क्रमशः BOOL और TIME के इनपुट IN और PT। आउटपुट Q और ET BOOL और TIME प्रकार के समान हैं। जबकि IN FALSE है, आउटपुट Q = FALSE, आउटपुट ET = 0. जैसे ही TRUE हो जाता है, आउटपुट ET पर उलटी गिनती (मिलीसेकंड में) PT के बराबर मान तक शुरू हो जाती है। इसके अलावा, काउंटर में वृद्धि नहीं होती है। Q TRUE है जब IN TRUE है और ET PT है, अन्यथा FALSE। इसलिये
इस प्रकार, आउटपुट Q इनपुट IN के किनारे से PT की देरी से सेट होता है।

Arduino IDE में:

विज्ञापन विकल्प:

 TON TON1(); TON TON1(unsigned long PT); //     PT

मामलों का उपयोग करें:

 Q = TON1.Run(boolean IN); //  "  " TON1.IN = IN; TON1.Run(); Q = TON1.Q;

टन ऑपरेशन समय आरेख:

TOF - फ़ंक्शन ब्लॉक "विलंबित शटडाउन के साथ टाइमर"

 TOF(IN, PT, Q, ET)

क्रमशः BOOL और TIME के इनपुट IN और PT। आउटपुट Q और ET BOOL और TIME प्रकार के समान हैं। यदि IN TRUE है, तो आउटपुट Q = TRUE और आउटपुट ET = 0. जैसे ही IN FALSE जाता है, आउटपुट ET पर उलटी गिनती (मिलीसेकंड में) शुरू हो जाती है। जब सेट अवधि पूरी हो जाती है, तो उलटी गिनती बंद हो जाती है। आउटपुट क्यू FALSE है यदि IN FALSE है और ET PT है, अन्यथा TRUE है। इस प्रकार, इनपुट Q की गिरावट से आउटपुट Q देरी पीटी के साथ रीसेट हो जाता है।

Arduino IDE में:

TON के समान, संक्षेप में:

 TOF TOF1(unsigned long PT); //     PT Q = TOF1.Run(boolean IN); //  "  "

TOF का समय रेखा चित्र:

टीपी - आवेग-टाइमर फ़ंक्शन ब्लॉक

 TP(IN, PT, Q, ET)

क्रमशः BOOL और TIME के इनपुट IN और PT। आउटपुट Q और ET BOOL और TIME प्रकार के समान हैं। जबकि IN FALSE है, आउटपुट Q = FALSE, आउटपुट ET = 0. जब IN को TRUE पर स्विच किया जाता है, आउटपुट Q को TRUE पर सेट किया जाता है और टाइमर आउटपुट PT पर पीटी द्वारा निर्दिष्ट अवधि तक पहुँचने तक (मिलीसेकंड में) की गिनती शुरू कर देता है। इसके अलावा, काउंटर में वृद्धि नहीं होती है। इस प्रकार, आउटपुट Q इनपुट IN के किनारे पीटी की अवधि के साथ पल्स उत्पन्न करता है।

Arduino IDE में:

TON के समान, संक्षेप में:

 TP TP1(unsigned long PT); //     PT Q = TP1.Run(boolean IN); //  "  "

टीपी ऑपरेशन टाइमिंग चार्ट:

R_TRIG - फ़ंक्शन ब्लॉक "फ्रंट डिटेक्टर"

R_TRIG फ़ंक्शन ब्लॉक इनपुट सिग्नल के बढ़ते किनारे पर एक पल्स बनाता है। आउटपुट Q FALSE है जब तक इनपुट CLK FALSE है। जैसे ही CLK TRUE हो जाता है, Q को TRUE पर सेट कर दिया जाता है। अगली बार जब फ़ंक्शन ब्लॉक कहा जाता है, तो आउटपुट FALSE पर रीसेट हो जाता है। इस प्रकार, ब्लॉक FALSE से TRUE तक प्रत्येक CLK संक्रमण पर एक एकल आवेग देता है।

उदाहरण STDEDESYS ST में:

 RTRIGInst : R_TRIG ; RTRIGInst(CLK:= VarBOOL1); VarBOOL2 := RTRIGInst.Q;

Arduino IDE में:

घोषणा:

 R_TRIG R_TRIG1;

मामलों का उपयोग करें:

 Q = R_TRIG1.Run(boolean CLK); //  "  " R_TRIG1.CLK = CLK; R_TRIG1.Run(); Q = R_TRIG1.Q;

F_TRIG - फ़ंक्शन यूनिट "गिरावट डिटेक्टर"

फंक्शन ब्लॉक F_TRIG इनपुट सिग्नल के अनुगामी किनारे पर एक पल्स उत्पन्न करता है।
आउटपुट क्यू FALSE है जब तक इनपुट CLK TRUE नहीं है। जैसे ही CLK FALSE पर सेट होता है, Q को TRUE पर सेट कर दिया जाता है। अगली बार जब फ़ंक्शन ब्लॉक कहा जाता है, तो आउटपुट FALSE पर रीसेट हो जाता है। इस प्रकार, ब्लॉक TRUE से FALSE में प्रत्येक CLK संक्रमण में एक एकल आवेग देता है।

Arduino IDE में:

 F_TRIG F_TRIG1; Q = F_TRIG1.Run(boolean CLK); //  "  "

RS_TRIG - फ़ंक्शन ब्लॉक RS-ट्रिगर / SR_TRIG - फ़ंक्शन ब्लॉक SR-ट्रिगर

प्रमुख स्विच बंद, आरएस-ट्रिगर के साथ स्विच करें:

 Q1 = RS (SET, RESET1)

पर प्रमुख के साथ स्विच करें:

 Q1 = SR (SET1, RESET)

इनपुट चर SET और RESET1, BOOL प्रकार के आउटपुट चर Q1 के समान हैं।

Arduino IDE में:

 RS_TRIG RS_TRIG1; Q = RS_TRIG1.Run(boolean SET, boolean RESET); //  "  "

 SR_TRIG SR_TRIG1; Q = SR_TRIG1.Run(boolean SET, boolean RESET); //  "  "

स्रोत कोड और उदाहरण

plcStandardLib_1.h

 /* * plcStandardLib_1.h * * Created on: 01.01.2017 * Author: Admin */ #ifndef PLCSTANDARDLIB_1_H_ #define PLCSTANDARDLIB_1_H_ #if ARDUINO >= 100 #include <Arduino.h> #else #include <WProgram.h> #endif /* ------------------- TON ------------------- */ class TON { public: TON(); TON(unsigned long PT); boolean Run(boolean IN); boolean Q; //   boolean IN; //   unsigned long PT; //   unsigned long ET; //   -    private: boolean _M; //   unsigned long _StartTime; }; /* ------------------- TOF ------------------- */ class TOF { public: TOF(); TOF(unsigned long PT); boolean Run(boolean IN); boolean Q; //   boolean IN; //   unsigned long PT; //   unsigned long ET; //   -    private: boolean _M; //   unsigned long _StartTime; }; /* ------------------- TP ------------------- */ class TP { public: TP(); TP(unsigned long PT); boolean Run(boolean IN); boolean Q; //   boolean IN; //   unsigned long PT; //   unsigned long ET; //   -    private: boolean _M; //   unsigned long _StartTime; }; /* ------------------- R_TRIG ------------------- */ class R_TRIG //    { public: R_TRIG(); boolean Run(boolean CLK); boolean CLK; //   boolean Q; //   private: boolean _M; //   }; /* ------------------- F_TRIG ------------------- */ class F_TRIG //    { public: F_TRIG(); boolean Run(boolean CLK); boolean CLK; //   boolean Q; //   private: boolean _M; //   }; /* ------------------- RS_TRIG ------------------- */ class RS_TRIG //    { public: RS_TRIG(); boolean Run(); boolean Run(boolean SET, boolean RESET); boolean SET; //   boolean RESET; //   boolean Q; //   //private: }; /* ------------------- SR_TRIG ------------------- */ class SR_TRIG //    { public: SR_TRIG(); boolean Run(); boolean Run(boolean SET, boolean RESET); boolean SET; //   boolean RESET; //   boolean Q; //   //private: }; #endif /* PLCSTANDARDLIB_H_ */

plcStandardLib_1.cpp

 /* * plcStandardLib_1.h * * Created on: 01.01.2017 * Author: Admin */ #include "plcStandardLib_1.h" /* ------------------- TON ------------------- */ TON::TON() { IN = false; PT = 0; _M = false; _StartTime = 0; Q = false; ET = 0; } TON::TON(unsigned long PT) { IN = false; TON::PT = PT; _M = false; _StartTime = 0; Q = false; ET = 0; } boolean TON::Run(boolean IN) { TON::IN = IN; if (!TON::IN) { Q = false; ET = 0; _M = false; } else { if (!_M) { _M = true; //    _StartTime = millis(); // ET = 0; //  = 0 } else { if (!Q) ET = millis() - _StartTime; //   } if (ET >= PT) Q = true; } return Q; } /* ------------------- TOF ------------------- */ TOF::TOF() { IN = false; PT = 0; _M = false; _StartTime = 0; Q = false; ET = 0; } TOF::TOF(unsigned long PT) { IN = false; TOF::PT = PT; _M = false; _StartTime = 0; Q = false; ET = 0; } boolean TOF::Run(boolean IN) { TOF::IN = IN; if (TOF::IN) { Q = true; ET = 0; _M = true; } else { if (_M) { _M = false; //    _StartTime = millis(); // ET = 0; //  = 0 } else { if (Q) ET = millis() - _StartTime; //   } if (ET >= PT) Q = false; } return Q; } /* ------------------- TP ------------------- */ TP::TP() { IN = false; PT = 0; _M = false; _StartTime = 0; Q = false; ET = 0; } TP::TP(unsigned long PT) { IN = false; TP::PT = PT; _M = false; _StartTime = 0; Q = false; ET = 0; } boolean TP::Run(boolean IN) { TP::IN = IN; if (!_M) { if (TP::IN) { _M = true; //    _StartTime = millis(); if (ET < PT) Q = true; } } else { if (Q) { ET = millis() - _StartTime; //   if (ET >= PT) Q = false; } else { if (!TP::IN) { _M = false; ET = 0; } } } return Q; } /* ------------------- R_TRIG ------------------- */ R_TRIG::R_TRIG() { CLK = false; _M = false; Q = false; } boolean R_TRIG::Run(boolean CLK) { R_TRIG::CLK = CLK; Q = R_TRIG::CLK && !_M; _M = R_TRIG::CLK; return Q; } F_TRIG::F_TRIG() { CLK = false; _M = true; Q = false; } boolean F_TRIG::Run(boolean CLK) { F_TRIG::CLK = CLK; Q = !F_TRIG::CLK && !_M; _M = !F_TRIG::CLK; return Q; } /* ------------------- RS_TRIG ------------------- */ RS_TRIG::RS_TRIG() { SET = false; RESET = false; Q = false; } boolean RS_TRIG::Run(boolean SET, boolean RESET) { RS_TRIG::SET = SET; RS_TRIG::RESET = RESET; Q = !RESET and (SET or Q); return Q; } boolean RS_TRIG::Run() { Q = !RESET and (SET or Q); return Q; } /* ------------------- SR_TRIG ------------------- */ SR_TRIG::SR_TRIG() { SET = false; RESET = false; Q = false; } boolean SR_TRIG::Run(boolean SET, boolean RESET) { SR_TRIG::SET = SET; SR_TRIG::RESET = RESET; Q = SET or (!RESET and Q); return Q; } boolean SR_TRIG::Run() { Q = SET or (!RESET and Q); return Q; }

plcStandardLib_1_example.ino

 #include "plcStandardLib_1.h" #define LED 13 #define ButtonIn 7 TON TON1(500); //   , 500. TON TON2(1000); //   , 1000. TOF TOF1(500); //   , 500. TP TP1(300); //   , 300. TP TP2(200); //   , 200. R_TRIG R_TRIG1; //      void setup() { pinMode(ButtonIn, INPUT_PULLUP); pinMode(LED, OUTPUT); } void loop() { digitalWrite(LED, TP1.Run(R_TRIG1.Run(TON1.Run(digitalRead(ButtonIn))))); // TON1 -    // R_TRIG1 -    // TP1 -     digitalWrite(LED, TP2.Run(TON2.Run(!TON2.Q))); //     TON  TP // TON2.Run(!TON2.Q)) -    // TP2 -     digitalWrite(LED, TOF1.Run(TON1.Run(digitalRead(ButtonIn)))); //     }

उदाहरण के लिए, बटन के संपर्कों के बकबक को फ़िल्टर करने के लिए (जब भी खुल रहा हो!), यह कोड पर्याप्त है:

 FiltredButtonIn = TON1.Run(digitalRead(ButtonIn))

निष्कर्ष में: यह कैसे CODESYS TON और TP टाइमर की श्रृंखला पर आधारित एक पल्स जनरेटर की तरह दिखता है। शुरुआत में, TON को उलटा के साथ प्रतिक्रिया द्वारा कवर किया जाता है, और इसमें से एक एकल पल्स जनरेटर उत्पन्न होता है, जो टीपी पल्स जनरेटर का संचालन शुरू करता है। मेरे Arduino उदाहरण में, इसका एक एनालॉग इस तरह दिखता है:

 digitalWrite(LED, TP2.Run(TON2.Run(!TON2.Q)));

टाइमर और ट्रिगर CODESYS। क्लासिक पीएलसी की ओर एक और Arduino कदम

TON - फ़ंक्शन ब्लॉक "टाइमर पर देरी के साथ"

Arduino IDE में:

TOF - फ़ंक्शन ब्लॉक "विलंबित शटडाउन के साथ टाइमर"

Arduino IDE में:

टीपी - आवेग-टाइमर फ़ंक्शन ब्लॉक

Arduino IDE में:

R_TRIG - फ़ंक्शन ब्लॉक "फ्रंट डिटेक्टर"

Arduino IDE में:

F_TRIG - फ़ंक्शन यूनिट "गिरावट डिटेक्टर"

Arduino IDE में:

RS_TRIG - फ़ंक्शन ब्लॉक RS-ट्रिगर / SR_TRIG - फ़ंक्शन ब्लॉक SR-ट्रिगर

Arduino IDE में:

स्रोत कोड और उदाहरण

More articles: