👨‍👨‍👦 👩🏼‍✈️ 🛕 Simatic S7-1200 औद्योगिक नियंत्रक के लिए फ़ंक्शन टाइमर 🎵 ♂️ 🚿

यहां तक कि चरण 7 के तहत S7-300 और S7-400 श्रृंखला के लिए, डेवलपर को पेश की जाने वाली टाइमर के क्लासिक संस्करण काफी पर्याप्त थे - ये मानक IEC टाइमर हैं, जिन्हें फ़ंक्शन ब्लॉक के रूप में लागू किया गया है, और S5 टाइमर (जो, वैसे, अभी भी S7- श्रृंखला के लिए मौजूद हैं 1500)। हालांकि, कुछ मामलों में, डेवलपर ने मानक उपकरणों का उपयोग नहीं किया और अपनी खुद की टाइमर को लागू किया, सबसे अधिक बार फ़ंक्शन के रूप में। प्रोग्रामिंग के लिए "आईटी" दृष्टिकोण के साथ ऐसे टाइमर-कार्य आवश्यक थे, जिसमें वे इनपुट और आउटपुट के संगत बंधन के साथ, लेकिन संरचनाओं के सरणियों के साथ तकनीकी उपकरणों के कार्यात्मक ब्लॉकों के अलग-अलग उदाहरणों के साथ नहीं संचालित होते थे। उदाहरण के लिए, असतत इनपुट प्रकार संरचना की एक सरणी। या कुल संरचना की एक सरणी। प्रोग्रामिंग के लिए इस दृष्टिकोण का अस्तित्व है, क्योंकि यह आपको सीपीयू की कार्यशील मेमोरी को गंभीरता से सहेजने की अनुमति देता है, लेकिन,दूसरी ओर, प्रोग्राम कोड को पढ़ना मुश्किल बनाता है। एक तृतीय-पक्ष प्रोग्रामर और एक LAD प्रोग्राम के साधारण लुक के साथ यह शायद ही सही समझ सकता है, लेकिन सूचकांकों, सरणियों और उन्हें संसाधित करने के कार्यों के ढेर सवाल से बाहर हैं; यहां, सॉफ्टवेयर के लिए प्रलेखन के बिना (और आधा लीटर के बिना), कहीं नहीं।

संरचनाओं के इन सरणियों को आम तौर पर कार्यों में संसाधित किया गया था। सिद्धांत रूप में, फ़ंक्शन ब्लॉकों के प्रसंस्करण को कुछ भी नहीं रोका गया, लेकिन हमेशा एक महत्वपूर्ण सवाल था - इन मामलों में टाइमर के साथ कैसे काम करें? मानक टाइमर या तो एक संख्या (S5) या फ़ंक्शन ब्लॉक (IEC) का एक उदाहरण मानते हैं। यह, मैं आपको याद दिलाता हूं, क्लासिक सिमैटिक पीएलसी के लिए संरचनाओं के प्रसंस्करण सरणियों के बारे में है, और इन संरचनाओं में टाइमर संख्याओं को "ट्विस्ट" करना है, और इससे भी अधिक, उदाहरण या तो मुश्किल या बस असंभव हैं।

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

300 और 400 श्रृंखलाओं के लिए, इस समय को निर्धारित करने के दो तरीके थे। पहला मुख्य OB1 के रनटाइम को देखना है (OB1 में एक संगत चर है) या चक्रीय OBs और प्रत्येक टाइमर कॉल के साथ आंतरिक समय संचायक को बढ़ाएं, बशर्ते कि "सच्चाई" इनपुट है। एक अच्छा विकल्प नहीं है, क्योंकि यह समय ओबी 1 और चक्रीय ओबी के लिए अलग है। दूसरी विधि TIME_TCK सिस्टम फ़ंक्शन है, जो प्रत्येक कॉल के साथ, एक एकल मान लौटाता है - केंद्रीय प्रोसेसर का आंतरिक मिलीसेकंड काउंटर।

इस प्रकार, TON प्रकार (देरी पर) के एक टाइमर के लिए, ऑपरेशन एल्गोरिथ्म इस प्रकार था:

प्रतिक्रिया अनुरोध के बढ़ते किनारे पर, आउटपुट रीसेट करें और सिस्टम टाइमर TIME_TCK के वर्तमान मूल्य को याद रखें
«» , ( , TIME_TCK 0 (2 ^ 31 — 1), ). , . , «», — «»
«»,

"हजारवां" श्रृंखला के आगमन के साथ, स्थिति थोड़ी बदल गई है। तथ्य यह है कि S7-1500 लाइन को TIME_TCK सिस्टम कॉल के लिए विरासत में मिला समर्थन, और "खड़े और एक झूला में" दृष्टिकोण के प्रेमी (आप किसी अन्य प्रोग्राम को कैसे कॉल कर सकते हैं जो खौफनाक अनुक्रमों के साथ संचालन करते समय संरचनाओं के सरणियों को संसाधित करता है?) शांति से अपनी सर्वोत्तम प्रथाओं का उपयोग करना जारी रखें।

आधार नियंत्रकों की S7-1200 श्रृंखला एक अलग वास्तुकला पर आधारित है, और इसमें S7-1500 से कई अंतर हैं। जिसमें TIME_TCK सिस्टम कॉल की कमी शामिल है। डेवलपर्स के रैंक में जिनके पास सोच का पर्याप्त लचीलापन नहीं है, असंतोष चला गया है - पुराने कार्यक्रमों की प्रतियां / पेस्ट निष्पादित करना असंभव है। हालांकि, यह निर्धारित करने का कार्य कि रनटाइम फ़ंक्शन का उपयोग करके पिछले कॉल को कितना समय बीत चुका है।

यह फ़ंक्शन अपने पिछले कॉल के बाद से बीता हुआ समय, सेकंड में, एक डबल सटीक वास्तविक संख्या LREAL के रूप में वापस करता है। विवरण मदद में वर्णित हैं। आंतरिक उद्देश्यों के लिए, एक अतिरिक्त मेम चर (LREAL प्रकार का) भी आवश्यक है।

मैं फ़ंक्शन के पहले सन्निकटन के स्रोत दूंगा, और मैं कुछ नोट्स दूंगा।

समारोह की घोषणा:

FUNCTION "PerversionTON" : Void
{ S7_Optimized_Access := 'TRUE' }
VERSION : 0.1
   VAR_INPUT 
      IN : Bool;   //  
      PT : Real;   //    
   END_VAR

   VAR_OUTPUT 
      Q : Bool;   //  
   END_VAR

   VAR_IN_OUT 
      INPrv : Bool;
      MEM : LReal;
      TimeACC : UDInt;
   END_VAR

   VAR_TEMP 
      udiCycle : UDInt;
      udiPT : UDInt;
   END_VAR

इनपुट / आउटपुट के साथ, सब कुछ स्पष्ट है: IN, Q और PT। मैंने वास्तविक समय के रूप में समय निर्धारित किया है, यह सेकंड है। बस (लेकिन व्यर्थ में, लेकिन उस नीचे अधिक) चाहता था। आगे InOut क्षेत्र के चर के बारे में। चूंकि हमारे पास एक फ़ंक्शन है, हमारे पास एक STAT क्षेत्र नहीं है, ऐसे कोई भी चर नहीं हैं जो अगले फ़ंक्शन कॉल के दौरान उनके मूल्य को बनाए रखते हैं, और ऐसे चर की आवश्यकता होती है:

INPrv - अनुरोध के सकारात्मक छोर को निर्धारित करने के लिए

MEM - सिस्टम कॉल के लिए सहायक चर के लिए रनटाइम

TimeACC - समय संचायक , जो वर्तमान में देरी से चल रहे माइक्रोसेकंड की संख्या को संग्रहीत करेगा।

चर TimeACC, udiCycle और udiPT UDINT प्रारूप में, एक अहस्ताक्षरित पूर्णांक, 4 बाइट्स में निर्दिष्ट हैं। इस तथ्य के बावजूद कि मैंने समय को वास्तविक के रूप में निर्दिष्ट किया है, और रनटाइम फ़ंक्शन वास्तविक रूप से दोगुना सटीक रिटर्न देता है, मैं प्रोसेसर के समय को बचाने के लिए योग के सरल संचालन और पूर्णांक के साथ तुलना करना पसंद करता हूं। मेरे मामले में समय microsecond को ध्यान में रखा जाता है। कारण सरल है - यदि आप मिलीसेकंड करने के लिए समय जुटाते हैं, तो लगभग खाली ओबी 1 (उदाहरण के लिए, यदि पूरे नियंत्रक कार्यक्रम में केवल एक टाइमर को बुलाया जाता है और अधिक कुछ नहीं), चक्रों के "स्किप" संभव हैं, कभी-कभी यह कार्यक्रम 250 μs तक चलता है। लेकिन इस मामले में, समय संचायक का अधिकतम स्वीकार्य मूल्य 4,294 सेकंड होगा, लगभग 4,295 (2 ^ 32 - 1 = 4,294,967,295)। कुछ भी नहीं करना है, ऐसे "अनुकूलन" के लिए बलिदान की आवश्यकता होती है।

समारोह पाठ।

#udiCycle := LREAL_TO_UDINT(RUNTIME(#MEM) * 1000000); //     
#udiPT := REAL_TO_UDINT(#PT * 1000000); //   

IF (#IN AND (NOT #INPrv)) THEN //         
    #TimeACC := 0;
    #Q := FALSE;
ELSIF (#IN AND #INPrv) THEN //     ""
    #TimeACC += #udiCycle; //     "    "
    IF #TimeACC >=  #udiPT THEN //      
        #Q := TRUE; //  ""
        #TimeACC := #udiPT; //  
    ELSE //      
        #Q := FALSE; // 
    END_IF;
ELSE //    -      
    #Q := FALSE;
    #TimeACC := 0;
END_IF;

#INPrv := #IN; //  

ENO := #Q; // ENO         LAD  FBD

पहली दो पंक्तियाँ REAL प्रारूप में निर्दिष्ट सेकंड की संख्या से टाइमर सेटिंग की पुनर्गणना होती हैं, जो microseconds की संख्या में होती हैं। पिछले कार्यक्रम ब्लॉक कॉल से समाप्त हुए माइक्रोसेकंड में समय भी निर्धारित किया जाता है।

इसके अलावा, एल्गोरिथ्म इस प्रकार है, और मैंने पहले ही दिया है:

इनपुट IN के बढ़ते किनारे पर, आउटपुट Q रीसेट करें और समय संचायक रीसेट करें
यदि "सत्य" इनपुट जारी है, तो हम पहले से ज्ञात यूडीसाइकल मूल्य द्वारा समय संचायक बढ़ाते हैं और समय सेटिंग के साथ इसकी तुलना करते हैं। यदि समय की सीमा पार हो गई है, तो टाइमर ने काम किया है, आउटपुट "सही" दें, अन्यथा, आउटपुट "गलत" दें
IN इनपुट में गलत इनपुट लगाने के मामले में, Q आउटपुट को रीसेट करें और समय संचायक को रीसेट करें।

फ़ंक्शन के अंत में, इनपुट IN के किनारे को निर्धारित करने के लिए, इसके पिछले मूल्य को याद रखें। आउटपुट ENO (जब ग्राफिकल भाषाओं में फ़ंक्शन का उपयोग करते समय, जैसे कि LAD) आउटपुट Q का मान दें।

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

संरचना की घोषणा। इसके क्षेत्र टाइमर फ़ंक्शन के इनपुट और आउटपुट चर की नकल करते हैं।

TYPE "typePervTONdata"
VERSION : 0.1
   STRUCT
      IN : Bool;   //  
      PT : Real;   //   
      Q : Bool;   //  
      INPrv : Bool;   //    
      MEM : LReal;   //    
      TimeACC : UDInt;   //  
   END_STRUCT;

END_TYPE

Tortureton वैश्विक डेटा ब्लॉक में संरचनाओं की एक सरणी घोषित की गई है:

TONs : Array[0..999] of "typePervTONdata";

निम्नलिखित कोड संगठनात्मक ब्लॉक OB1 में निष्पादित किया जाता है:

FOR #i := 0 TO 999 DO
    "TortureTON".TONs[#i].IN := "startton";
    "PerversionTON"(IN := "TortureTON".TONs[#i].IN,
                    PT := "TortureTON".TONs[#i].PT,
                    Q := "TortureTON".TONs[#i].Q,
                    INPrv := "TortureTON".TONs[#i].INPrv,
                    MEM := "TortureTON".TONs[#i].MEM,
                    TimeACC := "TortureTON".TONs[#i].TimeACC);
END_FOR;

घोषित 1000 "उदाहरण" टाइमर की, प्रत्येक 10 सेकंड का समय निर्धारित करता है। सभी 1000 टाइमर स्टार्टर मार्कर चर के मूल्य से समय की गिनती शुरू करते हैं।

मैं नियंत्रक (S7-1214C DC / DC / DC, संस्करण FW 4.4, संस्करण Step7 - V16) के नैदानिक कार्यों को लॉन्च करता हूं और नियंत्रक के स्कैन चक्र समय को देखता हूं। "निष्क्रिय" (जब "गलत" टाइमर के इनपुट पर आता है) पर, पूरे हजार को औसतन 36-42 मिलीसेकंड पर संसाधित किया जाता है। दस सेकंड की उलटी गिनती के दौरान, यह रीडिंग लगभग 6-8 मिलीसेकंड बढ़ती है और कभी-कभी 50 एमएस के लिए रोल करती है।

हम देखते हैं कि फ़ंक्शन कोड में क्या सुधार किया जा सकता है। सबसे पहले, कार्यक्रम ब्लॉक की शुरुआत में लाइनें:

#udiCycle := LREAL_TO_UDINT(RUNTIME(#MEM) * 1000000); //     
#udiPT := REAL_TO_UDINT(#PT * 1000000); //

उन्हें हमेशा कहा जाता है, भले ही टाइमर समय गिना जाए, गिनती नहीं करता है, या पहले से ही गिना जाता है। पैसे की एक बड़ी बर्बादी 1200 श्रृंखलाओं के बहुत शक्तिशाली सीपीयू को दोहरे परिशुद्धता सामग्री वाले गणनाओं के साथ लोड नहीं करना है। यह दोनों लाइनों को कोड के उस हिस्से में स्थानांतरित करने के लिए उचित है जो उलटी गिनती की प्रक्रिया करता है (यदि "सच्चाई" जारी रखना जारी है)। यह एक कोड में यूडी साइकिल गणना की नकल करने के लिए भी आवश्यक है जो टाइमर के इनपुट पर सकारात्मक बढ़त की प्रक्रिया करता है। इनपुट मान गलत होने पर यह टाइमर के "निष्क्रिय संचालन" से छुटकारा दिलाता है। व्यवहार में, प्रोग्रामेबल लॉजिक कंट्रोलर में टाइमर अक्सर "बेकार" काम करते हैं। उदाहरण के लिए, संपर्क उछाल का फ़िल्टरिंग समय मिलीसेकंड का दसवां हिस्सा है। असतत आउटपुट का नियंत्रण पल्स कुछ सौ मिलीसेकंड है, जो आमतौर पर 0.5 से 1.0 सेकंड तक होता है।यूनिट कमांड के निष्पादन की निगरानी के लिए समय (उदाहरण के लिए, वाल्व पूरी तरह से खुलने का समय) दसियों सेकंड से लेकर कई मिनटों तक है। उत्पादन में पीएलसी दिन में 24 घंटे काम करता है और 365 (और कभी-कभी अधिक!) साल में एक दिन। यही है, सबसे अधिक बार टाइमर का इनपुट या तो "शून्य" है, और टाइमर कुछ भी नहीं गिनता है, या "यूनिट" लंबे समय तक आता है, और टाइमर ने पहले ही सब कुछ गिना है। दूसरे चरण के सीपीयू आइडल (टाइमर की गिनती पहले ही हो चुकी है) को उतारने के लिए, स्टेज पर जांच करना आवश्यक है "इनपुट सत्य प्राप्त करना जारी है" - यदि टाइमर ने पहले ही हर समय गिना है और आउटपुट को सही पर सेट किया है। इस मामले में, कोई गणना नहीं की जानी चाहिए।सबसे अधिक बार टाइमर का इनपुट या तो "शून्य" है, और टाइमर कुछ भी नहीं गिनता है, या "यूनिट" लंबे समय तक आता है, और टाइमर ने पहले ही सब कुछ गिना है। दूसरे चरण के सीपीयू आइडल (टाइमर की गिनती पहले ही हो चुकी है) को उतारने के लिए, स्टेज पर जांच करना आवश्यक है "इनपुट सत्य प्राप्त करना जारी है" - यदि टाइमर ने पहले ही हर समय गिना है और आउटपुट को सही पर सेट किया है। इस मामले में, कोई गणना नहीं की जानी चाहिए।सबसे अधिक बार टाइमर का इनपुट या तो "शून्य" है, और टाइमर कुछ भी नहीं गिनता है, या "यूनिट" लंबे समय तक आता है, और टाइमर ने पहले ही सब कुछ गिना है। दूसरे चरण के सीपीयू आइडल (टाइमर को पहले ही गिना जा चुका है) को उतारने के लिए, स्टेज पर जांच करना आवश्यक है "इनपुट सत्य प्राप्त करना जारी है" - यदि टाइमर ने पहले ही हर समय गिना है और आउटपुट को सही पर सेट किया है। इस मामले में, कोई गणना नहीं की जानी चाहिए।

इन परिवर्तनों को करने के लिए, O टाइमरपूट क्षेत्र से Q_ आउटपुट को IN_OUT क्षेत्र में स्थानांतरित करना आवश्यक है, और आउटपुट मान बाहरी चर (इस उदाहरण में, संरचनाओं की एक सरणी में) में संग्रहीत किया जाएगा। शोधन के बाद, घोषणा सहित पूरा फ़ंक्शन कोड निम्नानुसार है:

FUNCTION "PerversionTON" : Void
{ S7_Optimized_Access := 'TRUE' }
VERSION : 0.1
   VAR_INPUT 
      IN : Bool;   //  
      PT : Real;   //    
   END_VAR

   VAR_IN_OUT 
      Q : Bool;   //  
      INPrv : Bool;
      MEM : LReal;
      TimeACC : UDInt;
   END_VAR

   VAR_TEMP 
      udiCycle : UDInt;
      udiPT : UDInt;
   END_VAR


BEGIN
	IF (#IN AND (NOT #INPrv)) THEN //         
	    #TimeACC := 0;
	    #Q := FALSE;
	    #udiCycle := LREAL_TO_UDINT(RUNTIME(#MEM) * 1000000); // " "  
	ELSIF (#IN AND #INPrv) THEN //     ""
	    IF (NOT #Q) THEN
	        #udiCycle := LREAL_TO_UDINT(RUNTIME(#MEM) * 1000000); //     
	        #udiPT := REAL_TO_UDINT(#PT * 1000000); //   
	        #TimeACC += #udiCycle; //     "    "
	        IF #TimeACC >= #udiPT THEN //      
	            #Q := TRUE; //  ""
	            #TimeACC := #udiPT; //  
	        END_IF;
	    END_IF;
	ELSE //    -      
	    #Q := FALSE;
	    #TimeACC := 0;
	END_IF;
	
	#INPrv := #IN; //  
	
	ENO := #Q; // ENO         LAD  FBD
END_FUNCTION

उसके बाद, निष्पादन समय में सुधार होता है: टाइमर का निष्क्रिय समय प्रसंस्करण 23 एमएस है, जिसमें 37-40 एमएस का एक कार्य फ़िल्टरिंग समय है।

यह फ़ंक्शन कोड टाइमर सेटिंग के एक अमान्य मान के लिए जांच नहीं करता है - एक नकारात्मक मान (यदि सामग्री एक अहस्ताक्षरित पूर्णांक में परिवर्तित हो जाती है, तो सेटिंग विकृत हो जाएगी) या 4294.9 सेकंड (समय सेटिंग अतिप्रवाह और विकृत) से अधिक मान होगा। आपको या तो कोड में पीटी मूल्य के मूल्य को नियंत्रित करना होगा, या समय-सीमा की सीमा (0 से 4294.9 सेकंड तक) की जांच करने का काम शीर्ष स्तर के ऑपरेटर सिस्टम को सौंपना होगा। पीएलसी कार्यक्रम के माध्यम से सीमा की जांच करने से प्रसंस्करण समय लगभग 45-46 एमएस तक बढ़ जाता है (और, सामान्य तौर पर, सबसे सही तरीका टाइमर समय को आरईएएल प्रारूप में नहीं, बल्कि यूडीआईटीटी प्रारूप में मिलीसेकंड और बकवास करने के लिए सेट करना है)।

TIA पोर्टल चरण 7 संस्करण 16 पर्यावरण के लिए एक टाइमर के साथ आवेदन परियोजना यहां उपलब्ध है ।

Simatic S7-1200 औद्योगिक नियंत्रक के लिए फ़ंक्शन टाइमर

More articles: