1. शुरुआती जानकारी
Google की ओर से रिलीज़ किया गया OpenThread, Thread नेटवर्किंग प्रोटोकॉल को ओपन-सोर्स लागू करता है. Google Nest ने OpenThread रिलीज़ किया, ताकि Nest प्रॉडक्ट में इस्तेमाल की जाने वाली टेक्नोलॉजी बड़े पैमाने पर डेवलपर के लिए उपलब्ध हो सके. इससे, कनेक्ट किए गए होम के लिए प्रॉडक्ट का डेवलपमेंट तेज़ी से किया जा सकेगा.
Thread की खास जानकारी में, IPv6 आधारित, सुरक्षित, और कम पावर वाले वायरलेस डिवाइस-से-डिवाइस कम्यूनिकेशन प्रोटोकॉल के बारे में बताया गया है. OpenThread, IPv6, 6LoWPAN, IEEE 802.15.4, MAC सुरक्षा, मेश लिंक इंस्टॉलेशन, और मेश रूटिंग के साथ सभी थ्रेड नेटवर्किंग लेयर को लागू करता है.
यह कोडलैब आपको डॉकर का इस्तेमाल करके, एम्युलेट किए गए डिवाइसों पर थ्रेड नेटवर्क को सिम्युलेट करने का तरीका बताएगा.
आप इन चीज़ों के बारे में जानेंगे
- OpenThread बिल्ड टूलचेन को सेट अप करने का तरीका
- Thread नेटवर्क की नकल करने का तरीका
- थ्रेड नोड की पुष्टि करने का तरीका
- OpenThread Deemon की मदद से, Thread नेटवर्क को मैनेज करने का तरीका
आपको इनकी ज़रूरत होगी
- डॉकर
- Linux, नेटवर्क रूटिंग के बारे में बुनियादी जानकारी
2. डॉकर सेट अप करें
यह कोडलैब, Linux, Mac OS X या Windows मशीन पर डॉकर का इस्तेमाल करने के लिए डिज़ाइन किया गया है. Linux, सुझाया गया एनवायरमेंट है.
डॉकर इंस्टॉल करें
अपनी पसंद के ओएस पर डॉकर इंस्टॉल करें.
डॉकर की चित्र खींचें
डॉकर इंस्टॉल होने के बाद, एक टर्मिनल विंडो खोलें और openthread/environment
डॉकर की इमेज खींचें. इस इमेज में, OpenThread और OpenThread डीमन पहले से बनाए गए हैं. साथ ही, इस कोडलैब का इस्तेमाल किया जा सकता है.
$ docker pull openthread/environment:latest
ध्यान दें कि पूरी तरह से डाउनलोड होने में कुछ मिनट लग सकते हैं.
टर्मिनल विंडो में, इमेज से डॉकर कंटेनर शुरू करें और इसके bash
शेल से कनेक्ट करें:
$ docker run --name codelab_otsim_ctnr -it --rm \ --sysctl net.ipv6.conf.all.disable_ipv6=0 \ --cap-add=net_admin openthread/environment bash
कंटेनर से बाहर निकलने पर, --rm
विकल्प कंटेनर को मिटा देता है. अगर कंटेनर को नहीं मिटाना है, तो इस विकल्प का इस्तेमाल न करें.
ध्यान दें कि इस कोडलैब के लिए ज़रूरी फ़्लैग:
--sysctl net.ipv6.conf.all.disable_ipv6=0
— इससे कंटेनर में IPv6 चालू हो जाता है--cap-add=net_admin
— NET_Admin क्षमता चालू करता है. इसकी मदद से नेटवर्क से जुड़े काम किए जा सकते हैं, जैसे कि आईपी रूट जोड़ना
कंटेनर में शामिल होने के बाद, आपको इस तरह का मैसेज मिलेगा:
root@c0f3912a74ff:/#
ऊपर दिए गए उदाहरण में, कंटेनर आईडी c0f3912a74ff
है. डॉकर कंटेनर के इंस्टेंस का कंटेनर आईडी, इस कोडलैब के निर्देशों में दिखाए गए कंटेनर आईडी से अलग होगा.
डॉकर का इस्तेमाल करना
इस कोडलैब से यह माना जाता है कि आपको डॉकर का इस्तेमाल करने के बारे में बुनियादी जानकारी है. कोडलैब के पूरे काम के लिए आपको डॉकर कंटेनर में ही रहना चाहिए.
3. किसी थ्रेड नेटवर्क को सिम्युलेट करना
उदाहरण के तौर पर, इस कोडलैब के लिए इस्तेमाल किया जाने वाला ऐप्लिकेशन, कम से कम OpenThread ऐप्लिकेशन को दिखाता है, जो एक बेसिक कमांड-लाइन इंटरफ़ेस (सीएलआई) के ज़रिए OpenThread कॉन्फ़िगरेशन और मैनेजमेंट इंटरफ़ेस को दिखाता है.
इस तरीके से, एम्युलेट किए गए किसी थ्रेड डिवाइस को दूसरे एम्युलेट किए गए थ्रेड डिवाइस से पिंग किया जा सकता है.
नीचे दी गई इमेज में थ्रेड नेटवर्क की बुनियादी टोपोलॉजी के बारे में बताया गया है. इस अभ्यास के लिए, हम हरे गोले में दो नोड को एम्युलेट करेंगे: थ्रेड लीडर और थ्रेड राऊटर.
नेटवर्क बनाएं
1. नोड 1 शुरू करें
अगर आपने अब तक ऐसा नहीं किया है, तो किसी टर्मिनल विंडो में डॉकर कंटेनर शुरू करें और उसके bash
शेल से कनेक्ट करें:
$ docker run --name codelab_otsim_ctnr -it --rm \ --sysctl net.ipv6.conf.all.disable_ipv6=0 \ --cap-add=net_admin openthread/environment bash
डॉकर कंटेनर में, ot-cli-ftd
बाइनरी का इस्तेमाल करके एम्युलेट किए गए थ्रेड डिवाइस के लिए, सीएलआई प्रोसेस जनरेट करें.
root@c0f3912a74ff:/# /openthread/build/examples/apps/cli/ot-cli-ftd 1
ध्यान दें: अगर आपको यह निर्देश चलाने के बाद >
का मैसेज नहीं दिखता है, तो enter
दबाएं.
यह बाइनरी एक OpenThread डिवाइस लागू करती है. आईईईई 802.15.4 रेडियो ड्राइवर यूडीपी के ऊपर लागू किया जाता है (IEEE 802.15.4 फ़्रेम यूडीपी पेलोड के अंदर भेजे जाते हैं).
1
का आर्ग्युमेंट एक फ़ाइल डिस्क्रिप्टर है, जो एम्युलेट किए गए डिवाइस के लिए, "फ़ैक्ट्री से असाइन किए गए" IEEE ईयूआई-64 के सबसे छोटे बिट का प्रतिनिधित्व करता है. इस वैल्यू का इस्तेमाल, आईईईई 802.15.4 रेडियो एम्युलेशन (पोर्ट = 9000 + फ़ाइल डिस्क्रिप्टर) के लिए यूडीपी पोर्ट से बाइंडिंग के दौरान भी किया जाता है. इस कोडलैब में एम्युलेट किए गए थ्रेड डिवाइस का हर इंस्टेंस, एक अलग फ़ाइल डिस्क्रिप्टर का इस्तेमाल करेगा.
ध्यान दें: एम्युलेट किए गए डिवाइस के लिए प्रोसेस जनरेट करते समय, कोडलैब में सिर्फ़ 1
या इससे ज़्यादा के फ़ाइल डिस्क्रिप्टर का इस्तेमाल करें. 0
की जानकारी देने वाली फ़ाइल, दूसरे इस्तेमाल के लिए रिज़र्व है.
नया ऑपरेशनल डेटासेट बनाएं और उसे चालू डेटासेट के तौर पर इस्तेमाल करें. ऑपरेशनल डेटासेट उस थ्रेड नेटवर्क का कॉन्फ़िगरेशन है जिसे बनाया जा रहा है.
> dataset init new Done > dataset Active Timestamp: 1 Channel: 20 Channel Mask: 07fff800 Ext PAN ID: d6263b6d857647da Mesh Local Prefix: fd61:2344:9a52:ede0/64 Network Key: e4344ca17d1dca2a33f064992f31f786 Network Name: OpenThread-c169 PAN ID: 0xc169 PSKc: ebb4f2f8a68026fc55bcf3d7be3e6fe4 Security Policy: 0, onrcb Done
इस डेटासेट को सक्रिय डेटासेट के तौर पर इस्तेमाल करें:
> dataset commit active Done
IPv6 इंटरफ़ेस दिखाएं:
> ifconfig up Done
थ्रेड के प्रोटोकॉल की कार्रवाई शुरू करें:
> thread start Done
कुछ सेकंड इंतज़ार करें और पुष्टि करें कि डिवाइस, थ्रेड लीडर बन गया है. लीडर, डिवाइस को राऊटर आईडी असाइन करने की ज़िम्मेदारी देता है.
> state leader Done
नोड 1 के थ्रेड इंटरफ़ेस को असाइन किए गए IPv6 पते देखें (आपका आउटपुट अलग होगा):
> ipaddr fd61:2344:9a52:ede0:0:ff:fe00:fc00 fd61:2344:9a52:ede0:0:ff:fe00:5000 fd61:2344:9a52:ede0:d041:c5ba:a7bc:5ce6 fe80:0:0:0:94da:92ea:1353:4f3b Done
किसी खास IPv6 पते पर ध्यान दें:
fd
से शुरू होता है = मेश-लोकल- इससे शुरू होता है
fe80
= link-local
मेश-स्थानीय पते के टाइप को आगे की कैटगरी में रखा जाता है:
- इसमें
ff:fe00
= राऊटर लोकेटर (RLOC) शामिल है - इसमें
ff:fe00
= एंडपॉइंट आइडेंटिफ़ायर (ईआईडी) शामिल नहीं है
अपने कंसोल आउटपुट में ईआईडी की पहचान करें और उसे बाद में इस्तेमाल करने के लिए नोट बनाएं. ऊपर दिए गए सैंपल आउटपुट में, ईआईडी यह है:
fd61:2344:9a52:ede0:d041:c5ba:a7bc:5ce6
2. दूसरा नोड शुरू करें
एक नया टर्मिनल खोलें और नोड 2 के लिए इस्तेमाल करने के लिए अभी चल रहे डॉकर कंटेनर में एक bash
शेल चलाएं.
$ docker exec -it codelab_otsim_ctnr bash
bash
के इस नए अनुरोध पर, सीएलआई प्रोसेस को आर्ग्युमेंट 2
के साथ जनरेट करें. यह आपका दूसरा एम्युलेट किया गया थ्रेड डिवाइस है:
root@c0f3912a74ff:/# /openthread/build/examples/apps/cli/ot-cli-ftd 2
ध्यान दें: अगर आपको यह निर्देश चलाने के बाद >
का मैसेज नहीं दिखता है, तो enter
दबाएं.
नोड 1 के ऑपरेशनल डेटासेट की वैल्यू का इस्तेमाल करके, थ्रेड नेटवर्क कुंजी और पैन आईडी को कॉन्फ़िगर करें:
> dataset networkkey e4344ca17d1dca2a33f064992f31f786 Done > dataset panid 0xc169 Done
इस डेटासेट को सक्रिय डेटासेट के तौर पर इस्तेमाल करें:
> dataset commit active Done
IPv6 इंटरफ़ेस दिखाएं:
> ifconfig up Done
थ्रेड के प्रोटोकॉल की कार्रवाई शुरू करें:
> thread start Done
डिवाइस खुद ही बच्चे के तौर पर शुरू होगा. Thread बच्चा, एक एंड डिवाइस की तरह काम करता है. यह एक ऐसा डिवाइस है जो सिर्फ़ माता-पिता के डिवाइस के साथ यूनिकास्ट ट्रैफ़िक को ट्रांसमिट और लेता है.
> state child Done
आपको दो मिनट में, child
से router
का स्टेटस दिखेगा. थ्रेड राऊटर, थ्रेड डिवाइसों के बीच ट्रैफ़िक को रूट कर सकता है. इसे अभिभावक भी कहा जाता है.
> state router Done
नेटवर्क की पुष्टि करें
मेश नेटवर्क की पुष्टि करने का एक आसान तरीका, राऊटर की टेबल देखना है.
1. कनेक्टिविटी की जांच करें
नोड 2 पर, RLOC16 पाएं. RLOC16, डिवाइस के RLOC IPv6 पते के आखिरी 16 बिट हैं.
> rloc16 5800 Done
नोड 1 पर, नोड 2 के RLOC16 के लिए राऊटर टेबल देखें. पक्का करें कि पहले नोड 2 को राऊटर की स्थिति पर स्विच कर दिया गया है.
> router table | ID | RLOC16 | Next Hop | Path Cost | LQ In | LQ Out | Age | Extended MAC | +----+--------+----------+-----------+--------+-------+---+--------------------+ | 20 | 0x5000 | 63 | 0 | 0 | 0 | 0 | 96da92ea13534f3b | | 22 | 0x5800 | 63 | 0 | 3 | 3 | 23 | 5a4eb647eb6bc66c |
0x5800
के नोड 2 का RLOC, टेबल में मिल गया है. इससे पता चलता है कि यह मेश से कनेक्ट है.
2. नोड 2 से नोड 1 को पिंग करें
एम्युलेट किए गए दो थ्रेड डिवाइसों के बीच कनेक्टिविटी की पुष्टि करें. नोड 2 में ping
को नोड 1 को असाइन किया गया:
> ping fd61:2344:9a52:ede0:d041:c5ba:a7bc:5ce6 > 16 bytes from fd61:2344:9a52:ede0:d041:c5ba:a7bc:5ce6: icmp_seq=1 hlim=64 time=12ms
>
सीएलआई के अनुरोध पर लौटने के लिए, enter
दबाएं.
नेटवर्क की जांच करना
अब आप दो एम्युलेट किए गए थ्रेड डिवाइसों के बीच पिंग कर सकते हैं. एक नोड को ऑफ़लाइन लेकर मेश नेटवर्क की जांच कर सकते हैं.
नोड 1 पर वापस जाएं और थ्रेड को रोकें:
> thread stop Done
नोड 2 पर स्विच करें और स्थिति देखें. दो मिनट के भीतर, नोड 2 को पता चलता है कि लीडर (नोड 1) ऑफ़लाइन है और आपको नेटवर्क के leader
के तौर पर नोड 2 का ट्रांज़िशन देखना होगा:
> state router Done ... > state leader Done
पुष्टि होने के बाद, थ्रेड को बंद करें और डॉकर bash
के प्रॉम्प्ट पर वापस जाने से पहले, नोड को फ़ैक्ट्री रीसेट करें. फ़ैक्ट्री रीसेट करके यह पक्का किया जाता है कि इस प्रैक्टिस में इस्तेमाल किए गए Thread नेटवर्क के क्रेडेंशियल, अगले अभ्यास में शामिल न किए जाएं.
> thread stop Done > factoryreset > > exit root@c0f3912a74ff:/#
factoryreset
निर्देश के बाद, >
को वापस लाने के लिए, हो सकता है कि आपको कुछ बार enter
दबाना पड़े. डॉकर कंटेनर से बाहर न निकलें.
फ़ैक्ट्री रीसेट करने के बाद, नोड 1 से बाहर निकलें:
> factoryreset > > exit root@c0f3912a74ff:/#
सभी उपलब्ध सीएलआई निर्देशों के बारे में जानने के लिए, OpenThread सीएलआई रेफ़रंस देखें.
4. कमीशन के साथ नोड की पुष्टि करें
इससे पहले, आपने दो सिम्युलेट किए गए डिवाइसों और पुष्टि की गई कनेक्टिविटी के साथ, Thread नेटवर्क सेट अप की थी. हालांकि, इससे सिर्फ़ पुष्टि नहीं किए गए IPv6 लिंक-लोकल ट्रैफ़िक को डिवाइसों के बीच पास होने की अनुमति मिलती है. दुनिया में IPv6 ट्रैफ़िक को (थ्रेड बॉर्डर राऊटर के ज़रिए इंटरनेट) रूट करने के लिए, नोड की पुष्टि की जानी चाहिए.
पुष्टि करने के लिए, एक डिवाइस को कमिश्नर की तरह काम करना होगा. फ़िलहाल, कमिश्नर नए थ्रेड डिवाइसों के लिए पुष्टि किया गया सर्वर है जिसे चुना गया है. साथ ही, यह तय करने का अधिकार देता है कि कौनसे नेटवर्क के लिए नेटवर्क में शामिल होना ज़रूरी है.
इस व्यायाम में, हम पहले की तरह ही दो नोड वाली टोपोलॉजी का इस्तेमाल करेंगे. पुष्टि करने के लिए, थ्रेड लीडर कमिश्नर की तरह काम करेगा, थ्रेड राऊटर, जॉइनर के तौर पर.
डॉकर
बाकी कसरतों में हर नोड (टर्मिनल विंडो) के लिए, पक्का करें कि आप OpenThread बिल्ड के साथ डॉकर कंटेनर चला रहे हों. अगर पिछले अभ्यास से जारी रखा जाता है, तो आपके पास एक ही डॉकर कंटेनर के अंदर पहले से ही दो bash
अनुरोध होंगे. अगर नहीं, तो डॉकर की समस्या हल करने का तरीका देखें या बस थ्रेड नेटवर्क को सिम्युलेट करें.
1. नेटवर्क बनाना
नोड 1 में सीएलआई प्रोसेस जनरेट करें:
root@c0f3912a74ff:/# /openthread/build/examples/apps/cli/ot-cli-ftd 1
ध्यान दें: अगर आपको यह निर्देश चलाने के बाद >
का मैसेज नहीं दिखता है, तो enter
दबाएं.
एक नया ऑपरेशनल डेटासेट बनाएं, इसे चालू डेटासेट के तौर पर इस्तेमाल करें, और थ्रेड शुरू करें:
> dataset init new Done > dataset Active Timestamp: 1 Channel: 12 Channel Mask: 07fff800 Ext PAN ID: e68d05794bf13052 Mesh Local Prefix: fd7d:ddf7:877b:8756/64 Network Key: a77fe1d03b0e8028a4e13213de38080e Network Name: OpenThread-8f37 PAN ID: 0x8f37 PSKc: f9debbc1532487984b17f92cd55b21fc Security Policy: 0, onrcb Done
इस डेटासेट को सक्रिय डेटासेट के तौर पर इस्तेमाल करें:
> dataset commit active Done
IPv6 इंटरफ़ेस दिखाएं:
> ifconfig up Done
थ्रेड के प्रोटोकॉल की कार्रवाई शुरू करें:
> thread start Done
कुछ सेकंड इंतज़ार करें और पुष्टि करें कि डिवाइस Thread लीडर बन गया है:
> state leader Done
2. कमिश्नर के रोल की शुरुआत करें
नोड 1 पर रहते हुए, कमिश्नर की भूमिका शुरू करें:
> commissioner start Done
नेटवर्क पर जुड़ने के लिए, किसी भी जॉइनर को *
वाइल्डकार्ड का इस्तेमाल करके J01NME
जॉइनर क्रेडेंशियल का इस्तेमाल करके अनुमति दें. जॉइनर एक ऐसा डिवाइस है जिसे किसी मानव एडमिन ने, कमीशन किए गए थ्रेड नेटवर्क में जोड़ा है.
> commissioner joiner add * J01NME Done
3. जॉइनर की भूमिका शुरू करें
डॉकर कंटेनर में एक दूसरी टर्मिनल विंडो में, एक नई सीएलआई प्रोसेस तैयार करें. यह नोड 2 है.
root@c0f3912a74ff:/# /openthread/build/examples/apps/cli/ot-cli-ftd 2
नोड 2 में, J01NME
जॉइनर क्रेडेंशियल का इस्तेमाल करके, जॉइनर रोल को चालू करें.
> ifconfig up Done > joiner start J01NME Done
... पुष्टि होने के लिए कुछ सेकंड इंतज़ार करें ...
Join success
जॉइनर के तौर पर, डिवाइस (Node 2) को कमिश्नर (नोड 1) ने खुद की पुष्टि की है और उसे Thread नेटवर्क के क्रेडेंशियल मिले हैं.
अब नोड 2 की पुष्टि हो गई है, तो थ्रेड शुरू करें:
> thread start Done
4. नेटवर्क की पुष्टि करना
state
को नोड 2 पर देखें, ताकि यह पुष्टि हो सके कि यह अब नेटवर्क से जुड़ गया है. दो मिनट के अंदर, नोड 2 child
से router
पर ट्रांज़िशन करता है:
> state child Done ... > state router Done
5. कॉन्फ़िगरेशन रीसेट करें
अगले अभ्यास की तैयारी के लिए, कॉन्फ़िगरेशन को रीसेट करें. हर नोड पर, थ्रेड बंद करें, फ़ैक्ट्री रीसेट करें, और एम्युलेट किए गए थ्रेड डिवाइस से बाहर निकलें:
> thread stop Done > factoryreset > > exit root@c0f3912a74ff:/#
factoryreset
निर्देश के बाद, >
को वापस लाने के लिए, हो सकता है कि आपको कुछ बार enter
दबाना पड़े.
5. OpenThread Deemon की मदद से नेटवर्क मैनेज करें
इस व्यायाम के लिए, हम एक सीएलआई इंस्टेंस (एक एम्बेड किया गया SoC थ्रेड डिवाइस) और एक रेडियो को-प्रोसेसर (आरसीपी) इंस्टेंस को सिम्युलेट करेंगे.
ot-daemon
, OpenThread Posix ऐप्लिकेशन का एक मोड है. यह इनपुट और आउटपुट के तौर पर UNIX सॉकेट का इस्तेमाल करता है, ताकि OpenThread कोर एक सेवा के रूप में चल सके. क्लाइंट, इस सेवा के साथ प्रोटोकॉल के रूप में OpenThread सीएलआई का इस्तेमाल करके, सॉकेट से कनेक्ट करके संपर्क कर सकता है.
ot-ctl
, सीएलआई है. इसे ot-daemon
ने उपलब्ध कराया है, ताकि आरसीपी को मैनेज और कॉन्फ़िगर किया जा सके. इसकी मदद से, हम आरसीपी को थ्रेड डिवाइस के नेटवर्क से कनेक्ट करेंगे.
डॉकर
इस एक्सरसाइज़ में मौजूद हर नोड (टर्मिनल विंडो) के लिए, पक्का करें कि आपके पास OpenThread बिल्ड वाले डॉकर कंटेनर का इस्तेमाल हो रहा हो. पिछले व्यायाम को जारी रखने पर, आपको एक ही डॉकर कंटेनर में दो bash
संकेत पहले से खुले होने चाहिए. अगर ऐसा नहीं है, तो डॉकर की समस्या हल करने का तरीका देखें.
ot-डीमन का इस्तेमाल करें
इस व्यायाम में तीन टर्मिनल विंडो का इस्तेमाल किया जाएगा, जो इन चीज़ों से जुड़ी होंगी:
- सिम्युलेट किए गए थ्रेड डिवाइस का सीएलआई इंस्टेंस (नोड 1)
ot-daemon
प्रोसेसot-ctl
सीएलआई इंस्टेंस
1. नोड 1 शुरू करें
पहली टर्मिनल विंडो में, एम्युलेट किए गए थ्रेड डिवाइस के लिए सीएलआई प्रोसेस जनरेट करें:
root@c0f3912a74ff:/# /openthread/build/examples/apps/cli/ot-cli-ftd 1
ध्यान दें: अगर आपको यह निर्देश चलाने के बाद >
का मैसेज नहीं दिखता है, तो enter
दबाएं.
एक नया ऑपरेशनल डेटासेट बनाएं, इसे चालू डेटासेट के तौर पर इस्तेमाल करें, और थ्रेड शुरू करें:
> dataset init new Done > dataset Active Timestamp: 1 Channel: 13 Channel Mask: 07fff800 Ext PAN ID: 97d584bcd493b824 Mesh Local Prefix: fd55:cf34:dea5:7994/64 Network Key: ba6e886c7af50598df1115fa07658a83 Network Name: OpenThread-34e4 PAN ID: 0x34e4 PSKc: 38d6fd32c866927a4dfcc06d79ae1192 Security Policy: 0, onrcb Done
इस डेटासेट को सक्रिय डेटासेट के तौर पर इस्तेमाल करें:
> dataset commit active Done
IPv6 इंटरफ़ेस दिखाएं:
> ifconfig up Done
थ्रेड के प्रोटोकॉल की कार्रवाई शुरू करें:
> thread start Done
नोड 1 के थ्रेड इंटरफ़ेस को असाइन किए गए IPv6 पते देखें:
> ipaddr fd55:cf34:dea5:7994:0:ff:fe00:fc00 fd55:cf34:dea5:7994:0:ff:fe00:d000 fd55:cf34:dea5:7994:460:872c:e807:c4ab fe80:0:0:0:9cd8:aab6:482f:4cdc Done >
जैसा कि थ्रेड नेटवर्क को सिम्युलेट करें चरण में बताया गया है, एक पता लिंक-लोकल (fe80
) और तीन मेश-लोकल (fd
) होता है. ईआईडी, मेश-लोकल पता है जिसमें पते में ff:fe00
नहीं होता. इस सैंपल आउटपुट में ईआईडी fd55:cf34:dea5:7994:460:872c:e807:c4ab
है.
ipaddr
आउटपुट से खास ईआईडी की पहचान करें. इसका इस्तेमाल नोड से संपर्क करने के लिए किया जाएगा.
2. ot-डीमन शुरू करें
दूसरी टर्मिनल विंडो में, tun
डिवाइस नोड बनाएं और पढ़ने/लिखने की अनुमतियां सेट करें:
root@c0f3912a74ff:/# mkdir -p /dev/net && mknod /dev/net/tun c 10 200 root@c0f3912a74ff:/# chmod 600 /dev/net/tun
इस डिवाइस का इस्तेमाल वर्चुअल डिवाइसों में पैकेट ट्रांसमिशन और रसीद के लिए किया जाता है. अगर डिवाइस पहले ही बनाया जा चुका है, तो आपको गड़बड़ी का मैसेज मिल सकता है—और यह सामान्य है और इसे अनदेखा किया जा सकता है.
RCP नोड के लिए ot-daemon
शुरू करें. हम Node 2 को कॉल करेंगे. -v
वर्बोस फ़्लैग का इस्तेमाल करें, ताकि आप लॉग आउटपुट देख सकें और उसके चलने की पुष्टि कर सकें:
root@c0f3912a74ff:/# /openthread/build/posix/src/posix/ot-daemon -v \ 'spinel+hdlc+forkpty:///openthread/build/examples/apps/ncp/ot-rcp?forkpty-arg=2'
सफल होने पर, वर्बोस मोड में ot-daemon
, इस तरह के आउटपुट जनरेट करता है:
ot-daemon[31]: Running OPENTHREAD/297a880; POSIX; Feb 1 2022 04:43:39 ot-daemon[31]: Thread version: 3 ot-daemon[31]: Thread interface: wpan0 ot-daemon[31]: RCP version: OPENTHREAD/297a880; SIMULATION; Feb 1 2022 04:42:50
इस टर्मिनल को खुला रहने दें और बैकग्राउंड में चलने दें. इसके बाद, आपको कोई और निर्देश नहीं देना होगा.
3. नेटवर्क से जुड़ने के लिए ot-ctl का इस्तेमाल करें
हमने अब तक किसी भी थ्रेड नेटवर्क पर नोड 2 (ot-daemon
आरसीपी) को चालू नहीं किया है. ot-ctl
यहीं काम करता है. ot-ctl
में सीएलआई का इस्तेमाल, OpenThread सीएलआई ऐप्लिकेशन की तरह ही किया जाता है. इसलिए, आपके पास ot-daemon
नोड को उसी तरह कंट्रोल करने का विकल्प होता है जिस तरह कोई अन्य थ्रेड डिवाइस सिम्युलेट किया जाता है.
तीसरी टर्मिनल विंडो खोलें और मौजूदा कंटेनर का इस्तेमाल करें:
$ docker exec -it codelab_otsim_ctnr bash
कंटेनर में शामिल होने के बाद, ot-ctl
का इस्तेमाल करना शुरू करें:
root@c0f3912a74ff:/# /openthread/build/posix/src/posix/ot-ctl >
ot-daemon
के साथ दूसरी टर्मिनल विंडो में शुरू किए गए नोड 2 (आरसीपी नोड) को मैनेज करने के लिए, इस तीसरे टर्मिनल विंडो में आपको ot-ctl
का इस्तेमाल करना होगा. नोड 2 के state
की जांच करें:
> state disabled Done
किसी खास जॉइनर से जुड़ने के लिए, नोड 2 के eui64
का ऐक्सेस पाएं:
> eui64 18b4300000000001 Done
नोड 1 (पहली टर्मिनल विंडो) पर, कमिश्नर को शुरू करें और सिर्फ़ उस eui64 में शामिल होने की पाबंदी लगाएं:
> commissioner start Done > commissioner joiner add 18b4300000000001 J01NME Done
तीसरी टर्मिनल विंडो में, नोड 2 के लिए नेटवर्क इंटरफ़ेस लेकर आएं और नेटवर्क से जुड़ें:
> ifconfig up Done > joiner start J01NME Done
... पुष्टि होने के लिए कुछ सेकंड इंतज़ार करें ...
Join success
जॉइनर के तौर पर, आरसीपी (नोड 2) ने कमिश्नर (नोड 1) के साथ अपनी पुष्टि की है और उसे Thread नेटवर्क के क्रेडेंशियल मिले हैं.
अब Thread नेटवर्क पर, नोड 2 को जॉइन करें (फिर से तीसरी टर्मिनल विंडो में):
> thread start Done
4. नेटवर्क की पुष्टि करना
तीसरे टर्मिनल में, नोड 2 पर state
की जांच करके पुष्टि करें कि वह अब नेटवर्क से जुड़ गया है. दो मिनट के अंदर, नोड 2 child
से router
पर ट्रांज़िशन करता है:
> state child Done ... > state router Done
5. कनेक्टिविटी की पुष्टि करें
तीसरी टर्मिनल विंडो में, Ctrl+D या exit
कमांड का इस्तेमाल करके ot-ctl
से बाहर निकलें और कंटेनर के bash
कंसोल पर वापस जाएं. इस कंसोल से, ping6
निर्देश के साथ अपने ईआईडी का इस्तेमाल करके नोड 1 को पिंग करें. अगर ot-daemon
आरसीपी इंस्टेंस जुड़ जाता है और वह थ्रेड नेटवर्क के साथ इंटरैक्ट करता है, तो पिंग हो जाता है:
root@c0f3912a74ff:/# ping6 -c 4 fd55:cf34:dea5:7994:460:872c:e807:c4ab PING fd55:cf34:dea5:7994:460:872c:e807:c4ab (fd55:cf34:dea5:7994:460:872c:e807:c4ab): 56 data bytes 64 bytes from fd55:cf34:dea5:7994:460:872c:e807:c4ab: icmp_seq=0 ttl=64 time=4.568 ms 64 bytes from fd55:cf34:dea5:7994:460:872c:e807:c4ab: icmp_seq=1 ttl=64 time=6.396 ms 64 bytes from fd55:cf34:dea5:7994:460:872c:e807:c4ab: icmp_seq=2 ttl=64 time=7.594 ms 64 bytes from fd55:cf34:dea5:7994:460:872c:e807:c4ab: icmp_seq=3 ttl=64 time=5.461 ms --- fd55:cf34:dea5:7994:460:872c:e807:c4ab ping statistics --- 4 packets transmitted, 4 packets received, 0% packet loss round-trip min/avg/max/stddev = 4.568/6.005/7.594/1.122 ms
6. डॉक से जुड़ी समस्या हल करना
अगर आपने डॉकर कंटेनर से बाहर निकल लिया है
bash
अनुरोध, आपको यह पता करना होगा कि यह चल रहा है या नहीं. इसके अलावा, ज़रूरत के हिसाब से रीस्टार्ट या फिर से डाला जा सकता है. अगर आपने ऐसे किसी भी डॉकर कंटेनर को बनाया है जिसमें आपने --rm
विकल्प का इस्तेमाल नहीं किया था, तो वह अब भी मौजूद रहेगा.
यह दिखाने के लिए कि कौनसे डॉकर कंटेनर चल रहे हैं:
$ docker ps CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES 505fc57ffc72 environment "bash" 10 minutes ago Up 10 minutes codelab_otsim_ctnr
सभी डॉकर कंटेनर दिखाने के लिए (चल रहे और रोके गए, दोनों):
$ docker ps -a CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES 505fc57ffc72 environment "bash" 10 minutes ago Up 10 minutes codelab_otsim_ctnr
अगर आपको docker ps
कमांड के आउटपुट में codelab_otsim_ctnr
कंटेनर नहीं दिखता है, तो उसे फिर से चलाएं:
$ docker run --name codelab_otsim_ctnr -it --rm \ --sysctl net.ipv6.conf.all.disable_ipv6=0 \ --cap-add=net_admin openthread/environment bash
कंटेनर से बाहर निकलने पर ही, कंटेनर को मिटाने के लिए --rm
विकल्प का इस्तेमाल करें.
अगर कंटेनर को docker ps -a
में हटा दिया गया है, लेकिन वह docker ps
में शामिल नहीं है, तो उसे रीस्टार्ट करें:
$ docker start -i codelab_otsim_ctnr
अगर डॉकर कंटेनर पहले से चल रहा है (docker ps
में मौजूद), तो हर टर्मिनल में कंटेनर को फिर से कनेक्ट करें:
$ docker exec -it codelab_otsim_ctnr bash
"कार्रवाई की अनुमति नहीं है" से जुड़ी गड़बड़ियां
नए OpenThread नोड बनाते समय (mknod
कमांड का इस्तेमाल करके), Operation not permitted
गड़बड़ियां होने पर, पक्का करें कि आपने इस कोडलैब (कोड बनाना सीखना) में दिए गए निर्देशों के मुताबिक, डॉक उपयोगकर्ता को रूट उपयोगकर्ता के तौर पर चलाया है. यह कोडलैब रूटलेस मोड में डॉक करने के लिए काम नहीं करता.
7. बधाई हो!
आपने OpenThread का इस्तेमाल करके अपने पहले थ्रेड नेटवर्क को सिम्युलेट कर दिया है. बहुत बढ़िया!
इस कोडलैब में आपने ये सीखा:
- OpenThread Simulation डॉकर कंटेनर को शुरू और मैनेज करें
- किसी थ्रेड नेटवर्क को सिम्युलेट करना
- थ्रेड नोड की पुष्टि करें
- OpenThread Deemon की मदद से, किसी थ्रेड नेटवर्क को मैनेज करना
Thread और OpenThread के बारे में ज़्यादा जानने के लिए, इन रेफ़रंस को देखें:
- openthread.io पर थ्रेड प्राइमर
- थ्रेड में स्पेसिफ़िकेशन
- OpenThread GitHub का डेटा स्टोर करने की जगह
- OpenThread सीएलआई रेफ़रंस
- OpenThread डॉकर की अतिरिक्त सहायता
इसके अलावा, डॉकर कंटेनर में OpenThread बॉर्डर राऊटर का इस्तेमाल करके देखें!