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