एक Arduino से दूसरे में संख्यात्मक डेटा भेजें: 16 कदम

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

परिचय

डेविड पामर, सीडीआईओ टेक द्वारा। एस्टन विश्वविद्यालय में।

क्या आपको कभी एक Arduino से दूसरे में कुछ नंबर भेजने की आवश्यकता थी? यह निर्देशयोग्य दिखाता है कि कैसे।

आप आसानी से सीरियल मॉनिटर टर्मिनल पर भेजने के लिए संख्याओं की एक स्ट्रिंग टाइप करके काम कर सकते हैं, और दूसरे Arduino से जुड़े दूसरे सीरियल मॉनिटर पर नंबर वापस आते हुए देख सकते हैं। तुम भी एक ब्लूटूथ लिंक का उपयोग कर सकते हैं।

यह क्या करता है

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

उपकरण

• 2 Arduino's
• 2 यूएसबी लीड
• पैच तार (आवश्यकतानुसार)
• 1 पीसी/लैपटॉप Arduino IDE से भरा हुआ है (Arduino.cc वेबसाइट से मुफ्त डाउनलोड के रूप में उपलब्ध है)

चरण 1: स्थापना - पहले अपना हार्डवेयर सेट करें

अपने कंप्यूटर पर 2 Arduinos को 2 USB पोर्ट में प्लग करें।

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

चरण 2: सेट अप - अपनी स्क्रीन सेट करें

सबसे अच्छी बात यह है कि अपनी स्क्रीन सेट अप करें ताकि आपके पास

• IDE बाईं ओर मास्टर प्रोग्राम के साथ लोड किया गया है और
• कि दास के साथ दाईं ओर।

मेसर और स्लेव के लिए सीरियल मॉनिटर्स को बाईं और दाईं ओर भी रखें जैसा कि यहां स्क्रीन शॉट में दिखाया गया है।

चरण 3: मास्टर एंड सेट-अप करें, फिर एक साथ कनेक्ट करें - भाग 1

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

अब आपको 2 Arduino को एक साथ सीरियल में कनेक्ट करने की आवश्यकता है। यह दो पैच तारों के साथ किया जाता है।

मैंने हरे और पीले रंग का इस्तेमाल किया

• पहले पीले रंग को लें, इसे एक Arduino में D6 और दूसरे में D7 में प्लग करना होगा
• फिर हरे रंग के तार के विपरीत, पहले पर D7 और दूसरे Arduino पर D6।

वैकल्पिक रूप से, यदि आपके पास ब्लूटूथ मॉड्यूल की एक जोड़ी की तरह कुछ उपलब्ध है - जैसे एचसी -05 - ये आपको ऊपर के तारों के समान प्रभाव देने के लिए भी काम करेंगे।

चरण 4: मास्टर एंड को सेट-अप करें, फिर एक साथ कनेक्ट करें - भाग 2

हम सॉफ्टवेयर सीरियल लाइब्रेरी का उपयोग कर रहे हैं। अधिक जानकारी इस लिंक https://www.arduino.cc/en/Reference/Libraries के साथ उपलब्ध है।

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

चरण 5: रेखाचित्रों/कार्यक्रमों का अवलोकन - कार्यक्रम की संरचना

लेआउट जैसे सभी Arduino रेखाचित्रों में 3 मूल भाग होते हैं:

• घोषणाएं
• जाल
• मुख्य लूप

जैसा कि अक्सर होता है, हमने यहां चौथे खंड का उपयोग किया है जो 'फ़ंक्शंस' का जोड़ है। यदि आप फ़ंक्शंस का उपयोग करने से परिचित नहीं हैं, तो आप "Arduino फ़ंक्शंस" के लिए Google कर सकते हैं और आपको इस लिंक में उदाहरण जैसी स्पष्टीकरण साइटें मिलेंगी: www.tutorialspoint.com/arduino/arduino_functions…।.

हमने प्रोग्राम को अधिक प्रबंधनीय ब्लॉकों में अलग करने के लिए टैब का भी उपयोग किया है।

हमने जिन तीन ब्लॉकों का उपयोग किया है, उन्हें ऊपर IDE विंडो के प्रत्येक चित्रण के शीर्ष पर देखा जा सकता है:

• सरलRxTx0330मास्टर
• सामान्य
• टिप्पणियाँ

ये वास्तव में प्रोग्राम के फोल्डर के अंदर अलग-अलग फाइलें हैं, जैसा कि आप स्लेव प्रोग्राम की फाइलों के इस विंडोज एक्सप्लोरर व्यू में देख सकते हैं।

हमने ऐसा क्यों किया है इसका एक बहुत अच्छा कारण है।

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

किसी भी फ़ंक्शन को सेटअप से कॉल नहीं किया जाता है, वे सभी लूप से कॉल किए जाते हैं, इसलिए हमने उन्हें सेटअप के बाद लेकिन लूप से पहले बनाया है।

चरण 6: टॉप डाउन डिज़ाइन।

आप जो करना चाहते हैं उसकी परिभाषा के साथ शुरू करते हुए अपने स्केच को डिजाइन करना एक अच्छा विचार है।

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

यह कई विश्वविद्यालयों में पढ़ाए जाने वाले अच्छे डिजाइन दर्शन का अनुसरण करता है, जिसे सीडीआईओ कहा जाता है (यदि आप इसे पहले से नहीं जानते हैं तो आप इसे Google कर सकते हैं, और इसे समझाने के लिए साइटें ढूंढ सकते हैं जैसे: https://www.cdio.org/s।) यह मूल रूप से कहता है: अवधारणा को स्पष्ट करने से पहले डिजाइन शुरू न करें। जब तक आपको डिज़ाइन स्पष्ट नहीं हो जाता तब तक कार्यान्वयन प्रारंभ न करें। कार्यान्वयन स्पष्ट होने से पहले इसे संचालित करने की अपेक्षा न करें। सी पहले, फिर डी, आई, और ओ। प्रत्येक बाद के चरण में आप पुनरावृति करते हैं (लूप के चारों ओर वापस जाएं), इसलिए एक बार जब आप अपने प्रारंभिक डिज़ाइन लूप से खुश हों और जांच लें कि यह अभी भी अवधारणा को पूरा करता है, और अपडेट करें सी अगर आपको जरूरत है। और इसी तरह, इसलिए जब आपको ऑपरेटिंग मिल गया है, तो सभी तरह से शीर्ष पर जाएं, और फिर देखें कि सी अब कैसा दिख रहा है, फिर डी और मैं, और सभी को बनाएं और जांचें आवश्यकतानुसार परिवर्तन। प्रोग्रामिंग स्केच के साथ यह ठीक उसी तरह काम करता है यदि आप टॉप-डाउन डिज़ाइन करते हैं।

चरण 7: अवधारणा और डिजाइन - भाग 1

यहां अवधारणा 'नोट्स' टैब में बताई गई रूपरेखा आवश्यकताओं की तरह दिखती है।

डिज़ाइन लूप के शुरुआती संस्करण की तरह दिख सकता है, जो नोट्स टैब से मेल खाता है और कुछ ऐसा दिख सकता है जैसा आप इस आंकड़े में देखते हैं

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

यह वास्तव में ठीक संकलित करता है जैसा कि आप चित्र में स्क्रीन के नीचे देख सकते हैं। यह सीडीआईओ चरण डी से आई तक पहुंच रहा है, और जैसे ही हम कोड विकसित करते हैं, इस डी-आई लूप के चारों ओर घूमते रहना एक अच्छा विचार है।

अब अगले चरण में जाने का समय है, वहां एक टिप्पणी है जो कहती है कि हम जा रहे हैं://हार्डवेयर यूएसबी से कुछ प्राप्त करें, फिर हम इसे सॉफ्टवेयर सीरियल चैनल पर प्रसारित करने जा रहे हैं। हम ऐसा करने के लिए यह कोड लिखते हैं - 133 से 138 की पंक्तियों को यहां पीले हाइलाइटर में दिखाया गया है

चरण 8: अवधारणा और डिजाइन - भाग 2

हार्डवेयर पोर्ट से रिसीविंग और सॉफ्टवेयर पोर्ट पर ट्रांसमिट करने के लिए हम यहां दो पहले दो फंक्शन पेश कर रहे हैं (recv() और tran() - इसलिए उन्हें दिखाए गए 'hw' या 'sw' पैरामीटर के साथ कॉल करना है।

उनके अलावा, हमने newData नामक वैश्विक चर पर एक परीक्षण जोड़ा है। यह एक ध्वज है जिसे हम " void recv (); " फ़ंक्शन के अंदर सेट करेंगे। जब कोई संदेश प्राप्त होता है तो इस चर को असत्य से सत्य में फ़्लैग किया जाता है। हम ऐसा इसलिए करते हैं ताकि हम केवल एक संदेश प्रसारित करें यदि कोई प्राप्त हुआ है (flag ==true) लाइन 134 में। और एक बार जब हमने अपना संदेश प्रसारित कर दिया है कि 'काम हो गया' तो हम फ़्लैग को फिर से 137 पंक्ति में साफ़ करते हैं।

फिर से हम संकलन (डी से आई) की जांच कर सकते हैं, और इस बार हमारे पास 'घोषित नहीं' त्रुटि संदेश (दिखाया गया) है। यह हमें बता रहा है कि हमने recv() घोषित नहीं किया है; समारोह। हम इसे बाद में करने की योजना बना रहे हैं, इसलिए अभी के लिए हमें एक साफ संकलन प्राप्त करने की अनुमति देने के लिए हमें एक डमी या प्लेसहोल्डर फ़ंक्शन बनाने की आवश्यकता है, जैसा कि आगे दिखाया गया है।

फिर से हम कंपाइल (डी टू आई) की जांच कर सकते हैं, और इस बार हमारे पास ट्रैन () के लिए एक और 'घोषित नहीं' त्रुटि संदेश है; समारोह। इसके लिए एक समान ठूंठ बनाने की जरूरत है। फिर से हम संकलन (डी से आई) की जांच कर सकते हैं, और इस बार हम पाएंगे कि यह पूरी तरह से काम करता है; अब तक तो सब ठीक है।

चरण 9: मुख्य लूप समाप्त करें: ए) यूएसबी से प्राप्त करना, बी) दास Arduino से प्राप्त करना।

इस भाग को समाप्त करने के लिए हमने एक अंतिम भाग जोड़ा है जो कुछ डिबगिंग कोड जोड़ना है।

डिबगिंग स्केच पर एक और निर्देश योग्य है जिसे यह समझने के लिए संदर्भित किया जा सकता है कि हमने यहां क्या किया है और क्यों। निर्देशयोग्य का संदर्भ लें "जब तक वे काम नहीं करते तब तक Arduino स्केच कैसे बनाएं और उनका परीक्षण करें"

तो ये डिबग लाइन [१३६-१३९ दिखाया गया] मुख्य लूप में जोड़ा गया है और, लो-एंड-देखो, आप डिबग वैरिएबल को सही बनाकर मास्टर एंड में उनका परीक्षण कर सकते हैं, और कंपाइलिंग (I), फिर यदि आप एक Arduino कनेक्ट करते हैं जिसे आप अपलोड कर सकते हैं, सीरियल मॉनिटर खोल सकते हैं और देख सकते हैं कि क्या सीरियल मॉनिटर में वापस आता है जैसा कि यहां दिखाया गया है (क्या आप देखते हैं कि "DEBUG MODE" संदेश जोड़ा गया है?)

चरण 10: दास Arduino में डेटा प्राप्त करना और संभालना

गुलाम Arduino. से प्राप्त करना

दूसरे चैनल के लिए मुख्य लूप में आवश्यक कोड जोड़ें, सॉफ्टवेयर सीरियल रिसीवर जैसा कि दिखाया गया है - लाइन 149 से 155।

क्या आप देख सकते हैं कि मास्टर केस के लिए हमने ऊपर जो लिखा है, उस पर संरचना शिथिल रूप से आधारित है?

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

गुलाम Arduino में डेटा को संभालना

Arduino के लिए आवश्यक मुख्य लूप कोड जोड़ें यदि इसे एक स्लेव डिवाइस के रूप में कॉन्फ़िगर किया गया है जैसा कि दिखाया गया है - लाइनें १६३ से १७४। क्या आप देख सकते हैं कि इसकी संरचना पहले चैनल के समान है?

और आपको इस बार यह बिल्कुल ठीक कंपाइल करना चाहिए।

चरण 11: रिसीव फंक्शन लिखें

रिसीव फंक्शन - शून्य आरईवी (चार से) {} - में दो मुख्य कार्य हैं।

1 USB चैनल से वर्णों की एक स्ट्रिंग प्राप्त करने के लिए, और

2 Arduino से Arduino चैनल में एक प्राप्त करने के लिए।

पहले के लिए हमें उपयोग करने की आवश्यकता होगी क्योंकि यह Arduino's निर्मित हार्डवेयर UART का उपयोग करता है, और दूसरे के लिए मानक Arduino लाइब्रेरी: सॉफ़्टवेयर UART का उपयोग करता है।

जब हम किसी फ़ंक्शन में कोड जोड़ना शुरू करते हैं - एक ऐसा फ़ंक्शन बनाने के लिए जो कुछ करता है, केवल एक स्टब के बजाय - हमें उस स्टब को हटाने या टिप्पणी करने के लिए याद रखना होगा जो इसे बदल रहा है। अन्यथा हमें एक संकलन त्रुटि मिलती है: 'void lrec (char)' का परिशोधन।

कोशिश करें और त्रुटि प्राप्त करें, और फिर इससे छुटकारा पाने के लिए ऊपर बताए गए तरीकों में से किसी एक को आजमाएं।

एक फ़ंक्शन के साथ प्रारंभ करें जो दिखता है जैसा कि हम यहां 75 से 88 की पंक्तियों में पीले रंग में दिखाते हैं।

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

अब उस कोड पर एक नजर डालते हैं जिसे हमने recv() फंक्शन के लिए लिखा है।

यह काफी साफ है, आप ऊपर बताए गए फंक्शन के दो हिस्सों को बनाने के लिए 'if' कंडीशन का इस्तेमाल देख सकते हैं।

'sw' भाग और 'hw' भाग के अंदर का कोड एक ही रूप का है, और मैं यहाँ इसका वर्णन करूँगा।

प्रत्येक मामले में लाइनों की जोड़ी में से पहला थोड़ी देर के लूप की शुरुआत है। यदि आप समय से परिचित नहीं हैं, तो आप स्पष्टीकरण और उदाहरणों के लिए इसे Arduino.cc/Reference साइट में देख सकते हैं। यहां हम प्रतीक्षा करते हैं 'जबकि' इनबिल्ट 'सीरियल' फ़ंक्शन को कोई वर्ण नहीं मिला है और क्योंकि newData चर बंद कर दिया गया है (यानी newData == false condition is true)। जैसे ही एक चरित्र - या एक से अधिक वर्ण - प्राप्त होते हैं, जबकि इस जोड़ी में दूसरी पंक्ति में 'ड्रॉप थ्रू' हो जाएगा। फिर वह recAstringChar(char) पर कॉल करेगा; वर्तमान चरित्र को संभालने के लिए कार्य। पंक्तियों की यह जोड़ी तब वैकल्पिक होगी (या जब तक) कोई भी वर्ण अभी भी प्राप्त करने की आवश्यकता है। एक बार जब वे सभी समाप्त हो जाते हैं, जबकि राज्य समाप्त हो जाता है, अगर या फिर अगले स्तर को समाप्त करने की इजाजत देता है, और बदले में आरई (चार) की इजाजत देता है; समाप्त करने के लिए कार्य। इस प्रकार अब एक पूरा संदेश प्राप्त हुआ है।

चरण 12: प्राप्त उप-कार्य लिखें - भाग 1

अब हमें recAstringChar(char) नामक फंक्शन लिखने की जरूरत है;. आप टिप्पणी से लाइन 50 तक यहां इसके शीर्ष पर देखते हैं, कि इसका काम आने वाले सीरियल संदेश की प्रतियों के साथ दो बफर अपडेट करना है। [यह तब निकला जब मैं यह सब काम करने की कोशिश कर रहा था कि एक चीज जो मैंने सीखी वह यह थी कि मुझे दो अलग-अलग बफ़र्स की ज़रूरत थी - या कम से कम यह कुछ समस्याओं को हल करने का सबसे आसान तरीका था, इसलिए यह थोड़े से 2 बफ़र्स की आवश्यकता में विकसित हुआ, इसलिए मैंने अभी उन्हें बनाया है।] मैंने एक बफर कहा है: प्राप्त डेटा, और दूसरा: प्राप्त चर्स।

बफ़र्स वैश्विक चर हैं, इसलिए उन्हें मॉड्यूल स्तर पर घोषित किया जाता है, सामान्य टैब की पंक्तियाँ 9 और 10 देखें। इस फ़ंक्शन के अंदर अन्य चर घोषित किए गए हैं, इसलिए स्थानीय दायरा है- यहां 51-54 की पंक्तियों में दिखाया गया है। यह वैश्विक और स्थानीय लोगों के बीच अंतर की व्याख्या करने का स्थान नहीं है, लेकिन स्थानीय और वैश्विक के तहत https://www.arduino.cc/glossary/en/ में इस पर अधिक जानकारी है।

आप यहां दिखाए गए https://www.arduino.cc/reference/en/#variables में डेटा प्रकार और टाइप-संशोधक: स्टेटिक, बूलियन, बाइट, कॉन्स्ट, चार के बारे में भी पता लगा सकते हैं।

इस फ़ंक्शन में मुख्य कार्यक्रम प्रवाह को यहां लाइन ५६ पर if द्वारा नियंत्रित किया जाता है, और इसके अनुरूप अन्य लाइन ७४ पर। यह दो परिदृश्यों से संबंधित है

ए) [पंक्ति ७४ से] जब प्राप्त संदेश शुरू हो रहा है। यह तब होता है जब startMarker देखा जाता है - इसे '<' वर्ण के रूप में परिभाषित किया गया है, यही कारण है कि जब भी हम स्केच का परीक्षण करते हैं तो हम हमेशा उस वर्ण के साथ अपनी स्ट्रिंग शुरू करते हैं। यदि हम नहीं करते हैं तो कुछ भी प्राप्त होने के रूप में संसाधित नहीं किया जाएगा, यह सब अनदेखा कर दिया जाएगा जैसे कि हम 'सीरियल मॉनिटर' कीबोर्ड प्रॉम्प्ट पर बकवास टाइप कर रहे हैं।

बी) [पंक्ति ५६ से ७३] जो अन्य सभी पात्रों को प्राप्त करता है, चाहे वे कुछ भी हों, लेकिन वे केवल एक वैध शुरुआत होने के बाद ही पात्रों से निपटते हैं (उपरोक्त एक के रूप में एक '>' प्राप्त हुआ है।)

इन पंक्तियों में (७४ से ७८ तक) हम उस प्राप्त < को एक बफ़र्स (प्राप्तडेटा [०]) में डालते हैं, लेकिन दूसरे में नहीं। हम पंक्ति ndx++ में पोस्ट-इन्क्रीमेंट कमांड (++) का उपयोग करके बफर पॉइंटर (चर: चार एनडीएक्स) को अगली अतिरिक्त बफर स्थिति (प्राप्त डेटा [1]) को इंगित करने के लिए समायोजित करते हैं;, और हम प्रगति ध्वज को सत्य पर सेट करते हैं।

फ़ंक्शन के इस भाग में प्रोग्राम प्रवाह को यहां लाइन ५७ पर इफ द्वारा नियंत्रित किया जाता है, और इसके अनुरूप अन्य लाइन ६५ पर। यह दो परिदृश्यों से संबंधित है

a) [पंक्ति ६५ से] जब प्राप्त संदेश समाप्त हो जाता है। ऐसा तब होता है जब एंडमार्कर को देखा जाता है - जिसे > के रूप में परिभाषित किया जाता है, यही कारण है कि जब भी हम अपने स्केच का परीक्षण करते हैं तो हम हमेशा उस चरित्र के साथ अपनी स्ट्रिंग समाप्त करते हैं। अंतिम वर्ण प्राप्त होने पर होने वाली चीजों में से एक यह है कि वैश्विक ध्वज (तकनीकी रूप से परिवर्तनीय) नया डेटा फ़ंक्शन समाप्त होने के साथ ही सत्य सेट हो जाता है, ताकि फ़ंक्शन जिसे हमारे उप-फ़ंक्शन (कॉलिंग फ़ंक्शन: आरईवी (चार) कहा जाता है।;) 'जान' सकता है कि वैध नया डेटा पूरा हो गया है।

b) [पंक्तियाँ ५७ से ६४] जो अन्य सभी पात्रों को प्राप्त करता है, चाहे वे कुछ भी हों। यह बस उन्हें दोनों बफ़र्स में पंक्तियों में बड़े करीने से पार्क करता है।

चरण 13: प्राप्त उप-कार्य लिखें - भाग 2

यह एक उदाहरण देने में मदद कर सकता है कि 2 बफर कैसे दिखते हैं जब वे पॉप्युलेट हो जाते हैं। यदि हम एंटर करते हैं, तो बफ़र्स में उनमें दिखाए गए वर्ण होंगे:

तो अब आप देख सकते हैं कि हमारे पास एक बफर है जो बिल्कुल वही वर्ण है जैसा हमने पहले टाइप किया था, और एक बफर जिसमें केवल दो मान और एक अलग कॉमा है। अब हमारे पास कुछ कोड हैं जो सीरियल मॉनिटर कीबोर्ड पर हमारे द्वारा टाइप किए गए वर्णों को प्राप्त कर सकते हैं, हम सीडीआईओ चरण I से O तक जा सकते हैं, कुछ स्ट्रिंग्स टाइप कर सकते हैं और देख सकते हैं कि क्या होता है। मास्टर Arduino पर कोड अपलोड करें, सीरियल मॉनिटर खोलें और कुछ मान्य टाइप करने का प्रयास करें, जैसे एंटर। क्या आपको यहां दिखाए गए की तरह सीरियल मॉनिटर स्क्रीन पर एक प्रतिध्वनि प्राप्त होती है?

चरण 14: संचारण और पार्स कार्य लिखें

संचारण के लिए प्रथम

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

इस फ़ंक्शन को यहां 117 से 133 की पंक्तियों में दिखाया गया है। जैसा कि आप पहचानेंगे, इसके दो भाग हैं, एक USB चैनल (हार्डवेयर UART) को संचारित करने के लिए और एक दूसरे Arduino (सॉफ़्टवेयर UART) को प्रेषित करने के लिए। यह त्रुटि को संकलित करना चाहिए -फ्री, और आप तुरंत स्केच अपलोड कर सकते हैं और देख सकते हैं कि क्या होता है। इस बार भेजूंगा। क्या आपको परिणाम दिखाया गया है?

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

चरण 15: संचारण और पार्स कार्य लिखें

फिर पारसी के लिए

यह कोड का एक टुकड़ा है जो संख्यात्मक आंशिक तारों को निकालने के लिए प्राप्त स्ट्रिंग को पार्स करता है और उन्हें पूर्णांक मानों में परिवर्तित करता है। यह शून्य है parseData(); मुख्य लूप का कार्य

पार्स स्टब को लाइन 98 - 113 में दिखाए गए कोड से बदलें। इसे अपलोड करें, और देखते हैं कि 2 पूर्णांक मानों के साथ हमें जो समस्या हो रही थी वह अब ठीक हो गई है। कोशिश करते हैं ।

हां, यह काम करता है, जैसा कि दिखाया गया है, पाए गए पूर्णांक 49 और 98 हैं।

चरण 16: समापन

यह डेटा पीसी से मास्टर के माध्यम से दास के माध्यम से और मास्टर के माध्यम से फिर से पीसी पर फिर से लूप के चारों ओर चला गया है। मास्टर और स्लेव दोनों सिरों में अपलोड किए गए कॉमन के तैयार संस्करण के साथ, और अब डिबग मोड बंद होने के साथ, हमें दोनों सिरों पर सही ढंग से प्राप्त डेटा देखने को मिलता है जैसा कि यहां दिखाया गया है।