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

1. परिचय

26b7f4f6b3ea0700.png

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

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

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

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

codelab_overview.png

आपको क्या सीखने को मिलेगा

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

आपको किन चीज़ों की ज़रूरत होगी

हार्डवेयर:

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

सॉफ़्टवेयर:

  • Telink Burning and Debugging Tool —— LinuxBDT.
  • PuTTY जैसे सीरियल पोर्ट टर्मिनल टूल.
  • Git और West जैसे अन्य टूल.

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

थ्रेड के कॉन्सेप्ट और OpenThread CLI

इस कोडलैब से पहले, OpenThread Simulation कोडलैब को पढ़कर, Thread के बुनियादी कॉन्सेप्ट और OpenThread CLI के बारे में जानकारी हासिल की जा सकती है.

Linux मशीन

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

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

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

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

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

overview.png

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

इंडेक्स

नाम

1

Telink B91 डेवलपमेंट बोर्ड

2

Telink Burning Board

3

2.4 गीगाहर्ट्ज़ वाला ऐंटीना

4

यूएसबी केबल (यूएसबी ए से मिनी यूएसबी)

Raspberry Pi 3B+ या इससे ज़्यादा, जिसमें Raspbian OS इमेज हो

इस कोडलैब के लिए, Raspbian Bullseye Lite OS image या Raspbian Bullseye with Desktop के साथ Raspberry Pi 3B+ या इससे ज़्यादा की ज़रूरत होती है. यह ईथरनेट के ज़रिए इंटरनेट से कनेक्ट होता है. इसे OpenThread बॉर्डर राऊटर (ओटीबीआर) के लिए होस्ट के तौर पर कॉन्फ़िगर किया जाएगा.

इंटरनेट कनेक्शन

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

LinuxBDT

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

अन्य

  • Git, Telink Zephyr डेवलपमेंट एनवायरमेंट सेट अप करने के लिए.
  • West, Zephyr प्रोजेक्ट को मैनेज करने और OpenThread बाइनरी बनाने के लिए.

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

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

$ 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
    फ़िलहाल, Zephyr के लिए मुख्य डिपेंडेंसी के कम से कम इन वर्शन की ज़रूरत होती है: 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 टूलचेन सेट अप करें. ज़्यादातर बोर्ड को फ़्लैश करने के लिए, Zephyr टूलचेन (करीब 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. एसडीके इंस्टॉल हो जाने के बाद, डायरेक्ट्री को दूसरी जगह नहीं ले जाया जा सकता. इसके बाद, 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' उदाहरण बनाएं. सबसे पहले, Hello World उदाहरण का इस्तेमाल करके पुष्टि करें कि Zephyr प्रोजेक्ट का आधिकारिक कॉन्फ़िगरेशन सही है. इसके बाद, अपने कस्टम प्रोजेक्ट को सेट अप करें.
    $ cd ~/zephyrproject/zephyr
$ west build -p auto -b tlsr9518adk80d samples/hello_world
    Zephyr रिपॉज़िटरी की रूट डायरेक्ट्री से hello_world उदाहरण बनाने के लिए, West build कमांड का इस्तेमाल करें. आपको build/zephyr directory में जाकर, zephyr.bin नाम का फ़र्मवेयर दिखेगा.
  7. ~/.bashrc में Zephyr एनवायरमेंट स्क्रिप्ट जोड़ें. इन कमांड को चलाएं.
    $ echo "source ~/zephyrproject/zephyr/zephyr-env.sh" >> ~/.bashrc
$ source ~/.bashrc
  8. Telink Zephyr की रिमोट रिपॉज़िटरी जोड़ें. Telink repo को डेवलपमेंट ब्रांच के तौर पर लोकल स्टोरेज में डाउनलोड करें और उसे अपडेट करें.
    $ 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 Doc – Getting Started Guide देखें.

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

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

Burning Board को यूएसबी इंटरफ़ेस के ज़रिए 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

फ़र्मवेयर फ़्लैश करना

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

connection_overview.png

फ़र्मवेयर बर्निंग के लिए, कमांड लाइन में ये कमांड चलाएं. यहां 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 के लिए फ़्लैश मेथड, ot-cli-ftd के लिए फ़्लैश मेथड की तरह ही होता है. हालांकि, फ़र्मवेयर के पाथ और नामों में अंतर होता है.

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

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

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

usb_connection.png

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

uart_console.png

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

उदाहरण：

> ot state
disabled
Done
> ot channel
11
Done
>

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

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

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

रेडियो को-प्रोसेसर（आरसीपी）

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

OTBR_overview.png

Raspberry Pi

  1. पक्का करें कि Raspbian Bullseye Lite OS इमेज या Raspbian Bullseye with Desktop को एसडी कार्ड में सही तरीके से लिखा गया हो.
  2. आपके पास Raspberry Pi में एसएसएच करने या सीधे Raspbian Desktop के साथ काम करने का विकल्प होता है. इस कोडलैब में एसएसएच का इस्तेमाल किया जाएगा.
  3. अगले चरण में OTBR Docker को इंस्टॉल करने से पहले, पक्का करें कि आपने लोकल रिपॉज़िटरी और पैकेज मैनेजर को अपडेट कर लिया हो.
    $ sudo apt-get update
$ sudp apt-get upgrade

Docker इंस्टॉल करना

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

  1. Docker इंस्टॉल करें:
    $ curl -sSL https://get.docker.com | sh
  2. मौजूदा खाते को Docker ग्रुप में डालें, ताकि अनुमति दी जा सके. इससे हर कमांड के आगे sudo जोड़ने की ज़रूरत नहीं पड़ेगी.
    $ sudo usermod -aG docker $USER
    इसे लागू करने के लिए, आपको Raspberry Pi को रीस्टार्ट करना होगा.
  3. अगर Docker शुरू नहीं हुआ है, तो इसे शुरू करें:
    $ sudo dockerd
  4. OTBR फ़ायरवॉल स्क्रिप्ट, Docker कंटेनर में नियम जनरेट करती हैं. इससे पहले, iptables के कर्नल मॉड्यूल को लोड करने के लिए modprobe कमांड चलाएं.
    $ sudo modprobe ip6table_filter

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

यह कोडलैब, OpenThread Docker Hub से सीधे तौर पर OTBR की Docker इमेज को पुल करता है. इस इमेज की जांच 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 चलाएं और आरसीपी (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. Raspberry Pi और RCP के बीच कनेक्टिविटी की जांच करने के लिए, नई SSH टर्मिनल विंडो खोलें.
    $ docker exec -ti otbr sh -c "sudo ot-ctl"
> state 
disabled
Done

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

  • चल रहे Docker कंटेनर के बारे में जानकारी पाने के लिए:
    $ docker ps -aq
  • OTBR Docker को बंद करें:
    $ docker stop otbr
  • OTBR Docker को हटाने के लिए:
    $ docker rm otbr
  • OTBR Docker को फिर से लोड करें:
    $ docker restart otbr

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

6. थ्रेड नेटवर्क बनाना

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

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

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

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

इंडेक्स

निर्देश

परिचय

उम्मीद के मुताबिक जवाब

1

dataset init new

एक नया रैंडम नेटवर्क डेटासेट बनाएं.

हो गया

2

dataset commit active

नए डेटासेट को नॉन-वोलैटाइल स्टोरेज में मौजूद, ऐक्टिव ऑपरेशनल डेटासेट में सेव करें.

हो गया

3

ifconfig up

आईपीवी6 इंटरफ़ेस खोलें.

हो गया

4

thread start

Thread प्रोटोकॉल ऑपरेशन चालू करें और Thread नेटवर्क से कनेक्ट करें.

हो गया

थ्रेड इंटरफ़ेस के चालू होने के लिए 10 सेकंड तक इंतज़ार करें.

5

state

डिवाइस की स्थिति की जांच करें.इस कमांड को तब तक कई बार कॉल किया जा सकता है, जब तक कि यह लीडर न बन जाए और अगले चरण पर न चला जाए.

leader
Done

6

dataset active

ऑपरेशनल डेटासेट की पूरी जानकारी देखें और नेटवर्क की रिकॉर्ड करें.

Active Timestamp: 1
Channel: 13
Channel Mask: 0x07fff800
Ext PAN ID: b07476e168eda4fc
Mesh Local Prefix: fd8c:60bc:a98:c7ba::/64
Network Key: c312485187484ceb5992d2343baaf93d
Network Name: OpenThread-599c
PAN ID: 0x599c
PSKc: 04f79ad752e8401a1933486c95299f60
Security Policy: 672 onrc 0
Done

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

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

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

इंडेक्स

निर्देश

परिचय

उम्मीद के मुताबिक जवाब

1

ot dataset networkkey c312485187484ceb5992d2343baaf93d

किसी डिवाइस को Thread नेटवर्क से कनेक्ट करने के लिए, सिर्फ़ नेटवर्क की की ज़रूरत होती है.

हो गया

2

ot dataset commit active

नए डेटासेट को नॉन-वोलैटाइल स्टोरेज में मौजूद, ऐक्टिव ऑपरेशनल डेटासेट में सेव करें.

हो गया

3

ot ifconfig up

आईपीवी6 इंटरफ़ेस खोलें.

हो गया

4

ot thread start

Thread प्रोटोकॉल ऑपरेशन चालू करें और Thread नेटवर्क से कनेक्ट करें.

हो गया

डिवाइस के कनेक्ट होने और कॉन्फ़िगर होने के दौरान, 20 सेकंड तक इंतज़ार करें.

5

ot state

डिवाइस की स्थिति देखें.

बच्चा/राउटर
हो गया

टोपोलॉजी

एसएसएच टर्मिनल में 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 Joiner का RLOC16, 0x8400 में बदल जाता है. इसमें देखा जा सकता है कि FTD जॉइनर को चाइल्ड से राउटर में अपग्रेड कर दिया गया है.

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

topology.png

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 Joiner के सीरियल कंसोल में यह कमांड डालें.

> 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 से मिला पिंग रिस्पॉन्स मिला है. दोनों डिवाइसों के बीच कम्यूनिकेशन हो गया है.

यूडीपी कम्यूनिकेशन

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

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

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

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

> udp open
Done
> udp bind :: 1022
Done

सीरियल कंसोल में यहां दिए गए कमांड डालें और FTD जॉइनर के यूडीपी को चालू करें. डिवाइस के 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 को FTD Joiner से 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 का इस्तेमाल करके, Raspberry Pi 3B+ या इसके बाद वाले वर्शन को OpenThread बॉर्डर राऊटर (ओटीबीआर) के तौर पर सेट अप करने का तरीका.
  • OTBR पर थ्रेड नेटवर्क बनाने का तरीका.
  • आउट-ऑफ़-बैंड कमीशनिंग की मदद से, Thread नेटवर्क में डिवाइसों को जोड़ने का तरीका.
  • Thread नेटवर्क में नोड के बीच कनेक्टिविटी की पुष्टि कैसे करें.

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

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

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