פיתוח רשת Thread עם B91 Development Board ו-OpenThread

1. מבוא

OpenThread הוא הטמעת קוד פתוח של פרוטוקול הרשת Thread®, פרוטוקול פרוטוקול רשת אלחוטי מאובטח ומאובטח שמיועד למכשירי האינטרנט של הדברים (IoT). צוות OpenThreads פותח על ידי צוות 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.

מה תלמדו

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

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

חומרה:

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

תוכנה:

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

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

קונספטים של Thread ו-OpenThread CLI

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

מכונת Linux

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

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

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

במעבדה הזו, משמש כלי הטרמינל PuTTY לשליטה על חיבור ה-FTD ועל פטל פאי. הוא כולל סקירה כללית של השימוש, אך ניתן להשתמש גם בתוכנות Terminal אחרות.

ערכת פיתוח Tlink_B91

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

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

Raspber Pi 3B או יותר עם Raspbian OS תמונה

ב-Codelab הזה נדרשת גרסה 3 יותר או יותר של Raspery Pi 3B או יותר עם Raspbian Bullsray Lite OS או Raspbian Bullsray עם מחשב. הוא מחובר לאינטרנט באמצעות אתרנט, והוא יוגדר כמארח של Openthread Border Router (OTBR).

חיבור לרשת

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

LinuxBDT

Telink Burling and Debugger (BDT), שחל על כל סדרת הצ'יפים של Telink, מאפשר למחוק ולהבליט קושחה של OpenThread בלוחות פיתוח של Telink B91. מתקינים את גרסת ה-Linux 8uxBlint במחשב עם Linux.

אחרים

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

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

הגדרה של סביבת פיתוח של Telink Zephyr

במחשב 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
   

   צריך לאמת את הגרסאות המותקנות במערכת לפני שממשיכים לשלבים הבאים. אם הגרסאות לא נכונות, יש להחליף את המראה של ה-AAP במראה יציב ועדכני, או לעדכן את יחסי התלות האלה באופן ידני.
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 (כ-1GB) לספרייה מקומית תאפשר לך להבליט את רוב הלוחות.

   $ 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
   

   מורידים את ה-SDK של Zephyr ומציבים אותו בנתיב המומלץ, כפי שמוצג בהמשך.

   $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
   

   כדי ליצור את הדוגמה hello_world מספריית הבסיס של מאגר Zephyr, צריך להשתמש בפקודה Build. הקושחה שנקראת 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

עליך להוריד את הכלי Telink LinuxBDT ולחלץ אותו לספרייה מקומית במחשב שלך כמו Linux, כמו ספריית הבית ~.

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

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

בשורת הפקודה, מבצעים את הפקודות הבאות כדי לבצע שריפת קושחה (באמצעות הבהוב של הקושחה של 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", ואת הלוח הבהב באמצעות ot-rcp לסימון "RCP".

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

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

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

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

דוגמאות:

> ot state
disabled
Done
> ot channel
11
Done
>

5. הגדרת פטל פאי כנתב גבול פתוח

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

• Raspney Pi מכיל את כל השירותים ואת הקושחה הנדרשים כדי לפעול כנתב גבול.
• RCP אחראי על התקשורת בשרשור.

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

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

פטל פאי

1. יש לוודא שתמונת ה-Rasbian Bullsray Lite OS או תמונת Raspbian Bullsray עם מחשב שולחני נכתבות כראוי בכרטיס ה-SD.
2. אפשר להשתמש ב-SSH ב-Raspney Pi או לעבוד ישירות ב-Raspbian Desktop. Codelab זה ישתמש ב-SSH.
3. לפני שממשיכים להתקין את OTBR Docker בשלב הבא, תחילה יש לעדכן את המאגר המקומי ואת מנהל החבילות.

   $ sudo apt-get update
   $ sudp apt-get upgrade
   

התקנת Docker

אם מעדכנים את המאגר המקומי ואת מנהל החבילות של ה-APT בשלב הקודם, צריך להפעיל מחדש את Raspery Pi ואז לפתוח חלון של מסוף SSH.

1. התקנת Docker:

   $ curl -sSL https://get.docker.com | sh
   

2. יש להעביר את החשבון הנוכחי לקבוצת Docker כדי להעניק את ההרשאה, כך שלא יהיה צורך להוסיף את sudo לפני כל פקודה.

   $ sudo usermod -aG docker $USER
   

   עליך להפעיל מחדש את ה-Raspney 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 כדי לבדוק את הקישוריות בין Raspney 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 rm otbr
  

• טעינה מחדש של אביזר העגינה של 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"

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

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

מוסיפים את המחבר של FTD ל-Thread דרך הזמנה מחוץ למסגרת

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

טופולוגיה

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

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

7. תקשורת בין מכשירי השרשור

תקשורת ב-ICMPv6

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

> 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. התקשורת בין שני המכשירים בוצעה בהצלחה.

תקשורת ב-UDP

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

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

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

קריאה נוספת

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

• פלטפורמות נתמכות – כל הפלטפורמות התומכות ב-OpenThread
• Open OpenThread — פרטים נוספים על יצירה והגדרה של OpenThread
• Thread Primer – מכסה את כל המושגים בשרשור שמוצגים ב-Codelab הזה

מסמכי עזר:

• חומרי עזר ל-OpenThread CLI
• חומרי עזר ל-OpenThread UDP CLI
• הפניית OpenThread UDP API