नेटवर्क प्रतिद्वंद्विता: बीबीसी माइक्रो के लिए एक कम विलंबता खेल: बिट: 10 कदम (चित्रों के साथ)

2024 लेखक: John Day | [email protected]. अंतिम बार संशोधित: 2024-01-30 09:21

इस ट्यूटोरियल में, मैं समझाऊंगा कि बीबीसी माइक्रो: बिट पर एक बुनियादी मल्टीप्लेयर गेम को निम्नलिखित विशेषताओं के साथ कैसे लागू किया जाए:

• एक सरल इंटरफ़ेस
• बटन प्रेस और स्क्रीन अपडेट के बीच कम विलंबता
• प्रतिभागियों की एक लचीली संख्या
• मास्टर रिमोट ("रूट") डिवाइस का उपयोग करके गेम पर आसान नियंत्रण

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

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

ऊपर दिया गया चित्र एक परिमित राज्य मशीन को दिखाता है, अर्थात उन राज्यों का एक विनिर्देश जो डिवाइस में हो सकता है और उन राज्यों के बीच संक्रमण हो सकता है।

एक राज्य को डेटा के वर्तमान सेट के रूप में माना जा सकता है जो डिवाइस की मेमोरी का वर्णन करता है क्योंकि इसे चालू किया गया था। उस डेटा के आधार पर, डिवाइस कुछ क्रियाएं कर सकता है या उपयोगकर्ता इनपुट पर अलग तरह से प्रतिक्रिया कर सकता है।

ट्रांज़िशन एक तार्किक स्थिति है, जो सही होने पर डिवाइस को अपनी स्थिति बदलने का कारण बनती है। एक राज्य से दूसरे राज्य में संक्रमण हो सकता है। एक राज्य में कई संक्रमण हो सकते हैं।

ऊपर दिया गया चित्र निम्नलिखित राज्यों को निर्दिष्ट करता है:

• सौंपे नहीं गए
• ए के लिए सुनो
• बी के लिए सुनो
• टीम ए
• टीम बी

गेम कोड चलाने वाला उपकरण इन पांच राज्यों में से किसी एक में हो सकता है, लेकिन एक समय में केवल एक, और केवल ये पांच।

मैं पूरी गाइड में मान लूंगा कि आप माइक्रोसॉफ्ट के मेककोड संपादक का उपयोग कर रहे हैं, जो यहां पाया जा सकता है:

खेल का पूर्ण कार्यान्वयन यहां पाया जा सकता है:

makecode.microbit.org/_CvRMtheLbRR3 ("माइक्रोबिट-डेमो-यूज़र" प्रोजेक्ट का नाम है)

और मास्टर ("रूट") नेटवर्क नियंत्रक का कार्यान्वयन यहां पाया जा सकता है:

makecode.microbit.org/_1kKE6TRc9TgE ("माइक्रोबिट-डेमो-रूट" प्रोजेक्ट का नाम है)

मैं अपने पूरे ट्यूटोरियल में इन उदाहरणों का उल्लेख करूंगा।

चरण 1: बड़े चित्र डिजाइन विचार

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

1. हम डिवाइस की वर्तमान स्थिति के आधार पर उसके कार्यों को नियंत्रित करना चाहते हैं
2. हम चाहते हैं कि डिवाइस उपयोगकर्ता इनपुट पर प्रतिक्रिया करे
3. हम 5 x 5 एलईडी डिस्प्ले का उपयोग करके एनिमेशन और ग्राफिक्स प्रदर्शित करना चाह सकते हैं
4. जब डिवाइस बूट होता है तो हम डिवाइस मेमोरी में डेटा मानों को प्रारंभ करना चाहते हैं
5. हम डिवाइस के रेडियो का उपयोग करके वायरलेस तरीके से डेटा संचारित करना चाहते हैं
6. हम डिवाइस के रेडियो पर डेटा सुनना और प्राप्त करना चाहते हैं और उसके अनुसार इसे संसाधित करना चाहते हैं

मुझे प्रत्येक के बारे में थोड़ा और विस्तार से जाने की अनुमति दें।

1. हम डिवाइस की वर्तमान स्थिति के आधार पर उसके कार्यों को नियंत्रित करना चाहते हैं

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

2. हम चाहते हैं कि डिवाइस उपयोगकर्ता इनपुट पर प्रतिक्रिया करे

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

3. हम 5 x 5 एलईडी डिस्प्ले का उपयोग करके एनिमेशन और ग्राफिक्स प्रदर्शित करना चाहते हैं

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

4. जब डिवाइस बूट होता है तो हम डिवाइस मेमोरी में डेटा मानों को प्रारंभ करना चाहते हैं

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

5. हम डिवाइस के रेडियो का उपयोग करके डेटा को वायरलेस तरीके से प्रसारित करना चाहते हैं

MakeCode ब्लॉक भाषा का उपयोग करते समय यह वास्तव में काफी सरल कार्य है। हम बस बूट समय पर सभी उपकरणों को एक ही रेडियो समूह में सेट करते हैं और फिर जब हम एक सिग्नल भेजना चाहते हैं, तो हम हमें प्रदान किए गए "रेडियो सेंड नंबर" ब्लॉक में एक नंबर पास कर सकते हैं। यह महत्वपूर्ण है कि प्रेषक और रिसीवर एक ही रेडियो समूह पर काम कर रहे हैं, क्योंकि यदि नहीं, तो वे अलग-अलग आवृत्तियों पर भेज या प्राप्त करेंगे, और संचार असफल हो जाएगा।

6. हम डिवाइस के रेडियो पर डेटा सुनना और प्राप्त करना चाहते हैं और तदनुसार इसे संसाधित करना चाहते हैं

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

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

1. हम एक संकेत का चयन करने में सक्षम होना चाहते हैं
2. हम एक संकेत संचारित करने में सक्षम होना चाहते हैं

-

1. हम एक संकेत का चयन करने में सक्षम होना चाहते हैं

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

2. हम एक संकेत संचारित करने में सक्षम होना चाहते हैं

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

मैं अगले भाग में सरल सिग्नल प्रोटोकॉल के बारे में अधिक बात करूंगा।

चरण 2: सिग्नल प्रोटोकॉल: नेटवर्क संचार के लिए एक सरल भाषा

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

0. रीसेट

• कोड में पहचानकर्ता: SIG-R
• पूर्णांक मान: 0
• उद्देश्य: सीमा के भीतर सभी उपकरणों को बताएं कि वे जो कर रहे हैं उसे छोड़ दें और कार्य करें जैसे कि वे अभी बूट हुए थे। यदि यह सिग्नल नेटवर्क के प्रत्येक डिवाइस तक पहुंच जाता है, तो पूरा नेटवर्क रीसेट हो जाएगा और उपयोगकर्ता एक नया गेम शुरू कर सकते हैं। यह सिग्नल केवल रूट डिवाइस द्वारा प्रसारित किया जा सकता है।

1. रूपांतरण ए

• कोड में पहचानकर्ता: SIG-A
• पूर्णांक मान: 1
• उद्देश्य: किसी भी डिवाइस को LISTEN_A स्थिति में होने के बारे में बताएं, एक बार जब वे रूपांतरण संकेत प्राप्त कर लेते हैं, तो उन्हें राज्य TEAM_A पर स्विच करने के लिए कहें।

2. रूपांतरण बी

1. कोड में पहचानकर्ता: SIG-B
2. पूर्णांक मान: 2
3. उद्देश्य: किसी भी उपकरण को LISTEN_B स्थिति में होने पर, रूपांतरण सिग्नल मिलने के बाद, TEAM_B स्थिति में जाने के लिए कहें।

चरण 3: हम डिवाइस की वर्तमान स्थिति के आधार पर उसके कार्यों को नियंत्रित करना चाहते हैं

अंत में, हम कोड लिखना शुरू कर सकते हैं।

सबसे पहले, मेक कोड में एक नया प्रोजेक्ट खोलें

• एक नया फ़ंक्शन बनाएं। मैंने अपना लूप कहा क्योंकि यह एप्लिकेशन का मुख्य लूप है
• एक लूप ब्लॉक जोड़ें जो अनिश्चित काल तक दोहराएगा। मैंने जबकि (सत्य) का उपयोग किया क्योंकि एक शाब्दिक सत्य कभी भी गलत नहीं होगा, इसलिए एप्लिकेशन का नियंत्रण प्रवाह कभी भी लूप से बाहर नहीं निकलेगा
• यह जांचने के लिए कि डिवाइस अपने पांच संभावित राज्यों में से किसी में है या नहीं, पर्याप्त if-else ब्लॉक जोड़ें
• डिवाइस की मौजूदा स्थिति को बनाए रखने के लिए एक वैरिएबल बनाएं

• पांच संभावित राज्यों में से प्रत्येक का प्रतिनिधित्व करने के लिए चर बनाएं

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

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

नोट: तीसरी छवि में ग्रे ब्लॉक के बारे में चिंता न करें। मैं उन तक बाद में पहुंचूंगा।

चरण 4: हम उपयोगकर्ता इनपुट पर प्रतिक्रिया करना चाहते हैं

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

• चार "ऑन इवेंट फ्रॉम…" ब्लॉक बनाएं।

  • इनमें से दो को ईवेंट स्रोत "MICROBIT_ID_BUTTON_A" की जांच करनी चाहिए
  • इनमें से दो को ईवेंट स्रोत "MICROBIT_ID_BUTTON_B" की जांच करनी चाहिए

  • प्रत्येक बटन को लक्षित करने वाली दो घटनाओं में से:

    • "MICROBIT_BUTTON_EVT_UP" प्रकार की घटना की जांच करनी चाहिए
    • "MICROBIT_BUTTON_EVT_DOWN" प्रकार की घटना की जांच करनी चाहिए
  • नोट: सभी बड़े अक्षरों में ये विकल्प लेबल हैं जो निचले स्तर के माइक्रो: बिट कोड में उपयोग किए जाते हैं। वे केवल प्लेसहोल्डर होते हैं जिन्हें बाद में पूर्णांक द्वारा प्रतिस्थापित किया जाता है जब कोड को निष्पादन योग्य बाइनरी में संकलित किया जाता है। मनुष्यों के लिए इन लेबलों का उपयोग करना आसान है, यह देखने के लिए कि कौन सा पूर्णांक डालना है, हालांकि दोनों एक ही तरह से काम करेंगे।

• मैंने शैली के मामले में, प्रत्येक "ऑन इवेंट फ्रॉम …" ब्लॉक को एक फ़ंक्शन कॉल करने के लिए चुना है जो उठाए गए ईवेंट का वर्णन करता है। जबकि सख्ती से जरूरी नहीं है, मेरी राय में यह पठनीयता में सुधार करता है। यदि कोई ऐसा करना चाहता है, तो वे ईवेंट-हैंडलिंग कोड को "ऑन इवेंट फ्रॉम…" ब्लॉक के अंदर ही डाल सकते हैं।

  नोट: कोड का ब्लॉक जो किसी ईवेंट के लिए डिवाइस की प्रतिक्रिया को संभालता है, उसे सहज रूप से "ईवेंट हैंडलर" कहा जाता है।

• जोड़ें, प्रत्येक ईवेंट हैंडलर में, वही if-else स्ट्रक्चर जो डिवाइस स्टेट के आधार पर कंट्रोल फ्लो को मुख्य स्टेट लूप में स्ट्रक्चर के रूप में विभाजित करने के लिए उपयोग किया जाता है।

• असाइनमेंट ब्लॉक जोड़ें जो हमारे राज्य आरेख द्वारा निर्दिष्ट डिवाइस की उस स्थिति को संशोधित करते हैं

  • हम जानते हैं कि जब डिवाइस बिना साइन की स्थिति में होता है, तो डिवाइस को LISTEN_A स्थिति में संक्रमण द्वारा दबाए गए बटन A पर प्रतिक्रिया करनी चाहिए, और स्थिति LISTEN_B में संक्रमण द्वारा दबाए गए बटन B पर प्रतिक्रिया देनी चाहिए।
  • हम यह भी जानते हैं कि जब डिवाइस LISTEN_A या LISTEN_B स्थिति में होता है, तो डिवाइस को क्रमशः जारी किए गए बटन A और जारी किए गए बटन B पर प्रतिक्रिया करनी चाहिए, जो कि वापस UNASSIGNED स्थिति में संक्रमण करके होता है।

  • अंत में, हम जानते हैं कि जब डिवाइस TEAM_A या TEAM_B स्थिति में होता है, तो डिवाइस को क्रमशः SIG_A को प्रसारित करके और SIG_B को प्रसारित करके दबाए गए बटन A और दबाए गए बटन B पर प्रतिक्रिया करनी चाहिए।

    प्रसारण संकेतों के विवरण भरने के लिए इस बिंदु पर यह आवश्यक नहीं है। हम उस पर बाद में पहुंचेंगे। महत्वपूर्ण बात यह है कि हम इन कार्यों को उस कोड का उपयोग करने के लिए निर्देश देते हैं जिसे हम कार्यों के उस ब्लॉक को एक नाम देकर लिखेंगे, जैसे BroadcastSignalSIG_A, जो बताता है कि उस बिंदु पर क्या किया जाना चाहिए।

चरण 5: हम डिवाइस के बूट होने पर डिवाइस मेमोरी में डेटा मान प्रारंभ करना चाहते हैं

इस बिंदु पर, हमने बहुत सारे चर (डेटा के लिए नाम) का उपयोग किया है, लेकिन हमने वास्तव में उन नामों को मान निर्दिष्ट नहीं किया है। हम चाहते हैं कि डिवाइस बूट होने पर इन सभी वेरिएबल्स के मानों को मेमोरी में लोड करे, इसलिए हम इन वेरिएबल्स के लिए इनिशियलाइज़ेशन को "ऑन स्टार्ट" ब्लॉक में रखते हैं।

ये वे मान हैं जिन्हें हमें प्रारंभ करना चाहिए:

• सिग्नल प्रोटोकॉल के अनुसार सिग्नल स्थिरांक। मान होना चाहिए:

  • एसआईजी_आर = 0
  • एसआईजी_ए = 1
  • एसआईजी_बी = 2
  • नोट: मैंने इन स्थिरांकों को "एनमसिग्नल्स" के साथ उपसर्ग किया है ताकि यह इंगित किया जा सके कि ये चर व्यवहार करने के लिए हैं जैसे कि वे सिग्नल नामक एक गणना प्रकार का हिस्सा थे। इस प्रकार इन चरों को अन्य प्रोग्रामिंग भाषाओं में लागू किया जा सकता है। प्रगणित प्रकारों की परिभाषा और व्याख्या मेरे ट्यूटोरियल के दायरे से बाहर है। अगर वे चाहें तो इसे गूगल कर सकते हैं। ये उपसर्ग केवल शैलीगत विकल्प हैं और कार्यक्रम के समुचित कार्य के लिए बिल्कुल भी आवश्यक नहीं हैं।

• राज्य स्थिरांक, जो तब तक मनमाना हो सकते हैं जब तक उनका कोई मूल्य हो। मैंने 0 से आरोही पूर्णांकों का उपयोग करने के लिए शैली पसंद की, जैसे:

  • अहस्ताक्षरित = 0
  • LISTEN_A = 1
  • LISTEN_B = 2
  • टीम_ए = 3
  • टीम_बी = 4
  • नोट: मैंने इन चरों के लिए उपसर्गों के संबंध में भी वही शैली निर्णय लिया है। इसके अलावा, मैं यह उल्लेख करूंगा कि इन असाइनमेंट, मूल्यों और क्रम के बारे में सब कुछ पूरी तरह से मनमाना है। इससे कोई फर्क नहीं पड़ता कि ये मान डिवाइस से डिवाइस के अनुरूप हैं, क्योंकि इनका उपयोग केवल आंतरिक रूप से किया जाता है न कि नेटवर्क पर संचार के लिए। यह सब मायने रखता है कि चर का एक मूल्य है और यह देखने के लिए कि वे समतुल्य हैं या नहीं, उनकी एक दूसरे से तुलना की जा सकती है।
• पठनीयता के लिए, एक स्थिरांक को BOOT_STATE कहा जाता है और इसे UNASSIGNED पर सेट किया जाता है। यह इस तथ्य को बनाता है कि हम अधिक मनमानी स्थिति के बजाय बूट स्थिति पर रीसेट करते हैं, जब डिवाइस को रीसेट सिग्नल प्राप्त होता है, जिसे हम बाद में लागू करेंगे।

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

  • TICKS_PER_FRAME_LOADING_ANIMATION = 50
  • MS_PER_DEVICE_TICK = 10
  • MS_PER_FRAME_BROADCAST_ANIMATION = 500
  • MICROSECONDS_PER_MILLISECOND = 1000
  • NUMBER_OF_FRAMES_IN_LOADING_ANIMATION = 4

• एनीमेशन के लिए एक और चर, इस बार एक काउंटर जो निश्चित रूप से स्थिर नहीं है। अधिकांश काउंटरों की तरह, हम इसे 0. से प्रारंभ करते हैं

  iTickLoadingएनीमेशन = 0

• एनिमेशन के फ्रेम को होल्ड करने के लिए वेरिएबल की दो सीरीज बनाएं। पहला, जिसे मैं "लोडिंग एनीमेशन" कहता हूं, उसमें चार छवियां होनी चाहिए (जिसका अनुमान आपने पिछले निरंतर आरंभीकरण से लगाया होगा), और दूसरा, जिसे मैं "प्रसारण एनीमेशन" कहता हूं, जिसमें तीन छवियां होनी चाहिए। मैं अनुशंसा करता हूं कि वेरिएबल्स को एनीमेशन के फ्रेम के अनुरूप नाम दें, उदा। रिंगएनीमेशन0, रिंगएनीमेशन1…

  जैसा मैंने किया था वैसा ही छवि मान बनाएं या अधिक मूल और कूलर छवियां बनाएं।

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

चरण 6: हम 5 X 5 एलईडी डिस्प्ले का उपयोग करके एनिमेशन और ग्राफिक्स प्रदर्शित करना चाहते हैं

और अब पूरी तरह से अलग कुछ करने के लिए।

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

• प्रत्येक छवि के लिए एक फ़ंक्शन बनाएं। यह हर बार जावास्क्रिप्ट को संपादित करने के बजाय छवि को प्रदर्शित करने के लिए एकल ब्लॉक का उपयोग करने की अनुमति देगा। इस विशिष्ट कार्यक्रम में, किसी भी छवि का एक से अधिक बार उपयोग नहीं किया जाता है, लेकिन मुझे अभी भी लगता है कि यह शैली कोड को पढ़ने में आसान बनाती है।
• प्रत्येक नए फ़ंक्शन में, संबंधित छवि चर नाम की जगह (X) के साथ "ऑफ़सेट 0 पर छवि (X) दिखाएं" ब्लॉक जोड़ें।

• मुख्य राज्य लूप में जोड़ें। राज्य को संभालने वाले ब्लॉक के अलावा प्रत्येक ब्लॉक में "स्ट्रिंग (एक्स)" ब्लॉक दिखाएं। डिवाइस की विभिन्न स्थितियों को इंगित करने के लिए प्रदर्शित करने के लिए एक वर्ण जोड़ें। मैंने जो किया था यह रहा:

  • LISTEN_A: 'ए'
  • LISTEN_B: 'बी'
  • टीम_ए: 'ए'

  • टीम_बी: 'बी'

    राज्य अप्रकाशित के लिए, एक फ़ंक्शन को कॉल करें जो लोडिंग एनीमेशन को अपडेट करेगा। हम नीचे इस फ़ंक्शन का विवरण भरेंगे।

• जावास्क्रिप्ट मोड पर स्विच करें।
• X.showImage(0) और basic.showString(X) पर हर कॉल का पता लगाएं

• हर एक को X.showImage(0, 0) या basic.showString(X, 0) में बदलें

  • इस अतिरिक्त तर्क को जोड़ने से कार्रवाई के बाद देरी 0 पर सेट हो जाएगी। डिफ़ॉल्ट रूप से, इसे छोड़ दिया जाता है, और इनमें से प्रत्येक ब्लॉक के निष्पादन के बाद डिवाइस 400 एमएस के लिए रुक जाएगा।
  • अब, हमारे पास अपने एनीमेशन ब्लॉक में अपनी छवियों को प्रदर्शित करने के लिए लगभग विलंबता-मुक्त तंत्र है, जिसे अब हम बना सकते हैं

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

• एक फ़ंक्शन बनाएं जो प्रसारण एनीमेशन प्रदर्शित करेगा।
• उस ब्लॉक के अंदर, एनीमेशन के प्रत्येक फ्रेम में तीन फ़ंक्शन कॉल जोड़ें, ताकि उन्हें प्रदर्शित किया जा सके

• छवि प्रदर्शित करने वाले फ़ंक्शन में प्रत्येक कॉल के बाद "प्रतीक्षा (हमें) (एक्स)" ब्लॉक जोड़ें।

  नोट: यह ब्लॉक, उन्नत नियंत्रण खंड से, "रोकें (एमएस)" से भी आगे जाएगा, जिसमें यह निर्दिष्ट समय बीत जाने तक प्रोसेसर को पूरी तरह से फ्रीज कर देगा। जब पॉज़ ब्लॉक का उपयोग किया जाता है, तो संभव है कि डिवाइस पर्दे के पीछे अन्य कार्य करेगा। प्रतीक्षा ब्लॉक के साथ यह असंभव है।

• (X) को (MS_PER_FRAME_BROADCAST_ANIMATION x MICROSECONDS_PER_MILLISECOND) से बदलें
• एनीमेशन अब ठीक से काम करना चाहिए

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

• एक फ़ंक्शन बनाएं जो लोडिंग एनीमेशन को अपडेट करेगा

• यह जांचने के लिए एक शर्त जोड़ें कि क्या टिक काउंटर अपने अधिकतम मूल्य तक पहुंच गया है। यह शर्त सही होगी यदि टिक काउंटर का मान लोडिंग एनीमेशन में फ्रेम की संख्या से अधिक है और प्रत्येक फ्रेम को प्रदर्शित करने के लिए टिकों की संख्या से गुणा किया जाता है।

  यदि स्थिति सही है, तो iTickLoadingAnimation को 0. पर रीसेट करें

• if-else शर्तों का एक ब्लॉक जोड़ें। ये निर्धारित करेंगे कि एनीमेशन के किस फ्रेम को प्रदर्शित करना है।

  एनीमेशन के प्रत्येक फ्रेम के लिए, यदि टिक काउंटर एनीमेशन के फ्रेम नंबर (1 से शुरू) से गुणा करके प्रत्येक एनीमेशन में टिकों की संख्या से कम है, तो उस फ्रेम को प्रदर्शित करें, अन्यथा जांचें कि अगला फ्रेम एक है या नहीं प्रदर्शित हों

• ब्लॉक के निचले भाग में, iTickLoadingAnimation बढ़ाएँ
• एनीमेशन अब ठीक से काम करना चाहिए

नोट: मेरे उदाहरण में दिखाई देने वाले सभी ग्रे ब्लॉक तब उत्पन्न होते हैं जब कोई किसी ब्लॉक के जावास्क्रिप्ट प्रतिनिधित्व को संपादित करता है। इसका सीधा सा मतलब है कि ब्लॉक जावास्क्रिप्ट कोड का प्रतिनिधित्व करता है जिसे ब्लॉक के मानक सेट का उपयोग करके प्रदर्शित नहीं किया जा सकता है और इसे टेक्स्ट फॉर्म में संपादित किया जाना चाहिए।

चरण 7: हम डिवाइस के रेडियो का उपयोग करके डेटा को वायरलेस तरीके से प्रसारित करना चाहते हैं

यह कदम पिछले की तुलना में बहुत छोटा है। वास्तव में, यह शायद इस पूरे ट्यूटोरियल का सबसे छोटा कदम है।

याद रखें कि जब हमने उपयोगकर्ता इनपुट के लिए डिवाइस की प्रतिक्रिया को प्रोग्राम किया था, तो मेरे पास स्क्रीनशॉट में दो ब्लॉक थे जिन्हें उस खंड में समझाया नहीं गया था। ये उन कार्यों के लिए कॉल थे जो रेडियो पर सिग्नल भेजते हैं। अधिक विशेष रूप से:

• बटन ए पर दबाया गया:

  • यदि डिवाइस TEAM_A स्थिति में है:

    प्रसारण संकेत SIG_A

• बटन बी पर दबाया गया:

  • अगर डिवाइस TEAM_B. स्थिति में है

    प्रसारण संकेत SIG_B

यह फ़ंक्शन बनाएं यदि वे पहले से मौजूद नहीं हैं।

प्रत्येक समारोह में:

• प्रसारण एनीमेशन फ़ंक्शन को कॉल करें। यह किसी अन्य चीज़ के पूर्ण होने तक उसे होने से रोकेगा, जो MS_PER_FRAME_BROADCAST_ANIMATION * 3 = 1.5 सेकंड में होगी। स्थिरांक को तीन से गुणा किया जाता है क्योंकि एनीमेशन में तीन फ्रेम होते हैं। यह मनमाना है और यदि सौंदर्य उन्नयन काफी अच्छा है तो और अधिक जोड़ा जा सकता है। इस एनिमेशन का दूसरा उद्देश्य किसी उपयोगकर्ता को प्रसारण फ़ंक्शन को स्पैम करने से रोकना है।
• एक "रेडियो सेंड नंबर (X)" ब्लॉक जोड़ें, जहां फ़ंक्शन नाम में उल्लिखित सिग्नल स्थिरांक है

बस इतना ही रेडियो पर प्रसारित करने की जरूरत है।

चरण 8: हम डिवाइस के रेडियो पर डेटा सुनना और प्राप्त करना चाहते हैं और उसके अनुसार इसे संसाधित करना चाहते हैं

यह मुख्य एप्लिकेशन बनाने का अंतिम चरण है।

हम डिवाइस को आने वाले रेडियो सिग्नल को प्रोसेस करने का तरीका बताने जा रहे हैं। सबसे पहले, हमारा डिवाइस प्राप्त सिग्नल को नाम देगा। फिर, उस संकेत के मूल्य के आधार पर, यह तय करेगा कि क्या कार्रवाई करनी है, यदि कोई हो।

प्रथम:

1. "रेडियो पर प्राप्त (X)" ब्लॉक से शुरू होने वाले कोड का एक ब्लॉक बनाएं।
2. वैकल्पिक रूप से, उस प्राप्त मान को अधिक वर्णनात्मक नाम के साथ किसी अन्य चर को असाइन करें।
3. एक फ़ंक्शन को कॉल करें जो सिग्नल को संसाधित करेगा

दूसरा, सिग्नल प्रोसेसिंग फ़ंक्शन में:

1. सिग्नल के मूल्य के आधार पर प्रवाह को नियंत्रित करने वाले इफ-इफ स्टेटमेंट का एक ब्लॉक बनाएं।

2. यदि संकेत SIG_R. था

   डिवाइस की स्थिति को BOOT_STATE पर सेट करें (इसीलिए हमने इसे पहले बनाया था)

3. यदि संकेत SIG_A था और यदि वर्तमान स्थिति LISTEN_A. है

   डिवाइस की स्थिति को TEAM_A. पर सेट करें

4. यदि संकेत SIG_B था और यदि वर्तमान स्थिति LISTEN_B. है

   डिवाइस की स्थिति को TEAM_B. पर सेट करें

बस, इतना ही। आवेदन समाप्त हो गया है।

चरण 9: रूट डिवाइस: हम एक सिग्नल का चयन करने में सक्षम होना चाहते हैं

अब, हम "रूट" डिवाइस के लिए एक साधारण एप्लिकेशन लिखेंगे, यानी एक ऐसा डिवाइस जो नेटवर्क को नियंत्रित करेगा।

इस उपकरण को दो कार्य करने की आवश्यकता होगी:

• हम उपयोगकर्ता को हमारे संकेतों में से एक का चयन करने की अनुमति देना चाहते हैं
• हम उपयोगकर्ता को सिग्नल प्रसारित करने की अनुमति देना चाहते हैं

चूंकि इस एप्लिकेशन का विनिर्देश पिछले का एक सबसेट है, इसलिए मैं एक सिंहावलोकन दूंगा लेकिन मैं उतना विवरण नहीं दूंगा जितना पहले था। ऊपर दी गई छवि में इस एप्लिकेशन का पूरा कोड है।

उपयोगकर्ता को सिग्नल चुनने की अनुमति देने के लिए:

1. "ऑन स्टार्ट" ब्लॉक में 5 वेरिएबल्स को इनिशियलाइज़ करें:

   1. तीन संकेत (0, 1, 2)
   2. संकेतों की संख्या (3)
   3. वर्तमान में चयनित सिग्नल को होल्ड करने के लिए एक वैरिएबल (शुरुआत में पहले सिग्नल पर सेट, 0)

2. ए बटन की एक प्रेस को संभालें:

   1. चयनित संकेत बढ़ाएँ

   2. जांचें कि क्या चयनित सिग्नल सिग्नल की संख्या से अधिक या उसके बराबर है

      यदि ऐसा है, तो चयनित सिग्नल को 0. पर सेट करें

3. ऑन स्टार्ट ब्लॉक के बाद, "हमेशा के लिए" लूप चलाएं जो बिना किसी देरी के वर्तमान चयनित सिग्नल मान प्रदर्शित करता है

उपयोगकर्ता को सिग्नल प्रसारित करने की अनुमति देने के लिए

1. "ऑन स्टार्ट" ब्लॉक में रेडियो ग्रुप को 0 पर सेट करें

2. बी बटन की एक प्रेस को संभालें:

   "रेडियो सेंड नंबर (X)" ब्लॉक का उपयोग करके चयनित सिग्नल को प्रसारित करें

बस, इतना ही। रूट नोड एप्लिकेशन बेहद सरल है।

चरण 10: हम समाप्त हो गए हैं।

ऊपर एप्लिकेशन चलाने वाले उपकरणों की एक तस्वीर है। दाईं ओर दो मुख्य "उपयोगकर्ता" एप्लिकेशन चला रहे हैं, और बाईं ओर वाला "रूट" एप्लिकेशन चला रहा है।

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

सीएस कनेक्शन 2018 के बारे में अधिक जानकारी यहां मिल सकती है।