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 מלא). אם הערכה עדיין לא ברשותכם, תוכלו לקבל פרטים נוספים מהאתר הרשמי של קישור הקישור. הנה כמה דוגמאות לשימוש:
אינדקס | שם |
1 | מועצת הפיתוח של Telink B91 |
2 | פאנל שור |
3 | אנטנת 2.4Ghz |
4 | כבל USB (USB A עד מיני USB) |
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
לאחר מכן, מבצעים את השלבים הבאים.
- מתקינים את יחסי התלות.
$ 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 במראה יציב ועדכני, או לעדכן את יחסי התלות האלה באופן ידני. - מתקינים את האפליקציה מערב.
$ pip3 install --user -U west $ echo 'export PATH=~/.local/bin:"$PATH"' >> ~/.bashrc $ source ~/.bashrc
יש לוודא שהמשתנה~/.local/bin
הוא במשתנה הסביבה$PATH
. - קבלת קוד המקור של פרויקט Zephyr.
$ west init ~/zephyrproject $ cd ~/zephyrproject $ west update $ west blobs fetch hal_telink $ west zephyr-export
- מתקינים יחסי תלות נוספים של Python ב-Zephyr.
$ pip3 install --user -r ~/zephyrproject/zephyr/scripts/requirements.txt
- מגדירים את ארגז הכלים של זפיר. הורדה של ערכת הכלים של 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
- בונים את דוגמה ל-Hello World. קודם צריך לוודא שהתצורה הרשמית של פרויקט Zephyr נכונה באמצעות הדוגמה 'שלום עולם', ואז להמשיך בהגדרת הפרויקט המותאם אישית.
$ cd ~/zephyrproject/zephyr $ west build -p auto -b tlsr9518adk80d samples/hello_world
כדי ליצור את הדוגמה hello_world מספריית הבסיס של מאגר Zephyr, צריך להשתמש בפקודה Build. הקושחה שנקראתzephyr.bin
נמצאת מתחת ל-build/zephyr directory
. - מוסיפים את הסקריפט של סביבת Zephyr ל-
~/.bashrc
. מריצים את הפקודות הבאות.$ echo "source ~/zephyrproject/zephyr/zephyr-env.sh" >> ~/.bashrc $ source ~/.bashrc
- מוסיפים את המאגר המרוחק של 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
.
שיטות האיסוף מופיעות כך:
- מעבד רדיו משותף (
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
- מכשיר עם שרשור מלא עם שורת פקודה אינטראקטיבית (
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, כפי שמתואר באיור למטה.
פטל פאי
- יש לוודא שתמונת ה-Rasbian Bullsray Lite OS או תמונת Raspbian Bullsray עם מחשב שולחני נכתבות כראוי בכרטיס ה-SD.
- אפשר להשתמש ב-SSH ב-Raspney Pi או לעבוד ישירות ב-Raspbian Desktop. Codelab זה ישתמש ב-SSH.
- לפני שממשיכים להתקין את OTBR Docker בשלב הבא, תחילה יש לעדכן את המאגר המקומי ואת מנהל החבילות.
$ sudo apt-get update $ sudp apt-get upgrade
התקנת Docker
אם מעדכנים את המאגר המקומי ואת מנהל החבילות של ה-APT בשלב הקודם, צריך להפעיל מחדש את Raspery Pi ואז לפתוח חלון של מסוף SSH.
- התקנת Docker:
$ curl -sSL https://get.docker.com | sh
- יש להעביר את החשבון הנוכחי לקבוצת Docker כדי להעניק את ההרשאה, כך שלא יהיה צורך להוסיף את
sudo
לפני כל פקודה.$ sudo usermod -aG docker $USER
עליך להפעיל מחדש את ה-Raspney Pi כדי להיכנס לתוקף. - אם Docker לא הופעל, מתחילים אותו:
$ sudo dockerd
- הסקריפטים של חומת האש ב-OTBR יוצרים כללים בתוך הקונטיינר של Docker. לפני כן, צריך להפעיל את
modprobe
כדי לטעון את מודול הליבה של ה-IPtables.$ sudo modprobe ip6table_filter
הגדרה והפעלה של Docker
תכונת ה-Codelab הזו שולפת ישירות את תמונת OTBR Docker מ-OpenThread Docker Hub. צוות Openthread נבדק ומאמת את התמונה הזו.
- יש למשוך את התמונה העדכנית ביותר:
$ docker pull openthread/otbr:latest
- בודקים את רשימת התמונות במאגר של Docker:
$ docker images REPOSITORY TAG IMAGE ID CREATED SIZE openthread/otbr latest db081f4de15f 6 days ago 766MB
- כדי לקבוע את שם היציאה הטורית של מכשיר ה-RCP, בודקים את
/dev
,ttyACM0
מציין שה-RCP מחובר כראוי.$ ls /dev/tty* ... /dev/ttyACM0 ...
- מריצים את 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
- פותחים חלון חדש של מסוף 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"
לאחר מכן, מזינים את הפקודות לפי הסדר שצוין בטבלה ומוודאים שכל שלב מגיע לתוצאה הצפויה לפני שממשיכים לשלב הבא.
אינדקס | Command | מבוא | תגובה צפויה | ||
1 |
| יצירת מערך נתונים חדש של רשת אקראית. | סיום | ||
2 |
| שומרים את מערך הנתונים החדש על מערך הנתונים התפעולי הפעיל בתנודתיות. | סיום | ||
3 |
| מציגים את ממשק IPv6. | סיום | ||
4 |
| הפעלה של פרוטוקול Thread והתחברות לרשת של Thread. | סיום | ||
ממתינים 10 שניות עד שממשק השרשור יופעל. | |||||
5 |
| צריך לבדוק את מצב המכשיר.אפשר לקרוא לפקודה הזו כמה פעמים עד שהיא תהפוך למובילה, ותועבר לשלב הבא. | מוביל | ||
6 |
| יש לבדוק את מערך הנתונים התפעולי המלא ולהקליט את מפתח הרשת. | חותמת זמן פעילה: 1 |
מפתח הרשת שנוצר באופן אקראי על ידי OTBR במהלך יצירת הרשת ישמש כשמכשירי ot-cli-ftd
יצטרפו לרשת ה-Thread הזו.
מוסיפים את המחבר של FTD ל-Thread דרך הזמנה מחוץ למסגרת
שימוש ב'עמלות מחוץ למסגרת' מתייחס להעברה של פרטי כניסה לרשת למכשירים שממתינים להצטרפות לרשת בשיטות לא אלחוטיות (למשל, הזנה ידנית ב-OpenThread CLI). מזינים את הפקודות הבאות לפי הסדר במסוף הטורי אל רכיב ה-FTD.
אינדקס | Command | מבוא | תגובות צפויות | ||
1 |
| רק מפתח הרשת נדרש כדי שהמכשיר יתחבר לרשת Thread. | סיום | ||
2 |
| שומרים את מערך הנתונים החדש על מערך הנתונים התפעולי הפעיל בתנודתיות. | סיום | ||
3 |
| מציגים את ממשק IPv6. | סיום | ||
4 |
| הפעלה של פרוטוקול Thread והתחברות לרשת של Thread. | סיום | ||
ממתינים 20 שניות עד שהמכשיר מצטרף ומגדיר את עצמו. | |||||
5 |
| בודקים את מצב המכשיר. | ילד/נתב |
טופולוגיה
יש להזין פקודות כמו 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 הזה
מסמכי עזר: