B91 डेवलपमेंट बोर्ड और OpenThread की मदद से, Thread नेटवर्क बनाना

1. शुरुआती जानकारी

OpenThread, Thread® नेटवर्किंग प्रोटोकॉल का एक ओपन सोर्स लागू करना है, जो एक मज़बूत और सुरक्षित वायरलेस मेश नेटवर्किंग प्रोटोकॉल है, जिसे Internet of Things (IoT) डिवाइसों के लिए डिज़ाइन किया गया है. OpenThread को Google की Nest टीम ने डेवलप किया है और यह डेवलपर कम्यूनिटी के लिए, ओपन-सोर्स प्रोजेक्ट के तौर पर मुफ़्त में उपलब्ध है.

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

Telink ने OpenThread को लागू करने के तरीके को Zephyr RTOS में इंटिग्रेट किया है. इससे Telink हार्डवेयर के साथ बिना किसी रुकावट के काम करने की सुविधा मिलती है. इस इंटिग्रेशन का सोर्स कोड GitHub पर आसानी से ऐक्सेस किया जा सकता है. साथ ही, इसे सॉफ़्टवेयर डेवलपमेंट किट (SDK टूल) के तौर पर भी दिया जाता है.

इस कोडलैब में, OpenThread को असल हार्डवेयर पर प्रोग्राम किया जा सकता है. साथ ही, Thread नेटवर्क को बनाया और मैनेज किया जा सकता है और एक-दूसरे को नोड के बीच मैसेज भेजे जा सकते हैं. नीचे दी गई इमेज में हार्डवेयर सेटअप किया गया है. इसमें कोडलैब में OT Border राऊटर (OTBR) और एक Thread डिवाइस दिखाया गया है.

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

• Telink Zephyr डेवलपमेंट एनवायरमेंट का इस्तेमाल करके, OpenThread को लागू करने की सुविधा सेट अप करने के लिए.
• OpenThread सीएलआई सैंपल (ot-cli-ftd और ot-rcp) को बनाने के लिए और उन्हें Telink B91 डेवलपमेंट बोर्ड पर फ़्लैश करें.
• Raspबेरी Pi 3B+ या इसके बाद के वर्शन पर Docker का इस्तेमाल करके OpenThread Border राऊटर (OTBR) को सेट अप करने के लिए.
• OTBR पर Thread नेटवर्क बनाने के लिए.
• आउट-ऑफ़-बैंड डीबगिंग का इस्तेमाल करके, Thread नेटवर्क से डिवाइसों को जोड़ने के लिए.
• सीएलआई का इस्तेमाल करके, Thread नेटवर्क के नोड के बीच कनेक्टिविटी की पुष्टि करने के लिए.

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

हार्डवेयर:

• दो B91 डेवलपमेंट बोर्ड.
• Raspbian OS इमेज के साथ एक Raspber Pi 3B+ या इससे बड़ी फ़ाइल.
• कम से कम दो यूएसबी पोर्ट वाली Linux मशीन.
• इंटरनेट से कनेक्ट किया गया स्विच (या राऊटर) और कई ईथरनेट केबल.

सॉफ़्टवेयर:

• Telink बर्निंग और डीबगिंग टूल —— LinuxBDT.
• सीरियल पोर्ट टर्मिनल टूल, जैसे कि पुटीटी.
• अन्य टूल, जैसे कि Git और West.

2. ज़रूरी शर्तें

Thread Concepts और OpenThread सीएलआई

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

Linux मशीन

Linux मशीन (Ubuntu v20.04 एलटीएस या इसके बाद के वर्शन), एक बिल्ड मशीन की तरह काम करती है, ताकि Telink Zephyr डेवलपमेंट एनवायरमेंट सेट अप किया जा सके और सभी Thread डेवलपमेंट बोर्ड को फ़्लैश किया जा सके. इन टास्क को पूरा करने के लिए, Linux मशीन को दो उपलब्ध यूएसबी पोर्ट और इंटरनेट कनेक्टिविटी की ज़रूरत होती है.

सीरियल पोर्ट कनेक्शन और टर्मिनल

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

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

Telink B91 डेवलपमेंट किट

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

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

Raspber Pi 3B+ या इससे नए वर्शन के साथ Raspbian OS इमेज का इस्तेमाल

इस कोडलैब में, Raspbian Bullsey Lite OS की इमेज या डेस्कटॉप के साथ Raaspbian Bullsea के साथ रैज़बेरी 3B या उससे ज़्यादा की इमेज की ज़रूरत होती है. इसे ईथरनेट के ज़रिए इंटरनेट से कनेक्ट किया गया है और इसे OpenThread Border राऊटर (OTBR) के होस्ट के तौर पर कॉन्फ़िगर किया जाएगा.

नेटवर्क कनेक्शन

इंटरनेट से कनेक्ट किया गया स्विच (या राऊटर) और कई ईथरनेट केबल. इनका इस्तेमाल, Raspber Pi को Linux मशीन से कनेक्ट करने के लिए किया जाता है. इससे, उपयोगकर्ताओं को होस्ट के ज़रिए Raspबेरी Pi को कॉन्फ़िगर करने में आसानी होती है.

LinuxBDT

Telink बर्निंग और डीबगिंग टूल (BDT) सभी Telink चिप सीरीज़ पर लागू होता है. इसकी मदद से, आपको Telink B91 डेवलपमेंट बोर्ड पर OpenThread फ़र्मवेयर को मिटाने और फ़्लैश करने की सुविधा मिलती है. अपने Linux मशीन पर, X86 पर आधारित Linux वर्शन linuxBDT इंस्टॉल करें.

अन्य

• Telink Zephyr Development Environment सेट अप करने के लिए Git.
• पश्चिम, Zephyr प्रोजेक्ट मैनेज करने और OpenThread बाइनरी बनाने के लिए.

3. फ़र्मवेयर सेट अप करें

Telink Zephyr Development Environment सेट अप करें

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

$ sudo apt update
$ sudo apt upgrade

इसके बाद, नीचे दिया गया तरीका अपनाएं.

1. डिपेंडेंसी इंस्टॉल करें.

   $ wget https://apt.kitware.com/kitware-archive.sh
   $ sudo bash kitware-archive.sh
   $ sudo apt install --no-install-recommends git cmake ninja-build \
   gperf ccache dfu-util device-tree-compiler python3-dev python3-pip \
   python3-setuptools python3-tk python3-wheel xz-utils file make gcc \
   gcc-multilib g++-multilib libsdl2-dev
   

   फ़िलहाल, Jephyr को मुख्य डिपेंडेंसी के कम से कम वर्शन की ज़रूरत होती है, जैसे कि CMake (3.20.0), Python3 (3.6), और Devicetree Compiler (1.4.6).

   $ cmake --version
   $ python3 --version
   $ dtc --version
   

   अगले चरण पर जाने से पहले, अपने सिस्टम पर इंस्टॉल किए गए वर्शन की पुष्टि करें. अगर वर्शन सही नहीं हैं, तो एपीटी मिरर को स्टेबल और अप-टू-डेट मिरर पर स्विच करें या इन डिपेंडेंसी को मैन्युअल तरीके से अपडेट करें.
2. पश्चिम दिशा में इंस्टॉल करें.

   $ pip3 install --user -U west
   $ echo 'export PATH=~/.local/bin:"$PATH"' >> ~/.bashrc
   $ source ~/.bashrc
   

   पक्का करें कि ~/.local/bin आपके $PATH के एनवायरमेंट वैरिएबल में हो.
3. Zephyr प्रोजेक्ट का सोर्स कोड पाएं.

   $ west init ~/zephyrproject
   $ cd ~/zephyrproject
   $ west update
   $ west blobs fetch hal_telink
   $ west zephyr-export
   

4. Zephyr के लिए अतिरिक्त Python डिपेंडेंसी इंस्टॉल करें.

   $ pip3 install --user -r ~/zephyrproject/zephyr/scripts/requirements.txt
   

5. Zephyr टूलचेन सेट अप करें. Gephyr टूलचेन (करीब 1~2 जीबी) को लोकल डायरेक्ट्री में डाउनलोड करें, ताकि आप ज़्यादातर बोर्ड फ़्लैश कर सकें.

   $ wget https://github.com/zephyrproject-rtos/sdk-ng/releases/download/v0.16.1/zephyr-sdk-0.16.1_linux-x86_64.tar.xz
   $ wget -O - https://github.com/zephyrproject-rtos/sdk-ng/releases/download/v0.16.1/sha256.sum | shasum --check --ignore-missing
   

   Zephyr SDK टूल डाउनलोड करें और उसे नीचे दिखाए गए तरीके से, सुझाए गए पाथ पर डालें.

   $HOME/zephyr-sdk[-x.y.z]
   $HOME/.local/zephyr-sdk[-x.y.z]
   $HOME/.local/opt/zephyr-sdk[-x.y.z]
   $HOME/bin/zephyr-sdk[-x.y.z]
   /opt/zephyr-sdk[-x.y.z]
   /usr/zephyr-sdk[-x.y.z]
   /usr/local/zephyr-sdk[-x.y.z]
   

   जहां [-x.y.z] वैकल्पिक टेक्स्ट है, जो कोई भी टेक्स्ट हो सकता है, जैसे कि -0.16.1. SDK टूल इंस्टॉल होने के बाद, डायरेक्ट्री को ट्रांसफ़र नहीं किया जा सकता. इसके बाद, Zephyr टूलचेन इंस्टॉल करें.

   $ tar xvf zephyr-sdk-0.16.1_linux-x86_64.tar.xz
   $ cd zephyr-sdk-0.16.1
   $ ./setup.sh -t riscv64-zephyr-elf -h -c
   

6. नमस्ते दुनिया का उदाहरण बनाएं. सबसे पहले, पुष्टि करें कि Hello World के उदाहरण का इस्तेमाल करके, आधिकारिक Zephyr प्रोजेक्ट का कॉन्फ़िगरेशन सही है या नहीं. इसके बाद, कस्टम प्रोजेक्ट सेट अप करें.

   $ cd ~/zephyrproject/zephyr
   $ west build -p auto -b tlsr9518adk80d samples/hello_world
   

   जेफ़िर के डेटा स्टोर करने की जगह की रूट डायरेक्ट्री से hello_world का उदाहरण बनाने के लिए, वेस्ट बिल्ड कमांड का इस्तेमाल करें. आपको build/zephyr directory में जाकर, zephyr.bin नाम का फ़र्मवेयर मिल सकता है.
7. ~/.bashrc में Zephyr एनवायरमेंट स्क्रिप्ट जोड़ें. इन निर्देशों का पालन करें.

   $ echo "source ~/zephyrproject/zephyr/zephyr-env.sh" >> ~/.bashrc
   $ source ~/.bashrc
   

8. Telink Zephyr रिमोट रिपॉज़िटरी जोड़ें. Telink रेपो को लोकल तौर पर डेवलपमेंट ब्रांच के तौर पर डाउनलोड करें और उसे अपडेट करें.

   $ cd ~/zephyrproject/zephyr
   $ git remote add telink-semi https://github.com/telink-semi/zephyr
   $ git fetch telink develop
   $ git checkout develop
   $ west update
   $ west blobs fetch hal_telink
   

ज़्यादा जानकारी के लिए, Zephyr दस्तावेज़ – शुरुआती निर्देश देखें.

Telink LinuxBDT सेट अप करें

Telink LinuxBDT टूल डाउनलोड करें और उसे अपनी Linux मशीन पर किसी लोकल डायरेक्ट्री (जैसे कि होम डायरेक्ट्री ~) में एक्सट्रैक्ट करें. इससे B91 डेवलपमेंट बोर्ड पर फ़र्मवेयर फ़्लैश करने की सुविधा चालू हो जाएगी.

$ cd ~
$ wget http://wiki.telink-semi.cn/tools_and_sdk/Tools/BDT/LinuxBDT.tar.bz2
$ tar -vxf LinuxBDT.tar.bz2 

बर्निंग बोर्ड को यूएसबी इंटरफ़ेस की मदद से Linux मशीन से कनेक्ट करें और फिर ये निर्देश डालें.

$ cd LinuxBDT
$ sudo ./bdt lsusb -v
Bus 002 Device 001: ID 1d6b:0003 xHCI Host Controller
Bus 001 Device 003: ID 0bda:565a Integrated_Webcam_HD
Bus 001 Device 023: ID 413c:301a Dell MS116 USB Optical Mouse
Bus 001 Device 037: ID 248a:826a Telink Web Debugger v3.6
Bus 001 Device 001: ID 1d6b:0002 xHCI Host Controller

अगर आपको "Telink Web Debugger v3.6" मैसेज दिखता है, तो इसका मतलब है कि BDT प्रोग्रामर को Linux मशीन से कनेक्ट कर दिया गया है.

फ़र्मवेयर का कंपाइलेशन

यह कोडलैब दो तरह का OpenThread फ़र्मवेयर बनाएगा:

• ot-cli-ftd,
• और ot-rcp.

कंपाइलेशन की स्थितियां इस तरह हैं：

1. रेडियो को-प्रोसेसर](ot-rcp)

   $ cd ~/zephyrproject
   $ rm -rf build_ot_coprocessor
   $ west build -b tlsr9518adk80d -d build_ot_coprocessor zephyr/samples/net/openthread/coprocessor -- -DDTC_OVERLAY_FILE="usb.overlay" -DOVERLAY_CONFIG=overlay-rcp-usb-telink.conf
   

2. इंटरैक्टिव कमांड लाइन के साथ फ़ुल-चुनिंदा थ्रेड डिवाइस (ot-cli-ftd)

   $ cd ~/zephyrproject
   $ rm -rf build_ot_cli_ftd
   $ west build -b tlsr9518adk80d -d build_ot_cli_ftd zephyr/samples/net/openthread/cli -- -DOVERLAY_CONFIG=overlay-telink-fixed-mac.conf -DCONFIG_OPENTHREAD_FTD=y
   

फ़र्मवेयर फ़्लैश

जैसा कि नीचे दिए गए चित्र में दिखाया गया है, USB केबल का उपयोग करके B91 डेवलपमेंट बोर्ड को बर्निंग बोर्ड से कनेक्ट करें.

कमांड लाइन में, फ़र्मवेयर बर्न करने के लिए इन कमांड को लागू करें (उदाहरण के तौर पर, ot-cli-ftd फ़र्मवेयर की फ़्लैशिंग का इस्तेमाल करके).

$ cd ~/zephyrproject/build_ot_cli_ftd/zephyr
$ cp zephyr.bin ~/LinuxBDT/bin/ot-cli-ftd.bin
$ cd ~/LinuxBDT
$ sudo ./bdt 9518 ac
 Activate OK!
$ sudo ./bdt 9518 wf 0 -i bin/ot-cli-ftd.bin
 EraseSectorsize...
 Total Time: 2181 ms
 Flash writing...
 [100%][-] [##################################################]
 File Download to Flash at address 0x000000: 491700 bytes
 Total Time: 30087 ms

ot-rcp के लिए Flash तरीका मूल रूप से वही है, जो ot-cli-ftd के लिए है. हालांकि, फ़र्मवेयर के पाथ और नामों में अंतर होते हैं.

फ़्लैशिंग के बाद, दोनों B91 डेवलपमेंट बोर्ड पर सही निशान लगाकर उन्हें अलग करें. बोर्ड पर ot-cli-ftd को "एफ़टीडी जॉइनर" के तौर पर फ़्लैश किया गया और बोर्ड पर ot-rcp को "आरसीपी" के तौर पर दिखाया गया.

4. FTD जॉइनर डिवाइस के लिए, सीरियल कंसोल को कॉन्फ़िगर करना

जैसा कि तस्वीर में दिखाया गया है, FTD जॉइनर को Linux मशीन के यूएसबी पोर्ट में सीधे प्लग करें.

FTD जॉइनर डिवाइस को Linux मशीन से कनेक्ट करने के बाद, Puटेली खोलें. इसके बाद, एक नया टर्मिनल बनाएं, सीरियल पोर्ट की जानकारी सेट करें, और सीरियल पोर्ट खोलें.

OpenThread कमांड लाइन का रेफ़रंस यहां दिया गया है: OpenThread सीएलआई रेफ़रंस. पक्का करें कि सभी कमांड से पहले ot लिखा हो.

उदाहरण：

> ot state
disabled
Done
> ot channel
11
Done
>

5. Raspber Pi को OpenThread बॉर्डर राऊटर के तौर पर सेट अप करना

OpenThread बॉर्डर राऊटर एक ऐसा डिवाइस है जिसमें दो मुख्य भाग होते हैं：

• Raspber Pi में वे सभी सेवाएं और फ़र्मवेयर मौजूद होते हैं जो किसी बॉर्डर राऊटर (BR) के तौर पर काम करने के लिए ज़रूरी होती हैं.
• RCP, Thread की कम्यूनिकेशन के लिए ज़िम्मेदार है.

रेडियो को-प्रोसेसर](आरसीपी)

ot-rcp फ़र्मवेयर को फ़्लैश करने के लिए, वही तरीका अपनाएं जो ot-cli-ftd फ़र्मवेयर फ़्लैश करने की प्रोसेस में दिया गया है. B91 डेवलपमेंट बोर्ड को Raspबेरी Pi पर यूएसबी पोर्ट से कनेक्ट करें, जैसा कि नीचे दिए गए चित्र में दिखाया गया है.

रैज़बेरी पाई

1. पक्का करें कि SD कार्ड पर Raspbian Bulls आय लाइट ओएस इमेज या डेस्कटॉप के साथ Raaspbian Bullsey ठीक से लिखा हुआ है.
2. आपके पास एसएसएच का इस्तेमाल करने का विकल्प है. आप चाहें, तो रैज़बेरी पाई में एसएसएच का इस्तेमाल करें या सीधे Raspbian डेस्कटॉप के साथ काम करें. यह कोडलैब, एसएसएच का इस्तेमाल करेगा.
3. अगले चरण में OTBR डॉकर को इंस्टॉल करने से पहले, पक्का करें कि आपने लोकल रिपॉज़िटरी और पैकेज मैनेजर को अपडेट किया हो.

   $ sudo apt-get update
   $ sudp apt-get upgrade
   

Docker इंस्टॉल करें

अगर आपने पिछले चरण में, लोकल रिपॉज़िटरी और पैकेज मैनेजर एपीटी को अपडेट किया है, तो Raspबेरी Pi को फिर से चालू करें और एसएसएच टर्मिनल विंडो खोलें.

1. Docker इंस्टॉल करें:

   $ curl -sSL https://get.docker.com | sh
   

2. अनुमति देने के लिए, मौजूदा खाते को Docker ग्रुप में रखें, ताकि हर निर्देश के पहले sudo को जोड़ने की ज़रूरत न पड़े.

   $ sudo usermod -aG docker $USER
   

   इसे लागू करने के लिए, आपको Raspबेरी Pi को रीस्टार्ट करना होगा.
3. अगर Docker शुरू नहीं हुआ है, तो इसे शुरू करें:

   $ sudo dockerd
   

4. OTBR फ़ायरवॉल स्क्रिप्ट, Docker कंटेनर के अंदर नियम जनरेट करती हैं. इससे पहले, iptables के कर्नेल मॉड्यूल को लोड करने के लिए modprobe को एक्ज़ीक्यूट करें.

   $ sudo modprobe ip6table_filter
   

Docker को कॉन्फ़िगर करें और चलाएं

यह कोडलैब सीधे OpenThread Docker Hub से OTBR की डॉकर इमेज लेता है. OpenThread टीम ने इस इमेज की जांच और पुष्टि की है.

1. नई इमेज खींचें:

   $ docker pull openthread/otbr:latest
   

2. Docker कंटेनर में इमेज की सूची देखें:

   $ docker images
   REPOSITORY        TAG       IMAGE ID       CREATED      SIZE
   openthread/otbr   latest    db081f4de15f   6 days ago   766MB
   

3. /dev, ttyACM0 से पता चलता है कि आरसीपी सही तरीके से कनेक्ट है. इससे, आरसीपी डिवाइस के सीरियल पोर्ट का नाम पता चलता है.

   $ ls /dev/tty*
   ...
   /dev/ttyACM0
   ... 
   

4. पहली बार OTBR Docker चलाएं और RCP (ttyACM0) के सीरियल पोर्ट का रेफ़रंस दें. अगर आपको इस OTBR Docker का इस्तेमाल करना जारी रखना है, तो docker start otbr निर्देश का इस्तेमाल करें.

   $ docker run --name "otbr" --sysctl "net.ipv6.conf.all.disable_ipv6=0 net.ipv4.conf.all.forwarding=1 net.ipv6.conf.all.forwarding=1" -p 8080:80 --dns=127.0.0.1 -it --volume /dev/ttyACM0:/dev/ttyACM0 --privileged openthread/otbr --radio-url spinel+hdlc+uart:///dev/ttyACM0
   

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

   $ docker exec -ti otbr sh -c "sudo ot-ctl"
   > state 
   disabled
   Done
   

डॉकर के वैकल्पिक निर्देश:

• चल रहे Docker कंटेनर के बारे में जानकारी पाएं:

  $ docker ps -aq
  

• OTBR Docker को बंद करें:

  $ docker stop otbr
  

• OTBR डॉकर हटाएं:

  $ docker rm otbr
  

• OTBR डॉकर को फिर से लोड करें:

  $ docker restart otbr
  

इसके बाद, FTD जॉइनर डिवाइस और OTBR तैयार हो जाएंगे. इसके बाद, Thread नेटवर्क को बनाने के लिए अगले चरण पर जाना जा सकता है.

6. Thread नेटवर्क बनाना

आरसीपी पर Thread नेटवर्क बनाना

हम Thread नेटवर्क को बनाने के लिए, OTBR पर ot-ctl शेल का इस्तेमाल करते हैं. अगर आपने आखिरी सेक्शन में शेल से बाहर निकला था, तो इसे एसएसएच टर्मिनल में फिर से शुरू करने के लिए यह कमांड डालें:

$ docker exec -ti otbr sh -c "sudo ot-ctl"

इसके बाद, टेबल में दिए गए क्रम में कमांड डालें. साथ ही, अगले चरण पर जाने से पहले पक्का करें कि हर चरण सही नतीजा मिले.

नेटवर्क बनाने के दौरान, OTBR से बिना किसी क्रम के जनरेट की गई नेटवर्क कुंजी का इस्तेमाल किया जाएगा. ऐसा तब किया जाएगा, जब ot-cli-ftd डिवाइस इस Thread नेटवर्क से जुड़े होंगे.

आउट-ऑफ़-बैंड कमीशनिंग की मदद से, Thread में FTD जॉइनर जोड़ें

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

टोपोलॉजी

नीचे दिए गए कोड स्निपेट जैसे जवाब पाने के लिए, एसएसएच टर्मिनल में ipaddr, child table, router table जैसे निर्देश डालें.

> ipaddr rloc
fd8c:60bc:a98:c7ba:0:ff:fe00:b000
Done
> child table
| ID  | RLOC16 | Timeout    | Age        | LQ In | C_VN |R|D|N|Ver|CSL|QMsgCnt|Suprvsn| Extended MAC     |
+-----+--------+------------+------------+-------+------+-+-+-+---+---+-------+-------+------------------+
|   1 | 0xb001 |        240 |         23 |     3 |   51 |1|1|1|  3| 0 |     0 |   129 | 82bc12fbe783468e |

Done
> router table
| ID | RLOC16 | Next Hop | Path Cost | LQ In | LQ Out | Age | Extended MAC     | Link |
+----+--------+----------+-----------+-------+--------+-----+------------------+------+
| 44 | 0xb000 |       63 |         0 |     0 |      0 |   0 | 7ae354109d611f7e |    0 |

Done
...
> child table
| ID  | RLOC16 | Timeout    | Age        | LQ In | C_VN |R|D|N|Ver|CSL|QMsgCnt|Suprvsn| Extended MAC     |
+-----+--------+------------+------------+-------+------+-+-+-+---+---+-------+-------+------------------+

Done
> router table
| ID | RLOC16 | Next Hop | Path Cost | LQ In | LQ Out | Age | Extended MAC     | Link |
+----+--------+----------+-----------+-------+--------+-----+------------------+------+
| 33 | 0x8400 |       63 |         0 |     3 |      3 |  13 | e61487c1cda940a6 |    1 |
| 44 | 0xb000 |       63 |         0 |     0 |      0 |   0 | 7ae354109d611f7e |    0 |

Done

OTBR का RLOC16, 0xb000 है और शुरू में FTD जॉइनर का RLOC16, 0xb001 है. इसके बाद, राऊटर आईडी पाने के बाद, FTD जॉइनर का RLOC16 0x8400 हो जाता है. यह देखा जा सकता है कि FTD जॉइनर को चाइल्ड से राऊटर पर अपग्रेड कर दिया गया है.

मौजूदा Thread नेटवर्क में दो नोड हैं और टोपोलॉजी को नीचे दिए गए डायग्राम में दिखाया गया है.

7. Thread डिवाइसों के बीच कम्यूनिकेशन की जानकारी

ICMPv6 कम्यूनिकेशन

हम ping कमांड का इस्तेमाल करके, यह पता लगाते हैं कि एक ही नेटवर्क से जुड़े Thread डिवाइस एक-दूसरे से कम्यूनिकेट कर सकते हैं या नहीं. सबसे पहले, डिवाइस का आरएलओसी पाने के लिए ipaddr निर्देश का इस्तेमाल करें.

> ipaddr
fd8c:60bc:a98:c7ba:0:ff:fe00:fc11
fdbd:7274:649c:1:1d19:9613:f705:a5af
fd8c:60bc:a98:c7ba:0:ff:fe00:fc10
fd8c:60bc:a98:c7ba:0:ff:fe00:fc38
fd8c:60bc:a98:c7ba:0:ff:fe00:fc00
fd8c:60bc:a98:c7ba:0:ff:fe00:b000       # Routing Locator (RLOC)
fd8c:60bc:a98:c7ba:5249:34ab:26d1:aff6
fe80:0:0:0:78e3:5410:9d61:1f7e
Done

पिंग कार्रवाई करने के लिए FTD जॉइनर के सीरियल कंसोल में, नीचे दिया गया कमांड डालें.

> ot ping fd8c:60bc:a98:c7ba:0:ff:fe00:b000
16 bytes from fd8c:60bc:a98:c7ba:0:ff:fe00:b000: icmp_seq=1 hlim=64 time=19ms
1 packets transmitted, 1 packets received. Packet loss = 0.0%. Round-trip min/avg/max = 19/19.0/19 ms.
Done

सीरियल पोर्ट के आउटपुट रिस्पॉन्स से पता चलता है कि OTBR साइड को पिंग का अनुरोध मिला है. साथ ही, FTD जॉइनर को, OTBR से मिला पिंग जवाब मिल गया है. दो डिवाइसों के बीच कनेक्ट हो गया है.

UDP कम्यूनिकेशन

OpenThread की ओर से उपलब्ध कराई जाने वाली ऐप्लिकेशन सेवाओं में, यूडीपी को भी शामिल किया जाता है. यूडीपी एपीआई का इस्तेमाल करके, Thread नेटवर्क के नोड के बीच जानकारी शेयर की जा सकती है. इसके अलावा, बॉर्डर राऊटर की मदद से किसी बाहरी नेटवर्क को जानकारी भेजी जा सकती है. OpenThread के UDP API के बारे में ज़्यादा जानकारी, OpenThread CLI - UDP API में दी गई है. यह कोडलैब, OTBR और FTD जॉइनर के बीच जानकारी भेजने के लिए, इसमें मौजूद कुछ एपीआई का इस्तेमाल करेगा.

सबसे पहले, OTBR का मेश-लोकल ईआईडी पाएं. यह पता, Thread डिवाइस के IPv6 पतों में से एक है. इसका इस्तेमाल, एक ही Thread नेटवर्क पार्टीशन में मौजूद Thread डिवाइसों को ऐक्सेस करने के लिए किया जा सकता है.

> ipaddr mleid
fd8c:60bc:a98:c7ba:5249:34ab:26d1:aff6
Done

OTBR यूडीपी को चालू करने और डिवाइस के 1022 पोर्ट को बाइंड करने के लिए, एसएसएच टर्मिनल में नीचे दिए गए कमांड डालें.

> udp open
Done
> udp bind :: 1022
Done

सीरियल कंसोल में ये निर्देश डालें और FTD जॉइनर का UDP चालू करें. डिवाइस के 1022 पोर्ट को जोड़ें और फिर OTBR को 5-बाइट वाला hello मैसेज भेजें.

> ot udp open 
Done
> ot udp bind :: 1022
Done
> ot udp send fd8c:60bc:a98:c7ba:5249:34ab:26d1:aff6 1022 hello
Done

एसएसएच टर्मिनल से यह जानकारी मिलती है. OTBR को एफ़टीडी जॉइनर से hello मैसेज मिलता है. इसका मतलब है कि यूडीपी कम्यूनिकेशन पूरा हो गया है.

> 5 bytes from fd8c:60bc:a98:c7ba:9386:63cf:19d7:5a61 1022 hello

8. बधाई हो

आपने एक आसान Thread नेटवर्क बनाया है और इस नेटवर्क में कम्यूनिकेशन की पुष्टि की है.

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

• Telink Zephyr डेवलपमेंट एनवायरमेंट बनाने और उसका इस्तेमाल करने का तरीका.
• ot-cli-ftd और ot-rcp बाइनरी बनाने का तरीका बताने के साथ-साथ उन्हें Telink B91 डेवलपमेंट बोर्ड पर फ़्लैश करने का तरीका.
• Docker का इस्तेमाल करके, OpenThread Border राऊटर (OTBR) के तौर पर Raspबेरी Pi 3B+ या इसके बाद के वर्शन को सेट अप करने का तरीका.
• OTBR पर Thread नेटवर्क कैसे बनाएं.
• आउट-ऑफ़-बैंड कमीशनिंग की मदद से, Thread नेटवर्क से डिवाइसों को जोड़ने का तरीका.
• Thread नेटवर्क के नोड के बीच कनेक्टिविटी की पुष्टि करने का तरीका जानें.

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

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

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

रेफ़रंस के लिए दस्तावेज़:

• OpenThread सीएलआई का रेफ़रंस
• OpenThread यूडीपी सीएलआई रेफ़रंस
• OpenThread UDP API का रेफ़रंस