🖖 👩🏿‍🔬 🈂️ पीएलसी पर सांप। सीमेंस को हमारा जवाब 👍🏿 🎆 🗣️

नमस्ते

हाल ही में, उन्होंने मुझे एक लेख के लिए एक लिंक भेजा जहां एक सरल और एक ही समय में सीमेंस s7-300 परिवार के नियंत्रक में पंथ गेम "स्नेक" के कार्यान्वयन का एक उदाहरण दिखाया गया था। और मैंने सोचा: हर कोई सीमेंस, एबीबी, आदि जैसे राक्षसों के बारे में जानता है। लेकिन आधुनिक घरेलू विकास छाया में रहते हैं।

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

तो, चलिए शुरू करते हैं:

हमारा काम आधे घंटे में खेल "सांप" लिखना है।
हमारे विचार के कार्यान्वयन के लिए:

QUINT 7 सॉफ्टवेयर के साथ कंप्यूटर स्थापित
पी -400 नियंत्रक
नियंत्रक और कंप्यूटर के बीच संचार के लिए पैच कॉर्ड
ऑपरेशनल टूल (गेम के लिए) और डिजाइन टूल्स (गेम लिखने के लिए) क्विंट 7 के लिए लाइसेंस

थोड़ा स्पष्टीकरण

यद्यपि QUINT 7 में पूरी प्रक्रिया नियंत्रण प्रणाली का पूर्ण वर्चुअलाइजेशन है, और एक कंप्यूटर पर एक मनमाने ढंग से जटिल परियोजना को लागू किया जा सकता है, लेकिन हम सब कुछ एक वयस्क तरीके से करेंगे।

गेम एल्गोरिथ्म को स्वयं कई बड़े ब्लॉकों में विभाजित किया जा सकता है:

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

जनक

सबसे पहले, साँप का आधार बनाएं। क्योंकि चूंकि सांप लगातार खेत के आसपास रेंगता रहता है, इसलिए पूरे कार्यक्रम का आधार एक जनरेटर होगा जो सांप की गति के अनुरूप अवधि के साथ दालों को बाहर निकालता है। पहले, इस गति को 1 सेल प्रति सेकंड के बराबर होने दें। ऐसे जनरेटर को व्यवस्थित करना बहुत सरल है। जरूरत है कि एक तार्किक और एल्गोरिथ्म, एक पल्स काउंटर, एक तुलना एल्गोरिथ्म, और एक चयन एल्गोरिथ्म है। कुल 1 मिनट के लिए हम सबसे सरल जनरेटर बनाते हैं।

क्रिया का सिद्धांत इस प्रकार है। " I1 " एल्गोब्लॉक के आउटपुट पर, प्रत्येक चक्र तार्किक मान 1 <-> 0 बदलता है।
आगे जटिल 1 पर इकाइयों की संख्या की गणना की जा रही है, जिसकी तुलना हमारे द्वारा निर्धारित मूल्य से की जाती है (इस उदाहरण में, 50 क्योंकि चक्र का समय 10 एमएस है, फिर काउंटर 1 सेकंड में 50 शुरू होता है)।
यदि काउंटर रीडिंग हमारे पूर्व निर्धारित मूल्य के बराबर हैं, तो हम काउंटर (" गणना 1 " एल्गोरिथ्म) पर मूल्य घाव को वापस कर देते हैं और " तुलना 1 " एल्गोरिथ्म के "=" आउटपुट से 10 एमएस अवधि (1 नियंत्रक चक्र) की घड़ी पल्स जारी करते हैं। अंतिम चयन एल्गोरिथ्म का उपयोग काउंटर को रीसेट सिग्नल द्वारा रीसेट करने के लिए किया जाता है।

चौकस पाठकों के लिए

एक चौकस पाठक ने देखा होगा कि जब आप पहली बार काउंटर चालू करते हैं, तो वह 1 सेकंड में नहीं बल्कि 980 एमएस में 50 दालों की गणना करेगा। क्योंकि हम अग्रणी किनारे पर गिनती कर रहे हैं, और अनुगामी किनारे पर नहीं। लेकिन एक ही समय में, वह 1 सेकंड में अन्य सभी घड़ी दालों को बाहर कर देगा। बेशक, इस स्थिति को ठीक करना बहुत सरल है, लेकिन मैंने जानबूझकर जनरेटर के कार्यान्वयन के ऐसे संस्करण को विशेष रूप से इस मुद्दे के लिए छोड़ दिया है।

जनरेटर होने के बाद, इसे एक कॉम्पैक्ट मैक्रो में संक्षिप्त करें और इसे पंखों में प्रतीक्षा करने के लिए छोड़ दें।

प्रबंध

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

सर्किट अतिरेक के बारे में थोड़ा स्पष्टीकरण

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

संचालन का सिद्धांत

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

यह कंट्रोल सर्किट को पूरा करता है। जब तक हम इसे एक मैक्रो में नहीं ढोते, क्योंकि हम इसे अंतिम चरण में थोड़ा और ठीक करेंगे।

सांप का सिर और पूंछ

जैसा कि पहले उल्लेख किया गया है, सांप का सिर एक सरणी सेल है जिसमें विशिष्ट निर्देशांक X और U हैं। लेकिन अभी तक हमारे पास यह सरणी नहीं है। इसके अलावा, भविष्य में एक छोटे से (अर्थात् सांप की पूंछ का निर्माण) को देखते हुए, यह स्पष्ट हो जाता है कि सरणी में यह सेल स्मृति के साथ होना चाहिए। स्मृति के साथ सबसे सरल तर्क तत्व एक ट्रिगर है। उनमें से कई किस्में हैं, जिनमें से प्रत्येक का उपयोग अपने स्वयं के प्रयोजनों के लिए किया जाता है। इस उदाहरण में, हम "आरएस-ट्रिगर" पसंद करेंगे। खेल में सुंदरता जोड़ने के लिए (उदाहरण के लिए, "सांप" और "भोजन" को अलग-अलग रंगों में रंगना, सांप के सिर को उजागर करना, आदि), तार्किक मेमोरी सेल पर्याप्त नहीं है, क्योंकि हमें 2 नहीं, बल्कि कम से कम दूसरे राज्यों में स्टोर करना होगा। यानी आपको कई ट्रिगर्स से, या किसी अन्य प्रारूप में मेमोरी सेल बनाना होगा - उदाहरण के लिए, सेल में एक पूर्णांक स्टोर करें। लेकिन इससे कार्यक्रम कुछ हद तक जटिल हो जाएगा, और इस पूरी कार्रवाई का एक लक्ष्य आधे घंटे के भीतर रखना है।
आइए हमारे सांप के लिए 20 से 20 फ़ील्ड बनाएं। हमें 400 ट्रिगर्स की आवश्यकता है। समस्या बस हल हो गई है। एक ट्रिगर के साथ एक सेल बनाएं और इसे मैक्रो में संक्षिप्त करें। हम बीस सेल मैक्रो बनाते हैं और उन्हें एक नए, बड़े मैक्रो में ढँक देते हैं। हम बीस बड़े मैक्रोज़ लगाते हैं और 400 मेमोरी सेल प्राप्त करते हैं।
सेल मैक्रो में 5 इनपुट और 4 आउटपुट होंगे।

आदानों:

इनपुट (एक तार्किक संकेत है कि क्या सांप का "सिर" इस मेमोरी सेल में है)
घड़ी (मुख्य थरथरानवाला के साथ तुल्यकालन के लिए घड़ी की दाल)
लंबाई (सांप की पूंछ की लंबाई)
रीसेट (नया गेम शुरू करने के लिए रीसेट बटन दबाने का तार्किक संकेत)
खाद्य (एक तार्किक संकेत, क्या इस सेल में सांप के लिए "भोजन" है)

भोजन और सांप के सिर के बारे में

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

आउटपुट:

आउटपुट (तार्किक संकेत, इस सेल को फ़ील्ड पर भरें या नहीं)
गेमओवर (अगर सांप अपनी पूंछ पर चढ़ गया तो खेल के अंत का एक तार्किक संकेत)
Yum_yam (एक तार्किक संकेत है कि सांप ने भोजन के साथ एक कोशिका पर कदम रखा है और आपको सांप के लिए नया भोजन बनाने की आवश्यकता है)
एक और_स्टेस्ट (एक तार्किक संकेत है कि भोजन के साथ एक सेल को एक क्षेत्र में बेतरतीब ढंग से फेंक दिया गया था जो पहले से ही एक सांप द्वारा कब्जा कर लिया गया था और एक नए यादृच्छिक सेल के निर्देशांक को पुन: उत्पन्न करना था)

सेल के इनपुट और आउटपुट को परिभाषित करने के बाद और ब्रो में यह स्पष्ट है कि हम इससे क्या चाहते हैं, हम सेल के तर्क का वर्णन करते हैं।

सेल एल्गोरिथ्म का सिद्धांत

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

1. स्थिति को संभालते हुए "सांप ने अपनी पूंछ पर कदम रखा।" थोड़ा सूक्ष्मता को छोड़कर सब कुछ सरल है। हम इनपुट सिग्नल और ट्रिगर स्थिति को जोड़ते हैं। यदि दोनों संकेत एकता के बराबर हैं, तो सिर पूंछ द्वारा कब्जाए गए सेल पर आ गया। यह नियमों का उल्लंघन है और हम एक संकेत देते हैं “GameOver” जिसके द्वारा खेल समाप्त होता है। सूक्ष्मता इस तथ्य में निहित है कि ट्रिगर से संकेत वर्तमान में नहीं, बल्कि पिछले चक्र में लिया जाना चाहिए। इसके लिए, यहां फीडबैक का उपयोग किया जाता है (धराशायी लाइन द्वारा प्रदर्शित)।

2. "खाना" प्रसंस्करण। यहां सब कुछ सरल भी है। हमें संकेत मिलता है कि इस सेल में भोजन होना चाहिए। इसे मुख्य ट्रिगर के साथ और में जोड़ें। यदि दोनों सिग्नल एकता हैं, तो भोजन कोशिका पहले से ही सांप के कब्जे वाले क्षेत्र में गिर गई है। इस मामले में, हम "मोर_ट्री" सिग्नल को आउटपुट करते हैं, जो नए यादृच्छिक निर्देशांक उत्पन्न करने के लिए कमांड देता है।

3. स्थिति को संभालते हुए "सांप ने खाना खाया।" यदि शर्तें 2 पूरी नहीं हुई हैं, अर्थात्। भोजन कक्ष मुक्त क्षेत्र में गिर गया, भोजन ट्रिगर " RS2 " लादा गया है। अगला, हम बस इस संकेत का इंतजार करते हैं कि सांप ने इस पिंजरे पर कदम रखा है। जैसे ही एक संकेत प्राप्त होता है, हम खाद्य ट्रिगर (भोजन खाया जाता है) को रीसेट करते हैं और एक "यम-यम" संकेत जारी करते हैं जिसके द्वारा हम सांप की लंबाई एक से बढ़ाते हैं और साथ ही भोजन के लिए नए निर्देशांक बनाने के लिए एक कमांड भेजते हैं।

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

"खाद्य"

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

हम सभी भागों को जोड़ते हैं और कार्यक्रम को कंघी करते हैं

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

1. मैदान से बाहर जाने के लिए जाँच करें।
यह सब खेल के कार्यान्वयन पर निर्भर करता है। हमें याद है कि "प्रबंधन" के दूसरे चरण में हमारे पास एक काउंटर था जिसमें साँप के सिर के निर्देशांक X और Y थे। बस इन निर्देशांकों की तुलना 0 और 21 के साथ करें (क्योंकि हमारे पास आकार 20 का क्षेत्र 20 है और निर्देशांक 1 है -20)। यदि कोई भी शर्त पूरी होती है, तो हम "गेम का एंड" (जो कि हमारे साइन "गेमओवर" के साथ जोड़ा जाना चाहिए) पर हस्ताक्षर सेट करते हैं। इसे पीएसी-मैन गेम के रूप में किया जा सकता है ताकि जब सांप खेत से बाहर निकलता है, तो वह दूसरी तरफ दिखाई दे। ऐसा करने के लिए, यह संबंधित समन्वय को रीसेट करने के लिए पर्याप्त है।

2. कमांड की शुद्धता के लिए जाँच करें।
हमारा साँप तुरन्त 180 डिग्री नहीं मुड़ सकता। इसलिए, हम एक छोटा सा चेक जोड़ते हैं, जो एक के बाद एक विपरीत दिशा के कमांड देने की अनुमति नहीं देगा।

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

3. "प्रारंभ" और "रीसेट" टीम।
सुविधा के लिए बनाया गया। "स्टार्ट" टीम एक ट्रिगर को कॉक करती है जो हमारे जनरेटर को सिग्नल भेजती है। जनरेटर को रोककर रीसेट कमांड इस ट्रिगर को रीसेट करता है। उसी समय, एक रीसेट सभी काउंटरों में सभी मेमोरी कोशिकाओं और डेटा को रीसेट करता है।

अंतिम कार्यक्रम। ड्राइंग बहुत बड़ी है

हम इंटरफ़ेस बनाते हैं और खेलते हैं

खेल के लिए हमें आवंटित समय से कुछ मिनट बचे हैं, जो खेल के लिए ग्राफिकल इंटरफ़ेस को जकड़ने के लिए पर्याप्त है।
हम चौकों से 20x20 का मैदान बनाते हैं। प्रत्येक बॉक्स अपने स्वयं के मेमोरी सेल से मेल खाता है। हम गुण सेट करते हैं ताकि 0 पर संबंधित मेमोरी सेल, बॉक्स ग्रे है, और 1 पर यह हरा है (या जो भी रंग आपको पसंद है)।

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

हम प्रोग्राम को नियंत्रक में संकलित और लोड करते हैं। हम ऑपरेशनल कंट्रोल स्टेशन लॉन्च करते हैं और खेलते हैं।

यह ऑपरेटर के लिए mnemonic योजना है

संक्षेप में कहना

इस लेख में, हमने नियंत्रकों PTK QUINT 7 के लिए FBD भाषा में प्रोग्रामिंग के सिद्धांतों पर थोड़ा ध्यान दिया। बहुत प्रयास के बिना, हमने "साँप" खेल को लागू किया। क्योंकि चूंकि एफबीडी भाषा मुख्य रूप से प्रौद्योगिकीविदों पर केंद्रित है, प्राथमिक तर्क से परिचित कोई भी (उदाहरण के लिए, AND, OR, ट्रिगर और काउंटर के संचालन का तर्क) काम के सिद्धांतों को समझ सकता है और अपने कार्यक्रम लिखना शुरू कर सकता है। इस मामले में, आपको प्रोग्रामिंग या सर्किट्री में व्यापक अनुभव होने की आवश्यकता नहीं है।

इस एल्गोरिथ्म को किसी भी प्रणाली पर लागू किया जा सकता है जो FBD प्रोग्रामिंग भाषा का समर्थन करता है, केवल चित्र में दिखाए गए एल्गोरिदम को कार्यक्षमता में समान लोगों के साथ बदलकर, क्योंकि यहां उपयोग किए गए एल्गोरिदम बुनियादी हैं और सभी प्रणालियों में हैं।

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

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

अंत तक पढ़ने वाले सभी को धन्यवाद। मुझे उम्मीद है कि यह दिलचस्प था।

पीएलसी पर सांप। सीमेंस को हमारा जवाब