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

1. מבוא

26b7f4f6b3ea0700.png

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

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

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

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

codelab_overview.png

מה תלמדו

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

למה תזדקק?

חומרה:

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

תוכנה:

  • הכלי Telink Burning וניפוי באגים — LinuxBDT.
  • כלי עם טרמינל עם יציאה טורית, כמו Puty.
  • כלים אחרים כמו Git ו-Western Union.

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

מושגי Thread ו-CLI של OpenThread

מומלץ לעבור על הקוד של OpenThread Simulation כדי להכיר את מושגי היסוד של פרוטוקול Thread ואת ה-CLI של OpenThread לפני ה-Codelab הזה.

מכונת Linux

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

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

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

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

ל-Codelab הזה נדרשות שתי ערכות של ערכות פיתוח B91. בתמונה שלמטה רואים את הרכיבים המינימליים הנדרשים בקבוצה אחת.

overview.png

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

אינדקס

שם

1

מועצת הפיתוח של Telink B91

2

לוח עבור צריבה של Telink

3

אנטנת 2.4Ghz

4

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

Raspberry Pi 3B+ או יותר עם תמונה של Raspbian OS

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

חיבור לרשת

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

LinuxBDT

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

אחרים

  • 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. התקנה לכיוון מערב.
    $ 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. מתקינים יחסי תלות נוספים של Python עבור Zephyr.
    $ pip3 install --user -r ~/zephyrproject/zephyr/scripts/requirements.txt
  5. הגדרת 'צרור הכלים של Zephyr'. מורידים את ה-toolchain של Zephyr (בערך 1~2GB) לספרייה מקומית כדי שתוכלו להפעיל את רוב הלוחות.
    $ 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 הרשמית היא נכונה בעזרת הדוגמה 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, כמו ספריית הבית ~, לצורך הפעלת קושחה מסוג 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

קושחה Flash

מחברים לוח פיתוח B91 ל-Burning Board באמצעות כבל 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 זהה בעיקרה לזו של ot-cli-ftd. עם זאת, יש הבדלים בשמות ובנתיבי הקושחה.

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

4. הגדרת מסוף טורי עבור מכשיר ההצטרפות ל-FTD

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

usb_connection.png

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

uart_console.png

כאן אפשר למצוא את ההפניה לשורת הפקודה של OpenThread: חומר עזר בנושא CLI של OpenThread. חשוב להוסיף 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 Development Board (מועצת הפיתוח B91) ליציאת USB ב-Raspberry Pi, כפי שמתואר באיור שלמטה.

OTBR_overview.png

פאי פטל

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

הגדרה והרצה של Docker

ה-Codelab הזה שולף את קובץ האימג' של OTBR באמצעות Docker מ-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. מריצים את Docker של OTBR בפעם הראשונה, ומכוונים את היציאה הטורית של RCP (ttyACM0). אם רוצים להמשיך להשתמש ב-Docker OTBR, משתמשים בפקודה 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

פקודות Docer אופציונליות:

  • מקבלים מידע על הקונטיינר של Docker שפועל:
    $ docker ps -aq
  • הפסקת Docker של OTBR:
    $ docker stop otbr
  • הסרת OTBR Docker:
    $ docker rm otbr
  • טעינה מחדש של Docker OTBR:
    $ docker restart otbr

בשלב הזה, מכשיר לצירוף FTD ו-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

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

סיום

3

ifconfig up

מציגים את ממשק IPv6.

סיום

4

thread start

הפעלת הפעולה של פרוטוקול Thread וצירוף לרשת של פרוטוקול Thread.

סיום

ממתינים 10 שניות עד שממשק ה-thread ייפתח.

5

state

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

leader
Done

6

dataset active

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











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

הוספה של חיבור FTD לשרשור באמצעות הזמנה מחוץ למסגרת

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

אינדקס

פקודה

מבוא

התגובות הצפויות

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 בטרמינל 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 הוא בהתחלה 0xb001. ואז RLOC16 של חיבור ה-FTD הופך ל-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, או להעביר מידע לרשתות חיצוניות באמצעות נתב הגבולות. המבוא המפורט ל-UDP API של OpenThread מופיע בקטע OpenThread CLI – דוגמה ל-UDP. ה-Codelab הזה ישתמש בחלק מממשקי ה-API כדי להעביר מידע בין OTBR לבין FTD Joiner.

קודם כול, מקבלים את ה-EID מסוג Mesh-Local של 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. מכסים את יציאת המכשיר 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, והמשמעות היא שהתקשורת בין ה-UDP בוצעה בהצלחה.

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

8. מזל טוב

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

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

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

קריאה נוספת

מומלץ להיכנס ל-openthread.io ול-GitHub כדי ללמוד על משאבים שונים של OpenThread, כולל:

מסמכי עזר: