1. परिचय
Google की ओर से रिलीज़ किया गया OpenThread, Thread® नेटवर्किंग प्रोटोकॉल को ओपन सोर्स लागू करने की एक सुविधा है. Google Nest ने OpenThread लॉन्च किया है, ताकि Nest के प्रॉडक्ट में इस्तेमाल की जाने वाली टेक्नोलॉजी को डेवलपर के लिए बड़े पैमाने पर उपलब्ध कराया जा सके. इससे कनेक्टेड होम के लिए प्रॉडक्ट बनाने में तेज़ी लाने में मदद मिली है.
Thread की खास बातें, होम ऐप्लिकेशन के लिए आईपीवी6 आधारित भरोसेमंद, सुरक्षित, और कम पावर वाले वायरलेस डिवाइस-टू-डिवाइस कम्यूनिकेशन प्रोटोकॉल के बारे में बताती हैं. OpenThread ने सभी Thread नेटवर्किंग लेयर को लागू किया होता है, जिनमें आईपीवी6, 6LoWPAN, IEEE 802.15.4 के साथ-साथ MAC सिक्योरिटी, मेश लिंक इस्टैब्लिशमेंट, और मेश रूटिंग शामिल हैं.
इस कोडलैब में, OpenThread को असल हार्डवेयर पर प्रोग्राम किया जाएगा, Thread नेटवर्क बनाया और मैनेज किया जाएगा, और मैसेज को नोड के बीच पास किया जाएगा.
आप इन चीज़ों के बारे में जानेंगे
- डेव बोर्ड पर OpenThread CLI बाइनरी बनाना और उन्हें फ़्लैश करना
- Linux मशीन और डेव बोर्ड वाला आरसीपी बनाना
- OpenThread Deemon और
ot-ctlका इस्तेमाल करके, आरसीपी से बातचीत करना - GNU स्क्रीन और OpenThread सीएलआई की मदद से, थ्रेड नोड को मैन्युअल तरीके से मैनेज करना
- Thread नेटवर्क पर डिवाइसों को सुरक्षित तरीके से चालू करना
- आईपीवी6 मल्टीकास्ट कैसे काम करता है
- यूडीपी वाले थ्रेड नोड के बीच मैसेज पास करना
आपको इनकी ज़रूरत होगी
हार्डवेयर:
- तीन नॉर्डिक सेमीकंडक्टर nRF52840 डेव बोर्ड
- बोर्ड को कनेक्ट करने के लिए 3 यूएसबी से माइक्रो-यूएसबी केबल
- कम से कम तीन यूएसबी पोर्ट वाली Linux मशीन
सॉफ़्टवेयर:
- जीएनयू टूलचेन
- नॉर्डिक nRF5x कमांड लाइन टूल
- सेगर जे-लिंक सॉफ़्टवेयर
- OpenThread
- Git
2. शुरू करना
OpenThread सिम्युलेशन
शुरू करने से पहले, हो सकता है कि Thread के बुनियादी सिद्धांतों और OpenThread सीएलआई को समझने के लिए, आपको OpenThread सिम्युलेशन कोडलैब के बारे में जानना हो.
सीरियल पोर्ट टर्मिनल
आपको टर्मिनल के ज़रिए सीरियल पोर्ट से कनेक्ट करने के तरीके की जानकारी होनी चाहिए. यह कोडलैब GNU स्क्रीन का इस्तेमाल करता है और इसके इस्तेमाल के बारे में खास जानकारी देता है. हालांकि, किसी दूसरे टर्मिनल सॉफ़्टवेयर का इस्तेमाल किया जा सकता है.
Linux मशीन
इस कोडलैब को i386- या x86-आधारित Linux मशीन का इस्तेमाल करने के लिए डिज़ाइन किया गया है, ताकि रेडियो को-प्रोसेसर (आरसीपी) थ्रेड डिवाइस के लिए होस्ट के तौर पर काम किया जा सके और सभी Thread डेवलपमेंट बोर्ड को फ़्लैश किया जा सके. सभी चरणों का Ubuntu 14.04.5 LTS (Trusty Tahr) पर परीक्षण किया गया था.
नॉर्डिक सेमीकंडक्टर nRF52840 बोर्ड
इस कोडलैब में तीन nRF52840 पीडीके बोर्ड इस्तेमाल किए जाते हैं.
SEGGER J-Link इंस्टॉल करें
हम nRF52840 बोर्ड को प्रोग्राम करने के लिए SEGGER J-Link का इस्तेमाल करते हैं, जिसमें JTAG मॉड्यूल होते हैं. इसे अपनी Linux मशीन पर इंस्टॉल करें.
अपनी मशीन के लिए सही पैकेज डाउनलोड करें और उसे सही जगह पर इंस्टॉल करें. Linux पर यह /opt/SEGGER/JLink है.
nRF5x कमांड लाइन टूल इंस्टॉल करें
nRF5x कमांड लाइन टूल आपको OpenThread बाइनरी को nRF52840 बोर्ड पर फ़्लैश करने की सुविधा देते हैं. सही nRF5x-Command-Line-Tools-<OS> इंस्टॉल करें एक नया सॉफ़्टवेयर बनाने की शुरुआत करेंगे.
निकाले गए पैकेज को रूट फ़ोल्डर ~/ में रखें
ARM GNU टूलचेन इंस्टॉल करें
ARM GNU टूलचेन का इस्तेमाल इमारत बनाने के लिए किया जाता है.
हमारा सुझाव है कि आप निकाले गए संग्रह को /opt/gnu-mcu-eclipse/arm-none-eabi-gcc/ में अपनी Linux मशीन पर रखें. इंस्टॉल करने के निर्देशों के लिए संग्रह की readme.txt फ़ाइल में दिए गए निर्देशों का पालन करें.
स्क्रीन इंस्टॉल करें (ज़रूरी नहीं)
स्क्रीन, सीरियल पोर्ट के ज़रिए कनेक्ट किए गए डिवाइसों को ऐक्सेस करने का एक आसान टूल है. यह कोडलैब, स्क्रीन का इस्तेमाल करता है. हालांकि, किसी भी सीरियल पोर्ट टर्मिनल ऐप्लिकेशन का इस्तेमाल किया जा सकता है.
$ sudo apt-get install screen
3. क्लोन रिपॉज़िटरी
OpenThread
OpenThread का क्लोन बनाएं और इसे इंस्टॉल करें. script/bootstrap निर्देशों से यह पक्का होता है कि टूलचेन इंस्टॉल हो गया है और एनवायरमेंट सही तरीके से कॉन्फ़िगर किया गया है:
$ mkdir -p ~/src $ cd ~/src $ git clone --recursive https://github.com/openthread/openthread.git $ cd openthread $ ./script/bootstrap
OpenThread डीमन बनाएं:
$ script/cmake-build posix -DOT_DAEMON=ON
अब आप OpenThread को nRF52840 बोर्ड पर बनाने और फ़्लैश करने के लिए तैयार हैं.
4. आरसीपी जॉइनर सेट अप करें
बिल्ड और फ़्लैश
जॉइनर और नेटिव यूएसबी की सुविधा की मदद से, OpenThread nRF52840 का उदाहरण बनाएं. सुरक्षित तरीके से पुष्टि करने और Thread नेटवर्क में शामिल होने के लिए, कोई डिवाइस जॉइनर की भूमिका का इस्तेमाल करता है. नेटिव यूएसबी की मदद से, nRF52840 और होस्ट के बीच सीरियल ट्रांसपोर्ट के तौर पर यूएसबी सीडीसी एसीएम का इस्तेमाल किया जा सकता है.
पहले हमेशा rm -rf build चलाकर, पिछले बिल्ड के रेपो को साफ़ करें.
$ cd ~/src $ git clone --recursive https://github.com/openthread/ot-nrf528xx.git $ cd ot-nrf528xx $ script/build nrf52840 USB_trans
OpenThread आरसीपी बाइनरी की मदद से, डायरेक्ट्री पर जाएं और इसे हेक्स फ़ॉर्मैट में बदलें:
$ cd ~/src/ot-nrf528xx/build/bin $ arm-none-eabi-objcopy -O ihex ot-rcp ot-rcp.hex
यूएसबी केबल को nRF52840 बोर्ड पर लगे बाहरी पावर पिन के बगल में मौजूद माइक्रो-यूएसबी डीबग पोर्ट में लगाएं और फिर उसे Linux मशीन में लगाएं. nRF52840 बोर्ड पर nRF पावर सोर्स स्विच को VDD पर सेट करें. सही तरीके से कनेक्ट होने पर, LED5 चालू हो जाता है.
अगर यह 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 डीमन को शुरू करें
आरसीपी डिज़ाइन में, Thread डिवाइस के साथ कम्यूनिकेट करने और इसे मैनेज करने के लिए, OpenThread Deemon का इस्तेमाल करें. ot-daemon को -v वर्बोस फ़्लैग के साथ शुरू करें, ताकि आप लॉग आउटपुट देख सकें और पुष्टि कर सकें कि यह चल रहा है:
$ cd ~/src/openthread
$ sudo ./build/posix/src/posix/ot-daemon -v \
'spinel+hdlc+uart:///dev/ttyACM0?uart-baudrate=115200'
पुष्टि हो जाने पर, वर्बोस मोड में, ot-daemon इस तरह का आउटपुट जनरेट करता है:
ot-daemon[12463]: Running OPENTHREAD/thread-reference-20200818-1938-g0f10480ed; POSIX; Aug 30 2022 10:55:05 ot-daemon[12463]: Thread version: 4 ot-daemon[12463]: Thread interface: wpan0 ot-daemon[12463]: RCP version: OPENTHREAD/thread-reference-20200818-1938-g0f10480ed; SIMULATION; Aug 30 2022 10:54:10
इस टर्मिनल विंडो को खुला रखें, ताकि ot-daemon के लॉग देखे जा सकें.
आरसीपी नोड से संपर्क करने के लिए ot-ctl का इस्तेमाल करें. ot-ctl, उसी सीएलआई का इस्तेमाल करता है जो OpenThread सीएलआई ऐप्लिकेशन में किया गया है. इसलिए, ot-daemon नोड को सिम्युलेट किए गए अन्य Thread डिवाइसों की तरह ही कंट्रोल किया जा सकता है.
दूसरी टर्मिनल विंडो में, ot-ctl से शुरू करें:
$ sudo ./build/posix/src/posix/ot-ctl >
ot-daemon के साथ शुरू किए गए नोड 2 (आरसीपी नोड) के state की जांच करें:
> state disabled Done
5. FTD सेट अप करें
इस कोडलैब में इस्तेमाल किए जाने वाले अन्य दो थ्रेड नोड, Full Thread डिवाइस (एफ़टीडी) हैं. ये स्टैंडर्ड सिस्टम-ऑन-चिप (SoC) डिज़ाइन पर काम करते हैं. प्रोडक्शन सेटिंग में, OpenThread NCP इंस्टेंस को कंट्रोल करने के लिए, प्रोडक्शन-ग्रेड नेटवर्क इंटरफ़ेस ड्राइवर wpantund का इस्तेमाल किया जा सकता है. हालांकि, इस कोडलैब में हम OpenThread सीएलआई ot-ctl का इस्तेमाल करेंगे.
एक डिवाइस कमिश्नर का काम करता है. इससे नेटवर्क पर डिवाइसों को सुरक्षित तरीके से पुष्टि और कमीशन किया जाता है. अन्य डिवाइस, जॉइनर के तौर पर काम करता है. कमिश्नर, Thread नेटवर्क के लिए पुष्टि कर सकता है.
बिल्ड और फ़्लैश
कमिश्नर और जॉइनर की भूमिका के साथ, nRF52840 प्लैटफ़ॉर्म के लिए OpenThread FTD उदाहरण तैयार करें:
$ cd ~/src/ot-nrf528xx $ rm -rf build $ script/build nrf52840 USB_trans -DOT_JOINER=ON -DOT_COMMISSIONER=ON
OpenThread Full Thread Device (FTD) सीएलआई बाइनरी के साथ डायरेक्ट्री पर जाएं और इसे हेक्स फ़ॉर्मैट में बदलें:
$ cd ~/src/ot-nrf528xx/build/bin $ arm-none-eabi-objcopy -O ihex ot-cli-ftd ot-cli-ftd.hex
यूएसबी केबल को nRF52840 बोर्ड पर लगे बाहरी पावर पिन के बगल में मौजूद माइक्रो-यूएसबी पोर्ट में लगाएं और फिर उसे Linux मशीन में लगाएं. अगर आरसीपी अब भी Linux मशीन से जुड़ा है, तो यह नया बोर्ड सीरियल पोर्ट /dev/ttyACM1 के तौर पर दिखना चाहिए. सभी nRF52840 बोर्ड, सीरियल पोर्ट आइडेंटिफ़ायर के लिए ttyACM का इस्तेमाल करते हैं.
$ ls /dev/ttyACM* /dev/ttyACM0 /dev/ttyACM1
पहले की तरह, FTD के लिए इस्तेमाल किए जा रहे nRF52840 बोर्ड का सीरियल नंबर नोट करें:
nRFx कमांड लाइन टूल की जगह पर जाएं और बोर्ड के सीरियल नंबर का इस्तेमाल करके, OpenThread CLI FTD हेक्स फ़ाइल को nRF52840 बोर्ड पर फ़्लैश करें:
$ cd ~/nrfjprog/
$ ./nrfjprog -f nrf52 -s 683704924 --verify --chiperase --program \
~/src/ot-nrf528xx/build/bin/ot-cli-ftd.hex --reset
बोर्ड पर "कमिश्नर" लेबल लगाएं.
मूल यूएसबी से कनेक्ट करें
OpenThread FTD बिल्ड, सीरियल ट्रांसपोर्ट के तौर पर मूल यूएसबी सीडीसी एसीएम के इस्तेमाल की सुविधा देता है. इसलिए, आपको आरसीपी होस्ट (Linux मशीन) से संपर्क करने के लिए nRF52840 बोर्ड पर nRF यूएसबी पोर्ट का इस्तेमाल करना होगा.
यूएसबी केबल के माइक्रो-यूएसबी वाले सिरे को, फ़्लैश किए गए nRF52840 बोर्ड के डीबग पोर्ट से अलग करें. इसके बाद, उसे रीसेट बटन के बगल में दिए गए माइक्रो-यूएसबी nRF यूएसबी पोर्ट में फिर से लगाएं. nRF पावर सोर्स स्विच को यूएसबी पर सेट करें.
बिल्ड की पुष्टि करें
टर्मिनल विंडो से GNU स्क्रीन का इस्तेमाल करके, OpenThread सीएलआई को ऐक्सेस करके, सफल बिल्ड की पुष्टि करें. nRF52840 बोर्ड 115200 के बॉड रेट का इस्तेमाल करते हैं.
$ screen /dev/ttyACM1 115200
नई विंडो में, OpenThread CLI > प्रॉम्प्ट को लाने के लिए, कीबोर्ड पर Return को कुछ बार दबाएं. आईपीवी6 इंटरफ़ेस को ऊपर लाएं और पतों की जांच करें:
> ifconfig up Done > ipaddr fe80:0:0:0:1cd6:87a9:cb9d:4b1d Done
Ctrl+a → का इस्तेमाल करें
d एफ़टीडी कमिश्नर सीएलआई स्क्रीन से अलग करने और Linux टर्मिनल पर वापस जाने के लिए, ताकि अगले बोर्ड को फ़्लैश किया जा सके. सीएलआई को फिर से किसी भी समय डालने के लिए, कमांड लाइन से screen -r इस्तेमाल करें. उपलब्ध स्क्रीन की सूची देखने के लिए, screen -ls का इस्तेमाल करें:
$ screen -ls
There is a screen on:
74182.ttys000.mylinuxmachine (Detached)
1 Socket in /tmp/uscreens/S-username.
FTD जॉइनर सेट करें
तीसरे nRF52840 बोर्ड को फ़्लैश करने के लिए, मौजूदा ot-cli-ftd.hex बिल्ड का इस्तेमाल करके ऊपर दी गई प्रक्रिया दोहराएं. काम पूरा होने के बाद, nRF यूएसबी पोर्ट का इस्तेमाल करके बोर्ड को पीसी से दोबारा कनेक्ट करना न भूलें. साथ ही, nRF पावर सोर्स स्विच को VDD पर सेट करें.
अगर इस तीसरे बोर्ड के अटैच होने के दौरान, अन्य दो नोड Linux मशीन से जुड़े हैं, तो यह सीरियल पोर्ट /dev/ttyACM2 के तौर पर दिखना चाहिए:
$ ls /dev/ttyACM* /dev/ttyACM0 /dev/ttyACM1 /dev/ttyACM2
बोर्ड पर "जॉइनर" का लेबल लगाएं.
स्क्रीन का इस्तेमाल करके पुष्टि करते समय, कमांड लाइन से Screen का नया इंस्टेंस बनाने के बजाय, मौजूदा विंडो में फिर से जोड़ें और उसमें एक नई विंडो बनाएं (जिसे आपने एफ़टीडी कमिश्नर के लिए इस्तेमाल किया है):
$ screen -r
स्क्रीन पर Ctrl+a → c का इस्तेमाल करके नई विंडो बनाएं.
नया कमांड लाइन प्रॉम्प्ट दिखता है. एफ़टीडी जॉइनर के लिए, OpenThread सीएलआई को ऐक्सेस करें:
$ screen /dev/ttyACM2 115200
इस नई विंडो में, OpenThread CLI > प्रॉम्प्ट को लाने के लिए, कीबोर्ड पर Return को कुछ बार दबाएं. आईपीवी6 इंटरफ़ेस को ऊपर लाएं और पतों की जांच करें:
> ifconfig up Done > ipaddr fe80:0:0:0:6c1e:87a2:df05:c240 Done
अब जब FTD जॉइनर सीएलआई, स्क्रीन के उसी इंस्टेंस में है जिसमें एफ़टीडी कमिश्नर है, तो Ctrl+a → n का इस्तेमाल करके इनके बीच स्विच किया जा सकता है.
Ctrl+a → का इस्तेमाल करें
d स्क्रीन से बाहर निकलने के लिए किसी भी समय.
6. टर्मिनल विंडो का सेटअप
इसके बाद, Thread डिवाइसों के बीच अक्सर स्विच किया जाता रहेगा, इसलिए पक्का करें कि सभी डिवाइस लाइव हों और उन्हें आसानी से ऐक्सेस किया जा सके. अब तक, हम दोनों एफ़टीडी को ऐक्सेस करने के लिए Screen का इस्तेमाल कर रहे हैं. यह टूल एक ही टर्मिनल विंडो पर स्प्लिट स्क्रीन की सुविधा भी देता है. इसका इस्तेमाल यह देखने के लिए करें कि एक नोड दूसरे नोड पर जारी किए गए निर्देशों पर कैसी प्रतिक्रिया देता है.
आम तौर पर, आपके पास चार विंडो आसानी से उपलब्ध होनी चाहिए:
ot-daemonसेवा / लॉगot-ctlसे मिला आरसीपी जॉइनर- OpenThread सीएलआई की मदद से, एफ़टीडी कमिश्नर
- OpenThread CLI से, एफ़टीडी जॉइनर
अगर आपको अपने टर्मिनल / सीरियल पोर्ट कॉन्फ़िगरेशन या टूल का इस्तेमाल करना है, तो सीधे अगले चरण पर जाएं. सभी डिवाइसों के लिए टर्मिनल विंडो को अपने हिसाब से कॉन्फ़िगर करें.
स्क्रीन का इस्तेमाल किया जा रहा है
इस्तेमाल में आसानी के लिए, सिर्फ़ एक स्क्रीन सेशन शुरू करें. दोनों FTD सेट अप करते समय, आपके पास पहले से ही एक कोड होना चाहिए.
स्क्रीन पर मौजूद सभी निर्देश Ctrl+a से शुरू होते हैं.
स्क्रीन के बुनियादी निर्देश:
स्क्रीन सेशन में (कमांड लाइन से) फिर से अटैच करें |
|
स्क्रीन सेशन छोड़ें | Ctrl+a → |
स्क्रीन सेशन में नई विंडो बनाएं | Ctrl+a → |
एक ही स्क्रीन सेशन में, एक विंडो से दूसरे पर स्विच करना | Ctrl+a → |
स्क्रीन सेशन में मौजूदा विंडो बंद करें | Ctrl+a → |
स्क्रीन विभाजित करें
स्क्रीन की मदद से, टर्मिनल को कई विंडो में बांटा जा सकता है:
screen में दिए गए निर्देशों को ऐक्सेस करने के लिए, Ctrl+a का इस्तेमाल करें. हर निर्देश इस ऐक्सेस कुंजी कॉम्बो से शुरू होना चाहिए.
अगर आपने कोडलैब को सही से फ़ॉलो किया है, तो आपके पास एक ही स्क्रीन इंस्टेंस पर दो विंडो (एफ़टीडी कमिश्नर, एफ़टीडी जॉइनर) होनी चाहिए. स्क्रीन को दो के बीच विभाजित करने के लिए, सबसे पहले अपना मौजूदा स्क्रीन सत्र डालें:
$ screen -r
आपको किसी एक FTD डिवाइस पर होना चाहिए. 'स्क्रीन' में यह तरीका अपनाएं:
- विंडो को हॉरिज़ॉन्टल तौर पर स्प्लिट करने के लिए, 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 → |
विंडो को वर्टिकल तौर पर स्प्लिट करें | Ctrl+a → |
विंडो को हॉरिज़ॉन्टल तौर पर स्प्लिट करें | Ctrl+a → |
अगली दिखाई गई विंडो पर जाएं | Ctrl+a → |
दिखाई जा रही विंडो को आगे या पीछे स्विच करें | Ctrl+a → |
मौजूदा विंडो का नाम बदलें | Ctrl+a → |
स्क्रीन से किसी भी समय, Ctrl+a → d का इस्तेमाल करें और कमांड लाइन से screen -r की मदद से इसे फिर से अटैच करें.
स्क्रीन के बारे में ज़्यादा जानने के लिए, GNU स्क्रीन का क्विक रेफ़रंस देखें.
7. Thread नेटवर्क बनाएं
अब आपने अपनी सभी टर्मिनल विंडो और स्क्रीन कॉन्फ़िगर कर ली हैं. इसलिए, अब अपना Thread नेटवर्क बनाएं. एफ़टीडी कमिश्नर पर, एक नया ऑपरेशनल डेटासेट बनाएं और उसे मौजूदा डेटासेट के तौर पर सेव करें. ऑपरेशनल डेटासेट उस Thread नेटवर्क का कॉन्फ़िगरेशन है, जिसे आप बना रहे हैं.
## FTD Commissioner ## ---------------------- > dataset init new Done > dataset Active Timestamp: 1 Channel: 11 Channel Mask: 07fff800 Ext PAN ID: c0de7ab5c0de7ab5 Mesh Local Prefix: fdc0:de7a:b5c0/64 Network Key: 1234c0de7ab51234c0de7ab51234c0de Network Name: OpenThread-c0de PAN ID: 0xc0de PSKc: ebb4f2f8a68026fc55bcf3d7be3e6fe4 Security Policy: 0, onrcb Done
नेटवर्क कुंजी 1234c0de7ab51234c0de7ab51234c0de को ध्यान में रखें. इसका इस्तेमाल बाद में किया जाएगा.
इस डेटासेट को ऐक्टिव डेटासेट के तौर पर सेट करें:
> dataset commit active Done
IPv6 इंटरफ़ेस खोलें:
> ifconfig up Done
Thread प्रोटोकॉल पर कार्रवाई शुरू करें:
> thread start Done
कुछ देर बाद, डिवाइस की स्थिति देखें. यह लीडर होना चाहिए. साथ ही, आने वाले समय में इस्तेमाल करने के लिए RLOC16 पाएं.
## FTD Commissioner ## ---------------------- > state leader Done > rloc16 0c00 Done
डिवाइस के आईपीवी6 पते देखें:
## FTD Commissioner ## ---------------------- > ipaddr fdc0:de7a:b5c0:0:0:ff:fe00:fc00 # Leader Anycast Locator (ALOC) fdc0:de7a:b5c0:0:0:ff:fe00:c00 # Routing Locator (RLOC) fdc0:de7a:b5c0:0:6394:5a75:a1ad:e5a # Mesh-Local EID (ML-EID) fe80:0:0:0:1cd6:87a9:cb9d:4b1d # Link-Local Address (LLA)
"कोडलैब" Thread डिवाइसों से स्कैन करने पर, नेटवर्क अब दिखता है.
आरसीपी जॉइनर पर ot-ctl से:
## RCP Joiner ## ---------------- > scan | PAN | MAC Address | Ch | dBm | LQI | +------+------------------+----+-----+-----+ | c0de | 1ed687a9cb9d4b1d | 11 | -36 | 232 |
FTD जॉइनर पर OpenThread CLI से:
## FTD Joiner ## ---------------- > scan | PAN | MAC Address | Ch | dBm | LQI | +------+------------------+----+-----+-----+ | c0de | 1ed687a9cb9d4b1d | 11 | -38 | 229 |
अगर "कोडलैब" नेटवर्क, सूची में नहीं दिख रहा है. फिर से स्कैन करके देखें.
8. आरसीपी जॉइनर जोड़ें
इस नेटवर्क पर थ्रेड कमीशन करने की सुविधा चालू नहीं है. इसका मतलब है कि हमें उस आरसीपी जॉइनर को Thread नेटवर्क में जोड़ना होगा जिसे हमने अभी-अभी आउट-ऑफ़-बैंड कमीशनिंग प्रोसेस का इस्तेमाल करके बनाया है.
एफ़टीडी कमिश्नर को हमने नेटवर्क कुंजी के बारे में जानकारी दी, जैसे कि 1234c0de7ab51234c0de7ab51234c0de. अगर आपको नेटवर्क कुंजी फिर से देखनी है, तो एफ़टीडी कमिश्नर पर यहां दिया गया कमांड चलाएं:
## FTD Commissioner ## > dataset networkkey 1234c0de7ab51234c0de7ab51234c0de Done
इसके बाद, RCP जॉइनर पर, इसकी चालू डेटासेट नेटवर्क कुंजी को FTD कमिश्नर नेटवर्क कुंजी पर सेट करें:
## RCP Joiner ## ---------------- > dataset networkkey 1234c0de7ab51234c0de7ab51234c0de Done > dataset commit active Done
डेटासेट की जांच करके पक्का करें कि यह सही तरीके से सेट है.
## RCP Joiner ## ---------------- > dataset Network Key: 1234c0de7ab51234c0de7ab51234c0de
Thread को खोलें, ताकि आरसीपी जॉइनर, "कोडलैब" में जुड़ सके नेटवर्क. कुछ सेकंड इंतज़ार करें, राज्य, RLOC16 और इसके IPv6 पते देखें:
## RCP Joiner ## ---------------- > ifconfig up Done > thread start Done > state child Done > rloc16 0c01 Done > ipaddr fdc0:de7a:b5c0:0:0:ff:fe00:0c01 # Routing Locator (RLOC) fdc0:de7a:b5c0:0:66bf:99b9:24c0:d55f # Mesh-Local EID (ML-EID) fe80:0:0:0:18e5:29b3:a638:943b # Link-Local Address (LLA) Done
मेश-लोकल आईपीवी6 पते को नोट कर लें (यहां fdc0:de7a:b5c0:0:66bf:99b9:24c0:d55f है). इसे बाद में इस्तेमाल किया जा सकेगा.
एफ़टीडी कमिश्नर की वेबसाइट पर जाएं और राऊटर और चाइल्ड टेबल पर जाकर देखें कि दोनों डिवाइस एक ही नेटवर्क से कनेक्ट हैं या नहीं. आरसीपी जॉइनर की पहचान करने के लिए, RLOC16 का इस्तेमाल करें.
## FTD Commissioner ## ---------------------- > router table | ID | RLOC16 | Next Hop | Path Cost | LQ In | LQ Out | Age | Extended MAC | +----+--------+----------+-----------+-------+--------+-----+------------------+ | 3 | 0x0c00 | 3 | 0 | 0 | 0 | 35 | 1ed687a9cb9d4b1d | Done > child table | ID | RLOC16 | Timeout | Age | LQ In | C_VN |R|S|D|VER| Extended MAC | +-----+--------+------------+------------+-------+------+-+-+-+---+------------------+ | 1 | 0x0c01 | 240 | 25 | 3 | 89 |1|1|1| 2| 1ae529b3a638943b | Done
कनेक्टिविटी की पुष्टि करने के लिए, आरसीपी जॉइनर का मेश-लोकल पता (आरसीपी जॉइनर के ipaddr आउटपुट से मिला मेश-लोकल पता) पिंग करें:
## FTD Commissioner ## ---------------------- > ping fdc0:de7a:b5c0:0:66bf:99b9:24c0:d55f > 8 bytes from fdc0:de7a:b5c0:0:66bf:99b9:24c0:d55f: icmp_seq=1 hlim=64 time=40ms
अब हमारे पास दो नोड वाला Thread नेटवर्क है. इसे इस टोपोलॉजी डायग्राम में दिखाया गया है:
टोपोलॉजी डायग्राम
कोडलैब के अन्य हिस्सों में काम करने पर, नेटवर्क की स्थिति में बदलाव होने पर, हम Thread टोपोलॉजी का नया डायग्राम दिखाएंगे. नोड की भूमिकाओं को इस तरह से दिखाया जाता है:
राऊटर हमेशा पेंटागन होते हैं और एंड डिवाइस हमेशा सर्कल होते हैं. हर नोड की संख्या, सीएलआई आउटपुट में दिखाए गए राऊटर आईडी या चाइल्ड आईडी को दिखाती है. यह आईडी, हर नोड की मौजूदा भूमिका और स्थिति पर निर्भर करता है.
9. FTD जॉइनर को कमीशन दें
अब तीसरे Thread डिवाइस को "कोडलैब" में जोड़ें नेटवर्क. इस बार हम ज़्यादा सुरक्षित इन-बैंड कमीशनिंग प्रोसेस का इस्तेमाल करेंगे और सिर्फ़ FTD जॉइनर को इसमें शामिल होने की अनुमति देंगे.
एफ़टीडी जॉइनर पर जाकर, eui64 हासिल करें, ताकि एफ़टीडी कमिश्नर इसकी पहचान कर सके:
## FTD Joiner ## ---------------- > eui64 2f57d222545271f1 Done
एफ़टीडी कमिश्नर से अपनी सदस्यता शुरू करें. इसके बाद, उस डिवाइस का eui64 बताएं जो जॉइन करने वाले के क्रेडेंशियल के साथ-साथ शामिल हो सकता है. जैसे, J01NME. जॉइनर क्रेडेंशियल, डिवाइस के हिसाब से बनी एक स्ट्रिंग है. इसमें अंग्रेज़ी के बड़े अक्षर वाले सभी वर्ण, यानी 0-9 और A-Y शामिल होते हैं. इनमें पढ़ने के लिहाज़ से I, O, Q, और Z शामिल नहीं होते. इसमें 6 से 32 वर्ण होते हैं.
## FTD Commissioner ## ---------------------- > commissioner start Done > commissioner joiner add 2f57d222545271f1 J01NME Done
FTD जॉइनर पर स्विच करें. एफ़टीडी कमिश्नर पर सेट अप किए गए जॉइनर क्रेडेंशियल की मदद से, जॉइनर की भूमिका शुरू करें:
## FTD Joiner ## ---------------- > ifconfig up Done > joiner start J01NME Done
एक मिनट के अंदर, आपको पुष्टि होने की पुष्टि करने वाला मैसेज मिलेगा:
## FTD Joiner ## ---------------- > Join success
Thread को खोलें, ताकि FTD जॉइनर, "कोडलैब" में जुड़ सके पर जाएं और तुरंत राज्य और RLOC16 की जाँच करें:
## FTD Joiner ## ---------------- > thread start Done > state child Done > rloc16 0c02 Done
डिवाइस के आईपीवी6 पतों की जांच करें. ध्यान दें कि कोई ALOC नहीं है. ऐसा इसलिए होता है, क्योंकि यह डिवाइस न तो लीडर है और न ही इस पर Anycast की ऐसी भूमिका है जिसके लिए ALOC की ज़रूरत होती है.
## FTD Joiner ## ---------------- > ipaddr fdc0:de7a:b5c0:0:0:ff:fe00:c02 # Routing Locator (RLOC) fdc0:de7a:b5c0:0:3e2e:66e:9d41:ebcd # Mesh-Local EID (ML-EID) fe80:0:0:0:e4cd:d2d9:3249:a243 # Link-Local Address (LLA)
तुरंत एफ़टीडी कमिश्नर पर जाएं और राऊटर और चाइल्ड टेबल की जांच करके, पुष्टि करें कि "कोडलैब" में तीन डिवाइस मौजूद हैं या नहीं नेटवर्क:
## FTD Commissioner ## ---------------------- > router table | ID | RLOC16 | Next Hop | Path Cost | LQ In | LQ Out | Age | Extended MAC | +----+--------+----------+-----------+-------+--------+-----+------------------+ | 3 | 0x0c00 | 3 | 0 | 0 | 0 | 50 | 1ed687a9cb9d4b1d | > child table | ID | RLOC16 | Timeout | Age | LQ In | C_VN |R|S|D|N| Extended MAC | +-----+--------+------------+------------+-------+------+-+-+-+-+------------------+ | 1 | 0x0c01 | 240 | 25 | 3 | 89 |1|1|1|1| 1ae529b3a638943b | | 2 | 0x0c02 | 240 | 15 | 3 | 44 |1|1|1|1| e6cdd2d93249a243 | Done
RLOC16 के आधार पर, FTD जॉइनर ने एंड डिवाइस (बच्चे) के तौर पर नेटवर्क से अटैच किया है. यहां हमारी अपडेट की गई टोपोलॉजी दी गई है:
10. थ्रेड इस्तेमाल में है
इस कोडलैब में मौजूद Thread डिवाइस एक खास तरह का फ़ुल थ्रेड डिवाइस (एफ़टीडी) होते हैं. इन्हें राऊटर योग्य एंड डिवाइस (REED) कहा जाता है. इसका मतलब है कि वे राऊटर या एंड डिवाइस के तौर पर काम कर सकते हैं. साथ ही, असली डिवाइस से राऊटर तक का प्रचार कर सकते हैं.
Thread में 32 राऊटर तक के साथ काम करने की सुविधा होती है. हालांकि, इसमें राऊटर की संख्या 16 से 23 के बीच रखने की कोशिश की जाती है. अगर कोई REED किसी एंड डिवाइस (बच्चा) के तौर पर जुड़ जाता है और राऊटर की संख्या 16 से कम है, तो दो मिनट के अंदर किसी भी समयावधि के बाद वह अपने-आप राऊटर में अपना नाम प्रमोट कर देगा.
अगर एफ़टीडी जॉइनर जोड़ने के बाद, आपके Thread नेटवर्क में दो बच्चे हुए थे, तो कम से कम दो मिनट इंतज़ार करें. इसके बाद, एफ़टीडी कमिश्नर की वेबसाइट पर जाकर राऊटर और चाइल्ड टेबल को फिर से देखें:
## FTD Commissioner ## ---------------------- > router table | ID | RLOC16 | Next Hop | Path Cost | LQ In | LQ Out | Age | Extended MAC | +----+--------+----------+-----------+-------+--------+-----+------------------+ | 3 | 0x0c00 | 3 | 0 | 0 | 0 | 50 | 1ed687a9cb9d4b1d | | 46 | 0xb800 | 63 | 0 | 3 | 3 | 1 | e6cdd2d93249a243 | > child table | ID | RLOC16 | Timeout | Age | LQ In | C_VN |R|S|D|N| Extended MAC | +-----+--------+------------+------------+-------+------+-+-+-+-+------------------+ | 1 | 0x0c01 | 240 | 61 | 3 | 89 |1|1|1|1| 1ae529b3a638943b | Done
FTD जॉइनर (एक्सटेंडेड MAC = e6cdd2d93249a243) ने खुद को राऊटर के तौर पर प्रमोट किया है. ध्यान दें कि RLOC16 अलग है (0c02 के बजाय b800). ऐसा इसलिए होता है, क्योंकि RLOC16, किसी डिवाइस के राऊटर आईडी और चाइल्ड आईडी पर आधारित होता है. जब डिवाइस को एंड डिवाइस से राऊटर में बदला जाता है, तब इसके राऊटर आईडी और चाइल्ड आईडी की वैल्यू भी बदल जाती है. इसी तरह, RLOC16 की भी वैल्यू बदल जाती है.
FTD जॉइनर पर, नए राज्य और RLOC16 की पुष्टि करें:
## FTD Joiner ## ---------------- > state router Done > rloc16 b800 Done
FTD जॉइनर को डाउनग्रेड करना
इस व्यवहार की जांच करने के लिए, 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 के आरएलओसी वाले राऊटर में स्विच हो जाएगा.
लीडर को हटाएं
सभी थ्रेड राऊटर में लीडर खुद चुना जाता है. इसका मतलब है कि अगर मौजूदा लीडर को Thread नेटवर्क से हटाया जाता है, तो अन्य राऊटर में से कोई एक नया लीडर बन जाएगा.
FTD कमिश्नर पर, Thread को Thread नेटवर्क से हटाने के लिए इसे बंद करें:
## FTD Commissioner ## ---------------------- > thread stop Done > ifconfig down Done
दो मिनट में, FTD जॉइनर Thread का नया लीडर बन जाता है. इसकी पुष्टि करने के लिए, एफ़टीडी जॉइनर के राज्य और आईपीवी6 पते देखें:
## FTD Joiner ## ---------------- > state leader Done > ipaddr fdc0:de7a:b5c0:0:0:ff:fe00:fc00 # Now it has the Leader ALOC! fdc0:de7a:b5c0:0:0:ff:fe00:b800 fdc0:de7a:b5c0:0:3e2e:66e:9d41:ebcd fe80:0:0:0:e4cd:d2d9:3249:a243 Done
चाइल्ड टेबल देखें. ध्यान दें कि एक नया RLOC16 मौजूद है. यह आरसीपी जॉइनर है, जैसा कि इसके आईडी और एक्सटेंडेड MAC से पता चलता है. Thread नेटवर्क को एक साथ रखने के लिए, इसने पैरंट राऊटर को एफ़टीडी कमिश्नर से बदलकर एफ़टीडी जॉइनर बना दिया है. इसकी वजह से, आरसीपी जॉइनर के लिए एक नया RLOC16 बन जाता है. ऐसा इसलिए होता है, क्योंकि इसका राऊटर आईडी बदलकर 3 से 46 हो जाता है.
## FTD Joiner ## ---------------- > child table | ID | RLOC16 | Timeout | Age | LQ In | C_VN |R|S|D|N| Extended MAC | +-----+--------+------------+------------+-------+------+-+-+-+-+------------------+ | 1 | 0xb801 | 240 | 27 | 3 | 145 |1|1|1|1| 1ae529b3a638943b | Done
एफ़टीडी जॉइनर से बच्चे के तौर पर, आरसीपी जॉइनर को अटैच करने के लिए, आपको कुछ मिनट इंतज़ार करना पड़ सकता है. राज्य और RLOC16 की जांच करके पुष्टि करें कि:
## RCP Joiner ## -------------- > state child > rloc16 b801
एफ़टीडी कमिश्नर को फिर से अटैच करें
दो नोड वाला Thread नेटवर्क ज़्यादा मज़ेदार नहीं होता है. आइए, एफ़टीडी कमिश्नर को फिर से ऑनलाइन प्लैटफ़ॉर्म पर लाते हैं.
FTD कमिश्नर पर, Thread को रीस्टार्ट करें:
## FTD Commissioner ## ---------------------- > ifconfig up Done > thread start Done
दो मिनट में, यह अपने-आप "कोडलैब" से फिर से जुड़ जाता है एक एंड डिवाइस के तौर पर नेटवर्क बनाता है और फिर उसका प्रमोशन राऊटर में करता है.
## FTD Commissioner ## ---------------------- > state router Done
इनकी पुष्टि करने के लिए, FTD जॉइनर पर राऊटर और चाइल्ड टेबल देखें:
## FTD Joiner ## ---------------- > router table | ID | RLOC16 | Next Hop | Path Cost | LQ In | LQ Out | Age | Extended MAC | +----+--------+----------+-----------+-------+--------+-----+------------------+ | 3 | 0x0c00 | 63 | 0 | 3 | 3 | 0 | 1ed687a9cb9d4b1d | | 46 | 0xb800 | 46 | 0 | 0 | 0 | 15 | e6cdd2d93249a243 | > child table | ID | RLOC16 | Timeout | Age | LQ In | C_VN |R|S|D|N| Extended MAC | +-----+--------+------------+------------+-------+------+-+-+-+-+------------------+ | 1 | 0xb801 | 240 | 184 | 3 | 145 |1|1|1|1| 1ae529b3a638943b | Done
हमारे Thread नेटवर्क में फिर से तीन नोड होते हैं.
11. समस्या का हल
अलग-अलग टर्मिनल या स्क्रीन विंडो पर, एक से ज़्यादा डिवाइसों के साथ Thread नेटवर्क को मैनेज करना मुश्किल हो सकता है. "रीसेट करने" के लिए इन सलाहों का इस्तेमाल करें नेटवर्क या आपके फ़ाइल फ़ोल्डर की स्थिति.
स्क्रीन करें
अगर आप कभी भी अपने कॉन्फ़िगरेशन (बहुत ज़्यादा स्क्रीन विंडो या स्क्रीन की स्क्रीन) में खो जाएं, तो स्क्रीन विंडो को Ctrl+a → k के साथ तब तक बंद करते रहें, जब तक कि कोई मौजूद न हो और screen -ls कमांड लाइन आउटपुट के रूप में No Sockets found नहीं देता. इसके बाद, हर डिवाइस के लिए स्क्रीन विंडो फिर से बनाएं. स्क्रीन बंद होने के बाद भी, डिवाइस की स्थिति बनी रहती है.
थ्रेड नोड
अगर Thread नेटवर्क टोपोलॉजी की जानकारी इस कोडलैब में दी गई जानकारी के हिसाब से नहीं है या नोड किसी वजह से डिसकनेक्ट हो जाते हैं (ऐसा शायद इसलिए होता है, क्योंकि उन्हें चलाने वाली Linux मशीन स्लीप मोड में है), तो Thread को बंद करना, नेटवर्क क्रेडेंशियल को हटाना, और फिर Thread नेटवर्क बनाना चरण से फिर से शुरू करना सबसे अच्छा है.
एफ़टीडी रीसेट करने के लिए:
## FTD Commissioner or FTD Joiner ## ------------------------------------ > thread stop Done > ifconfig down Done > factoryreset Done
आरसीपी को ot-ctl के ज़रिए इसी तरह रीसेट किया जा सकता है:
## RCP Joiner ## ---------------- > thread stop Done > ifconfig down Done > factoryreset Done
12. मल्टीकास्ट का इस्तेमाल करना
मल्टीकास्ट का इस्तेमाल, एक साथ कई डिवाइसों को जानकारी देने के लिए किया जाता है. Thread नेटवर्क में, अलग-अलग ग्रुप के साथ मल्टीकास्ट इस्तेमाल करने के लिए कुछ पते रिज़र्व किए जाते हैं. हालांकि, यह इस पर निर्भर करता है कि स्कोप का इस्तेमाल किया गया है या नहीं.
IPv6 पता | स्कोप | डिलीवरी की जगह |
| लिंक-लोकल | सभी FTD और MED |
| लिंक-लोकल | सभी FTD और बॉर्डर राऊटर |
| मेश-लोकल | सभी FTD और MED |
| मेश-लोकल | सभी FTD और बॉर्डर राऊटर |
हम इस कोडलैब में बॉर्डर राऊटर का इस्तेमाल नहीं कर रहे हैं. इसलिए, आइए दो एफ़टीडी और एमईडी मल्टीकास्ट पतों के बारे में बात करते हैं.
लिंक-लोकल
लिंक-लोकल स्कोप में Thread नेटवर्क के वे सभी इंटरफ़ेस शामिल होते हैं जिन्हें एक रेडियो ट्रांसमिशन या एक "हॉप" से ऐक्सेस किया जा सकता है. नेटवर्क टोपोलॉजी से पता चलता है कि ff02::1 मल्टीकास्ट पते के लिए पिंग किए जाने पर कौनसे डिवाइस जवाब देते हैं.
एफ़टीडी कमिश्नर से ff02::1 की पिंग करें:
## FTD Commissioner ## ---------------------- > ping ff02::1 > 8 bytes from fe80:0:0:0:e4cd:d2d9:3249:a243: icmp_seq=2 hlim=64 time=9ms
इस नेटवर्क में दो अन्य डिवाइस (एफ़टीडी जॉइनर और आरसीपी जॉइनर) हैं. हालांकि, एफ़टीडी कमिश्नर को एफ़टीडी जॉइनर के लिंक-लोकल पते (एलएलए) से सिर्फ़ एक जवाब मिला है. इसका मतलब है कि एफ़टीडी जॉइनर ही ऐसा डिवाइस है जिस पर एफ़टीडी कमिश्नर एक ही हॉप करके पहुंच सकता है.
अब 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 से खत्म होने वाला), आरसीपी जॉइनर का एलएलए है.
इसका मतलब है कि एफ़टीडी जॉइनर, एफ़टीडी कमिश्नर और आरसीपी जॉइनर, दोनों से सीधे तौर पर जुड़ा है. इससे हमारे टोपोलॉजी की पुष्टि होती है.
मेश-लोकल
मेश-लोकल स्कोप में सभी Thread इंटरफ़ेस शामिल हैं. इन इंटरफ़ेस को एक ही Thread नेटवर्क पर ऐक्सेस किया जा सकता है. आइए, ff03::1 मल्टीकास्ट पते के लिए पिंग के जवाब देखते हैं.
एफ़टीडी कमिश्नर से ff03::1 की पिंग करें:
## FTD Commissioner ## ---------------------- > ping ff03::1 > 8 bytes from fdc0:de7a:b5c0:0:0:ff:fe00:b800: icmp_seq=3 hlim=64 time=9ms 8 bytes from fdc0:de7a:b5c0:0:66bf:99b9:24c0:d55f: icmp_seq=3 hlim=64 time=68ms
इस बार एफ़टीडी कमिश्नर को दो जवाब मिले. एक जवाब, एफ़टीडी जॉइनर रूटिंग लोकेटर (आरएलओसी, जिसके आखिर में b800 है) से और दूसरा आरसीपी जॉइनर के मेश-लोकल ईआईडी (एमएल-ईआईडी, जो d55f पर खत्म होता है) से. ऐसा इसलिए, क्योंकि मेश-लोकल स्कोप में पूरा Thread नेटवर्क शामिल है. डिवाइस चाहे कहीं भी हो, ff03::1 वाले पते से उसकी सदस्यता ली जाएगी.
इसी व्यवहार की पुष्टि करने के लिए, एफ़टीडी जॉइनर से 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
दोनों पिंग आउटपुट में, आरसीपी जॉइनर के लिए जवाब देने में लगने वाला समय नोट करें. FTD जॉइनर (23 मि॰से॰) तक पहुंचने के मुकाबले, आरसीपी जॉइनर को FTD कमिश्नर (68 मि॰से॰) तक पहुंचने में ज़्यादा समय लगा. ऐसा इसलिए, क्योंकि FTD जॉइनर के लिए एक हॉप की तुलना में, एफ़टीडी कमिश्नर तक पहुंचने के लिए दो बार छलांग लगानी होती है.
आपने यह भी देखा होगा कि मेश-लोकल मल्टीकास्ट पिंग ने सिर्फ़ दो एफ़टीडी के लिए आरएलओसी के साथ जवाब दिया, न कि आरसीपी जॉइनर के लिए. ऐसा इसलिए है, क्योंकि एफ़टीडी नेटवर्क में मौजूद राऊटर हैं, जबकि आरसीपी एक एंड डिवाइस है.
इसकी पुष्टि करने के लिए, आरसीपी जॉइनर की स्थिति देखें:
## RCP Joiner ## ---------------- > state child
13. यूडीपी का इस्तेमाल करके मैसेज भेजें
User Datagram प्रोटोकॉल (यूडीपी) एक ऐसी ऐप्लिकेशन सेवा है जो OpenThread मुहैया कराती है, जो एक ट्रांसपोर्ट लेयर प्रोटोकॉल है. OpenThread पर बनाया गया ऐप्लिकेशन, Thread नेटवर्क में नोड के बीच मैसेज को भेजने के लिए, यूडीपी एपीआई का इस्तेमाल कर सकता है. इसके अलावा, वह किसी बाहरी नेटवर्क के अन्य डिवाइसों पर मैसेज पास कर सकता है (जैसे, अगर Thread नेटवर्क में बॉर्डर राऊटर की सुविधा हो, तो इंटरनेट).
UDP सॉकेट, OpenThread CLI के ज़रिए दिखाए जाते हैं. आइए, इसका इस्तेमाल दो FTD के बीच मैसेज भेजने के लिए करते हैं.
एफ़टीडी जॉइनर के लिए, मेश-लोकल ईआईडी पता पाएं. हम इस पते का इस्तेमाल कर रहे हैं, क्योंकि इसे Thread नेटवर्क पर कहीं से भी ऐक्सेस किया जा सकता है.
## FTD Joiner ## ---------------- > ipaddr fdc0:de7a:b5c0:0:0:ff:fe00:fc00 # Leader Anycast Locator (ALOC) fdc0:de7a:b5c0:0:0:ff:fe00:b800 # Routing Locator (RLOC) fe80:0:0:0:e4cd:d2d9:3249:a243 # Link-Local Address (LLA) fdc0:de7a:b5c0:0:3e2e:66e:9d41:ebcd # Mesh-Local EID (ML-EID) Done
यूडीपी को शुरू करें और उसे किसी भी आईपीवी6 पते के सॉकेट से बाइंड करें:
## FTD Joiner ## ---------------- > udp open Done > udp bind :: 1212
FTD कमिश्नर पर स्विच करें, UDP शुरू करें, और FTD जॉइनर पर आपके सेट किए गए सॉकेट से कनेक्ट करें. इसके लिए, इसके ML-EID का इस्तेमाल करें:
## FTD Commissioner ## ---------------------- > udp open Done > udp connect fdc0:de7a:b5c0:0:3e2e:66e:9d41:ebcd 1212 Done
यूडीपी कनेक्शन दो नोड के बीच लाइव होना चाहिए. एफ़टीडी कमिश्नर से मैसेज भेजें:
## FTD Commissioner ## ---------------------- > udp send hellothere Done
FTD जॉइनर पर, यूडीपी मैसेज मिल गया है!
## FTD Joiner ## ---------------- > 10 bytes from fdc0:de7a:b5c0:0:0:ff:fe00:c00 49153 hellothere
14. बधाई हो!
आपने Thread नेटवर्क बना लिया है!
अब आपको पता है:
- Thread डिवाइस के टाइप, रोल, और स्कोप में अंतर
- Thread डिवाइस, नेटवर्क में अपने स्टेटस कैसे मैनेज करते हैं
- यूडीपी का इस्तेमाल करके नोड के बीच आसान मैसेज कैसे पास करें
अगले चरण
इस कोडलैब को बनाने के बाद, ये काम करके देखें:
ot-cli-mtdबाइनरी का इस्तेमाल करके, FTD जॉइनर बोर्ड को MTD के तौर पर फिर से फ़्लैश करें. साथ ही, देखें कि यह कभी भी खुद को राऊटर में अपग्रेड नहीं करता या लीडर बनने की कोशिश नहीं करता- नेटवर्क में और डिवाइस जोड़ें (कोई दूसरा प्लैटफ़ॉर्म आज़माएं!) और राऊटर और चाइल्ड टेबल का इस्तेमाल करके, टोपोलॉजी की जानकारी तैयार करें. साथ ही, मल्टीकास्ट पतों के लिए पिंग भी करें
- एनसीपी को कंट्रोल करने के लिए, pyspinel का इस्तेमाल करें
- OpenThread Border राऊटर का इस्तेमाल करके, एनसीपी को बॉर्डर राऊटर में बदलें और अपने Thread नेटवर्क को इंटरनेट से कनेक्ट करें
इसके बारे में और पढ़ें
OpenThread के अलग-अलग संसाधनों के लिए, openthread.io और GitHub पर जाएं. इनमें ये संसाधन भी शामिल हैं:
- इस्तेमाल किए जा सकने वाले प्लैटफ़ॉर्म — ऐसे सभी प्लैटफ़ॉर्म खोजें जिन पर OpenThread की सुविधा काम करती हो
- OpenThread बनाएं — OpenThread को बनाने और कॉन्फ़िगर करने के बारे में ज़्यादा जानकारी
- Thread Primer: इसमें इस कोडलैब में दिखाए गए Thread के सभी कॉन्सेप्ट शामिल होते हैं
संदर्भ: