nRF52840 बोर्ड और OpenThread की मदद से Thread नेटवर्क बनाएं

1. परिचय

26b7f4f6b3ea0700.png

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

Thread की खास बातें, होम ऐप्लिकेशन के लिए आईपीवी6 आधारित भरोसेमंद, सुरक्षित, और कम पावर वाले वायरलेस डिवाइस-टू-डिवाइस कम्यूनिकेशन प्रोटोकॉल के बारे में बताती हैं. OpenThread ने सभी Thread नेटवर्किंग लेयर को लागू किया होता है, जिनमें आईपीवी6, 6LoWPAN, IEEE 802.15.4 के साथ-साथ MAC सिक्योरिटी, मेश लिंक इस्टैब्लिशमेंट, और मेश रूटिंग शामिल हैं.

इस कोडलैब में, OpenThread को असल हार्डवेयर पर प्रोग्राम किया जाएगा, Thread नेटवर्क बनाया और मैनेज किया जाएगा, और मैसेज को नोड के बीच पास किया जाएगा.

4806d16a8c137c6d.jpeg

आप इन चीज़ों के बारे में जानेंगे

  • डेव बोर्ड पर OpenThread CLI बाइनरी बनाना और उन्हें फ़्लैश करना
  • Linux मशीन और डेव बोर्ड वाला आरसीपी बनाना
  • OpenThread Deemon और ot-ctl का इस्तेमाल करके, आरसीपी से बातचीत करना
  • GNU स्क्रीन और OpenThread सीएलआई की मदद से, थ्रेड नोड को मैन्युअल तरीके से मैनेज करना
  • Thread नेटवर्क पर डिवाइसों को सुरक्षित तरीके से चालू करना
  • आईपीवी6 मल्टीकास्ट कैसे काम करता है
  • यूडीपी वाले थ्रेड नोड के बीच मैसेज पास करना

आपको इनकी ज़रूरत होगी

हार्डवेयर:

  • तीन नॉर्डिक सेमीकंडक्टर nRF52840 डेव बोर्ड
  • बोर्ड को कनेक्ट करने के लिए 3 यूएसबी से माइक्रो-यूएसबी केबल
  • कम से कम तीन यूएसबी पोर्ट वाली Linux मशीन

सॉफ़्टवेयर:

  • जीएनयू टूलचेन
  • नॉर्डिक nRF5x कमांड लाइन टूल
  • सेगर जे-लिंक सॉफ़्टवेयर
  • OpenThread
  • Git

2. शुरू करना

OpenThread सिम्युलेशन

शुरू करने से पहले, हो सकता है कि Thread के बुनियादी सिद्धांतों और OpenThread सीएलआई को समझने के लिए, आपको OpenThread सिम्युलेशन कोडलैब के बारे में जानना हो.

सीरियल पोर्ट टर्मिनल

आपको टर्मिनल के ज़रिए सीरियल पोर्ट से कनेक्ट करने के तरीके की जानकारी होनी चाहिए. यह कोडलैब GNU स्क्रीन का इस्तेमाल करता है और इसके इस्तेमाल के बारे में खास जानकारी देता है. हालांकि, किसी दूसरे टर्मिनल सॉफ़्टवेयर का इस्तेमाल किया जा सकता है.

Linux मशीन

इस कोडलैब को i386- या x86-आधारित Linux मशीन का इस्तेमाल करने के लिए डिज़ाइन किया गया है, ताकि रेडियो को-प्रोसेसर (आरसीपी) थ्रेड डिवाइस के लिए होस्ट के तौर पर काम किया जा सके और सभी Thread डेवलपमेंट बोर्ड को फ़्लैश किया जा सके. सभी चरणों का Ubuntu 14.04.5 LTS (Trusty Tahr) पर परीक्षण किया गया था.

नॉर्डिक सेमीकंडक्टर nRF52840 बोर्ड

इस कोडलैब में तीन nRF52840 पीडीके बोर्ड इस्तेमाल किए जाते हैं.

a6693da3ce213856.png

हम nRF52840 बोर्ड को प्रोग्राम करने के लिए SEGGER J-Link का इस्तेमाल करते हैं, जिसमें JTAG मॉड्यूल होते हैं. इसे अपनी Linux मशीन पर इंस्टॉल करें.

अपनी मशीन के लिए सही पैकेज डाउनलोड करें और उसे सही जगह पर इंस्टॉल करें. Linux पर यह /opt/SEGGER/JLink है.

nRF5x कमांड लाइन टूल इंस्टॉल करें

nRF5x कमांड लाइन टूल आपको OpenThread बाइनरी को nRF52840 बोर्ड पर फ़्लैश करने की सुविधा देते हैं. सही nRF5x-Command-Line-Tools-<OS> इंस्टॉल करें एक नया सॉफ़्टवेयर बनाने की शुरुआत करेंगे.

निकाले गए पैकेज को रूट फ़ोल्डर ~/ में रखें

ARM GNU टूलचेन इंस्टॉल करें

ARM GNU टूलचेन का इस्तेमाल इमारत बनाने के लिए किया जाता है.

हमारा सुझाव है कि आप निकाले गए संग्रह को /opt/gnu-mcu-eclipse/arm-none-eabi-gcc/ में अपनी Linux मशीन पर रखें. इंस्टॉल करने के निर्देशों के लिए संग्रह की readme.txt फ़ाइल में दिए गए निर्देशों का पालन करें.

स्क्रीन इंस्टॉल करें (ज़रूरी नहीं)

स्क्रीन, सीरियल पोर्ट के ज़रिए कनेक्ट किए गए डिवाइसों को ऐक्सेस करने का एक आसान टूल है. यह कोडलैब, स्क्रीन का इस्तेमाल करता है. हालांकि, किसी भी सीरियल पोर्ट टर्मिनल ऐप्लिकेशन का इस्तेमाल किया जा सकता है.

$ sudo apt-get install screen

3. क्लोन रिपॉज़िटरी

OpenThread

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

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

OpenThread डीमन बनाएं:

$ script/cmake-build posix -DOT_DAEMON=ON

अब आप OpenThread को nRF52840 बोर्ड पर बनाने और फ़्लैश करने के लिए तैयार हैं.

4. आरसीपी जॉइनर सेट अप करें

बिल्ड और फ़्लैश

जॉइनर और नेटिव यूएसबी की सुविधा की मदद से, OpenThread nRF52840 का उदाहरण बनाएं. सुरक्षित तरीके से पुष्टि करने और Thread नेटवर्क में शामिल होने के लिए, कोई डिवाइस जॉइनर की भूमिका का इस्तेमाल करता है. नेटिव यूएसबी की मदद से, nRF52840 और होस्ट के बीच सीरियल ट्रांसपोर्ट के तौर पर यूएसबी सीडीसी एसीएम का इस्तेमाल किया जा सकता है.

पहले हमेशा rm -rf build चलाकर, पिछले बिल्ड के रेपो को साफ़ करें.

$ cd ~/src
$ git clone --recursive https://github.com/openthread/ot-nrf528xx.git
$ cd ot-nrf528xx
$ script/build nrf52840 USB_trans

OpenThread आरसीपी बाइनरी की मदद से, डायरेक्ट्री पर जाएं और इसे हेक्स फ़ॉर्मैट में बदलें:

$ cd ~/src/ot-nrf528xx/build/bin
$ arm-none-eabi-objcopy -O ihex ot-rcp ot-rcp.hex

यूएसबी केबल को nRF52840 बोर्ड पर लगे बाहरी पावर पिन के बगल में मौजूद माइक्रो-यूएसबी डीबग पोर्ट में लगाएं और फिर उसे Linux मशीन में लगाएं. nRF52840 बोर्ड पर nRF पावर सोर्स स्विच को VDD पर सेट करें. सही तरीके से कनेक्ट होने पर, LED5 चालू हो जाता है.

20a3b4b480356447.png

अगर यह Linux मशीन से जुड़ा पहला बोर्ड है, तो यह सीरियल पोर्ट /dev/ttyACM0 के तौर पर दिखता है. सभी nRF52840 बोर्ड, सीरियल पोर्ट आइडेंटिफ़ायर के लिए ttyACM का इस्तेमाल करते हैं.

$ ls /dev/ttyACM*
/dev/ttyACM0

आरसीपी के लिए इस्तेमाल किए जा रहे nRF52840 बोर्ड का सीरियल नंबर नोट करें:

c00d519ebec7e5f0.jpeg

nRFx कमांड लाइन टूल की जगह पर जाएं और बोर्ड के सीरियल नंबर का इस्तेमाल करके, OpenThread RCP हेक्स फ़ाइल को nRF52840 बोर्ड पर दिखाएं. ध्यान दें कि अगर आप --verify फ़्लैग को छोड़ देते हैं, तो आपको एक चेतावनी संदेश दिखाई देगा, जो आपको बताएगा कि फ़्लैश प्रक्रिया बिना किसी गड़बड़ी के विफल हो सकती है.

$ cd ~/nrfjprog/
$ ./nrfjprog -f nrf52 -s 683704924  --verify --chiperase --program \
       ~/src/ot-nrf528xx/build/bin/ot-rcp.hex --reset

सफलता मिलने पर यह आउटपुट जनरेट होता है:

Parsing hex file.
Erasing user available code and UICR flash areas.
Applying system reset.
Checking that the area to write is not protected.
Programing device.
Applying system reset.
Run.

बोर्ड पर "आरसीपी" का लेबल लगाएं ताकि बाद में आप बोर्ड की भूमिकाओं को लेकर भ्रमित न हों.

मूल यूएसबी से कनेक्ट करें

क्योंकि OpenThread RCP बिल्ड, सीरियल ट्रांसपोर्ट के तौर पर स्थानीय यूएसबी सीडीसी एसीएम के इस्तेमाल को चालू करता है. इसलिए, आपको आरसीपी होस्ट (Linux मशीन) से संपर्क करने के लिए nRF52840 बोर्ड पर nRF यूएसबी पोर्ट का इस्तेमाल करना होगा.

यूएसबी केबल के माइक्रो-यूएसबी वाले सिरे को, फ़्लैश किए गए nRF52840 बोर्ड के डीबग पोर्ट से अलग करें. इसके बाद, उसे रीसेट बटन के बगल में दिए गए माइक्रो-यूएसबी nRF यूएसबी पोर्ट में फिर से लगाएं. nRF पावर सोर्स स्विच को यूएसबी पर सेट करें.

46e7b670d2464842.png

OpenThread डीमन को शुरू करें

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

$ cd ~/src/openthread
$ sudo ./build/posix/src/posix/ot-daemon -v \
    'spinel+hdlc+uart:///dev/ttyACM0?uart-baudrate=115200'

पुष्टि हो जाने पर, वर्बोस मोड में, 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

इस टर्मिनल विंडो को खुला रखें, ताकि ot-daemon के लॉग देखे जा सकें.

आरसीपी नोड से संपर्क करने के लिए ot-ctl का इस्तेमाल करें. ot-ctl, उसी सीएलआई का इस्तेमाल करता है जो OpenThread सीएलआई ऐप्लिकेशन में किया गया है. इसलिए, ot-daemon नोड को सिम्युलेट किए गए अन्य Thread डिवाइसों की तरह ही कंट्रोल किया जा सकता है.

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

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

ot-daemon के साथ शुरू किए गए नोड 2 (आरसीपी नोड) के state की जांच करें:

> state
disabled
Done

5. FTD सेट अप करें

इस कोडलैब में इस्तेमाल किए जाने वाले अन्य दो थ्रेड नोड, Full Thread डिवाइस (एफ़टीडी) हैं. ये स्टैंडर्ड सिस्टम-ऑन-चिप (SoC) डिज़ाइन पर काम करते हैं. प्रोडक्शन सेटिंग में, OpenThread NCP इंस्टेंस को कंट्रोल करने के लिए, प्रोडक्शन-ग्रेड नेटवर्क इंटरफ़ेस ड्राइवर wpantund का इस्तेमाल किया जा सकता है. हालांकि, इस कोडलैब में हम OpenThread सीएलआई ot-ctl का इस्तेमाल करेंगे.

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

बिल्ड और फ़्लैश

कमिश्नर और जॉइनर की भूमिका के साथ, nRF52840 प्लैटफ़ॉर्म के लिए OpenThread FTD उदाहरण तैयार करें:

$ cd ~/src/ot-nrf528xx
$ rm -rf build
$ script/build nrf52840 USB_trans -DOT_JOINER=ON -DOT_COMMISSIONER=ON

OpenThread Full Thread Device (FTD) सीएलआई बाइनरी के साथ डायरेक्ट्री पर जाएं और इसे हेक्स फ़ॉर्मैट में बदलें:

$ cd ~/src/ot-nrf528xx/build/bin
$ arm-none-eabi-objcopy -O ihex ot-cli-ftd ot-cli-ftd.hex

यूएसबी केबल को nRF52840 बोर्ड पर लगे बाहरी पावर पिन के बगल में मौजूद माइक्रो-यूएसबी पोर्ट में लगाएं और फिर उसे Linux मशीन में लगाएं. अगर आरसीपी अब भी Linux मशीन से जुड़ा है, तो यह नया बोर्ड सीरियल पोर्ट /dev/ttyACM1 के तौर पर दिखना चाहिए. सभी nRF52840 बोर्ड, सीरियल पोर्ट आइडेंटिफ़ायर के लिए ttyACM का इस्तेमाल करते हैं.

$ ls /dev/ttyACM*
/dev/ttyACM0  /dev/ttyACM1

पहले की तरह, FTD के लिए इस्तेमाल किए जा रहे nRF52840 बोर्ड का सीरियल नंबर नोट करें:

c00d519ebec7e5f0.jpeg

nRFx कमांड लाइन टूल की जगह पर जाएं और बोर्ड के सीरियल नंबर का इस्तेमाल करके, OpenThread CLI FTD हेक्स फ़ाइल को nRF52840 बोर्ड पर फ़्लैश करें:

$ cd ~/nrfjprog/
$ ./nrfjprog -f nrf52 -s 683704924 --verify --chiperase --program \
       ~/src/ot-nrf528xx/build/bin/ot-cli-ftd.hex --reset

बोर्ड पर "कमिश्नर" लेबल लगाएं.

मूल यूएसबी से कनेक्ट करें

OpenThread FTD बिल्ड, सीरियल ट्रांसपोर्ट के तौर पर मूल यूएसबी सीडीसी एसीएम के इस्तेमाल की सुविधा देता है. इसलिए, आपको आरसीपी होस्ट (Linux मशीन) से संपर्क करने के लिए nRF52840 बोर्ड पर nRF यूएसबी पोर्ट का इस्तेमाल करना होगा.

यूएसबी केबल के माइक्रो-यूएसबी वाले सिरे को, फ़्लैश किए गए nRF52840 बोर्ड के डीबग पोर्ट से अलग करें. इसके बाद, उसे रीसेट बटन के बगल में दिए गए माइक्रो-यूएसबी nRF यूएसबी पोर्ट में फिर से लगाएं. nRF पावर सोर्स स्विच को यूएसबी पर सेट करें.

46e7b670d2464842.png

बिल्ड की पुष्टि करें

टर्मिनल विंडो से GNU स्क्रीन का इस्तेमाल करके, OpenThread सीएलआई को ऐक्सेस करके, सफल बिल्ड की पुष्टि करें. nRF52840 बोर्ड 115200 के बॉड रेट का इस्तेमाल करते हैं.

$ screen /dev/ttyACM1 115200

नई विंडो में, OpenThread CLI > प्रॉम्प्ट को लाने के लिए, कीबोर्ड पर Return को कुछ बार दबाएं. आईपीवी6 इंटरफ़ेस को ऊपर लाएं और पतों की जांच करें:

> ifconfig up
Done
> ipaddr
fe80:0:0:0:1cd6:87a9:cb9d:4b1d
Done

Ctrl+a → का इस्तेमाल करें

d एफ़टीडी कमिश्नर सीएलआई स्क्रीन से अलग करने और Linux टर्मिनल पर वापस जाने के लिए, ताकि अगले बोर्ड को फ़्लैश किया जा सके. सीएलआई को फिर से किसी भी समय डालने के लिए, कमांड लाइन से screen -r इस्तेमाल करें. उपलब्ध स्क्रीन की सूची देखने के लिए, screen -ls का इस्तेमाल करें:

$ screen -ls
There is a screen on:
        74182.ttys000.mylinuxmachine        (Detached)
1 Socket in /tmp/uscreens/S-username.

FTD जॉइनर सेट करें

तीसरे nRF52840 बोर्ड को फ़्लैश करने के लिए, मौजूदा ot-cli-ftd.hex बिल्ड का इस्तेमाल करके ऊपर दी गई प्रक्रिया दोहराएं. काम पूरा होने के बाद, nRF यूएसबी पोर्ट का इस्तेमाल करके बोर्ड को पीसी से दोबारा कनेक्ट करना न भूलें. साथ ही, nRF पावर सोर्स स्विच को VDD पर सेट करें.

अगर इस तीसरे बोर्ड के अटैच होने के दौरान, अन्य दो नोड Linux मशीन से जुड़े हैं, तो यह सीरियल पोर्ट /dev/ttyACM2 के तौर पर दिखना चाहिए:

$ ls /dev/ttyACM*
/dev/ttyACM0  /dev/ttyACM1  /dev/ttyACM2

बोर्ड पर "जॉइनर" का लेबल लगाएं.

स्क्रीन का इस्तेमाल करके पुष्टि करते समय, कमांड लाइन से Screen का नया इंस्टेंस बनाने के बजाय, मौजूदा विंडो में फिर से जोड़ें और उसमें एक नई विंडो बनाएं (जिसे आपने एफ़टीडी कमिश्नर के लिए इस्तेमाल किया है):

$ screen -r

स्क्रीन पर Ctrl+a → c का इस्तेमाल करके नई विंडो बनाएं.

नया कमांड लाइन प्रॉम्प्ट दिखता है. एफ़टीडी जॉइनर के लिए, OpenThread सीएलआई को ऐक्सेस करें:

$ screen /dev/ttyACM2 115200

इस नई विंडो में, OpenThread CLI > प्रॉम्प्ट को लाने के लिए, कीबोर्ड पर Return को कुछ बार दबाएं. आईपीवी6 इंटरफ़ेस को ऊपर लाएं और पतों की जांच करें:

> ifconfig up
Done
> ipaddr
fe80:0:0:0:6c1e:87a2:df05:c240
Done

अब जब FTD जॉइनर सीएलआई, स्क्रीन के उसी इंस्टेंस में है जिसमें एफ़टीडी कमिश्नर है, तो Ctrl+a → n का इस्तेमाल करके इनके बीच स्विच किया जा सकता है.

Ctrl+a → का इस्तेमाल करें

d स्क्रीन से बाहर निकलने के लिए किसी भी समय.

6. टर्मिनल विंडो का सेटअप

इसके बाद, Thread डिवाइसों के बीच अक्सर स्विच किया जाता रहेगा, इसलिए पक्का करें कि सभी डिवाइस लाइव हों और उन्हें आसानी से ऐक्सेस किया जा सके. अब तक, हम दोनों एफ़टीडी को ऐक्सेस करने के लिए Screen का इस्तेमाल कर रहे हैं. यह टूल एक ही टर्मिनल विंडो पर स्प्लिट स्क्रीन की सुविधा भी देता है. इसका इस्तेमाल यह देखने के लिए करें कि एक नोड दूसरे नोड पर जारी किए गए निर्देशों पर कैसी प्रतिक्रिया देता है.

आम तौर पर, आपके पास चार विंडो आसानी से उपलब्ध होनी चाहिए:

  1. ot-daemon सेवा / लॉग
  2. ot-ctl से मिला आरसीपी जॉइनर
  3. OpenThread सीएलआई की मदद से, एफ़टीडी कमिश्नर
  4. OpenThread CLI से, एफ़टीडी जॉइनर

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

स्क्रीन का इस्तेमाल किया जा रहा है

इस्तेमाल में आसानी के लिए, सिर्फ़ एक स्क्रीन सेशन शुरू करें. दोनों FTD सेट अप करते समय, आपके पास पहले से ही एक कोड होना चाहिए.

स्क्रीन पर मौजूद सभी निर्देश Ctrl+a से शुरू होते हैं.

स्क्रीन के बुनियादी निर्देश:

स्क्रीन सेशन में (कमांड लाइन से) फिर से अटैच करें

screen -r

स्क्रीन सेशन छोड़ें

Ctrl+a → d

स्क्रीन सेशन में नई विंडो बनाएं

Ctrl+a → c

एक ही स्क्रीन सेशन में, एक विंडो से दूसरे पर स्विच करना

Ctrl+a → n (आगे)Ctrl+a → p (पीछे)

स्क्रीन सेशन में मौजूदा विंडो बंद करें

Ctrl+a → k

स्क्रीन विभाजित करें

स्क्रीन की मदद से, टर्मिनल को कई विंडो में बांटा जा सकता है:

f1cbf1258cf0a5a.png

screen में दिए गए निर्देशों को ऐक्सेस करने के लिए, Ctrl+a का इस्तेमाल करें. हर निर्देश इस ऐक्सेस कुंजी कॉम्बो से शुरू होना चाहिए.

अगर आपने कोडलैब को सही से फ़ॉलो किया है, तो आपके पास एक ही स्क्रीन इंस्टेंस पर दो विंडो (एफ़टीडी कमिश्नर, एफ़टीडी जॉइनर) होनी चाहिए. स्क्रीन को दो के बीच विभाजित करने के लिए, सबसे पहले अपना मौजूदा स्क्रीन सत्र डालें:

$ screen -r

आपको किसी एक FTD डिवाइस पर होना चाहिए. 'स्क्रीन' में यह तरीका अपनाएं:

  1. विंडो को हॉरिज़ॉन्टल तौर पर स्प्लिट करने के लिए, Ctrl+a → S
  2. कर्सर को नई खाली विंडो पर ले जाने के लिए, Ctrl+a → Tab
  3. नई विंडो को अगली विंडो पर स्विच करने के लिए, Ctrl+a → n पर जाएं
  4. अगर यह सबसे ऊपर वाली विंडो के जैसा ही है, तो अन्य FTD डिवाइस देखने के लिए Ctrl+a → n फिर से देखें

अब वे दोनों दिखाई दे रहे हैं. Ctrl+a → Tab का इस्तेमाल करके, इनके बीच स्विच करें. हमारा सुझाव है कि भ्रम की स्थिति से बचने के लिए, हर विंडो के टाइटल को Ctrl+a → A के साथ फिर से सेट करें.

बेहतर इस्तेमाल

स्क्रीन को क्वाड्रेंट में बांटने और ot-daemon के लॉग और आरसीपी जॉइनर ot-ctl को देखने के लिए, इन सेवाओं को उसी स्क्रीन इंस्टेंस में शुरू किया जाना चाहिए. ऐसा करने के लिए, ot-daemon को रोकें और ot-ctl से बाहर निकलें. इसके बाद, उन्हें नई स्क्रीन विंडो (Ctrl+a → c) में रीस्टार्ट करें.

यह सेटअप ज़रूरी नहीं है और इसे उपयोगकर्ता के लिए कसरत के तौर पर छोड़ दिया जाता है.

इन्हें अलग-अलग विंडो में बांटें और इन निर्देशों का इस्तेमाल करके, एक से दूसरी विंडो पर जाएं:

नई विंडो बनाएं

Ctrl+a → c

विंडो को वर्टिकल तौर पर स्प्लिट करें

Ctrl+a →

विंडो को हॉरिज़ॉन्टल तौर पर स्प्लिट करें

Ctrl+a → S

अगली दिखाई गई विंडो पर जाएं

Ctrl+a → Tab

दिखाई जा रही विंडो को आगे या पीछे स्विच करें

Ctrl+a → n या p

मौजूदा विंडो का नाम बदलें

Ctrl+a → A

स्क्रीन से किसी भी समय, Ctrl+a → d का इस्तेमाल करें और कमांड लाइन से screen -r की मदद से इसे फिर से अटैच करें.

स्क्रीन के बारे में ज़्यादा जानने के लिए, GNU स्क्रीन का क्विक रेफ़रंस देखें.

7. Thread नेटवर्क बनाएं

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

## FTD Commissioner ##
----------------------

> dataset init new
Done
> dataset
Active Timestamp: 1
Channel: 11
Channel Mask: 07fff800
Ext PAN ID: c0de7ab5c0de7ab5
Mesh Local Prefix: fdc0:de7a:b5c0/64
Network Key: 1234c0de7ab51234c0de7ab51234c0de
Network Name: OpenThread-c0de
PAN ID: 0xc0de
PSKc: ebb4f2f8a68026fc55bcf3d7be3e6fe4
Security Policy: 0, onrcb
Done

नेटवर्क कुंजी 1234c0de7ab51234c0de7ab51234c0de को ध्यान में रखें. इसका इस्तेमाल बाद में किया जाएगा.

इस डेटासेट को ऐक्टिव डेटासेट के तौर पर सेट करें:

> dataset commit active
Done

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

> ifconfig up
Done

Thread प्रोटोकॉल पर कार्रवाई शुरू करें:

> thread start
Done

कुछ देर बाद, डिवाइस की स्थिति देखें. यह लीडर होना चाहिए. साथ ही, आने वाले समय में इस्तेमाल करने के लिए RLOC16 पाएं.

## FTD Commissioner ##
----------------------

> state
leader
Done
> rloc16
0c00
Done

डिवाइस के आईपीवी6 पते देखें:

## FTD Commissioner ##
----------------------

> ipaddr
fdc0:de7a:b5c0:0:0:ff:fe00:fc00        # Leader Anycast Locator (ALOC)
fdc0:de7a:b5c0:0:0:ff:fe00:c00         # Routing Locator (RLOC)
fdc0:de7a:b5c0:0:6394:5a75:a1ad:e5a    # Mesh-Local EID (ML-EID)
fe80:0:0:0:1cd6:87a9:cb9d:4b1d         # Link-Local Address (LLA)

"कोडलैब" Thread डिवाइसों से स्कैन करने पर, नेटवर्क अब दिखता है.

आरसीपी जॉइनर पर ot-ctl से:

## RCP Joiner ##
----------------

> scan
| PAN  | MAC Address      | Ch | dBm | LQI |
+------+------------------+----+-----+-----+
| c0de | 1ed687a9cb9d4b1d | 11 | -36 | 232 |

FTD जॉइनर पर OpenThread CLI से:

## FTD Joiner ##
----------------

> scan
| PAN  | MAC Address      | Ch | dBm | LQI |
+------+------------------+----+-----+-----+
| c0de | 1ed687a9cb9d4b1d | 11 | -38 | 229 |

अगर "कोडलैब" नेटवर्क, सूची में नहीं दिख रहा है. फिर से स्कैन करके देखें.

8. आरसीपी जॉइनर जोड़ें

इस नेटवर्क पर थ्रेड कमीशन करने की सुविधा चालू नहीं है. इसका मतलब है कि हमें उस आरसीपी जॉइनर को Thread नेटवर्क में जोड़ना होगा जिसे हमने अभी-अभी आउट-ऑफ़-बैंड कमीशनिंग प्रोसेस का इस्तेमाल करके बनाया है.

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

## FTD Commissioner ##

> dataset networkkey
1234c0de7ab51234c0de7ab51234c0de
Done

इसके बाद, RCP जॉइनर पर, इसकी चालू डेटासेट नेटवर्क कुंजी को FTD कमिश्नर नेटवर्क कुंजी पर सेट करें:

## RCP Joiner ##
----------------

> dataset networkkey 1234c0de7ab51234c0de7ab51234c0de
Done
> dataset commit active
Done

डेटासेट की जांच करके पक्का करें कि यह सही तरीके से सेट है.

## RCP Joiner ##
----------------

> dataset
Network Key: 1234c0de7ab51234c0de7ab51234c0de

Thread को खोलें, ताकि आरसीपी जॉइनर, "कोडलैब" में जुड़ सके नेटवर्क. कुछ सेकंड इंतज़ार करें, राज्य, RLOC16 और इसके IPv6 पते देखें:

## RCP Joiner ##
----------------

> ifconfig up
Done
> thread start
Done
> state
child
Done
> rloc16
0c01
Done
> ipaddr
fdc0:de7a:b5c0:0:0:ff:fe00:0c01         # Routing Locator (RLOC)
fdc0:de7a:b5c0:0:66bf:99b9:24c0:d55f    # Mesh-Local EID (ML-EID)
fe80:0:0:0:18e5:29b3:a638:943b          # Link-Local Address (LLA)
Done

मेश-लोकल आईपीवी6 पते को नोट कर लें (यहां fdc0:de7a:b5c0:0:66bf:99b9:24c0:d55f है). इसे बाद में इस्तेमाल किया जा सकेगा.

एफ़टीडी कमिश्नर की वेबसाइट पर जाएं और राऊटर और चाइल्ड टेबल पर जाकर देखें कि दोनों डिवाइस एक ही नेटवर्क से कनेक्ट हैं या नहीं. आरसीपी जॉइनर की पहचान करने के लिए, RLOC16 का इस्तेमाल करें.

## FTD Commissioner ##
----------------------

> router table
| ID | RLOC16 | Next Hop | Path Cost | LQ In | LQ Out | Age | Extended MAC     |
+----+--------+----------+-----------+-------+--------+-----+------------------+
|  3 | 0x0c00 |        3 |         0 |     0 |      0 |  35 | 1ed687a9cb9d4b1d |

Done
> child table
| ID  | RLOC16 | Timeout    | Age        | LQ In | C_VN |R|S|D|VER| Extended MAC     |
+-----+--------+------------+------------+-------+------+-+-+-+---+------------------+
|   1 | 0x0c01 |        240 |         25 |     3 |   89 |1|1|1|  2| 1ae529b3a638943b |
Done

कनेक्टिविटी की पुष्टि करने के लिए, आरसीपी जॉइनर का मेश-लोकल पता (आरसीपी जॉइनर के ipaddr आउटपुट से मिला मेश-लोकल पता) पिंग करें:

## FTD Commissioner ##
----------------------

> ping fdc0:de7a:b5c0:0:66bf:99b9:24c0:d55f
> 8 bytes from fdc0:de7a:b5c0:0:66bf:99b9:24c0:d55f: icmp_seq=1 hlim=64 time=40ms

अब हमारे पास दो नोड वाला Thread नेटवर्क है. इसे इस टोपोलॉजी डायग्राम में दिखाया गया है:

otcodelab_top01C_2nodes.png

टोपोलॉजी डायग्राम

कोडलैब के अन्य हिस्सों में काम करने पर, नेटवर्क की स्थिति में बदलाव होने पर, हम Thread टोपोलॉजी का नया डायग्राम दिखाएंगे. नोड की भूमिकाओं को इस तरह से दिखाया जाता है:

b75a527be4563215.png

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

9. FTD जॉइनर को कमीशन दें

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

एफ़टीडी जॉइनर पर जाकर, eui64 हासिल करें, ताकि एफ़टीडी कमिश्नर इसकी पहचान कर सके:

## FTD Joiner ##
----------------

> eui64
2f57d222545271f1
Done

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

## FTD Commissioner ##
----------------------

> commissioner start
Done
> commissioner joiner add 2f57d222545271f1 J01NME
Done

FTD जॉइनर पर स्विच करें. एफ़टीडी कमिश्नर पर सेट अप किए गए जॉइनर क्रेडेंशियल की मदद से, जॉइनर की भूमिका शुरू करें:

## FTD Joiner ##
----------------

> ifconfig up
Done
> joiner start J01NME
Done

एक मिनट के अंदर, आपको पुष्टि होने की पुष्टि करने वाला मैसेज मिलेगा:

## FTD Joiner ##
----------------

>
Join success

Thread को खोलें, ताकि FTD जॉइनर, "कोडलैब" में जुड़ सके पर जाएं और तुरंत राज्य और RLOC16 की जाँच करें:

## FTD Joiner ##
----------------

> thread start
Done
> state
child
Done
> rloc16
0c02
Done

डिवाइस के आईपीवी6 पतों की जांच करें. ध्यान दें कि कोई ALOC नहीं है. ऐसा इसलिए होता है, क्योंकि यह डिवाइस न तो लीडर है और न ही इस पर Anycast की ऐसी भूमिका है जिसके लिए ALOC की ज़रूरत होती है.

## FTD Joiner ##
----------------

> ipaddr
fdc0:de7a:b5c0:0:0:ff:fe00:c02         # Routing Locator (RLOC)
fdc0:de7a:b5c0:0:3e2e:66e:9d41:ebcd    # Mesh-Local EID (ML-EID)
fe80:0:0:0:e4cd:d2d9:3249:a243         # Link-Local Address (LLA)

तुरंत एफ़टीडी कमिश्नर पर जाएं और राऊटर और चाइल्ड टेबल की जांच करके, पुष्टि करें कि "कोडलैब" में तीन डिवाइस मौजूद हैं या नहीं नेटवर्क:

## FTD Commissioner ##
----------------------

> router table
| ID | RLOC16 | Next Hop | Path Cost | LQ In | LQ Out | Age | Extended MAC     |
+----+--------+----------+-----------+-------+--------+-----+------------------+
|  3 | 0x0c00 |        3 |         0 |     0 |      0 |  50 | 1ed687a9cb9d4b1d |

> child table
| ID  | RLOC16 | Timeout    | Age        | LQ In | C_VN |R|S|D|N| Extended MAC     |
+-----+--------+------------+------------+-------+------+-+-+-+-+------------------+
|   1 | 0x0c01 |        240 |         25 |     3 |   89 |1|1|1|1| 1ae529b3a638943b |
|   2 | 0x0c02 |        240 |         15 |     3 |   44 |1|1|1|1| e6cdd2d93249a243 |
Done

RLOC16 के आधार पर, FTD जॉइनर ने एंड डिवाइस (बच्चे) के तौर पर नेटवर्क से अटैच किया है. यहां हमारी अपडेट की गई टोपोलॉजी दी गई है:

otcodelab_top01C_ed01.png

10. थ्रेड इस्तेमाल में है

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

Thread में 32 राऊटर तक के साथ काम करने की सुविधा होती है. हालांकि, इसमें राऊटर की संख्या 16 से 23 के बीच रखने की कोशिश की जाती है. अगर कोई REED किसी एंड डिवाइस (बच्चा) के तौर पर जुड़ जाता है और राऊटर की संख्या 16 से कम है, तो दो मिनट के अंदर किसी भी समयावधि के बाद वह अपने-आप राऊटर में अपना नाम प्रमोट कर देगा.

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

## FTD Commissioner ##
----------------------

> router table
| ID | RLOC16 | Next Hop | Path Cost | LQ In | LQ Out | Age | Extended MAC     |
+----+--------+----------+-----------+-------+--------+-----+------------------+
|  3 | 0x0c00 |        3 |         0 |     0 |      0 |  50 | 1ed687a9cb9d4b1d |
| 46 | 0xb800 |       63 |         0 |     3 |      3 |   1 | e6cdd2d93249a243 |

> child table
| ID  | RLOC16 | Timeout    | Age        | LQ In | C_VN |R|S|D|N| Extended MAC     |
+-----+--------+------------+------------+-------+------+-+-+-+-+------------------+
|   1 | 0x0c01 |        240 |         61 |     3 |   89 |1|1|1|1| 1ae529b3a638943b |
Done

FTD जॉइनर (एक्सटेंडेड MAC = e6cdd2d93249a243) ने खुद को राऊटर के तौर पर प्रमोट किया है. ध्यान दें कि RLOC16 अलग है (0c02 के बजाय b800). ऐसा इसलिए होता है, क्योंकि RLOC16, किसी डिवाइस के राऊटर आईडी और चाइल्ड आईडी पर आधारित होता है. जब डिवाइस को एंड डिवाइस से राऊटर में बदला जाता है, तब इसके राऊटर आईडी और चाइल्ड आईडी की वैल्यू भी बदल जाती है. इसी तरह, RLOC16 की भी वैल्यू बदल जाती है.

otcodelab_top01C.png

FTD जॉइनर पर, नए राज्य और RLOC16 की पुष्टि करें:

## FTD Joiner ##
----------------

> state
router
Done
> rloc16
b800
Done

FTD जॉइनर को डाउनग्रेड करना

इस व्यवहार की जांच करने के लिए, FTD जॉइनर को राऊटर से वापस एंड डिवाइस पर डाउनग्रेड करें. स्टेटस को चाइल्ड के तौर पर सेट करें और RLOC16 देखें:

## FTD Joiner ##
----------------

> state child
Done
> rloc16
0c03
Done

otcodelab_top01C_ed02.png

एफ़टीडी कमिश्नर की मदद से, एफ़टीडी जॉइनर अब चाइल्ड टेबल (आईडी = 3) में दिखेगा. बदलाव के दौरान, यह दोनों फ़ॉर्मैट में भी हो सकता है:

## FTD Commissioner ##
----------------------

> router table
| ID | RLOC16 | Next Hop | Path Cost | LQ In | LQ Out | Age | Extended MAC     |
+----+--------+----------+-----------+-------+--------+-----+------------------+
|  3 | 0x0c00 |        3 |         0 |     0 |      0 |  50 | 1ed687a9cb9d4b1d |
| 46 | 0xb800 |       63 |         0 |     3 |      3 |   1 | e6cdd2d93249a243 |

> child table
| ID  | RLOC16 | Timeout    | Age        | LQ In | C_VN |R|S|D|N| Extended MAC     |
+-----+--------+------------+------------+-------+------+-+-+-+-+------------------+
|   1 | 0x0c01 |        240 |         61 |     3 |   89 |1|1|1|1| 1ae529b3a638943b |
|   3 | 0x0c03 |        240 |         16 |     3 |   94 |1|1|1|1| e6cdd2d93249a243 |
Done

कुछ समय बाद, यह वापस b800 के आरएलओसी वाले राऊटर में स्विच हो जाएगा.

otcodelab_top01C.png

लीडर को हटाएं

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

FTD कमिश्नर पर, Thread को Thread नेटवर्क से हटाने के लिए इसे बंद करें:

## FTD Commissioner ##
----------------------

> thread stop
Done
> ifconfig down
Done

दो मिनट में, FTD जॉइनर Thread का नया लीडर बन जाता है. इसकी पुष्टि करने के लिए, एफ़टीडी जॉइनर के राज्य और आईपीवी6 पते देखें:

## FTD Joiner ##
----------------

> state
leader
Done
> ipaddr
fdc0:de7a:b5c0:0:0:ff:fe00:fc00       # Now it has the Leader ALOC!
fdc0:de7a:b5c0:0:0:ff:fe00:b800
fdc0:de7a:b5c0:0:3e2e:66e:9d41:ebcd
fe80:0:0:0:e4cd:d2d9:3249:a243
Done

otcodelab_top02C_01.png

चाइल्ड टेबल देखें. ध्यान दें कि एक नया RLOC16 मौजूद है. यह आरसीपी जॉइनर है, जैसा कि इसके आईडी और एक्सटेंडेड MAC से पता चलता है. Thread नेटवर्क को एक साथ रखने के लिए, इसने पैरंट राऊटर को एफ़टीडी कमिश्नर से बदलकर एफ़टीडी जॉइनर बना दिया है. इसकी वजह से, आरसीपी जॉइनर के लिए एक नया RLOC16 बन जाता है. ऐसा इसलिए होता है, क्योंकि इसका राऊटर आईडी बदलकर 3 से 46 हो जाता है.

## FTD Joiner ##
----------------

> child table
| ID  | RLOC16 | Timeout    | Age        | LQ In | C_VN |R|S|D|N| Extended MAC     |
+-----+--------+------------+------------+-------+------+-+-+-+-+------------------+
|   1 | 0xb801 |        240 |         27 |     3 |  145 |1|1|1|1| 1ae529b3a638943b |
Done

एफ़टीडी जॉइनर से बच्चे के तौर पर, आरसीपी जॉइनर को अटैच करने के लिए, आपको कुछ मिनट इंतज़ार करना पड़ सकता है. राज्य और RLOC16 की जांच करके पुष्टि करें कि:

## RCP Joiner ##
--------------

> state
child
> rloc16
b801

एफ़टीडी कमिश्नर को फिर से अटैच करें

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

FTD कमिश्नर पर, Thread को रीस्टार्ट करें:

## FTD Commissioner ##
----------------------

> ifconfig up
Done
> thread start
Done

दो मिनट में, यह अपने-आप "कोडलैब" से फिर से जुड़ जाता है एक एंड डिवाइस के तौर पर नेटवर्क बनाता है और फिर उसका प्रमोशन राऊटर में करता है.

## FTD Commissioner ##
----------------------

> state
router
Done

इनकी पुष्टि करने के लिए, FTD जॉइनर पर राऊटर और चाइल्ड टेबल देखें:

## FTD Joiner ##
----------------

> router table
| ID | RLOC16 | Next Hop | Path Cost | LQ In | LQ Out | Age | Extended MAC     |
+----+--------+----------+-----------+-------+--------+-----+------------------+
|  3 | 0x0c00 |       63 |         0 |     3 |      3 |   0 | 1ed687a9cb9d4b1d |
| 46 | 0xb800 |       46 |         0 |     0 |      0 |  15 | e6cdd2d93249a243 |

> child table
| ID  | RLOC16 | Timeout    | Age        | LQ In | C_VN |R|S|D|N| Extended MAC     |
+-----+--------+------------+------------+-------+------+-+-+-+-+------------------+
|   1 | 0xb801 |        240 |        184 |     3 |  145 |1|1|1|1| 1ae529b3a638943b |
Done

otcodelab_top02C_02.png

हमारे Thread नेटवर्क में फिर से तीन नोड होते हैं.

11. समस्या का हल

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

स्क्रीन करें

अगर आप कभी भी अपने कॉन्फ़िगरेशन (बहुत ज़्यादा स्क्रीन विंडो या स्क्रीन की स्क्रीन) में खो जाएं, तो स्क्रीन विंडो को Ctrl+a → k के साथ तब तक बंद करते रहें, जब तक कि कोई मौजूद न हो और screen -ls कमांड लाइन आउटपुट के रूप में No Sockets found नहीं देता. इसके बाद, हर डिवाइस के लिए स्क्रीन विंडो फिर से बनाएं. स्क्रीन बंद होने के बाद भी, डिवाइस की स्थिति बनी रहती है.

थ्रेड नोड

अगर Thread नेटवर्क टोपोलॉजी की जानकारी इस कोडलैब में दी गई जानकारी के हिसाब से नहीं है या नोड किसी वजह से डिसकनेक्ट हो जाते हैं (ऐसा शायद इसलिए होता है, क्योंकि उन्हें चलाने वाली Linux मशीन स्लीप मोड में है), तो Thread को बंद करना, नेटवर्क क्रेडेंशियल को हटाना, और फिर Thread नेटवर्क बनाना चरण से फिर से शुरू करना सबसे अच्छा है.

एफ़टीडी रीसेट करने के लिए:

## FTD Commissioner or FTD Joiner ##
------------------------------------

> thread stop
Done
> ifconfig down
Done
> factoryreset
Done

आरसीपी को ot-ctl के ज़रिए इसी तरह रीसेट किया जा सकता है:

## RCP Joiner ##
----------------

> thread stop
Done
> ifconfig down
Done
> factoryreset
Done

12. मल्टीकास्ट का इस्तेमाल करना

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

IPv6 पता

स्कोप

डिलीवरी की जगह

ff02::1

लिंक-लोकल

सभी FTD और MED

ff02::2

लिंक-लोकल

सभी FTD और बॉर्डर राऊटर

ff03::1

मेश-लोकल

सभी FTD और MED

ff03::2

मेश-लोकल

सभी FTD और बॉर्डर राऊटर

हम इस कोडलैब में बॉर्डर राऊटर का इस्तेमाल नहीं कर रहे हैं. इसलिए, आइए दो एफ़टीडी और एमईडी मल्टीकास्ट पतों के बारे में बात करते हैं.

लिंक-लोकल स्कोप में Thread नेटवर्क के वे सभी इंटरफ़ेस शामिल होते हैं जिन्हें एक रेडियो ट्रांसमिशन या एक "हॉप" से ऐक्सेस किया जा सकता है. नेटवर्क टोपोलॉजी से पता चलता है कि ff02::1 मल्टीकास्ट पते के लिए पिंग किए जाने पर कौनसे डिवाइस जवाब देते हैं.

एफ़टीडी कमिश्नर से ff02::1 की पिंग करें:

## FTD Commissioner ##
----------------------

> ping ff02::1
> 8 bytes from fe80:0:0:0:e4cd:d2d9:3249:a243: icmp_seq=2 hlim=64 time=9ms

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

otcodelab_top02C_02_LL.png

अब FTD जॉइनर से ff02::1 को पिंग करें:

## FTD Joiner ##
----------------

> ping ff02::1
> 8 bytes from fe80:0:0:0:1cd6:87a9:cb9d:4b1d: icmp_seq=1 hlim=64 time=11ms
8 bytes from fe80:0:0:0:18e5:29b3:a638:943b: icmp_seq=1 hlim=64 time=24ms

दो जवाब! अन्य डिवाइसों के आईपीवी6 पते की जांच करने पर, हमें पता चला है कि पहला डिवाइस (4b1d पर खत्म होने वाला) एफ़टीडी कमिश्नर का एलएलए है और दूसरा डिवाइस (943b से खत्म होने वाला), आरसीपी जॉइनर का एलएलए है.

otcodelab_top02C_02_LL02.png

इसका मतलब है कि एफ़टीडी जॉइनर, एफ़टीडी कमिश्नर और आरसीपी जॉइनर, दोनों से सीधे तौर पर जुड़ा है. इससे हमारे टोपोलॉजी की पुष्टि होती है.

मेश-लोकल

मेश-लोकल स्कोप में सभी Thread इंटरफ़ेस शामिल हैं. इन इंटरफ़ेस को एक ही Thread नेटवर्क पर ऐक्सेस किया जा सकता है. आइए, ff03::1 मल्टीकास्ट पते के लिए पिंग के जवाब देखते हैं.

एफ़टीडी कमिश्नर से ff03::1 की पिंग करें:

## FTD Commissioner ##
----------------------

> ping ff03::1
> 8 bytes from fdc0:de7a:b5c0:0:0:ff:fe00:b800: icmp_seq=3 hlim=64 time=9ms
8 bytes from fdc0:de7a:b5c0:0:66bf:99b9:24c0:d55f: icmp_seq=3 hlim=64 time=68ms

इस बार एफ़टीडी कमिश्नर को दो जवाब मिले. एक जवाब, एफ़टीडी जॉइनर रूटिंग लोकेटर (आरएलओसी, जिसके आखिर में b800 है) से और दूसरा आरसीपी जॉइनर के मेश-लोकल ईआईडी (एमएल-ईआईडी, जो d55f पर खत्म होता है) से. ऐसा इसलिए, क्योंकि मेश-लोकल स्कोप में पूरा Thread नेटवर्क शामिल है. डिवाइस चाहे कहीं भी हो, ff03::1 वाले पते से उसकी सदस्यता ली जाएगी.

otcodelab_top02C_02_ML.png

इसी व्यवहार की पुष्टि करने के लिए, एफ़टीडी जॉइनर से ff03::1 को पिंग करें:

## FTD Joiner ##
----------------

> ping ff03::1
> 8 bytes from fdc0:de7a:b5c0:0:0:ff:fe00:c00: icmp_seq=2 hlim=64 time=11ms
8 bytes from fdc0:de7a:b5c0:0:66bf:99b9:24c0:d55f: icmp_seq=2 hlim=64 time=23ms

otcodelab_top02C_02_LL02.png

दोनों पिंग आउटपुट में, आरसीपी जॉइनर के लिए जवाब देने में लगने वाला समय नोट करें. FTD जॉइनर (23 मि॰से॰) तक पहुंचने के मुकाबले, आरसीपी जॉइनर को FTD कमिश्नर (68 मि॰से॰) तक पहुंचने में ज़्यादा समय लगा. ऐसा इसलिए, क्योंकि FTD जॉइनर के लिए एक हॉप की तुलना में, एफ़टीडी कमिश्नर तक पहुंचने के लिए दो बार छलांग लगानी होती है.

आपने यह भी देखा होगा कि मेश-लोकल मल्टीकास्ट पिंग ने सिर्फ़ दो एफ़टीडी के लिए आरएलओसी के साथ जवाब दिया, न कि आरसीपी जॉइनर के लिए. ऐसा इसलिए है, क्योंकि एफ़टीडी नेटवर्क में मौजूद राऊटर हैं, जबकि आरसीपी एक एंड डिवाइस है.

इसकी पुष्टि करने के लिए, आरसीपी जॉइनर की स्थिति देखें:

## RCP Joiner ##
----------------

> state
child

13. यूडीपी का इस्तेमाल करके मैसेज भेजें

User Datagram प्रोटोकॉल (यूडीपी) एक ऐसी ऐप्लिकेशन सेवा है जो OpenThread मुहैया कराती है, जो एक ट्रांसपोर्ट लेयर प्रोटोकॉल है. OpenThread पर बनाया गया ऐप्लिकेशन, Thread नेटवर्क में नोड के बीच मैसेज को भेजने के लिए, यूडीपी एपीआई का इस्तेमाल कर सकता है. इसके अलावा, वह किसी बाहरी नेटवर्क के अन्य डिवाइसों पर मैसेज पास कर सकता है (जैसे, अगर Thread नेटवर्क में बॉर्डर राऊटर की सुविधा हो, तो इंटरनेट).

UDP सॉकेट, OpenThread CLI के ज़रिए दिखाए जाते हैं. आइए, इसका इस्तेमाल दो FTD के बीच मैसेज भेजने के लिए करते हैं.

एफ़टीडी जॉइनर के लिए, मेश-लोकल ईआईडी पता पाएं. हम इस पते का इस्तेमाल कर रहे हैं, क्योंकि इसे Thread नेटवर्क पर कहीं से भी ऐक्सेस किया जा सकता है.

## FTD Joiner ##
----------------

> ipaddr
fdc0:de7a:b5c0:0:0:ff:fe00:fc00        # Leader Anycast Locator (ALOC)
fdc0:de7a:b5c0:0:0:ff:fe00:b800        # Routing Locator (RLOC)
fe80:0:0:0:e4cd:d2d9:3249:a243         # Link-Local Address (LLA)
fdc0:de7a:b5c0:0:3e2e:66e:9d41:ebcd    # Mesh-Local EID (ML-EID)
Done

यूडीपी को शुरू करें और उसे किसी भी आईपीवी6 पते के सॉकेट से बाइंड करें:

## FTD Joiner ##
----------------

> udp open
Done
> udp bind :: 1212

FTD कमिश्नर पर स्विच करें, UDP शुरू करें, और FTD जॉइनर पर आपके सेट किए गए सॉकेट से कनेक्ट करें. इसके लिए, इसके ML-EID का इस्तेमाल करें:

## FTD Commissioner ##
----------------------

> udp open
Done
> udp connect fdc0:de7a:b5c0:0:3e2e:66e:9d41:ebcd 1212
Done

यूडीपी कनेक्शन दो नोड के बीच लाइव होना चाहिए. एफ़टीडी कमिश्नर से मैसेज भेजें:

## FTD Commissioner ##
----------------------

> udp send hellothere
Done

FTD जॉइनर पर, यूडीपी मैसेज मिल गया है!

## FTD Joiner ##
----------------

> 10 bytes from fdc0:de7a:b5c0:0:0:ff:fe00:c00 49153 hellothere

14. बधाई हो!

आपने Thread नेटवर्क बना लिया है!

b915c433e7027cc7.png

अब आपको पता है:

  • Thread डिवाइस के टाइप, रोल, और स्कोप में अंतर
  • Thread डिवाइस, नेटवर्क में अपने स्टेटस कैसे मैनेज करते हैं
  • यूडीपी का इस्तेमाल करके नोड के बीच आसान मैसेज कैसे पास करें

अगले चरण

इस कोडलैब को बनाने के बाद, ये काम करके देखें:

  • ot-cli-mtd बाइनरी का इस्तेमाल करके, FTD जॉइनर बोर्ड को MTD के तौर पर फिर से फ़्लैश करें. साथ ही, देखें कि यह कभी भी खुद को राऊटर में अपग्रेड नहीं करता या लीडर बनने की कोशिश नहीं करता
  • नेटवर्क में और डिवाइस जोड़ें (कोई दूसरा प्लैटफ़ॉर्म आज़माएं!) और राऊटर और चाइल्ड टेबल का इस्तेमाल करके, टोपोलॉजी की जानकारी तैयार करें. साथ ही, मल्टीकास्ट पतों के लिए पिंग भी करें
  • एनसीपी को कंट्रोल करने के लिए, pyspinel का इस्तेमाल करें
  • OpenThread Border राऊटर का इस्तेमाल करके, एनसीपी को बॉर्डर राऊटर में बदलें और अपने Thread नेटवर्क को इंटरनेट से कनेक्ट करें

इसके बारे में और पढ़ें

OpenThread के अलग-अलग संसाधनों के लिए, openthread.io और GitHub पर जाएं. इनमें ये संसाधन भी शामिल हैं:

संदर्भ: