OpenThread की मदद से, Thread नेटवर्क को सिम्युलेट करना

1. परिचय

Google ने OpenThread को रिलीज़ किया है. यह Thread नेटवर्किंग प्रोटोकॉल का ओपन सोर्स वर्शन है. Google Nest ने OpenThread को रिलीज़ किया है. इससे Nest प्रॉडक्ट में इस्तेमाल की गई टेक्नोलॉजी, डेवलपर के लिए बड़े पैमाने पर उपलब्ध हो जाएगी. इससे कनेक्टेड होम के लिए प्रॉडक्ट को तेज़ी से डेवलप किया जा सकेगा.

Thread स्पेसिफ़िकेशन, घर के ऐप्लिकेशन के लिए डिवाइस-से-डिवाइस के बीच कम पावर में वायरलेस तरीके से कम्यूनिकेट करने का एक भरोसेमंद और सुरक्षित प्रोटोकॉल तय करता है. यह प्रोटोकॉल, IPv6 पर आधारित है. OpenThread, Thread की सभी नेटवर्किंग लेयर लागू करता है. इनमें IPv6, 6LoWPAN, IEEE 802.15.4 with MAC security, Mesh Link Establishment, और Mesh Routing शामिल हैं.

इस कोडलैब में, सिम्युलेट किए गए डिवाइसों पर Thread नेटवर्क को सिम्युलेट करने का तरीका बताया गया है.

आपको क्या सीखने को मिलेगा

OpenThread के लिए, बिल्ड टूलचेन को सेट अप करने का तरीका
Thread नेटवर्क को सिम्युलेट करने का तरीका
Thread नोड की पुष्टि करने का तरीका
OpenThread Daemon की मदद से थ्रेड नेटवर्क को मैनेज करने का तरीका

आपको किन चीज़ों की ज़रूरत होगी

git
Linux और नेटवर्क राउटिंग की बुनियादी जानकारी

2. बिल्ड सिस्टम सेट अप करना

Git

इस कोडलैब को पूरा करने के लिए, Git का इस्तेमाल करना ज़रूरी है. आगे बढ़ने से पहले, इसे डाउनलोड और इंस्टॉल करें.

इंस्टॉल करने के बाद, अपने ओएस के लिए दिए गए निर्देशों का पालन करके, OpenThread को डाउनलोड और बिल्ड करें.

Mac OS X के लिए XCode

Mac OS X पर OpenThread को इंस्टॉल और बिल्ड करने के लिए, XCode की ज़रूरत होती है.

XCode इंस्टॉल करने के बाद, XCode Command Line Tools इंस्टॉल करें:

$ xcode-select --install

Linux / Mac OS X पर बिल्ड करना

इंस्टॉल करने के इन निर्देशों को Ubuntu Server 14.04 LTS और Mac OS X Sierra 10.12.6 पर आज़माया गया है.

OpenThread इंस्टॉल करें. bootstrap कमांड से यह पक्का किया जाता है कि टूलचेन इंस्टॉल हो और एनवायरमेंट सही तरीके से कॉन्फ़िगर किया गया हो:

$ mkdir -p ~/src
$ cd ~/src
$ git clone --recursive https://github.com/openthread/openthread.git
$ cd openthread
$ ./script/bootstrap

Windows का इस्तेमाल करना

अगर आपको Windows का इस्तेमाल करना है, तो हमारा सुझाव है कि आप इस Codelab के Docker वर्शन को आज़माएं.

3. OpenThread ऐप्लिकेशन बनाना

इंस्टॉल करने की प्रोसेस पूरी होने के बाद, OpenThread ऐप्लिकेशन का उदाहरण बनाएं. इस कोडलैब के लिए, हम सिम्युलेशन के उदाहरण का इस्तेमाल कर रहे हैं.

$ cd ~/src/openthread
$ ./script/cmake-build simulation

अब OpenThread Daemon बनाएं:

$ ./script/cmake-build posix -DOT_DAEMON=ON

4. Thread नेटवर्क को सिम्युलेट करना

इस कोडलैब के लिए इस्तेमाल किया जाने वाला उदाहरण ऐप्लिकेशन, OpenThread का एक सामान्य ऐप्लिकेशन है. यह एक बेसिक कमांड-लाइन इंटरफ़ेस (सीएलआई) के ज़रिए, OpenThread के कॉन्फ़िगरेशन और मैनेजमेंट इंटरफ़ेस को दिखाता है.

इस कसरत में, आपको एक सिम्युलेटेड Thread डिवाइस से दूसरे सिम्युलेटेड Thread डिवाइस को पिंग करने के लिए ज़रूरी कम से कम चरणों के बारे में बताया गया है.

नीचे दी गई इमेज में, थ्रेड नेटवर्क टोपोलॉजी के बारे में बताया गया है. इस अभ्यास के लिए, हम हरे रंग के सर्कल में मौजूद दो नोड का सिम्युलेट करेंगे: एक थ्रेड लीडर और दूसरा थ्रेड राउटर. इन दोनों के बीच एक कनेक्शन होगा.

किसी नोड को पिंग करना

1. नोड 1 शुरू करें

openthread डायरेक्ट्री पर जाएं और ot-cli-ftd बाइनरी का इस्तेमाल करके, सिम्युलेट किए गए थ्रेड डिवाइस के लिए सीएलआई प्रोसेस शुरू करें.

$ cd ~/src/openthread
$ ./build/simulation/examples/apps/cli/ot-cli-ftd 1

ध्यान दें: अगर यह निर्देश चलाने के बाद आपको > प्रॉम्प्ट नहीं दिखता है, तो enter दबाएं.

यह बाइनरी, POSIX पर सिम्युलेट किए गए OpenThread डिवाइस को लागू करती है. IEEE 802.15.4 रेडियो ड्राइवर को यूडीपी के ऊपर लागू किया जाता है. IEEE 802.15.4 फ़्रेम, यूडीपी पेलोड में पास किए जाते हैं.

1 का तर्क, फ़ाइल डिस्क्रिप्टर है. यह सिम्युलेट किए गए डिवाइस के लिए, "फ़ैक्ट्री से असाइन किए गए" IEEE EUI-64 के सबसे कम सार्थक बिट को दिखाता है. इस वैल्यू का इस्तेमाल, IEEE 802.15.4 रेडियो इम्यूलेशन के लिए यूडीपी पोर्ट से बाइंड करते समय भी किया जाता है (पोर्ट = 9000 + फ़ाइल डिस्क्रिप्टर). इस कोडलैब में, सिम्युलेट किए गए Thread डिवाइस का हर इंस्टेंस, अलग फ़ाइल डिस्क्रिप्टर का इस्तेमाल करेगा.

ध्यान दें: सिम्युलेट किए गए डिवाइस के लिए प्रोसेस शुरू करते समय, इस कोडलैब में बताए गए 1 या इससे ज़्यादा के फ़ाइल डिस्क्रिप्टर का ही इस्तेमाल करें. 0 का फ़ाइल डिस्क्रिप्टर, किसी और काम के लिए रिज़र्व किया गया है.

एक नया ऑपरेशनल डेटासेट बनाएं और उसे चालू डेटासेट के तौर पर इस्तेमाल करें. ऑपरेशनल डेटासेट, बनाए जा रहे Thread नेटवर्क का कॉन्फ़िगरेशन होता है.

> 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 से शुरू होता है = mesh-local
fe80 से शुरू होता है = लिंक-लोकल

मेश-लोकल पतों को आगे इन कैटगरी में बांटा गया है:

इसमें ff:fe00 = राऊटर लोकेटर (आरएलओसी) शामिल है
इसमें ff:fe00 = एंडपॉइंट आइडेंटिफ़ायर (ईआईडी) शामिल नहीं है

अपनी कंसोल आउटपुट में EID की पहचान करें और इसे बाद में इस्तेमाल करने के लिए नोट कर लें. ऊपर दिए गए सैंपल आउटपुट में, ईआईडी यह है:

fd61:2344:9a52:ede0:d041:c5ba:a7bc:5ce6

2. नोड 2 शुरू करें

एक नया टर्मिनल खोलें और openthread डायरेक्ट्री पर जाएं. इसके बाद, सीएलआई प्रोसेस शुरू करें. यह आपका दूसरा सिम्युलेटेड Thread डिवाइस है:

$ cd ~/src/openthread
$ ./build/simulation/examples/apps/cli/ot-cli-ftd 2

नोड 1 के ऑपरेशनल डेटासेट की वैल्यू का इस्तेमाल करके, थ्रेड नेटवर्क की और पैन आईडी कॉन्फ़िगर करें:

> dataset networkkey e4344ca17d1dca2a33f064992f31f786
Done
> dataset panid 0xc169
Done

इस डेटासेट को चालू डेटासेट के तौर पर सेट करें:

> dataset commit active
Done

IPv6 इंटरफ़ेस खोलें:

> ifconfig up
Done

थ्रेड शुरू करने के प्रोटोकॉल का ऑपरेशन:

> thread start
Done

डिवाइस, खुद को बच्चे के तौर पर सेट अप कर लेगा. थ्रेड चाइल्ड, एंड डिवाइस के बराबर होता है. यह एक थ्रेड डिवाइस होता है, जो सिर्फ़ पैरंट डिवाइस के साथ यूनिकास्ट ट्रैफ़िक भेजता और पाता है.

> state
child
Done

दो मिनट के अंदर, आपको स्थिति child से router में बदलती हुई दिखेगी. Thread राऊटर, Thread डिवाइसों के बीच ट्रैफ़िक को रूट कर सकता है. इसे माता-पिता या अभिभावक भी कहा जाता है.

> state
router
Done

नेटवर्क की पुष्टि करना

मेश नेटवर्क की पुष्टि करने का आसान तरीका, राऊटर टेबल देखना है.

1. कनेक्टिविटी की जांच करें

दूसरे नोड पर, RLOC16 पाएं. RLOC16, डिवाइस के RLOC IPv6 पते के आखिरी 16 बिट होते हैं.

> rloc16
5800
Done

नोड 1 पर, नोड 2 के RLOC16 के लिए राऊटर टेबल देखें. पक्का करें कि नोड 2, राऊटर मोड पर स्विच हो गया हो.

> router table
| ID | RLOC16 | Next Hop | Path Cost | LQI In | LQI Out | Age | Extended MAC  |
+----+--------+----------+----------+-------+---------+-----+------------------+
| 20 | 0x5000 |       63 |         0 |     0 |      0 |   0 | 96da92ea13534f3b |
| 22 | 0x5800 |       63 |         0 |     3 |      3 |  23 | 5a4eb647eb6bc66c |

टेबल में नोड 1 का RLOC 0xa800 मौजूद है. इससे पुष्टि होती है कि यह मेश से कनेक्ट है.

2. नोड 2 से नोड 1 को पिंग करना

सिम्युलेट किए गए दोनों Thread डिवाइसों के बीच कनेक्टिविटी की पुष्टि करें. नोड 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

> CLI प्रॉम्प्ट पर वापस जाने के लिए, enter दबाएं.

नेटवर्क की जांच करना

अब जब दो सिम्युलेटेड Thread डिवाइसों के बीच पिंग किया जा सकता है, तो किसी एक नोड को ऑफ़लाइन करके मेश नेटवर्क की जांच करें.

नोड 1 पर वापस जाएं और थ्रेड बंद करें:

> thread stop
Done

नोड 2 पर स्विच करें और स्थिति देखें. दो मिनट के अंदर, नोड 2 को पता चल जाता है कि लीडर (नोड 1) ऑफ़लाइन है. इसके बाद, आपको नोड 2 को नेटवर्क का leader बनते हुए दिखेगा:

> state
router
Done
...
> state
leader
Done

पुष्टि हो जाने के बाद, Thread को बंद करें और Node 2 को फ़ैक्ट्री रीसेट करें. इसके बाद, बाहर निकलें. फ़ैक्ट्री रीसेट इसलिए किया जाता है, ताकि इस अभ्यास में इस्तेमाल किए गए थ्रेड नेटवर्क के क्रेडेंशियल, अगले अभ्यास में न ले जाए जाएं.

> thread stop
Done
> factoryreset
>
> exit

साथ ही, Node 1 को फ़ैक्ट्री रीसेट करें और उससे बाहर निकलें:

> factoryreset
>
> exit

उपलब्ध सभी सीएलआई कमांड के बारे में जानने के लिए, OpenThread सीएलआई का रेफ़रंस देखें.

5. कमीशनिंग की मदद से नोड की पुष्टि करना

पिछली कसरत में, आपने दो सिम्युलेटेड डिवाइसों के साथ एक थ्रेड नेटवर्क सेट अप किया था और कनेक्टिविटी की पुष्टि की थी. हालांकि, इससे सिर्फ़ बिना पुष्टि किए गए IPv6 लिंक-लोकल ट्रैफ़िक को डिवाइसों के बीच पास करने की अनुमति मिलती है. इनके बीच ग्लोबल IPv6 ट्रैफ़िक को रूट करने के लिए, नोड की पुष्टि की जानी चाहिए. साथ ही, थ्रेड बॉर्डर राउटर के ज़रिए इंटरनेट का इस्तेमाल करने के लिए भी नोड की पुष्टि की जानी चाहिए.

पुष्टि करने के लिए, किसी एक डिवाइस को कमिश्नर के तौर पर काम करना होगा. कमिश्नर, फ़िलहाल नए Thread डिवाइसों के लिए चुना गया पुष्टि करने वाला सर्वर है. साथ ही, यह डिवाइसों को नेटवर्क से जुड़ने के लिए ज़रूरी नेटवर्क क्रेडेंशियल देने वाला व्यक्ति है.

इस एक्सरसाइज़ में, हम पहले की तरह ही दो नोड वाली टोपोलॉजी का इस्तेमाल करेंगे. पुष्टि करने के लिए, Thread लीडर, कमिश्नर के तौर पर काम करेगा. वहीं, Thread राऊटर, जॉइनर के तौर पर काम करेगा.

1. नेटवर्क बनाना

अगर आपको पिछले चरण से आगे बढ़ना है, तो आपके पास पहले से ही दो टर्मिनल विंडो खुली होनी चाहिए. अगर ऐसा नहीं है, तो पक्का करें कि दो टैब खुले हों और इस्तेमाल के लिए तैयार हों. इनमें से एक को नोड 1 और दूसरे को नोड 2 के तौर पर इस्तेमाल किया जाएगा.

Node 1 में, CLI प्रोसेस को स्पॉन करें:

$ cd ~/src/openthread
$ ./build/simulation/examples/apps/cli/ot-cli-ftd 1

नया ऑपरेशनल डेटासेट बनाएं, उसे चालू के तौर पर सेट करें, और थ्रेड शुरू करें:

> 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 Leader बन गया है:

> state
leader
Done

2. कमिश्नर की भूमिका शुरू करना

नोड 1 पर रहते हुए, कमिश्नर की भूमिका शुरू करें:

> commissioner start
Done

* वाइल्डकार्ड का इस्तेमाल करके, J01NME जॉइनर क्रेडेंशियल वाले किसी भी जॉइनर को नेटवर्क पर कमीशन करने की अनुमति दें. जॉइनर, ऐसा डिवाइस होता है जिसे कोई एडमिन, कमीशन किए गए Thread नेटवर्क में जोड़ता है.

> commissioner joiner add * J01NME
Done

J01NME, उपयोगकर्ता के तय किए गए जॉइनर क्रेडेंशियल हैं. इनका इस्तेमाल इस कोडलैब के लिए किया जाता है. थ्रेड नेटवर्क को लागू करने के अलग तरीके में, अपनी पसंद के मुताबिक कोई भी जॉइनर क्रेडेंशियल चुना जा सकता है. शामिल होने वाले व्यक्ति का क्रेडेंशियल, डिवाइस के हिसाब से तय की गई एक स्ट्रिंग होती है. इसमें सभी अपरकेस वाले अक्षर और अंक (0-9 और A-Y) होते हैं. इसमें I, O, Q, और Z को छोड़कर, पढ़ने में आसानी होने वाले अक्षर और अंक शामिल होते हैं. इसकी लंबाई 6 से 32 वर्णों के बीच होती है. ज़्यादा जानकारी के लिए, Thread Commissioning देखें.

3. शामिल होने वाले व्यक्ति की भूमिका शुरू करना

दूसरी टर्मिनल विंडो में, नई सीएलआई प्रोसेस शुरू करें. यह नोड 2 है.

$ cd ~/src/openthread
$ ./build/simulation/examples/apps/cli/ot-cli-ftd 2

दूसरे नोड पर, J01NME जॉइनर क्रेडेंशियल का इस्तेमाल करके, जॉइनर की भूमिका चालू करें.

