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

1. परिचय

26b7f4f6b3ea0700.png

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

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

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

4806d16a8c137c6d.jpeg

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

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

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

हार्डवेयर:

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

सॉफ़्टवेयर:

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

2. शुरू करना

OpenThread सिम्युलेशन

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

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

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

Linux मशीन

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

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

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

6693da3ce213856.png

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

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

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

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

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

ARM GNU Toolchain इंस्टॉल करें

ARM GNU Toolchain का इस्तेमाल बिल्डिंग बनाने के लिए किया जाता है.

हम एक्सट्रैक्ट किए गए संग्रह को, अपनी Linux मशीन पर /opt/gnu-mcu-eclipse/arm-none-eabi-gcc/ में रखने का सुझाव देते हैं. इंस्टॉल करने के निर्देशों के लिए, संग्रह की 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

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

4. RCP योजक सेट अप करें

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

ओपनर और नेटिव यूएसबी की सुविधा की मदद से, 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 मशीन में लगाएं. nRF52840 बोर्ड पर nRF पावर स्रोत स्विच को VDD पर सेट करें. सही से कनेक्ट होने पर, LED5 चालू होती है.

20a3b4b480356447.png

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

$ ls /dev/ttyACM*
/dev/ttyACM0

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

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

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

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

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

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

46e7b670d2464842.png

OpenThread Deemon शुरू करें

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

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

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

ot-daemon[228024]: Running OPENTHREAD/20191113-00831-gfb399104; POSIX; Jun  7 2020 18:05:15
ot-daemon[228024]: Thread version: 2
ot-daemon[228024]: RCP version: OPENTHREAD/20191113-00831-gfb399104; SIMULATION; Jun  7 2020 18:06:08

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

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

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

$ ./build/posix/bin/ot-ctl
>

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

> state
disabled
Done

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

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

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

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

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

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

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

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

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

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

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

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

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

46e7b670d2464842.png

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

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

$ screen /dev/ttyACM1 115200

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

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

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

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

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

FTD योजक का सेट अप करें

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

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

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

बोर्ड "योजक" लेबल करें.

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

$ screen -r

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

एक नया कमांड लाइन संकेत दिखाई देता है. FTD जॉइनर के लिए OpenThread CLI ऐक्सेस करें:

$ screen /dev/ttyACM2 115200

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

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

अब, FTD joiner CLI, स्क्रीन के उसी इंस्टेंस में है जिस तरह FTD कमिश्नर की है, तो आप Ctrl+a → n का इस्तेमाल करके उनके बीच स्विच कर सकते हैं.

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

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

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

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

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

  1. ot-daemon सेवा / लॉग
  2. ot-ctl का इस्तेमाल करके आरसीपी जॉइनर
  3. OpenThread CLI के ज़रिए FTD कमिश्नर
  4. OpenThread CLI के ज़रिए FTD योजक

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

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

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

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

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

दूसरे थ्रेड डिवाइस से स्कैन किए जाने पर अब "codelab" नेटवर्क दिखाई देता है.

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

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

> scan
| J | Network Name     | Extended PAN     | PAN  | MAC Address      | Ch | dBm | LQI |
+---+------------------+------------------+------+------------------+----+-----+-----+
| 0 | OpenThread-c0de  | c0de7ab5c0de7ab5 | c0de | 1ed687a9cb9d4b1d | 11 | -36 | 232 |

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

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

> scan
| J | Network Name     | Extended PAN     | PAN  | MAC Address      | Ch | dBm | LQI |
+---+------------------+------------------+------+------------------+----+-----+-----+
| 0 | OpenThread-c0de  | c0de7ab5c0de7ab5 | c0de | 1ed687a9cb9d4b1d | 11 | -38 | 229 |

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

आप ध्यान दे सकते हैं कि दोनों स्कैन में, नेटवर्क शामिल नहीं हो सकता (RCP योनर और FTD योजक का J कॉलम). इसका मतलब सिर्फ़ यह है कि नेटवर्क पर थ्रेड कमीशन चालू नहीं है. नेटवर्क में अब भी 'शामिल होने वाले डिवाइस' में नेटवर्क कुंजी डालकर, आप उससे बाहर निकल सकते हैं.

8. RCP योजक जोड़ें

आइए आउट-ऑफ़-बैंड प्रोसेस का इस्तेमाल करके अभी-अभी बनाए गए थ्रेड नेटवर्क में RCP माइनर को जोड़ें. आरसीपी योजक के नेटवर्क के लिए स्कैन करें:

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

> scan
| J | Network Name     | Extended PAN     | PAN  | MAC Address      | Ch | dBm | LQI |
+---+------------------+------------------+------+------------------+----+-----+-----+
| 0 | OpenThread-c0de  | c0de7ab5c0de7ab5 | c0de | 1ed687a9cb9d4b1d | 11 | -38 | 229 |

जुड़ने के लिए, RCP योजक के सक्रिय डेटासेट में नेटवर्क कुंजी (हमें अभी-अभी FTD कमीशन से मिली) सेट करें.

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

> dataset networkkey 1234c0de7ab51234c0de7ab51234c0de
Done
> dataset commit active
Done

यह पक्का करने के लिए कि डेटासेट सही तरीके से सेट है, उसे देखें.

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

> dataset
Network Key: 1234c0de7ab51234c0de7ab51234c0de

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

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

> 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 यहां) पर ध्यान दें, आप बाद में इसका इस्तेमाल कर सकते हैं.

FTD कमिश्नर पर वापस, राऊटर और चाइल्ड टेबल की जांच करके पुष्टि करें कि दोनों डिवाइस एक ही नेटवर्क का हिस्सा हैं. RCP ज़ोन की पहचान करने के लिए 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

कनेक्टिविटी की पुष्टि करने के लिए, RCP योजक के मेश-लोकल पते (RCP योजक के 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

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

otcodelab_top01C_2nodes.png

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

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

b75a527be4563215.png

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

9. FTD योद्धा को कमीशन दें

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

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

> scan
| J | Network Name     | Extended PAN     | PAN  | MAC Address      | Ch | dBm | LQI |
+---+------------------+------------------+------+------------------+----+-----+-----+
| 0 | OpenThread-c0de  | c0de7ab5c0de7ab5 | c0de | f65ae2853ff0c4e4 | 11 | -36 |  57 |

J कॉलम में 0 का मतलब है कि डिवाइस पर थ्रेड कमीशन चालू नहीं है.

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

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

> eui64
2f57d222545271f1
Done

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

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

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

FTD ज़ोन में स्विच करें और फिर से स्कैन करें:

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

> scan
| J | Network Name     | Extended PAN     | PAN  | MAC Address      | Ch | dBm | LQI |
+---+------------------+------------------+------+------------------+----+-----+-----+
| 1 | OpenThread-c0de  | c0de7ab5c0de7ab5 | c0de | 1ed687a9cb9d4b1d | 11 | -45 | 196 |

जैसा कि 1 कॉलम में बताया गया है, नेटवर्क पर थ्रेड कमीशन की सुविधा अब चालू है. ऐसे 'शामिल होने वाले क्रेडेंशियल' के साथ 'शामिल होने वाले व्यक्ति' की भूमिका शुरू करें जिन्हें आपने अभी FTD कमिश्नर पर सेट किया है:

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

> ifconfig up
Done
> joiner start J01NME
Done

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

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

>
Join success

थ्रेड लाएं, ताकि FTD योजक "कोडलैब" नेटवर्क में शामिल हो सके और राज्य और RLOC16 को तुरंत देख सके:

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

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

डिवाइस के IPv6 पते देखें. ध्यान दें कि कोई एएलओसी नहीं है. ऐसा इसलिए है, क्योंकि न तो यह डिवाइस लीडर है और न ही कोई ऐसा Cast असाइन करता है जिसके लिए एएलओसी की ज़रूरत होती है.

## 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. कार्यरूप में थ्रेड

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

थ्रेड में 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

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

otcodelab_top01C.png

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

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

> state
router
Done
> rloc16
b800
Done

FTD योद्धा को डाउनग्रेड करें

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

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

> state child
Done
> rloc16
0c03
Done

otcodelab_top01C_ed02.png

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

otcodelab_top01C.png

लीडर को हटाना

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

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

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

> thread stop
Done
> ifconfig down
Done

दो मिनट में, FTD joiner नया थ्रेड लीडर बन जाएगा. पुष्टि करने के लिए, FTD योजक के राज्य और 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

otcodelab_top02C_01.png

चाइल्ड टेबल देखें. ध्यान दें कि एक नया RLOC16 है. यह आरसीपी जॉइनर है. इसका आईडी और इसे बढ़ाए गए MAC के तौर पर दिखाया गया है. थ्रेड नेटवर्क को एक साथ रखने के लिए, इसने पैरंट रूटर, FTD कमिश्नर से FTD योजक पर स्विच कर दिए हैं. इससे RCP जॉइनर के लिए एक नया 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 योजक के साथ जुड़ने के लिए, आपको RCP योजक के लिए कुछ मिनट इंतज़ार करना पड़ सकता है. राज्य और RLOC16 की जांच करके पुष्टि करें कि:

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

> state
child
> rloc16
b801

FTD कमिश्नर को फिर से अटैच करें

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

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

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

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

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

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

स्क्रीन

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

थ्रेड नोड

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

FTD को रीसेट करने के लिए:

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

> thread stop
Done
> ifconfig down
Done
> factoryreset
Done

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

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

> thread stop
Done
> ifconfig down
Done
> factoryreset
Done

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

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

IPv6 पता

दायरा

डिलीवर किया गया

ff02::1

लिंक-लोकल

सभी FTD और MED

ff02::2

लिंक-लोकल

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

ff03::1

मेश-लोकल

सभी FTD और MED

ff03::2

मेश-लोकल

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

हम इस कोडलैब (कोड बनाना सीखना) में बॉर्डर रूटर का इस्तेमाल नहीं कर रहे हैं, तो चलिए दूसरे FTD और MED मल्टीकास्ट पतों पर ध्यान देते हैं.

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

FTD कमिश्नर से 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 योजक और RCP जूनर), लेकिन FTD कमिश्नर को सिर्फ़ एक जवाब मिला है, FTD योजक के लिंक लोकल पते (LLA) से. इसका मतलब है कि एफ़टीडी जॉइनर ही एक ऐसा डिवाइस है जिस पर एफ़टीडी कमिश्नर से सिर्फ़ एक हॉप मिल सकता है.

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

दो जवाब! दूसरे डिवाइस के IPv6 पतों की जांच करने पर, हम देख सकते हैं कि पहला, (4b1d में खत्म होने वाला) FTD कमिश्नर का LLA है और दूसरा (943b में खत्म होने वाला) RCP माइनर का LLA है.

otcodelab_top02C_02_LL02.png

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

मेश-लोकल

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

FTD कमिश्नर से 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

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

otcodelab_top02C_02_ML.png

एक ही तरह के व्यवहार की पुष्टि करने के लिए, 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

otcodelab_top02C_02_LL02.png

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

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

पुष्टि करने के लिए RCP योजक की स्थिति देखें:

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

> state
child

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

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

यूपीडी सॉकेट, 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

यूडीपी शुरू करें और इसे किसी भी IPv6 पते के लिए एक सॉकेट से जोड़ें:

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

> udp open
Done
> udp bind :: 1212

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

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

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

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

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

> udp send hellothere
Done

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

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

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

14. बधाई हो!

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

b915c433e7027cc7.png

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

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

अगले चरण

इस कोडलैब (कोड बनाना सीखना) से बचने के लिए, इन तरीकों को आज़माएं:

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

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

ओपन थ्रेड संसाधनों के लिए, openthread.io और GitHub देखें. इनमें ये भी शामिल हैं:

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

रेफ़रंस: