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

1. परिचय

26b7f4f6b3ea0700.png

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

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

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

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

codelab_overview.png

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

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

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

हार्डवेयर:

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

सॉफ़्टवेयर:

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

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

Thread Concepts और OpenThread सीएलआई

कोडलैब का यह मॉड्यूल शुरू होने से पहले, Thread के बुनियादी सिद्धांतों और OpenThread सीएलआई को अच्छी तरह से समझने के लिए, OpenThread सिम्युलेशन कोडलैब को पढ़ना मददगार हो सकता है.

Linux मशीन

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

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

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

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

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

overview.png

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

इंडेक्स

नाम

1

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

2

टेलिंक बर्निंग बोर्ड

3

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

4

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

Raspbian OS इमेज के साथ Raspberry Pi 3B+ या इससे ज़्यादा

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

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

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

LinuxBDT

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

अन्य

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

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

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
    फ़िलहाल, 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 Project का सोर्स कोड पाएं.
    $ 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. 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
    zephyr डेटा स्टोर करने की जगह की रूट डायरेक्ट्री से, 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 Doc – शुरुआती निर्देश देखें.

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

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

यूएसबी केबल का इस्तेमाल करके, 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 जॉइनर को Linux मशीन के यूएसबी पोर्ट में सीधे प्लग करें.

usb_connection.png

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

uart_console.png

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

उदाहरण：

> ot state
disabled
Done
> ot channel
11
Done
>

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

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

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

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

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

OTBR_overview.png

रैज़बेरी पाई

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

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

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

  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 चलाएं और 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. Raspberry Pi और आरसीपी के बीच कनेक्टिविटी की जांच करने के लिए नई एसएसएच टर्मिनल विंडो खोलें.
    $ docker exec -ti otbr sh -c "sudo ot-ctl"
> state 
disabled
Done

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

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

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

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

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

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

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

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

इंडेक्स

आदेश

परिचय

अनुमानित जवाब

1

dataset init new

बिना किसी क्रम के, कोई नया नेटवर्क डेटासेट बनाएं.

हो गया

2

dataset commit active

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

हो गया

3

ifconfig up

IPv6 इंटरफ़ेस खोलें.

हो गया

4

thread start

Thread प्रोटोकॉल पर कार्रवाई करने की सुविधा चालू करें और Thread नेटवर्क से अटैच करें.

हो गया

थ्रेड का इंटरफ़ेस खुलने में 10 सेकंड लगेंगे.

5

state

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

leader
Done

6

dataset active

ऐक्टिव ऑपरेशनल डेटासेट और रिकॉर्ड नेटवर्क कुंजी की जांच करें.











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

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

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

इंडेक्स

आदेश

परिचय

अनुमानित जवाब

1

ot dataset networkkey c312485187484ceb5992d2343baaf93d

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

हो गया

2

ot dataset commit active

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

हो गया

3

ot ifconfig up

IPv6 इंटरफ़ेस खोलें.

हो गया

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

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

topology.png

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

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

हम ping कमांड का इस्तेमाल करके, यह पता लगाते हैं कि एक ही नेटवर्क में मौजूद Thread डिवाइस एक-दूसरे के साथ इंटरैक्ट कर सकते हैं या नहीं. सबसे पहले, डिवाइस का RLOC पाने के लिए, 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

सीरियल पोर्ट के आउटपुट रिस्पॉन्स से पता चलता है कि ओटीबीआर साइड को पिंग करने का अनुरोध मिल गया है और एफ़टीडी जॉइनर को ओटीबीआर से मिला पिंग रिस्पॉन्स मिला है. दोनों डिवाइसों के बीच कम्यूनिकेशन हो गया.

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

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

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

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

OTBR यूडीपी को चालू करने और डिवाइस के 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

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

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

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

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