पीएलसी पर सांप? आराम से!

शुभ दिन, हैरानी!

हाल ही में यह शिकायत की गई है कि "औद्योगिक प्रोग्रामिंग" के विषय को पर्याप्त रूप से संबोधित नहीं किया गया है। मैं इसे ठीक करने की कोशिश करूंगा।
स्पष्टता के लिए, हम यह पता लगाएंगे कि सीमेंस s7-300 परिवार के नियंत्रक के लिए क्लासिक सांप कैसे लिखें।



यदि यह दिलचस्प हो गया - बिल्ली का स्वागत।
चेतावनी - चित्रों और कोडांतरक जैसी भाषा में बहुत सारे कोड!

पूरे कार्यक्रम को संगठनात्मक ब्लॉक OB1 में निष्पादित किया जाता है, जिसमें दो फ़ंक्शन ब्लॉक FB10 और FB11 होते हैं, जिनके उदाहरण डेटा ब्लॉक DB10 और 11 हैं।



खेल का मैदान ही 10x10 सेल 10x10 बाइट्स का एक दो आयामी सरणी है।



हमारे साँप के काम के लिए हमें एक छोटी सी समस्या को हल करने की आवश्यकता है - हमें एक सटीक आवेग की आवश्यकता है जो समय में उत्पन्न होती है। आप "ब्लिंकिंग बीट्स" का उपयोग कर सकते हैं, यह नियंत्रक की एक अंतर्निहित सुविधा है, लेकिन हम अपने स्वयं के पल्स जनरेटर FB10 को मर्कर्स और संरचनाओं के साथ बनाएंगे।

आप अस्थायी चर OB1 में बहुत सारी दिलचस्प चीजें पा सकते हैं, इस बार हमें पिछले कार्यक्रम चक्र के समय की आवश्यकता होगी। इस समय के दौरान, नियंत्रक "सब कुछ" पचाता है और आउटपुट को मान जारी करता है, फिर इनपुट पढ़ता है। इसे उच्च सटीकता के साथ मापा जाता है, और हम इसे मानते हैं।



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



इन दालों से, बड़ी मात्रा में जोड़ना बहुत आसान है, उदाहरण के लिए, 5 सेकंड।



आप मिनट, घंटे भी कर सकते हैं, लेकिन यह एक और कहानी है।

कृपया ध्यान दें कि आप एक ही एज वैरिएबल का दो बार उपयोग नहीं कर सकते हैं, इससे प्रोग्राम लॉजिक में त्रुटि पकड़ने में बहुत मुश्किल होगी।

अब यह साँप के कार्यात्मक ब्लॉक की बारी है।



इनपुट चर बाएँ, दाएँ, ऊपर, नीचे, और कमांड शुरू करते हैं।
यदि आपके पास नियंत्रक और असतत इनपुट मॉड्यूल है, तो आप इन चर इनपुटों पर इनपुट लटका सकते हैं, जिसमें फिक्सिंग के बिना बटन संलग्न होते हैं। एक पूर्ण स्लॉट मशीन प्राप्त करें। विशेष इच्छा के साथ, एक सरणी को प्रकाश बल्ब से बनाया जा सकता है, लेकिन मुझे इसके लिए तुरंत निकाल दिया जाएगा =)

पहला उदाहरण एक लेफ्ट मूव कमांड है।



यदि हमने इसे दर्ज किया है, तो हम दाईं ओर नहीं जाते हैं, यह केवल इस चक्र में हुआ है, तो हम सभी पिछले आदेशों को रीसेट करते हैं और बाईं ओर आंदोलन की घोषणा करते हैं।


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

शुरुआत में, हम सांप के सिर को 9.5 के तत्व को संबोधित करते हुए स्थानांतरित करते हैं, इसे लंबाई में 2 बनाते हैं, क्रॉल को कमांड देते हैं, खेल को रीसेट करते हैं और खेल मैदान पर एक यादृच्छिक बिंदु पर भोजन को बाहर फेंकने के लिए कमांड देते हैं।


आगे हमें सांप के लिए भोजन बनाने की आवश्यकता है। मैं स्वीकार करता हूं, पीढ़ी एल्गोरिथ्म मुझे पहले Google लिंक में से एक पर "अच्छे के लिए पीएलसी" पर जासूसी कर रहा था।

यह इस तथ्य में शामिल है कि नियंत्रक सिस्टम समय के मिलीसेकंड को गिनता है। यदि हम इस संख्या को लेते हैं, तो इसे यादृच्छिक रूप से जोड़ते हैं, और फिर अतिरिक्त को त्याग देते हैं, हमें एक छद्म-यादृच्छिक संख्या जनरेटर 0 से दिए गए मान में मिलता है।

इसके अलावा, जब एक्स और वाई बेतरतीब ढंग से गिर गए, तो हम उन्हें लेते हैं और सरणी तत्व की संख्या की गणना करते हैं। X के साथ प्रत्येक चरण का मतलब है कि आपको तत्वों की अगली पंक्ति में स्थानांतरित करने की आवश्यकता है, अर्थात 10 है, और Y के साथ प्रत्येक का अर्थ है 0-तत्व से 1 तक बढ़ना।

परिणामस्वरूप, सरणी तत्व X [4] Y [7] एक-आयामी सरणी के 47 वें तत्व में बदल जाता है। हम उसे 7 का दर्जा देते हैं - भोजन।

तत्व व्यस्त होने की स्थिति में, हम जनरेटर को फिर से शुरू करते हैं।


भोजन की एक सफल अस्वीकृति के बाद, सांप ने अपना आंदोलन शुरू किया, बाईं ओर आंदोलन के आधार पर एक एल्गोरिथ्म पर विचार करें।


इस एल्गोरिथ्म में, हम तुरंत कई जांच करते हैं। 10 से विभाजित करें - हमें शेष मिलता है - वर्तमान तत्व की पंक्ति में संख्या। यदि हम शून्य तत्व में जा रहे हैं, तो खेल का अंत।



यही बात होती है अगर आंदोलन के रास्ते में भोजन के अलावा कुछ और हो। यदि आप भोजन पर ठोकर खाते हैं - जो आप खा चुके हैं, उसे थोड़ा हिलाएं, यह जनरेटर शुरू करेगा, पूंछ को 1 से बढ़ाएं।

अगला अंतिम एल्गोरिथ्म है - टेल कटर। वह अंतिम समन्वय को एक आधार के रूप में लेता है, इस समन्वय पर कमांड पढ़ता है और सांप के सिर से पूंछ तक रिवर्स ऑर्डर में जाता है। यदि सेल लंबाई से आगे बढ़ जाती है - मान शून्य करके इसे हटा दें


लेख के अंत में पहुंचने वाले सभी लोगों के लिए आपका बहुत बहुत धन्यवाद, मुझे उम्मीद है कि यह दिलचस्प था।

प्रोजेक्ट डाउनलोड करने के लिए लिंक