> ifconfig up
Done
> joiner start J01NME
Done

... पुष्टि होने तक कुछ सेकंड इंतज़ार करें ...

Join success

डिवाइस (नोड 2) ने जॉइनर के तौर पर, कमिश्नर (नोड 1) के साथ अपनी पुष्टि कर ली है. साथ ही, उसे Thread नेटवर्क के क्रेडेंशियल मिल गए हैं.

अगर आपको Join failed मैसेज मिलता है, तो हो सकता है कि कमिश्नर ने शामिल होने के अनुरोध का इंतज़ार करने की समयसीमा खत्म कर दी हो. ऐसे में, commissioner joiner कमांड से शुरू करें. कमिश्नर को शुरू करने के बाद, जॉइनर की भूमिका को चालू करने के लिए ज़्यादा इंतज़ार न करें.

शामिल होने के बाद, आपको दोनों नोड 1 और 2 पर गड़बड़ी और/या लॉग मैसेज भी मिल सकते हैं. ये सामान्य सूचनाएं हैं और इन्हें अनदेखा किया जा सकता है.

अब Node 2 की पुष्टि हो गई है. इसलिए, थ्रेड शुरू करें:

> thread start
Done

4. नेटवर्क की पुष्टि करने की सुविधा की पुष्टि करना

नोड 2 पर state की जांच करें, ताकि यह पुष्टि की जा सके कि यह अब नेटवर्क से जुड़ गया है. दो मिनट के अंदर, नोड 2, child से router में बदल जाता है:

> state
child
Done
...
> state
router
Done

5. कॉन्फ़िगरेशन रीसेट करना

अगली कसरत के लिए, कॉन्फ़िगरेशन को रीसेट करें. हर नोड पर, Thread को बंद करें, फ़ैक्ट्री रीसेट करें, और सिम्युलेट किए गए Thread डिवाइस से बाहर निकलें:

> thread stop
Done
> factoryreset
>
> exit

factoryreset कमांड के बाद, > प्रॉम्प्ट को वापस लाने के लिए, आपको enter को कुछ बार दबाना पड़ सकता है.

6. OpenThread Daemon की मदद से नेटवर्क मैनेज करना

इस एक्सरसाइज़ के लिए, हम एक सीएलआई इंस्टेंस (एक एम्बेड किया गया एसओसी थ्रेड डिवाइस) और एक रेडियो को-प्रोसेसर (आरसीपी) इंस्टेंस का सिम्युलेशन करेंगे.

ot-daemon, OpenThread Posix ऐप्लिकेशन का एक मोड है. यह इनपुट और आउटपुट के तौर पर UNIX सॉकेट का इस्तेमाल करता है, ताकि OpenThread कोर को सेवा के तौर पर चलाया जा सके. क्लाइंट, इस सेवा से कम्यूनिकेट कर सकता है. इसके लिए, उसे प्रोटोकॉल के तौर पर OpenThread CLI का इस्तेमाल करके सॉकेट से कनेक्ट करना होगा.

ot-ctl एक सीएलआई है. इसे ot-daemon ने आरसीपी को मैनेज और कॉन्फ़िगर करने के लिए उपलब्ध कराया है. इसका इस्तेमाल करके, हम आरसीपी को Thread डिवाइस से बनाए गए नेटवर्क से कनेक्ट करेंगे.

ot-daemon का इस्तेमाल करना

इस एक्सरसाइज़ में, तीन टर्मिनल विंडो का इस्तेमाल किया जाएगा. ये विंडो, यहां दी गई जानकारी के हिसाब से होंगी:

सिम्युलेट किए गए Thread डिवाइस (नोड 1) का सीएलआई इंस्टेंस
ot-daemon प्रोसेस
ot-ctl सीएलआई इंस्टेंस

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

1. नोड 1 शुरू करें

पहली टर्मिनल विंडो में, सिम्युलेट किए गए Thread डिवाइस के लिए सीएलआई प्रोसेस शुरू करें:

$ cd ~/src/openthread
$ ./build/simulation/examples/apps/cli/ot-cli-ftd 1

नया ऑपरेशनल डेटासेट बनाएं, उसे चालू के तौर पर सेट करें, और थ्रेड शुरू करें:

> 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 के Thread इंटरफ़ेस को असाइन किए गए 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-daemon शुरू करना

दूसरी टर्मिनल विंडो में, openthread डायरेक्ट्री पर जाएं. इसके बाद, आरसीपी नोड के लिए ot-daemon शुरू करें. इसे हम नोड 2 कहेंगे. -v वर्बोस फ़्लैग का इस्तेमाल करें, ताकि आपको लॉग आउटपुट दिख सके और पुष्टि हो सके कि यह चल रहा है. साथ ही, sudo का इस्तेमाल करना न भूलें:

$ cd ~/src/openthread
$ sudo ./build/posix/src/posix/ot-daemon -v \
    'spinel+hdlc+forkpty://build/simulation/examples/apps/ncp/ot-rcp?forkpty-arg=2'

सफल होने पर, वर्बोस मोड में ot-daemon, इस तरह का आउटपुट जनरेट करता है:

ot-daemon[12463]: Running OPENTHREAD/thread-reference-20200818-1938-g0f10480ed; POSIX; Aug 30 2022 10:55:05
ot-daemon[12463]: Thread version: 4
ot-daemon[12463]: Thread interface: wpan0
ot-daemon[12463]: RCP version: OPENTHREAD/thread-reference-20200818-1938-g0f10480ed; SIMULATION; Aug 30 2022 10:54:10

इस टर्मिनल को खुला रखें और बैकग्राउंड में चलने दें. इसमें कोई और कमांड नहीं डाली जाएगी.

3. नेटवर्क से जुड़ने के लिए, ot-ctl का इस्तेमाल करना

हमने Node 2 (ot-daemon आरसीपी) को अब तक किसी भी Thread नेटवर्क के लिए चालू नहीं किया है. ऐसे में, ot-ctl आपकी मदद कर सकता है. ot-ctl, OpenThread CLI ऐप्लिकेशन की तरह ही CLI का इस्तेमाल करता है. इसलिए, ot-daemon नोड को उसी तरह से कंट्रोल किया जा सकता है जिस तरह से सिम्युलेट किए गए अन्य Thread डिवाइसों को कंट्रोल किया जाता है.

तीसरी टर्मिनल विंडो में, ot-ctl शुरू करें:

$ sudo ./build/posix/src/posix/ot-ctl
>

ot-ctl का इस्तेमाल, इस तीसरी टर्मिनल विंडो में Node 2 (आरसीपी नोड) को मैनेज करने के लिए किया जाएगा. इसे आपने दूसरी टर्मिनल विंडो में ot-daemon की मदद से शुरू किया था. नोड 2 का state देखें:

> state
disabled
Done

किसी खास जॉइनर को शामिल होने से रोकने के लिए, Node 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) के साथ खुद की पुष्टि कर ली है. साथ ही, उसे थ्रेड नेटवर्क के क्रेडेंशियल मिल गए हैं.

अब नोड 2 को Thread नेटवर्क से कनेक्ट करें:

> thread start
Done

4. नेटवर्क की पुष्टि करने की सुविधा की पुष्टि करना

> state
child
Done
...
> state
router
Done

5. कनेक्टिविटी की पुष्टि करना

ot-ctl से बाहर निकलने के लिए, Ctrl+D या exit कमांड का इस्तेमाल करें. इसके बाद, होस्ट मशीन की कमांड लाइन पर, ping6 कमांड के साथ Node 1 के ईआईडी का इस्तेमाल करके, उसे पिंग करें. अगर ot-daemon आरसीपी इंस्टेंस, Thread नेटवर्क से कनेक्ट हो गया है और उससे कम्यूनिकेट कर रहा है, तो पिंग करने पर यह मैसेज दिखेगा:

$ 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

7. बधाई हो!

आपने OpenThread का इस्तेमाल करके, अपने पहले थ्रेड नेटवर्क को सिम्युलेट कर लिया है. बहुत बढ़िया!

इस कोडलैब में, आपने ये सीखा:

OpenThread बिल्ड टूलचेन सेट अप करना
Thread नेटवर्क को सिम्युलेट करना
Thread नोड की पुष्टि करना
OpenThread Daemon की मदद से Thread नेटवर्क मैनेज करना

ज़्यादा जानने के लिए, इन रेफ़रंस को देखें: