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

1. מבוא

26b7f4f6b3ea0700.png

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

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

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

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

codelab_overview.png

מה תלמדו

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

מה הדרישות כדי להצטרף לתוכנית?

חומרה:

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

תוכנה:

  • הכלי לצריבה וניפוי באגים של Telink — LinuxBDT.
  • כלי לטרמינל יציאה טורית, כגון PuTTY.
  • כלים אחרים כמו Git ו-Wast.

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

מושגי Thread ו-OpenThread CLI

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

מחשב Linux

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

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

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

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

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

overview.png

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

אינדקס

שם

1

Telink B91 Development Board (מועצת הפיתוח של Telink B91)

2

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

3

אנטנה של 2.4Ghz

4

כבל USB (מ-USB A ל-mini USB)

Raspberry Pi 3B+ ומעלה עם תמונת מערכת הפעלה של Raspbian

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

חיבור לרשת

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

LinuxBDT

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

אחרים

  • Git, להגדרת סביבת הפיתוח של Telink Zephyr.
  • מערב, כדי לנהל את פרויקט 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 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~2 GB) לספרייה מקומית כדי להבהב את רוב הלוחות.
    $ 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
    משתמשים בפקודה West build כדי ליצור את הדוגמה 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 Docs – המדריך לתחילת העבודה.

הורד את הכלי Telink LinuxBDT וחלץ אותו לספרייה מקומית במחשב Linux שלך, כגון ספריית הבית ~. פעולה זו מאפשרת להפעיל קושחה של קושחה ל-B91 Development Board.

$ 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

הבזק קושחה

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

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

4. הגדרת קונסולה טורית למכשיר הצירוף FTD

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

usb_connection.png

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

uart_console.png

ההפניה לשורת הפקודה OpenThread נמצאת כאן: OpenThread CLI. חשוב להוסיף את התחילית ot לכל הפקודות.

דוגמאות:

> ot state
disabled
Done
> ot channel
11
Done
>

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

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

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

מעבד רדיו משותף (RCP)

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

OTBR_overview.png

פטל פאי

  1. צריך לוודא שתמונת מערכת ההפעלה Raspbian Bullseye Lite או Raspbian Bullseye with Desktop כתובים כראוי בכרטיס ה-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 כדי לטעון את מודול הליבה של iptables.
    $ 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. מריצים את 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 ps -aq
  • הפסקת OTBR Docker:
    $ docker stop otbr
  • הסרת Docker של OTBR:
    $ docker rm otbr
  • טעינה מחדש של Docker OTBR:
    $ docker restart otbr

בשלב הזה, מכשיר FTD Connector ו-OTBR מוכנים, ואפשר להמשיך לשלב הבא של יצירת רשת Thread.

6. יצירת Thread Network

יצירת Thread Network ב-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 שניות עד שממשק השרשור יהיה מוכן.

5

state

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

מנהיג
סיום

6

dataset active

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

Active Timestamp: 1
ערוץ: 13
מסכת ערוץ: 0x07fff800
מזהה PAN חיצוני: b07476e168eda4fc
Mesh קידומת מקומית: fd8c:60bc:a98:c7ba::/64
מפתח רשת: c312485187484




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

הוספת FTD Shareder ל-Thread דרך הזמנה מחוץ למסגרת

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

אינדקס

פקודה

מבוא

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

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 Connectorer שודרג מילד לנתב.

רשת ה-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

כדי לבצע את פעולת ה-ping, מזינים את הפקודה הבאה במסוף הטורי של FTD Shareder.

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

תקשורת ב-UDP

שירותי האפליקציות שמסופקים על ידי OpenThread כוללים גם UDP. אתם יכולים להשתמש ב-UDP API כדי להעביר מידע בין צמתים ברשת ה-Thread או להעביר מידע לרשתות חיצוניות באמצעות נתב הגבולות. במבוא ל-UDP API של OpenThread אפשר למצוא את OpenThread CLI – דוגמה ל-UDP. ה-Codelab הזה ישתמש בחלק מממשקי ה-API שבו כדי להעביר מידע בין OTBR ל-FTD Connector.

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

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

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

> udp open
Done
> udp bind :: 1022
Done

מזינים את הפקודות הבאות במסוף הטורי ומפעילים את ה-UDP של FTD Connector. מקשרים את יציאת 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, וכן לשלב אותם בלוחות הפיתוח של Telink B91.
  • איך להגדיר Raspberry Pi 3B+ בגרסה חדשה יותר כנתב OpenThread Border (OTBR) באמצעות Docker.
  • איך יוצרים רשת Thread ב-OTBR
  • איך להוסיף מכשירים לרשת Thread באמצעות הזמנה מחוץ למסגרת.
  • איך מאמתים את הקישוריות בין הצמתים ברשת ה-thread.

קריאה נוספת

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

מסמכי עזר: