इस पेज का अनुवाद Cloud Translation API से किया गया है.

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

1. शुरुआती जानकारी

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

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

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

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

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

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

हार्डवेयर:

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

सॉफ़्टवेयर:

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

2. शुरू करना

OpenThread सिम्युलेशन

शुरू करने से पहले, हो सकता है कि आप OpenThread सिम्युलेशन सिम्युलेशन कोड से गुज़रना चाहें. इससे, थ्रेड के बुनियादी सिद्धांतों और OpenThread CLI के बारे में जाना जा सकेगा.

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

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

Linux मशीन

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

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

यह कोडलैब तीन nRF52840 PDK बोर्ड का इस्तेमाल करता है.

SEGGER J-Link इंस्टॉल करें

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

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

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

nRF5x कमांड लाइन टूल की मदद से, आप OpenThread बाइनरी को nRF52840 बोर्ड पर फ़्लैश कर सकते हैं. अपनी nLinux मशीन पर सही 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

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

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

बनाएं और फ़्लैश करें

जॉइनर और नेटिव यूएसबी फ़ंक्शन की मदद से, OpenThread nRF52840 उदाहरण बनाएं. किसी डिवाइस को जॉइन करने की अनुमति का इस्तेमाल, थ्रेड की नेटवर्क में सुरक्षित तरीके से पुष्टि करने और उसे चालू करने के लिए किया जाता है. नेटिव यूएसबी, यूएसबी सीडीसी एसीएम को 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 RCP बाइनरी की मदद से डायरेक्ट्री पर जाएं और उसे हेक्स फ़ॉर्मैट में बदलें:

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

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

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

$ ls /dev/ttyACM*
/dev/ttyACM0

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

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 पावर स्रोत स्विच को यूएसबी पर सेट करें.

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

आरसीपी डिज़ाइन में, थ्रेड थ्रेड के साथ बातचीत करने और उसे मैनेज करने के लिए, 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 एक ही CLI का इस्तेमाल OpenThread CLI ऐप्लिकेशन के तौर पर करता है. इसलिए, आप ot-daemon नोड को उसी तरह से कंट्रोल कर सकते हैं जैसे अन्य सिम्युलेटेड थ्रेड डिवाइस करते हैं.

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

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

आपने ot-daemon के साथ जो नोड 2 (RCP नोड) शुरू किया है उसकी state की जांच करें:

> state
disabled
Done

5. एफ़टीडी सेट अप करना

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

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

बनाएं और फ़्लैश करें

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

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

OpenThread फ़ुल थ्रेड डिवाइस (एफ़टीडी) CLI बाइनरी की डायरेक्ट्री पर जाएं और उसे हेक्स फ़ॉर्मैट में बदलें:

$ 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

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

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 यूएसबी पोर्ट का इस्तेमाल करना चाहिए.

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

टर्मिनल थ्रेड से GNU स्क्रीन का इस्तेमाल करके OpenThread CLI ऐक्सेस करके, सही तरीके से बिल्ड करें. nRF52840 बोर्ड 115200 की कलमान दर का इस्तेमाल करते हैं.

$ screen /dev/ttyACM1 115200

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

> 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.

एफ़टीडी जॉइनर सेट अप करना

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

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

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

बोर्ड को कोट करें; शामिल हों."

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

$ screen -r

स्क्रीन के अंदर Ctrl+a → c से नई विंडो बनाएं.

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

$ screen /dev/ttyACM2 115200

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

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

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

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

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

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

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

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

ot-daemon सेवा / लॉग
ot-ctl के ज़रिए आरसीपी जॉइन
OpenThread CLI के ज़रिए FTD कमिश्नर
OpenThread CLI के ज़रिए एफ़टीडी जॉइनर

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

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

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

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

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

स्क्रीन सेशन में फिर से अटैच करें (कमांड लाइन से)	`screen -r`
स्क्रीन सेशन छोड़ना	Ctrl+a → `d`
स्क्रीन सेशन में नई विंडो बनाएं	Ctrl+a → `c`
एक ही स्क्रीन सेशन में विंडो के बीच स्विच करना	Ctrl+a → `n` (आगे)Ctrl+a → `p` (पीछे)
स्क्रीन सेशन में मौजूदा विंडो को बंद करें	Ctrl+a → `k`

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

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

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

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

$ screen -r

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

विंडो को क्षैतिज रूप से बांटने के लिए Ctrl+a → S
Ctrl+a → Tab, कर्सर को नई खाली विंडो पर ले जाने के लिए
उस नई विंडो को अगली विंडो पर स्विच करने के लिए, Ctrl+a → n
अगर यह टॉप विंडो की तरह है, तो अन्य 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 नेटवर्क बनाएं

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

## 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 start
Done

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

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

> state
leader
Done
> rloc16
0c00
Done

डिवाइस के IPv6 पते देखें:

## 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 डिवाइसों से स्कैन किए जाने पर, "codelab" नेटवर्क अब दिखता है.

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

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

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

एफ़टीडी जॉइनर पर OpenThread CLI की मदद से:

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

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

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

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

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

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

## 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

मेश-लोकल IPv6 पते (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

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

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

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

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

9. एफ़टीडी जॉइनर को कमीशन

अब तीसरे थ्रेड के डिवाइस को "codelab" नेटवर्क में जोड़ें. इस बार हम #

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

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

> eui64
2f57d222545271f1
Done

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

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

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

एफ़टीडी जॉइनर पर स्विच करें. जॉइनर क्रेडेंशियल से जॉइनर रोल शुरू करें, जिसे आपने अभी-अभी एफ़टीडी कमिश्नर के साथ सेट अप किया है:

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

> ifconfig up
Done
> joiner start J01NME
Done

एक मिनट में आपको पुष्टि होने की पुष्टि का मैसेज मिलता है:

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

>
Join success

थ्रेड को लाएं, ताकि एफ़टीडी जॉइनर "codelab" नेटवर्क से जुड़ सके और राज्य और RLOC16 की तुरंत जांच कर सके:

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

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

डिवाइस और IPv6 पते देखें. ध्यान दें कि कोई अनुमति नहीं है. यह' है, क्योंकि यह डिवाइस लीडर नहीं है, न ही इसमें कोई विशेष भूमिका है, जिसके लिए 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)

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

## 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 के आधार पर, एफ़टीडी जॉइनर ने नेटवर्क से एंड डिवाइस (चाइल्ड) के तौर पर अटैच किया है. यहां हमारा अपडेट किया गया टोपोलॉजी दिया गया है:

10. लागू किए गए थ्रेड

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

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

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

## 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

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

एफ़टीडी जॉइन पर नई स्थिति और RLOC16 की पुष्टि करें:

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

> state
router
Done
> rloc16
b800
Done

एफ़टीडी जॉइनर को डाउनग्रेड करना

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

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

> state child
Done
> rloc16
0c03
Done

एफ़टीडी कमिश्नर की वेबसाइट पर, एफ़टीडी जॉइनर अब चाइल्ड टेबल में दिखना चाहिए (आईडी = 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 के आरएलसी के साथ राऊटर पर वापस स्विच हो जाएगा.

लीडर हटाएं

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

FTD कमिश्नर पर, थ्रेड को 'थ्रेड नेटवर्क' से हटाने के लिए शट डाउन करें:

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

> thread stop
Done
> ifconfig down
Done

दो मिनट के अंदर, एफ़टीडी जॉइन नए थ्रेड लीडर बन जाता है. यह पुष्टि करने के लिए एफ़टीडी जॉइनर का राज्य और IPv6 पता देखें:

## 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

चाइल्ड टेबल की जांच करें. ध्यान दें कि एक नया RLOC16 है. यह आरसीपी जॉइनर है, जैसा कि इसके आईडी और एक्सटेंडेड एमएसी ने बताया है. थ्रेड नेटवर्क को एक साथ रखने के लिए, इसे पैरंट राऊटर को स्विच किया गया है. इसे एफ़टीडी कमिश्नर से एफ़टीडी जॉइनर पर स्विच किया गया है. इससे आरसीपी जॉइनर का नया आरएलओसी16 बनता है, क्योंकि इसका राऊटर आईडी 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 कमिश्नर पर, थ्रेड को रीस्टार्ट करें:

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

> ifconfig up
Done
> thread start
Done

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

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

> state
router
Done

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

## 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

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

"दो मिनट के अंदर..."

हो सकता है कि आपने कोडलैब के दौरान किसी डिवाइस का स्टेटस बदलने के दौरान, कई बार इस समस्या का ज़िक्र किया हो. 120 सेकंड, ThreadR_choices_JITTER नाम के थ्रेड नेटवर्क पैरामीटर की डिफ़ॉल्ट वैल्यू है. एंड डिवाइस से राऊटर या इसके उलट बदलने वाले डिवाइस में, 0 और ROUTER_ लगाना_JITTER (सेकंड में) के बीच रैंडम में बदलाव होता है. Thread नेटवर्क के पैरामीटर के बारे में ज़्यादा जानकारी के लिए, थ्रेड की खास बातें देखें.

11. समस्याएं हल करना

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

फ़ोन की स्क्रीन

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

थ्रेड नोड

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

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

## 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. मल्टीकास्ट का इस्तेमाल करना

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

IPv6 पता	दायरा	डिलीवर किया गया
`ff02::1`	लिंक-लोकल	सभी एफ़टीडी और एमईडी
`ff02::2`	लिंक-लोकल	सभी एफ़टीडी और बॉर्डर राऊटर
`ff03::1`	मेश-लोकल	सभी एफ़टीडी और एमईडी
`ff03::2`	मेश-लोकल	सभी एफ़टीडी और बॉर्डर राऊटर

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

लिंक-लोकल

लिंक-स्थानीय के दायरे में ऐसे सभी थ्रेड इंटरफ़ेस शामिल होते हैं जिन्हें एक ही रेडियो ट्रांसमिशन या एक "Hop." से ऐक्सेस किया जा सकता है. नेटवर्क टोपोलॉजी तय करती है कि कौनसे डिवाइस 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

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

अब एफ़टीडी जॉइन से 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

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

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

मेश-लोकल

मेश-लोकल दायरे में वे सभी थ्रेड इंटरफ़ेस शामिल होते हैं जिन तक एक ही थ्रेड नेटवर्क के अंदर पहुंचा जा सकता है. चलिए, 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

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

इसी तरह के व्यवहार की पुष्टि करने के लिए, एफ़टीडी जॉइनर से 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

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

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

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

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

> state
child

13. यूडीपी के साथ मैसेज भेजें

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

यूडीपी सॉकेट की जानकारी OpenThread सीएलआई से ली जाती है. आइए, दोनों 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

यूडीपी शुरू करें और इसे किसी भी IPv6 पते के लिए सॉकेट में बाइंड करें:

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

> udp open
Done
> udp bind :: 1212

एफ़टीडी कमिश्नर पर स्विच करें, यूडीपी शुरू करें, और अपने एमएल-ईआईडी का इस्तेमाल करके, एफ़टीडी जॉइनर पर सेट किए गए सॉकेट से कनेक्ट करें:

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

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

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

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

> udp send hellothere
Done

एफ़टीडी जॉइनर पर यूडीपी मैसेज मिला है!

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

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

14. बधाई हो!

आपने'एक फ़िज़िकल थ्रेड नेटवर्क बनाया है!

अब आप जानते हैं:

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

अगले चरण

कोडलैब के इस मॉड्यूल के लिए नीचे दिए गए तरीके आज़माएं:

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

आगे पढ़ना

कई ओपन थ्रेड संसाधनों के साथ-साथ openthread.io और GitHub को भी देखें:

काम करने वाले प्लैटफ़ॉर्म — उन सभी प्लैटफ़ॉर्म के बारे में जानें जिनमें OpenThread काम करता है
OpenThread बनाएं — OpenThread को बनाने और कॉन्फ़िगर करने के बारे में ज़्यादा जानकारी
Thread Primer — इस कोडलैब में दिखाए गए सभी थ्रेड के सिद्धांतों को शामिल करता है

रेफ़रंस: