nRF52840 बोर्ड और OpenThread की मदद से Thread नेटवर्क बनाएं
bookmark_border संग्रह की मदद से व्यवस्थित रहें अपनी प्राथमिकताओं के आधार पर, कॉन्टेंट को सेव करें और कैटगरी में बांटें.

इस कोडलैब (कोड बनाना सीखने के लिए ट्यूटोरियल) के बारे में जानकारी

88 मिनट

पिछली बार 24 अप्रैल 2025 को अपडेट किया गया

Jeff Bumgardner ने लिखा

1. परिचय

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

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

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

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

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

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

हार्डवेयर:

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

सॉफ़्टवेयर:

GNU टूलचेन
Nordic nRF5x कमांड-लाइन टूल
Segger J-Link सॉफ़्टवेयर
OpenThread
Git

2. शुरू करना

OpenThread सिम्युलेशन

शुरू करने से पहले, Thread के बुनियादी कॉन्सेप्ट और OpenThread CLI के बारे में जानने के लिए, OpenThread सिम्युलेशन कोडलैब को देखें.

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

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

Linux मशीन

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

Nordic Semiconductor nRF52840 बोर्ड

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

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

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

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

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

nRF5x कमांड-लाइन टूल की मदद से, nRF52840 बोर्ड पर OpenThread बाइनरी को फ़्लैश किया जा सकता है. अपनी Linux मशीन पर, nRF5x-Command-Line-Tools-<OS> का सही बिल्ड इंस्टॉल करें.

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

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

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

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

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

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

$ 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

अब आपके पास nRF52840 बोर्ड पर OpenThread बनाने और उसे फ़्लैश करने का विकल्प है.

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

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

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

हमेशा 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 चालू हो जाता है.

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

$ ls /dev/ttyACM*
/dev/ttyACM0

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

nRFx कमांड लाइन टूल की जगह पर जाएं और बोर्ड के सीरियल नंबर का इस्तेमाल करके, nRF52840 बोर्ड पर OpenThread आरसीपी हेक्स फ़ाइल को फ़्लैश करें. ध्यान दें कि अगर --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 आरसीपी बिल्ड, नेटिव यूएसबी सीडीसी ACM को सीरियल ट्रांसपोर्ट के तौर पर इस्तेमाल करने की सुविधा देता है. इसलिए, आरसीपी होस्ट (Linux मशीन) के साथ कम्यूनिकेट करने के लिए, आपको nRF52840 बोर्ड पर nRF यूएसबी पोर्ट का इस्तेमाल करना होगा.

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

OpenThread डीमन शुरू करना

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

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

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

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

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

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

> state
disabled
Done

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

इस कोडलैब में इस्तेमाल किए गए दो अन्य थ्रेड नोड, स्टैंडर्ड सिस्टम-ऑन-चिप (SoC) डिज़ाइन पर फ़ुल थ्रेड डिवाइस (FTD) हैं. प्रोडक्शन सेटिंग में, OpenThread एनसीपी इंस्टेंस को कंट्रोल करने के लिए, 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 फ़ुल थ्रेड डिवाइस (एफ़टीडी) सीएलआई बाइनरी वाली डायरेक्ट्री पर जाएं और उसे हेक्स फ़ॉर्मैट में बदलें:

$ 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 कमांड लाइन टूल की जगह पर जाएं और बोर्ड के सीरियल नंबर का इस्तेमाल करके, nRF52840 बोर्ड पर OpenThread CLI FTD हेक्स फ़ाइल को फ़्लैश करें:

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

बोर्ड को "कमिश्नर" लेबल करें.

डिवाइस को नेटिव यूएसबी से कनेक्ट करना

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

बिल्ड की पुष्टि करना

टर्मिनल विंडो से GNU Screen का इस्तेमाल करके, OpenThread CLI को ऐक्सेस करके, बिल्ड की पुष्टि करें.

$ screen /dev/ttyACM1

नई विंडो में, OpenThread CLI > प्रॉम्प्ट दिखाने के लिए, कीबोर्ड पर Return बटन को कुछ समय तक दबाकर रखें. 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 यूएसबी पोर्ट का इस्तेमाल करके बोर्ड को फिर से पीसी से कनेक्ट करें. साथ ही, nRF पावर सोर्स स्विच को VDD पर सेट करें.

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

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

बोर्ड को "जॉइनर" लेबल करें.

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

$ screen -r

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

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

$ screen /dev/ttyACM2

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

$ screen -r

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

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

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

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

आरसीपी जॉइनर पर 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 |

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

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

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

इन-बैंड कमीशनिंग तब होती है, जब रेडियो के ज़रिए नेटवर्क क्रेडेंशियल, जॉइन करने वाले व्यक्ति को ट्रांसफ़र किए जाते हैं. जब डिवाइस को शामिल करने वाले व्यक्ति को, डिवाइस को शामिल करने के लिए अन्य तरीकों से क्रेडेंशियल दिए जाते हैं, तो उसे आउट-ऑफ-बैंड कमीशनिंग कहा जाता है. उदाहरण के लिए, OpenThread CLI में मैन्युअल एंट्री.

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

## FTD Commissioner ##

> dataset networkkey
1234c0de7ab51234c0de7ab51234c0de
Done

इसके बाद, आरसीपी जॉइनर पर, उसके चालू डेटासेट के नेटवर्क पासकोड को एफ़टीडी कमिश्नर के नेटवर्क पासकोड पर सेट करें:

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

> dataset networkkey 1234c0de7ab51234c0de7ab51234c0de
Done
> dataset commit active
Done

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

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

> dataset
Network Key: 1234c0de7ab51234c0de7ab51234c0de

थ्रेड खोलें, ताकि आरसीपी जॉइनर "codelab" नेटवर्क में शामिल हो सके. कुछ सेकंड इंतज़ार करें और स्टेटस, 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. FTD जॉइनर को चालू करना

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

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

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

> eui64
2f57d222545271f1
Done

FTD कमिश्नर पर, कमिश्नर को शुरू करें और उस डिवाइस का 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 कमिश्नर पर सेट अप किया है:

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

डिवाइस के आईपीवी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)

तुरंत एफ़टीडी कमिश्नर पर स्विच करें और राऊटर और चाइल्ड टेबल की जांच करें. इससे यह पक्का किया जा सकेगा कि "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 के बीच रखने की कोशिश की जाती है. अगर कोई आरईईडी, एंड डिवाइस (चाइल्ड) के तौर पर जुड़ता है और राउटर की संख्या 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

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

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

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

> state
router
Done
> rloc16
b800
Done

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

इस व्यवहार की जांच करने के लिए, एफ़टीडी जॉइनर को राउटर से वापस एंड डिवाइस पर मैन्युअल तरीके से डाउनग्रेड करें. स्टेटस को 'बच्चा' पर सेट करें और 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 के RLOC वाले राउटर पर वापस स्विच हो जाएगा.

लीडर को हटाना

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

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

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

> thread stop
Done
> ifconfig down
Done

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

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

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

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

> state
child
> rloc16
b801

एफ़टीडी कमिश्नर को फिर से जोड़ना

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

एफ़टीडी कमिश्नर पर, थ्रेड को रीस्टार्ट करें:

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

> ifconfig up
Done
> thread start
Done

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

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

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

"दो मिनट में..."

आपको Codelab में, किसी डिवाइस की स्थिति बदलने के लिए इंतज़ार करते समय, इस बारे में कुछ बार बताया गया होगा. ROUTER_SELECTION_JITTER नाम के थ्रेड नेटवर्क पैरामीटर की डिफ़ॉल्ट वैल्यू 120 सेकंड होती है. जब कोई डिवाइस, एंड डिवाइस से राउटर में बदलता है या राउटर से एंड डिवाइस में बदलता है, तो उसमें बदलाव होने में 0 से ROUTER_SELECTION_JITTER (सेकंड में) के बीच का समय लग सकता है. थ्रेड नेटवर्क पैरामीटर के बारे में ज़्यादा जानने के लिए, थ्रेड स्पेसिफ़िकेशन देखें.

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`	Link-Local	सभी एफ़टीडी और एमईडी
`ff02::2`	Link-Local	सभी एफ़टीडी और बॉर्डर राऊटर
`ff03::1`	Mesh-Local	सभी एफ़टीडी और एमईडी
`ff03::2`	Mesh-Local	सभी एफ़टीडी और बॉर्डर राऊटर

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

Link-Local

लिंक-लोकल स्कोप में, एक रेडियो ट्रांसमिशन या एक "हॉप" से पहुंचने वाले सभी 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

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

अब 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 पर खत्म होने वाला) आरसीपी जॉइनर का एलएलए है.

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

Mesh-Local

मेश-लोकल स्कोप में, एक ही 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 पर खत्म होता है) से मिला. ऐसा इसलिए हुआ, क्योंकि मेश-लोकल स्कोप में पूरा थ्रेड नेटवर्क शामिल होता है. नेटवर्क में किसी भी डिवाइस की जगह से कोई फ़र्क़ नहीं पड़ता. वह ff03::1 पते की सदस्यता ले लेगा.

FTD जॉइनर से 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

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

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

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

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

> state
child

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

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

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

एफ़टीडी जॉइनर के लिए, मेश-लोकल ईआईडी पता पाएं. हम इस पते का इस्तेमाल इसलिए कर रहे हैं, क्योंकि 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 कमिश्नर पर स्विच करें, यूडीपी शुरू करें, और 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 नेटवर्क बना लिया है!

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

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

अगले चरण

इस कोडलैब के आधार पर, ये एक्सरसाइज़ आज़माएं:

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

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

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

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

रेफ़रंस: