בניית Thread Network באמצעות B91 Development Board ו-OpenThread

1. מבוא

26b7f4f6b3ea0700.png

‫OpenThread הוא הטמעה בקוד פתוח של פרוטוקול הרשת Thread®‎, שהוא פרוטוקול רשת אלחוטי חזק ומאובטח מסוג Mesh, שנועד למכשירי האינטרנט של הדברים (IoT). ‫OpenThread פותח על ידי צוות Nest של Google, והוא זמין בחינם לקהילת המפתחים כפרויקט בקוד פתוח.

מפרט Thread קובע פרוטוקול תקשורת אלחוטי אמין, מאובטח וחסכוני באנרגיה למכשירים עם משאבים מוגבלים, שנפוצים בבתים חכמים ובבניינים מסחריים. ‫OpenThread כולל את כל היקף שכבת הרשת ב-Thread, כמו IPv6,‏ 6LoWPAN,‏ IEEE 802.15.4 עם אבטחת MAC, יצירת קישור לרשת Mesh וניתוב רשת Mesh.

חברת Telink שילבה את הטמעת OpenThread ב-Zephyr RTOS, וכך אפשרה תאימות חלקה לחומרה של Telink. קוד המקור של השילוב הזה זמין ב-GitHub, והוא מסופק גם כערכת כלים לפיתוח תוכנה (SDK).

ב-Codelab הזה תלמדו איך לתכנת את OpenThread בחומרה בפועל, ליצור ולנהל רשת פרוטוקול Thread ולהחליף הודעות בין צמתים. בתמונה שלמטה מוצגת הגדרת החומרה, שכוללת נתב גבול OT (OTBR) ומכשיר Thread אחד ב-codelab.

codelab_overview.png

מה תלמדו

  • כדי להגדיר הטמעה של OpenThread באמצעות סביבת הפיתוח Telink Zephyr.
  • כדי ליצור את הדוגמאות של OpenThread CLI‏ (ot-cli-ftd ו-ot-rcp) ולהעביר אותן ללוחות פיתוח של Telink B91.
  • כדי להגדיר נתב גבול OpenThread‏ (OTBR) באמצעות Docker ב-Raspberry Pi 3B+‎ ואילך.
  • כדי ליצור רשת Thread ב-OTBR.
  • כדי להוסיף מכשירים לרשת Thread באמצעות ניפוי באגים מחוץ לפס.
  • כדי לאמת את הקישוריות בין הצמתים ברשת Thread באמצעות CLI.

הדרישות

חומרה:

  • שני כרטיסי פיתוח B91.
  • ‫Raspberry Pi 3B+‎ או גרסה מתקדמת יותר עם תמונת מערכת הפעלה Raspbian.
  • מחשב Linux עם לפחות שתי יציאות USB.
  • מתג (או נתב) שמחובר לאינטרנט וכמה כבלי אתרנט.

תוכנה:

  • Telink Burning and Debugging Tool —— LinuxBDT.
  • כלי טרמינל של יציאה טורית, כמו PuTTY.
  • כלים אחרים, כמו Git ו-West.

2. דרישות מוקדמות

מושגים שקשורים ל-Thread וממשק שורת הפקודה (CLI) של OpenThread

לפני שממשיכים עם ה-codelab הזה, מומלץ לעבור על ה-codelab בנושא סימולציה של OpenThread כדי להכיר את המושגים הבסיסיים של Thread ואת ה-CLI של OpenThread.

מכונת Linux

מכונת Linux (Ubuntu v20.04 LTS ואילך) משמשת כמכונת בנייה להגדרת סביבת הפיתוח של Telink Zephyr ולהצגת כל לוחות הפיתוח של Thread. כדי לבצע את המשימות האלה, למכשיר Linux צריכים להיות שני חיבורי USB פנויים וחיבור לאינטרנט.

חיבור ליציאה טורית ומסופים

אפשר לחבר את המכשיר ישירות ליציאת ה-USB במחשב Linux. בנוסף, תצטרכו כלי מסוף של יציאה טורית כדי לגשת למכשירים.

ב-codelab הזה, כלי הטרמינל PuTTY משמש לשליטה ב-FTD Joiner וב-Raspberry Pi. הוא מספק סקירה כללית של השימוש בו, אבל אפשר להשתמש גם בתוכנות אחרות של מסוף.

ב-codelab הזה צריך שתי ערכות פיתוח B91. בתמונה שלמטה מוצגים הרכיבים המינימליים הנדרשים בסט אחד.

overview.png

אחד מהערכות האלה ישמש כ-RCP (מעבד משותף של רדיו), והשני ישמש כ-FTD (מכשיר Thread מלא). אם עדיין לא קיבלתם את הערכה, תוכלו לקבל פרטים נוספים באתר הרשמי של Telink. אלה כמה רכיבים שאפשר להשתמש בהם:

אינדקס

שם

1

Telink B91 Development Board

2

Telink Burning Board

3

אנטנה 2.4GHz

4

כבל USB (מ-USB A למיני USB)

‫Raspberry Pi 3B+‎ או גרסה מתקדמת יותר עם קובץ אימג' של מערכת ההפעלה Raspbian

ב-codelab הזה נדרש Raspberry Pi 3B+‎ או גרסה מתקדמת יותר עם תמונת מערכת הפעלה של Raspbian Bullseye Lite או Raspbian Bullseye עם Desktop. הוא מחובר לאינטרנט באמצעות אתרנט ויוגדר כמארח של OpenThread Border Router‏ (OTBR).

חיבור לרשת

מתג (או נתב) שמחובר לאינטרנט וכמה כבלי אתרנט. הם משמשים לחיבור של Raspberry Pi למכונת Linux, ומאפשרים למשתמש להגדיר את Raspberry Pi דרך המארח.

LinuxBDT

‫Telink Burning and Debugging Tool (BDT), שרלוונטי לכל סדרות השבבים של Telink, מאפשר לכם למחוק ולצרוב קושחת OpenThread בלוחות הפיתוח של Telink B91. מתקינים את גרסת Linux מבוססת X86‏ linuxBDT במחשב Linux.

אחרים

  • ‫Git, להגדרת סביבת הפיתוח של Telink Zephyr.
  • ‫West, כדי לנהל פרויקט Zephyr ולבנות קבצים בינאריים של OpenThread.

3. הגדרת קושחה

במחשב Linux, פותחים טרמינל של CLI ומתחילים בהרצת הפקודות הבאות כדי לוודא ש-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
    לפני שממשיכים לשלבים הבאים, צריך לוודא שהגרסאות המותקנות במערכת תואמות. אם הגרסאות לא נכונות, צריך להחליף את שרת ה-APT לשרת יציב ומעודכן, או לעדכן את התלויות האלה באופן ידני.
  2. מתקינים את west.
    ‫
    $ 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. מתקינים יחסי תלות נוספים של Python עבור Zephyr.
    $ pip3 install --user -r ~/zephyrproject/zephyr/scripts/requirements.txt
  5. מגדירים את ערכת הכלים של Zephyr. מורידים את ערכת הכלים של Zephyr (בערך 1-2GB) לספרייה מקומית כדי לאפשר צריבת ROM‏ (flash) לרוב הלוחות.
    ‫
    $ 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 toolchain.
    $ 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 נכונה באמצעות הדוגמה Hello World, ואז להמשיך בהגדרת הפרויקט המותאם אישית.
    ‫
    $ cd ~/zephyrproject/zephyr
$ west build -p auto -b tlsr9518adk80d samples/hello_world
    משתמשים בפקודת ה-build של West כדי ליצור את הדוגמה hello_world מהספרייה הבסיסית של מאגר Zephyr. אפשר למצוא את הקושחה בשם zephyr.bin בקטע build/zephyr directory.
  7. מוסיפים את סקריפט הסביבה של Zephyr ל-~/.bashrc. מריצים את הפקודות הבאות.
    $ 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, כמו ספריית הבית ~, כדי לאפשר צריבת ROM‏ (flash) של קושחה בלוח הפיתוח B91.

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

מחברים את ה-Burning Board למחשב Linux דרך ממשק ה-USB, ואז מזינים את הפקודות הבאות.

$ 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.

קומפילציה של קושחה

ב-Codelab הזה ניצור שני סוגים של קושחת 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. מכשיר Thread עם כל התכונות ושורת פקודה אינטראקטיבית (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

העברת קושחה (Firmware Flash)

מחברים ל-Burning Board לוח פיתוח B91 באמצעות כבל USB, כמו שמוצג באיור שלמטה.

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

השיטה להפעלת Flash ב-ot-rcp זהה לשיטה להפעלת Flash ב-ot-cli-ftd. עם זאת, יש הבדלים בנתיבים ובשמות של הקושחה.

אחרי ההפעלה, מבחינים בין שני לוחות הפיתוח B91 על ידי סימון שלהם בהתאם. נותנים ללוח שמופיע לרגע עם ot-cli-ftd את התווית FTD Joiner וללוח שמופיע לרגע עם ot-rcp את התווית RCP.

4. הגדרת מסוף סדרתי למכשיר FTD Joiner

כמו שרואים בתמונה, מחברים את FTD Joiner ישירות ליציאת ה-USB של מכונת Linux.

usb_connection.png

אחרי שמחברים את מכשיר ה-Joiner של FTD למכונת Linux, פותחים את PuTTY. לאחר מכן יוצרים טרמינל חדש, מגדירים את פרטי היציאה הטורית ופותחים את היציאה הטורית.

uart_console.png

מאמרי עזרה על OpenThread CLI חשוב להוסיף את הקידומת ot לכל הפקודות.

דוגמאות:

> ot state
disabled
Done
> ot channel
11
Done
>

5. הגדרת Raspberry Pi כנתב גבול OpenThread

נתב גבולות OpenThread הוא מכשיר שמורכב משני חלקים עיקריים:

  • ‫Raspberry Pi מכיל את כל השירותים והקושחה שנדרשים כדי לפעול כנתב גבול (BR).
  • ‫RCP אחראי על התקשורת בפרוטוקול Thread.

מעבד משנה של רדיו (RCP)

כדי לצרוב את ot-rcp הקושחה, פועלים לפי אותם השלבים כמו בתהליך צריבת הקושחה ot-cli-ftd. מחברים את לוח הפיתוח B91 ליציאת USB ב-Raspberry Pi, כמו שמוצג באיור שלמטה.

OTBR_overview.png

Raspberry Pi

  1. מוודאים שתמונת מערכת ההפעלה Raspbian Bullseye Lite או Raspbian Bullseye עם Desktop נכתבו בצורה תקינה לכרטיס ה-SD.
  2. יש לכם אפשרות להתחבר ל-Raspberry Pi באמצעות SSH או לעבוד ישירות עם Raspbian Desktop. ב-codelab הזה נשתמש ב-SSH.
  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. כדי להעניק את ההרשאה כך שלא יהיה צורך להוסיף את sudo לפני כל פקודה, צריך להוסיף את החשבון הנוכחי לקבוצת Docker.
    $ sudo usermod -aG docker $USER
    כדי שהשינויים ייכנסו לתוקף, צריך להפעיל מחדש את Raspberry Pi.
  3. אם Docker לא הופעל, מפעילים אותו:
    $ sudo dockerd
  4. סקריפטים של חומת האש של OTBR יוצרים כללים בתוך קונטיינר Docker. לפני כן, מריצים את הפקודה modprobe כדי לטעון את מודול הליבה של iptables.
    $ sudo modprobe ip6table_filter

הגדרה והפעלה של Docker

ב-Codelab הזה, קובץ אימג' של Docker של OTBR נמשך ישירות מ-OpenThread Docker Hub. התמונה הזו נבדקה ואומתה על ידי צוות 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. כדי לדעת מה שם היציאה הטורית של מכשיר ה-RCP, בודקים את /dev. אם מופיע ttyACM0, סימן שמכשיר ה-RCP מחובר בצורה תקינה.
    $ 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. פותחים חלון טרמינל חדש של SSH כדי לבדוק את הקישוריות בין Raspberry Pi לבין RCP.
    $ 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 Joiner ו-OTBR מוכנים, ואפשר להמשיך לשלב הבא כדי ליצור את רשת Thread.

6. יצירת רשת Thread

יצירת רשת Thread ב-RCP

אנחנו משתמשים במעטפת ot-ctl ב-OTBR כדי ליצור רשת Thread. אם יצאתם מהמעטפת בקטע הקודם, מזינים את הפקודה הבאה כדי להפעיל אותה שוב בטרמינל SSH:

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

לאחר מכן, מזינים את הפקודות בסדר שצוין בטבלה, ומוודאים שבכל שלב מתקבלת התוצאה הצפויה לפני שממשיכים לשלב הבא.

אינדקס

פקודה

מבוא

תשובה צפויה

1

dataset init new

יוצרים מערך נתונים חדש של רשת אקראית.

סיום

2

dataset commit active

ביצוע Commit למערך נתונים חדש במערך הנתונים התפעולי הפעיל באחסון לא נדיף.

סיום

3

ifconfig up

פותחים את ממשק IPv6.

סיום

4

thread start

להפעיל את הפרוטוקול Thread ולהתחבר לרשת Thread.

סיום

מחכים 10 שניות עד שממשק השרשור מופיע.

5

state

בודקים את מצב המכשיר.אפשר להפעיל את הפקודה הזו כמה פעמים עד שהמכשיר הופך למוביל ועובר לשלב הבא.

מוביל
סיום

6

dataset active

בודקים את מערך הנתונים המבצעי הפעיל המלא ורושמים את מפתח הרשת.

חותמת זמן פעילה: 1
ערוץ: 13
מסכת ערוץ: 0x07fff800
מזהה PAN חיצוני: b07476e168eda4fc
קידומת מקומית של רשת Mesh: fd8c:60bc:a98:c7ba::/64
מפתח רשת: c312485187484ceb5992d2343baaf93d
שם רשת: OpenThread-599c
מזהה PAN: 0x599c
PSKc: 04f79ad752e8401a1933486c95299f60
מדיניות אבטחה: 672 onrc 0
בוצע

מכשירים מסוג ot-cli-ftd יצטרפו לרשת Thread הזו באמצעות מפתח הרשת שנוצר באופן אקראי על ידי OTBR במהלך יצירת הרשת.

הוספה של FTD Joiner לפרוטוקול Thread באמצעות הפעלה מחוץ לפס

הקצאת הרשאות מחוץ לפס (Out-of-band commissioning) מתייחסת להעברה של פרטי הכניסה לרשת למכשירים שממתינים להצטרפות לרשת באמצעות שיטות לא אלחוטיות (לדוגמה, הזנה ידנית ב-OpenThread CLI). מזינים את הפקודות הבאות בסדר הזה במסוף הסדרתי כדי להצטרף ל-FTD.

אינדקס

פקודה

מבוא

תשובות צפויות

1

ot dataset networkkey c312485187484ceb5992d2343baaf93d

כדי שמכשיר יוכל להתחבר לרשת בפרוטוקול Thread, נדרש רק מפתח הרשת.

סיום

2

ot dataset commit active

ביצוע Commit למערך נתונים חדש במערך הנתונים התפעולי הפעיל באחסון לא נדיף.

סיום

3

ot ifconfig up

פותחים את ממשק IPv6.

סיום

4

ot thread start

להפעיל את הפרוטוקול Thread ולהתחבר לרשת Thread.

סיום

ממתינים 20 שניות בזמן שהמכשיר מצטרף ומוגדר.

5

ot state

בודקים את מצב המכשיר.

child/router
Done

טופולוגיה

מזינים פקודות כמו ipaddr, child table, router table בטרמינל SSH כדי לקבל תשובות כמו קטעי הקוד הבאים.

> 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

ה-RLOC16 של OTBR הוא 0xb000 וה-RLOC16 של FTD Joiner הוא 0xb001. אחרי שמקבלים את מזהה הנתב, מזהה ה-FTD של המצטרף RLOC16 הופך ל-0x8400. אפשר לראות שה-FTD Joiner שודרג מצאצא לנתב.

רשת ה-Thread הנוכחית מכילה שני צמתים, והטופולוגיה שלה מוצגת באיור שלמטה.

topology.png

7. תקשורת בין מכשירים בפרוטוקול Thread

תקשורת ICMPv6

אנחנו משתמשים בפקודה ping כדי לבדוק אם מכשירי Thread באותה רשת יכולים לתקשר ביניהם. קודם כל, משתמשים בפקודה ipaddr כדי לקבל את RLOC של המכשיר.

> 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 Joiner קיבל את תגובת הפינג שהוחזרה על ידי ה-OTBR. התקשורת בין שני המכשירים תקינה.

תקשורת UDP

שירותי האפליקציות שמסופקים על ידי OpenThread כוללים גם UDP. אפשר להשתמש ב-UDP API כדי להעביר מידע בין צמתים ברשת Thread, או להעביר מידע לרשתות חיצוניות דרך נתב הגבול. הסבר מפורט על OpenThread's UDP API מופיע במאמר OpenThread CLI - UDP Example. ב-codelab הזה נשתמש בחלק מממשקי ה-API כדי להעביר מידע בין OTBR ל-FTD Joiner.

קודם כול, צריך לקבל את ה-EID המקומי של רשת ה-Mesh של OTBR. הכתובת הזו היא גם אחת מכתובות ה-IPv6 של מכשיר Thread, ואפשר להשתמש בה כדי לגשת למכשירי Thread באותו חלק של רשת Thread.

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

מזינים את הפקודות הבאות בטרמינל SSH כדי להפעיל את OTBR UDP ולאגד את יציאת 1022 של המכשיר.

> udp open
Done
> udp bind :: 1022
Done

מזינים את הפקודות הבאות במסוף הטורי ומפעילים את ה-UDP של FTD Joiner. מבצעים binding של יציאת 1022 במכשיר, ואז שולחים הודעת hello באורך 5 בייט ל-OTBR.

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

בטרמינל של SSH מוצג המידע הבא. ה-OTBR מקבל את ההודעה hello מה-FTD Joiner, כלומר תקשורת ה-UDP הצליחה.

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

8. מזל טוב

יצרתם רשת פשוטה עם פרוטוקול Thread ואימתתם את התקשורת בתוך הרשת הזו.

עכשיו אתם יודעים:

  • איך יוצרים את סביבת הפיתוח Telink Zephyr ומשתמשים בה.
  • איך לבנות את הקבצים הבינאריים ot-cli-ftd ו-ot-rcp, וגם לצרוב אותם ללוחות פיתוח Telink B91.
  • איך מגדירים Raspberry Pi 3B+‎ או גרסה מתקדמת יותר כנתב גבול OpenThread ‏ (OTBR) באמצעות Docker.
  • איך יוצרים רשת Thread ב-OTBR.
  • איך מוסיפים מכשירים לרשת Thread באמצעות הקצאת הרשאות מחוץ לפס.
  • איך מאמתים את החיבור בין הצמתים ברשת Thread.

קריאה נוספת

באתר openthread.io וב-GitHub אפשר לקרוא על משאבים שונים של OpenThread, כולל:

  • פלטפורמות נתמכות – כאן אפשר לראות את כל הפלטפורמות שתומכות ב-OpenThread
  • Build OpenThread – פרטים נוספים על בנייה והגדרה של OpenThread
  • ‫Thread Primer – הסבר על כל המושגים שקשורים ל-Thread שמופיעים ב-Codelab הזה

מסמכי עזר: