1. परिचय
Google ने OpenThread को रिलीज़ किया है. यह Thread® नेटवर्किंग प्रोटोकॉल का ओपन-सोर्स वर्शन है. Google Nest ने OpenThread को रिलीज़ किया है. इससे Nest प्रॉडक्ट में इस्तेमाल की गई टेक्नोलॉजी, डेवलपर के लिए बड़े पैमाने पर उपलब्ध हो जाएगी. इससे कनेक्टेड होम के लिए प्रॉडक्ट को तेज़ी से डेवलप किया जा सकेगा.
Thread स्पेसिफ़िकेशन, होम ऐप्लिकेशन के लिए डिवाइस-टू-डिवाइस कम्यूनिकेशन प्रोटोकॉल को तय करता है. यह प्रोटोकॉल, IPv6 पर आधारित होता है. साथ ही, यह भरोसेमंद, सुरक्षित, और कम पावर वाला वायरलेस प्रोटोकॉल होता है. OpenThread, Thread की सभी नेटवर्किंग लेयर लागू करता है. इनमें IPv6, 6LoWPAN, IEEE 802.15.4, एमएसी सुरक्षा, मेश लिंक इस्टैब्लिशमेंट, और मेश राउटिंग शामिल हैं.
इस कोडलैब में, आपको असली हार्डवेयर पर OpenThread को प्रोग्राम करने, Thread नेटवर्क बनाने और उसे मैनेज करने, और नोड के बीच मैसेज भेजने का तरीका बताया जाएगा.
आपको क्या सीखने को मिलेगा
- डेवलपमेंट बोर्ड पर OpenThread CLI बाइनरी बनाना और फ़्लैश करना
- Linux मशीन और डेवलपमेंट बोर्ड से मिलकर बना आरसीपी
- OpenThread Daemon और
ot-ctlका इस्तेमाल करके, आरसीपी से कम्यूनिकेट करना - GNU Screen और OpenThread CLI की मदद से, थ्रेड नोड को मैन्युअल तरीके से मैनेज करना
- डिवाइसों को Thread नेटवर्क पर सुरक्षित तरीके से चालू करना
- IPv6 मल्टीकास्ट कैसे काम करता है
- यूडीपी की मदद से, थ्रेड नोड के बीच मैसेज भेजना
आपको किन चीज़ों की ज़रूरत होगी
हार्डवेयर:
- Nordic Semiconductor nRF52840 के तीन डेवलपमेंट बोर्ड
- बोर्ड को कनेक्ट करने के लिए, यूएसबी से माइक्रो-यूएसबी केबल
- कम से कम तीन यूएसबी पोर्ट वाली Linux मशीन
सॉफ़्टवेयर:
- GNU टूलचेन
- Nordic nRF5x कमांड-लाइन टूल
- Segger J-Link सॉफ़्टवेयर
- OpenThread
- Git
2. शुरू करना
OpenThread सिम्युलेशन
शुरू करने से पहले, OpenThread Simulation Codelab को आज़माएं. इससे आपको Thread के बुनियादी कॉन्सेप्ट और OpenThread CLI के बारे में जानकारी मिलेगी.
सीरियल पोर्ट टर्मिनल
आपको टर्मिनल के ज़रिए सीरियल पोर्ट से कनेक्ट करने का तरीका पता होना चाहिए. इस कोडलैब में 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 Command Line Tools की मदद से, OpenThread बाइनरी को nRF52840 बोर्ड पर फ़्लैश किया जा सकता है. अपनी 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 और होस्ट के बीच सीरियल ट्रांसपोर्ट के तौर पर यूएसबी सीडीसी एसीएम का इस्तेमाल किया जा सकता है.
पिछली बिल्ड की रीपो को हमेशा साफ़ करें. इसके लिए, सबसे पहले 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
USB केबल को nRF52840 बोर्ड पर, बाहरी पावर पिन के बगल में मौजूद Micro-USB डीबग पोर्ट से कनेक्ट करें. इसके बाद, इसे Linux मशीन में प्लग करें. nRF52840 बोर्ड पर मौजूद nRF पावर सोर्स स्विच को VDD पर सेट करें. सही तरीके से कनेक्ट होने पर, LED5 चालू हो जाती है.
अगर यह Linux मशीन से अटैच किया गया पहला बोर्ड है, तो यह सीरियल पोर्ट /dev/ttyACM0 के तौर पर दिखता है. सभी nRF52840 बोर्ड, सीरियल पोर्ट आइडेंटिफ़ायर के लिए ttyACM का इस्तेमाल करते हैं.
$ ls /dev/ttyACM* /dev/ttyACM0
आरसीपी के लिए इस्तेमाल किए जा रहे nRF52840 बोर्ड का सीरियल नंबर नोट करें:
nRFx Command Line Tools की जगह पर जाएं और बोर्ड के सीरियल नंबर का इस्तेमाल करके, nRF52840 बोर्ड पर OpenThread RCP हेक्स फ़ाइल फ़्लैश करें. ध्यान दें कि अगर आपने --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 बिल्ड, सीरियल ट्रांसपोर्ट के तौर पर नेटिव USB CDC ACM का इस्तेमाल करने की सुविधा देता है. इसलिए, RCP होस्ट (Linux मशीन) से कम्यूनिकेट करने के लिए, आपको nRF52840 बोर्ड पर nRF USB पोर्ट का इस्तेमाल करना होगा.
यूएसबी केबल के माइक्रो-यूएसबी वाले सिरे को, फ़्लैश किए गए nRF52840 बोर्ड के डीबग पोर्ट से हटाएं. इसके बाद, इसे RESET बटन के बगल में मौजूद माइक्रो-यूएसबी nRF USB पोर्ट से फिर से कनेक्ट करें. nRF पावर सोर्स स्विच को USB पर सेट करें.
OpenThread डीमन शुरू करें
आरसीपी डिज़ाइन में, Thread डिवाइस से कम्यूनिकेट करने और उसे मैनेज करने के लिए, OpenThread Daemon का इस्तेमाल करें. -v वर्बोस फ़्लैग के साथ ot-daemon शुरू करें, ताकि आपको लॉग आउटपुट दिख सके और पुष्टि हो सके कि यह चल रहा है:
$ 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 ऐप्लिकेशन की तरह ही CLI का इस्तेमाल करता है. इसलिए, ot-daemon नोड को उसी तरह से कंट्रोल किया जा सकता है जिस तरह से सिम्युलेट किए गए अन्य Thread डिवाइसों को कंट्रोल किया जाता है.
दूसरी टर्मिनल विंडो में, ot-ctl शुरू करें:
$ sudo ./build/posix/src/posix/ot-ctl >
आपने जिस ot-daemon से शुरुआत की थी उस नोड 2 (आरसीपी नोड) का state देखें:
> state disabled Done
5. एफटीडी सेट अप करना
इस कोडलैब में इस्तेमाल किए गए अन्य दो थ्रेड नोड, स्टैंडर्ड सिस्टम-ऑन-चिप (एसओसी) डिज़ाइन पर आधारित फ़ुल थ्रेड डिवाइस (एफ़टीडी) हैं. एक डिवाइस कमिश्नर के तौर पर काम करता है. यह डिवाइसों को सुरक्षित तरीके से पुष्टि करने और उन्हें नेटवर्क पर चालू करने का काम करता है. दूसरा डिवाइस, जॉइनर के तौर पर काम करता है. कमिश्नर इसकी पुष्टि करके, इसे 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) CLI बाइनरी वाली डायरेक्ट्री पर जाएं और उसे हेक्स फ़ॉर्मैट में बदलें:
$ cd ~/src/ot-nrf528xx/build/bin $ arm-none-eabi-objcopy -O ihex ot-cli-ftd ot-cli-ftd.hex
USB केबल को nRF52840 बोर्ड पर, बाहरी पावर पिन के बगल में मौजूद Micro-USB पोर्ट से कनेक्ट करें. इसके बाद, इसे Linux मशीन में प्लग करें. अगर आरसीपी अब भी Linux मशीन से जुड़ा है, तो यह नया बोर्ड सीरियल पोर्ट /dev/ttyACM1 के तौर पर दिखेगा. सभी nRF52840 बोर्ड, सीरियल पोर्ट आइडेंटिफ़ायर के लिए ttyACM का इस्तेमाल करते हैं.
$ ls /dev/ttyACM* /dev/ttyACM0 /dev/ttyACM1
पहले की तरह, FTD के लिए इस्तेमाल किए जा रहे nRF52840 बोर्ड का सीरियल नंबर नोट करें:
nRFx Command Line Tools की जगह पर जाएं और बोर्ड के सीरियल नंबर का इस्तेमाल करके, 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 बिल्ड, सीरियल ट्रांसपोर्ट के तौर पर नेटिव यूएसबी सीडीसी एसीएम का इस्तेमाल करने की सुविधा देता है. इसलिए, आपको आरसीपी होस्ट (Linux मशीन) से कम्यूनिकेट करने के लिए, nRF52840 बोर्ड पर nRF USB पोर्ट का इस्तेमाल करना होगा.
यूएसबी केबल के माइक्रो-यूएसबी वाले सिरे को, फ़्लैश किए गए nRF52840 बोर्ड के डीबग पोर्ट से हटाएं. इसके बाद, इसे RESET बटन के बगल में मौजूद माइक्रो-यूएसबी nRF USB पोर्ट से फिर से कनेक्ट करें. nRF पावर सोर्स स्विच को USB पर सेट करें.
बिल्ड की पुष्टि करना
टर्मिनल विंडो से GNU Screen का इस्तेमाल करके, OpenThread CLI को ऐक्सेस करें. इससे आपको यह पुष्टि करने में मदद मिलेगी कि बिल्ड सही तरीके से बनाया गया है.
$ screen /dev/ttyACM1
नई विंडो में, कीबोर्ड पर Return बटन को कुछ बार दबाएं, ताकि OpenThread CLI > प्रॉम्प्ट दिखे. IPv6 इंटरफ़ेस खोलें और पतों की जांच करें:
> ifconfig up Done > ipaddr fe80:0:0:0:1cd6:87a9:cb9d:4b1d Done
Ctrl+a का इस्तेमाल करें →
d FTD Commissioner 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 Joiner को सेट अप करना
मौजूदा ot-cli-ftd.hex बिल्ड का इस्तेमाल करके, तीसरे nRF52840 बोर्ड को फ़्लैश करने के लिए, ऊपर दी गई प्रोसेस को दोहराएं. जब यह प्रोसेस पूरी हो जाए, तो nRF यूएसबी पोर्ट का इस्तेमाल करके बोर्ड को पीसी से फिर से कनेक्ट करें. साथ ही, nRF पावर सोर्स स्विच को VDD पर सेट करें.
अगर इस तीसरे बोर्ड को अटैच करते समय, अन्य दो नोड Linux मशीन से अटैच हैं, तो यह सीरियल पोर्ट /dev/ttyACM2 के तौर पर दिखेगा:
$ ls /dev/ttyACM* /dev/ttyACM0 /dev/ttyACM1 /dev/ttyACM2
बोर्ड को "ज्वाइनर" के तौर पर लेबल करें.
स्क्रीन का इस्तेमाल करके पुष्टि करते समय, कमांड लाइन से स्क्रीन का नया इंस्टेंस बनाने के बजाय, मौजूदा इंस्टेंस से फिर से अटैच करें और उसमें एक नई विंडो बनाएं. इस विंडो का इस्तेमाल आपने एफ़टीडी कमिश्नर के लिए किया था:
$ screen -r
Ctrl+a → c दबाकर, स्क्रीन पर नई विंडो बनाएं.
आपको एक नया कमांड लाइन प्रॉम्प्ट दिखेगा. FTD जॉइनर के लिए OpenThread CLI को ऐक्सेस करें:
$ screen /dev/ttyACM2
इस नई विंडो में, कीबोर्ड पर Return बटन को कुछ बार दबाएं, ताकि OpenThread CLI > प्रॉम्प्ट खुल जाए. IPv6 इंटरफ़ेस खोलें और पतों की जांच करें:
> ifconfig up Done > ipaddr fe80:0:0:0:6c1e:87a2:df05:c240 Done
FTD जॉइनर सीएलआई, FTD कमिश्नर की तरह ही स्क्रीन के एक ही इंस्टेंस में है. इसलिए, Ctrl+a → n का इस्तेमाल करके, इनके बीच स्विच किया जा सकता है.
Ctrl+a का इस्तेमाल करें →
d पर टैप करके, स्क्रीन से बाहर निकलें.
6. टर्मिनल विंडो सेटअप करना
आने वाले समय में, आपको Thread की सुविधा वाले डिवाइसों के बीच अक्सर स्विच करना होगा. इसलिए, पक्का करें कि वे सभी डिवाइस चालू हों और आसानी से ऐक्सेस किए जा सकें. अब तक, हमने दो FTD को ऐक्सेस करने के लिए Screen का इस्तेमाल किया है. यह टूल, एक ही टर्मिनल विंडो पर स्प्लिट स्क्रीन की सुविधा भी देता है. इसका इस्तेमाल यह देखने के लिए करें कि एक नोड, दूसरे नोड पर दी गई कमांड पर कैसे प्रतिक्रिया करता है.
आपके पास ये चार विंडो आसानी से उपलब्ध होनी चाहिए:
ot-daemonसेवा / लॉगot-ctlके ज़रिए RCP Joiner- OpenThread CLI के ज़रिए FTD कमिश्नर
- OpenThread CLI की मदद से FTD जॉइनर
अगर आपको अपने टर्मिनल / सीरियल पोर्ट कॉन्फ़िगरेशन या टूल का इस्तेमाल करना है, तो अगले चरण पर जाएं. सभी डिवाइसों के लिए टर्मिनल विंडो को अपने हिसाब से कॉन्फ़िगर करें.
स्क्रीन का इस्तेमाल करना
आसानी से इस्तेमाल करने के लिए, सिर्फ़ एक स्क्रीन सेशन शुरू करें. आपने दोनों FTD सेट अप करते समय, पहले ही एक बना लिया होगा.
स्क्रीन पर मौजूद सभी कमांड, Ctrl+a से शुरू होती हैं.
स्क्रीन के लिए बुनियादी निर्देश:
स्क्रीन सेशन से फिर से अटैच करना (कमांड लाइन से) |
|
स्क्रीन शेयर करने वाले सेशन से बाहर निकलना | Ctrl+a → |
स्क्रीन सेशन में नई विंडो बनाना | Ctrl+a → |
एक ही स्क्रीन सेशन में अलग-अलग विंडो के बीच स्विच करना | Ctrl+a → |
स्क्रीन सेशन में मौजूदा विंडो बंद करना | Ctrl+a → |
स्क्रीन विभाजित करें
स्क्रीन की मदद से, टर्मिनल को कई विंडो में बांटा जा सकता है:
screen में मौजूद निर्देशों को ऐक्सेस करने के लिए, Ctrl+a का इस्तेमाल करें. हर निर्देश, इस ऐक्सेस कुंजी के कॉम्बिनेशन से शुरू होना चाहिए.
अगर आपने Codelab को सही तरीके से फ़ॉलो किया है, तो आपको एक ही स्क्रीन इंस्टेंस पर दो विंडो (FTD Commissioner, FTD Joiner) दिखनी चाहिए. स्क्रीन को दो हिस्सों में बांटने के लिए, पहले अपने मौजूदा स्क्रीन सेशन में जाएं:
$ screen -r
आपके पास FTD डिवाइसों में से कोई एक होना चाहिए. स्क्रीन पर यह तरीका अपनाएं:
- Ctrl+a →
Sदबाकर विंडो को हॉरिज़ॉन्टल तौर पर स्प्लिट करें - Ctrl+a →
Tabदबाकर, कर्सर को नई खाली विंडो पर ले जाएं - Ctrl+a →
nदबाकर, नई विंडो को अगली विंडो पर स्विच करें - अगर यह सबसे ऊपर वाली विंडो के जैसा ही है, तो Ctrl+a →
nदबाकर, दूसरे FTD डिवाइस को देखें
अब दोनों दिख रहे हैं. 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 Screen की क्विक रेफ़रंस गाइड देखें.
7. Thread नेटवर्क बनाना
अब जब आपने सभी टर्मिनल विंडो और स्क्रीन कॉन्फ़िगर कर ली हैं, तो आइए अपना थ्रेड नेटवर्क बनाएं. FTD कमिश्नर पर, नया ऑपरेशनल डेटासेट बनाएं और उसे चालू डेटासेट के तौर पर सेट करें. ऑपरेशनल डेटासेट, बनाए जा रहे Thread नेटवर्क का कॉन्फ़िगरेशन होता है.
## FTD Commissioner ## ---------------------- > dataset init new Done > dataset Active Timestamp: 1 Channel: 11 Channel Mask: 07fff800 Ext PAN ID: c0de7ab5c0de7ab5 Mesh Local Prefix: fdc0:de7a:b5c0/64 Network Key: 1234c0de7ab51234c0de7ab51234c0de Network Name: OpenThread-c0de PAN ID: 0xc0de PSKc: ebb4f2f8a68026fc55bcf3d7be3e6fe4 Security Policy: 0, onrcb Done
नेटवर्क की 1234c0de7ab51234c0de7ab51234c0de को नोट कर लें. इसका इस्तेमाल बाद में किया जाएगा.
इस डेटासेट को चालू डेटासेट के तौर पर सेट करें:
> dataset commit active Done
IPv6 इंटरफ़ेस खोलें:
> ifconfig up Done
थ्रेड शुरू करने के प्रोटोकॉल का ऑपरेशन:
> thread start Done
कुछ देर बाद, डिवाइस की स्थिति देखें. यह लीडर होना चाहिए. आने वाले समय में इस्तेमाल करने के लिए, RLOC16 भी पाएं.
## FTD Commissioner ## ---------------------- > state leader Done > rloc16 0c00 Done
डिवाइस के IPv6 पतों की जांच करें:
## FTD Commissioner ## ---------------------- > ipaddr fdc0:de7a:b5c0:0:0:ff:fe00:fc00 # Leader Anycast Locator (ALOC) fdc0:de7a:b5c0:0:0:ff:fe00:c00 # Routing Locator (RLOC) fdc0:de7a:b5c0:0:6394:5a75:a1ad:e5a # Mesh-Local EID (ML-EID) fe80:0:0:0:1cd6:87a9:cb9d:4b1d # Link-Local Address (LLA)
अब "codelab" नेटवर्क, थ्रेड की सुविधा वाले अन्य डिवाइसों से स्कैन करने पर दिखता है.
आरसीपी जॉइनर पर ot-ctl से:
## RCP Joiner ## ---------------- > scan | PAN | MAC Address | Ch | dBm | LQI | +------+------------------+----+-----+-----+ | c0de | 1ed687a9cb9d4b1d | 11 | -36 | 232 |
FTD Joiner पर OpenThread CLI से:
## FTD Joiner ## ---------------- > scan | PAN | MAC Address | Ch | dBm | LQI | +------+------------------+----+-----+-----+ | c0de | 1ed687a9cb9d4b1d | 11 | -38 | 229 |
अगर आपको सूची में "codelab" नेटवर्क नहीं दिखता, तो फिर से स्कैन करें.
8. RCP Joiner को जोड़ना
नेटवर्क पर थ्रेड कमीशनिंग चालू नहीं है. इसका मतलब है कि हमें अभी-अभी बनाए गए थ्रेड नेटवर्क में आरसीपी जॉइनर को जोड़ना होगा. इसके लिए, हमें आउट-ऑफ़-बैंड कमीशनिंग प्रोसेस का इस्तेमाल करना होगा.
FTD कमिश्नर पर, हमने नेटवर्क कुंजी नोट की. उदाहरण के लिए, 1234c0de7ab51234c0de7ab51234c0de. अगर आपको नेटवर्क कुंजी को फिर से देखना है, तो FTD कमिश्नर पर यह कमांड चलाएं:
## 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) को नोट करें. इसका इस्तेमाल बाद में किया जाएगा.
FTD Commissioner पर वापस जाएं. इसके बाद, राउटर और चाइल्ड टेबल देखें. इससे पुष्टि करें कि दोनों डिवाइस एक ही नेटवर्क का हिस्सा हैं. आरसीपी जॉइनर की पहचान करने के लिए, 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 Joiner को कमीशन करना
अब "codelab" नेटवर्क में तीसरा Thread डिवाइस जोड़ते हैं. इस बार, हम इन-बैंड कमीशनिंग की ज़्यादा सुरक्षित प्रोसेस का इस्तेमाल करेंगे. साथ ही, सिर्फ़ FTD Joiner को शामिल होने की अनुमति देंगे.
FTD Joiner पर, eui64 पाएं, ताकि FTD Commissioner इसकी पहचान कर सके:
## 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 Joiner पर स्विच करें. FTD कमिश्नर पर अभी-अभी सेट अप की गई जॉइनर क्रेडेंशियल का इस्तेमाल करके, जॉइनर की भूमिका शुरू करें:
## FTD Joiner ## ---------------- > ifconfig up Done > joiner start J01NME Done
एक मिनट के अंदर, आपको पुष्टि हो जाने की सूचना मिलती है:
## FTD Joiner ## ---------------- > Join success
थ्रेड को चालू करें, ताकि FTD जॉइनर "codelab" नेटवर्क से जुड़ जाए. इसके बाद, तुरंत स्थिति और RLOC16 की जांच करें:
## FTD Joiner ## ---------------- > thread start Done > state child Done > rloc16 0c02 Done
डिवाइस के आईपीवी6 पतों की जांच करें. ध्यान दें कि इसमें कोई एएलओसी नहीं है. ऐसा इसलिए है, क्योंकि यह डिवाइस लीडर नहीं है. साथ ही, इसके पास एनीकास्ट से जुड़ी कोई ऐसी भूमिका भी नहीं है जिसके लिए एएलओसी की ज़रूरत हो.
## 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 पर स्विच करें. इसके बाद, राऊटर और चाइल्ड टेबल देखें. इससे पुष्टि करें कि "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 के आधार पर, FTD जॉइनर नेटवर्क से एंड डिवाइस (चाइल्ड) के तौर पर जुड़ा है. यहां हमारी अपडेट की गई टोपोलॉजी दी गई है:
10. फ़िलहाल दिखाई जा रही स्टोरीज़
इस कोडलैब में इस्तेमाल किए गए थ्रेड डिवाइस, एक खास तरह के फ़ुल थ्रेड डिवाइस (एफ़टीडी) होते हैं. इन्हें राउटर के तौर पर काम करने की सुविधा वाले एंड डिवाइस (आरईईडी) कहा जाता है. इसका मतलब है कि वे राऊटर या एंड डिवाइस के तौर पर काम कर सकते हैं. साथ ही, वे खुद को एंड डिवाइस से राऊटर में प्रमोट कर सकते हैं.
Thread नेटवर्क में ज़्यादा से ज़्यादा 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 (Extended MAC = e6cdd2d93249a243) ने खुद को राऊटर के तौर पर प्रमोट किया है. ध्यान दें कि RLOC16 अलग है (b800 के बजाय 0c02). ऐसा इसलिए है, क्योंकि RLOC16, डिवाइस के राउटर आईडी और चाइल्ड आईडी पर आधारित होता है. जब यह एंड डिवाइस से राउटर में बदलता है, तो इसके राउटर आईडी और चाइल्ड आईडी की वैल्यू बदल जाती हैं. साथ ही, RLOC16 भी बदल जाता है.
FTD Joiner पर, नई स्थिति और RLOC16 की पुष्टि करें:
## FTD Joiner ## ---------------- > state router Done > rloc16 b800 Done
FTD Joiner को डाउनग्रेड करना
इस व्यवहार की जांच करने के लिए, FTD Joiner को मैन्युअल तरीके से राउटर से वापस एंड डिवाइस पर डाउनग्रेड करें. खाते को बच्चे के तौर पर सेट करें और RLOC16 की जांच करें:
## FTD Joiner ## ---------------- > state child Done > rloc16 0c03 Done
FTD Commissioner पर वापस जाने पर, FTD Joiner अब चाइल्ड टेबल (आईडी = 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 वाले राउटर पर वापस स्विच हो जाएगा.
लीडर को हटाना
लीडर को सभी थ्रेड राउटर में से चुना जाता है. इसका मतलब है कि अगर मौजूदा लीडर को थ्रेड नेटवर्क से हटा दिया जाता है, तो अन्य राऊटर में से कोई एक नया लीडर बन जाएगा.
Thread नेटवर्क से हटाने के लिए, FTD कमिश्नर पर जाकर Thread बंद करें:
## FTD Commissioner ## ---------------------- > thread stop Done > ifconfig down Done
दो मिनट के अंदर, FTD Joiner नया थ्रेड लीडर बन जाता है. FTD Joiner की स्थिति और IPv6 पतों की जांच करके पुष्टि करें कि:
## FTD Joiner ## ---------------- > state leader Done > ipaddr fdc0:de7a:b5c0:0:0:ff:fe00:fc00 # Now it has the Leader ALOC! fdc0:de7a:b5c0:0:0:ff:fe00:b800 fdc0:de7a:b5c0:0:3e2e:66e:9d41:ebcd fe80:0:0:0:e4cd:d2d9:3249:a243 Done
चाइल्ड टेबल देखें. ध्यान दें कि नया RLOC16 मौजूद है. यह आरसीपी जॉइनर है. इसकी पहचान इसके आईडी और एक्सटेंडेड मैक से होती है. थ्रेड नेटवर्क को एक साथ रखने के लिए, इसने पैरंट राउटर बदले हैं. अब यह एफटीडी कमिश्नर के बजाय एफटीडी जॉइनर का इस्तेमाल कर रहा है. इस वजह से, आरसीपी जॉइनर के लिए नया 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
FTD कमिशनर को फिर से अटैच करना
दो नोड वाले Thread नेटवर्क का इस्तेमाल करने में ज़्यादा मज़ा नहीं आता. चलिए, FTD कमिश्नर को फिर से ऑनलाइन लाते हैं.
FTD कमिश्नर पर, थ्रेड को रीस्टार्ट करें:
## FTD Commissioner ## ---------------------- > ifconfig up Done > thread start Done
दो मिनट के अंदर, यह एंड डिवाइस के तौर पर "codelab" नेटवर्क से अपने-आप फिर से जुड़ जाता है. इसके बाद, यह खुद को राउटर के तौर पर प्रमोट करता है.
## FTD Commissioner ## ---------------------- > state router Done
पुष्टि करने के लिए, FTD Joiner पर राऊटर और चाइल्ड टेबल देखें:
## 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. समस्या का हल
अलग-अलग टर्मिनल या स्क्रीन विंडो पर मौजूद कई डिवाइसों के साथ थ्रेड नेटवर्क को मैनेज करना मुश्किल हो सकता है. अगर आपको समस्याएं आ रही हैं, तो नेटवर्क या अपने Workspace की स्थिति को "रीसेट" करने के लिए, इन सुझावों का इस्तेमाल करें.
स्क्रीन
अगर आपको कॉन्फ़िगरेशन में कोई समस्या आती है (बहुत ज़्यादा स्क्रीन विंडो या स्क्रीन के अंदर स्क्रीन), तो Ctrl+a → k दबाकर स्क्रीन विंडो बंद करें. ऐसा तब तक करें, जब तक कोई भी स्क्रीन विंडो न बची हो और कमांड लाइन पर screen -ls आउटपुट No Sockets found न दिखे. इसके बाद, हर डिवाइस के लिए स्क्रीन विंडो फिर से बनाएं. स्क्रीन बंद होने पर भी डिवाइस की स्थितियां बनी रहती हैं.
Thread नोड
अगर थ्रेड नेटवर्क टोपोलॉजी, इस कोडलैब में बताई गई टोपोलॉजी के मुताबिक नहीं है या नोड किसी वजह से डिसकनेक्ट हो जाते हैं (ऐसा शायद इसलिए होता है, क्योंकि उन्हें चलाने वाला Linux मशीन स्लीप मोड में चला गया है), तो थ्रेड को बंद करना, नेटवर्क क्रेडेंशियल मिटाना, और थ्रेड नेटवर्क बनाएं चरण से फिर से शुरू करना सबसे अच्छा है.
FTD को रीसेट करने के लिए:
## FTD Commissioner or FTD Joiner ## ------------------------------------ > thread stop Done > ifconfig down Done > factoryreset Done
ot-ctl की मदद से, आरसीपी को उसी तरीके से रीसेट किया जा सकता है:
## RCP Joiner ## ---------------- > thread stop Done > ifconfig down Done > factoryreset Done
12. मल्टीकास्ट का इस्तेमाल करना
मल्टीकास्ट का इस्तेमाल, एक साथ कई डिवाइसों के ग्रुप को जानकारी भेजने के लिए किया जाता है. थ्रेड नेटवर्क में, स्कोप के आधार पर डिवाइसों के अलग-अलग ग्रुप के साथ मल्टीकास्ट के लिए कुछ पते रिज़र्व किए जाते हैं.
IPv6 पता | स्कोप | डिलीवर किया गया |
| लिंक-लोकल | सभी एफ़टीडी और एमईडी |
| लिंक-लोकल | सभी FTD और बॉर्डर राऊटर |
| Mesh-Local | सभी एफ़टीडी और एमईडी |
| Mesh-Local | सभी FTD और बॉर्डर राऊटर |
इस Codelab में बॉर्डर राउटर का इस्तेमाल नहीं किया जा रहा है. इसलिए, आइए दो FTD और MED मल्टीकास्ट पतों पर फ़ोकस करें.
लिंक-लोकल
लिंक-लोकल स्कोप में, वे सभी 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 Joiner और RCP Joiner) हैं, लेकिन FTD Commissioner को सिर्फ़ एक जवाब मिला है. यह जवाब, FTD Joiner के लिंक-लोकल पते (एलएलए) से मिला है. इसका मतलब है कि FTD जॉइनर ही ऐसा डिवाइस है जिस तक FTD कमिश्नर एक हॉप में पहुंच सकता है.
अब FTD Joiner से 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 कमिशनर का एलएलए है और दूसरा पता (943b पर खत्म होने वाला) आरसीपी जॉइनर का एलएलए है.
इसका मतलब है कि FTD Joiner, FTD Commissioner और RCP Joiner, दोनों से सीधे तौर पर कनेक्ट है. इससे हमारी टोपोलॉजी की पुष्टि होती है.
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
इस बार, FTD कमिश्नर को दो जवाब मिले. एक जवाब, FTD जॉइनर के राउटिंग लोकेटर (आरएलओसी, b800 पर खत्म होता है) से मिला और दूसरा जवाब, RCP जॉइनर के मेश-लोकल ईआईडी (एमएल-ईआईडी, d55f पर खत्म होता है) से मिला. ऐसा इसलिए हुआ, क्योंकि मेश-लोकल स्कोप में पूरा थ्रेड नेटवर्क शामिल होता है. नेटवर्क में डिवाइस कहीं भी हो, उसे ff03::1 पते पर सब्सक्राइब किया जाएगा.
इसकी पुष्टि करने के लिए, FTD Joiner से ff03::1 करें:
## FTD Joiner ## ---------------- > ping ff03::1 > 8 bytes from fdc0:de7a:b5c0:0:0:ff:fe00:c00: icmp_seq=2 hlim=64 time=11ms 8 bytes from fdc0:de7a:b5c0:0:66bf:99b9:24c0:d55f: icmp_seq=2 hlim=64 time=23ms
दोनों पिंग आउटपुट में, आरसीपी जॉइनर के जवाब देने के समय को नोट करें. आरसीपी जॉइनर को एफटीडी कमिश्नर तक पहुंचने में, एफटीडी जॉइनर तक पहुंचने में लगने वाले समय (23 मि॰से॰) से ज़्यादा समय (68 मि॰से॰) लगा. ऐसा इसलिए है, क्योंकि इसे एफ़टीडी कमिश्नर तक पहुंचने के लिए दो हॉप करने पड़ते हैं. वहीं, एफ़टीडी जॉइनर को सिर्फ़ एक हॉप करना पड़ता है.
आपने यह भी देखा होगा कि मेश-लोकल मल्टीकास्ट पिंग ने सिर्फ़ दो FTD के लिए RLOC के साथ जवाब दिया है, न कि RCP Joiner के लिए. ऐसा इसलिए है, क्योंकि FTD नेटवर्क में राउटर होते हैं, जबकि RCP एक एंड डिवाइस होता है.
पुष्टि करने के लिए, RCP Joiner का स्टेटस देखें:
## RCP Joiner ## ---------------- > state child
13. यूडीपी का इस्तेमाल करके मैसेज भेजना
OpenThread, ऐप्लिकेशन की कई सेवाएं उपलब्ध कराता है. इनमें से एक सेवा, यूज़र डेटाग्राम प्रोटोकॉल (यूडीपी) है. यह ट्रांसपोर्ट लेयर प्रोटोकॉल है. OpenThread पर बनाया गया कोई ऐप्लिकेशन, UDP API का इस्तेमाल करके Thread नेटवर्क में मौजूद नोड के बीच मैसेज भेज सकता है. इसके अलावा, इसका इस्तेमाल बाहरी नेटवर्क (जैसे कि इंटरनेट, अगर Thread नेटवर्क में बॉर्डर राउटर मौजूद है) में मौजूद अन्य डिवाइसों के बीच मैसेज भेजने के लिए भी किया जा सकता है.
यूडीपी सॉकेट, OpenThread CLI के ज़रिए दिखाए जाते हैं. आइए, इसका इस्तेमाल दो FTD के बीच मैसेज भेजने के लिए करें.
FTD Joiner के लिए, Mesh-Local EID पता पाएं. हम इस पते का इस्तेमाल इसलिए कर रहे हैं, क्योंकि इसे Thread नेटवर्क में कहीं से भी ऐक्सेस किया जा सकता है.
## FTD Joiner ## ---------------- > ipaddr fdc0:de7a:b5c0:0:0:ff:fe00:fc00 # Leader Anycast Locator (ALOC) fdc0:de7a:b5c0:0:0:ff:fe00:b800 # Routing Locator (RLOC) fe80:0:0:0:e4cd:d2d9:3249:a243 # Link-Local Address (LLA) fdc0:de7a:b5c0:0:3e2e:66e:9d41:ebcd # Mesh-Local EID (ML-EID) Done
किसी भी IPv6 पते के लिए, यूडीपी शुरू करें और उसे सॉकेट से बाइंड करें:
## FTD Joiner ## ---------------- > udp open Done > udp bind :: 1212
FTD Commissioner पर स्विच करें, यूडीपी शुरू करें, और FTD Joiner पर सेट अप किए गए सॉकेट से कनेक्ट करें. इसके लिए, 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 Joiner पर, यूडीपी मैसेज मिल गया है!
## FTD Joiner ## ---------------- > 10 bytes from fdc0:de7a:b5c0:0:0:ff:fe00:c00 49153 hellothere
14. बधाई हो!
आपने एक फ़िज़िकल थ्रेड नेटवर्क बना लिया है!
अब आपको यह जानकारी मिल गई है:
- थ्रेड डिवाइस टाइप, भूमिकाओं, और स्कोप के बीच अंतर
- Thread डिवाइस, नेटवर्क में अपनी स्थितियों को कैसे मैनेज करते हैं
- यूडीपी का इस्तेमाल करके, नोड के बीच सामान्य मैसेज कैसे पास करें
अगले चरण
इस कोडलैब के आधार पर, ये काम करके देखें:
ot-cli-mtdबाइनरी का इस्तेमाल करके, FTD जॉइनर बोर्ड को MTD के तौर पर फिर से फ़्लैश करें. साथ ही, देखें कि यह कभी भी राउटर के तौर पर अपग्रेड नहीं होता है या लीडर बनने की कोशिश नहीं करता है- नेटवर्क में ज़्यादा डिवाइस जोड़ें (किसी दूसरे प्लैटफ़ॉर्म का इस्तेमाल करके देखें!). साथ ही, राऊटर और चाइल्ड टेबल का इस्तेमाल करके टोपोलॉजी का स्केच बनाएं. इसके अलावा, मल्टीकास्ट पतों को पिंग करें
- एनसीपी को कंट्रोल करने के लिए, pyspinel का इस्तेमाल करना
- OpenThread Border Router का इस्तेमाल करके, एनसीपी को बॉर्डर राऊटर में बदलें और अपने Thread नेटवर्क को इंटरनेट से कनेक्ट करें
इसके बारे में और पढ़ें
OpenThread के अलग-अलग संसाधनों के लिए, openthread.io और GitHub देखें. इनमें ये संसाधन शामिल हैं:
- OpenThread के साथ काम करने वाले प्लैटफ़ॉर्म — उन सभी प्लैटफ़ॉर्म के बारे में जानें जिन पर OpenThread काम करता है
- OpenThread को बिल्ड करना — OpenThread को बिल्ड और कॉन्फ़िगर करने के बारे में ज़्यादा जानकारी
- थ्रेड के बारे में बुनियादी जानकारी — इसमें इस कोडलैब में शामिल थ्रेड के सभी कॉन्सेप्ट के बारे में बताया गया है
रेफ़रंस: