1. מבוא
OpenThread, Google הוציאה משימוש את הקוד הפתוח של פרוטוקול Thread®. Google Nest השיקה את OpenThread, כדי שטכנולוגיה המשמשת במוצרי Nest תהיה זמינה באופן נרחב למפתחים כדי להאיץ את פיתוח המוצרים לבית החכם.
המפרט של Thread מגדיר פרוטוקול תקשורת אמין, מאובטח וחזק עם חיבור Bluetooth למכשירים שונים, לשימוש באפליקציות ביתיות. Openthread מיישם את כל שכבות הרשת של Thread, כולל IPv6, 6LoWPAN, IEEE 802.15.4 עם אבטחת MAC, תשתית לקישור רשת וניתוב רשת.
ב-Codelab הזה תלמדו לתכנת ב-OpenThread בחומרה אמיתית, ליצור ולנהל רשת Thread ולהעביר הודעות בין צמתים.
מה תלמדו
- בנייה והעברה של קובצי בינאריים של OpenCLI אל לוחות פיתוח
- בניית RCP המורכב ממכונת Linux ומלוח פיתוח
- תקשורת עם RCP באמצעות OpenThread Daemon ו-
ot-ctl
- ניהול ידני של צומתי Thread עם מסך GNU ועם CLI של OpenThread
- שליחה מאובטחת של מכשירים לרשת Thread
- איך פועל IPv6 מולטיקאסט
- העברת הודעות בין צומתי Thread עם UDP
מה הדרישות כדי להצטרף לתוכנית?
חומרה:
- 3 לוחות נורדיים למחצה nRF52840 פיתוח
- 3 כבלי USB למיקרו USB כדי לחבר את הלוחות
- מכונת Linux עם לפחות 3 יציאות USB
תוכנה:
- ארגז כלים של GNU
- כלי שורת הפקודה הנורדיים של nRF5x
- תוכנת Segger J-Link
- OpenThread
- Git
2. איך מתחילים
הדמיית Openthread
לפני שמתחילים, כדאי לעיין ב-OpenThread Simulation Codelab כדי להכיר את המושגים הבסיסיים של Thread ואת המדיניות של OpenThread CLI.
מסופי יציאה טורית
עליכם לדעת איך להתחבר ליציאה טורית באמצעות מסוף. Codelab זה משתמש ב-GNU Screen ומספק סקירה כללית של השימוש, אבל ניתן להשתמש בכל תוכנת מסוף אחרת.
מכונת Linux
Codelab זה תוכנן להשתמש במכונת Linux המבוססת על i386 או x86 כדי לשמש כמארח של מכשיר Thread Co- אחרים. כל השלבים נבדקו ב-Ubuntu 14.04.5 LTS (Trusty Tahr).
לוחות nRF52840 נורדיים
Codelab זה משתמש בשלושה nRF52840 PDK לוחות.
התקנת SEGGER J-Link
אנחנו משתמשים ב-SEGGER J-Link כדי לתכנת את לוחות nRF52840 הכוללים מודולים של JTAG. מתקינים את ההתקנה במחשב של Linux.
מורידים את החבילה המתאימה למכשיר ומתקינים אותה במיקום הנכון. ב-Linux זה /opt/SEGGER/JLink
.
התקנת nRF5x כלי שורת הפקודה
כלי שורת הפקודה nRF5x מאפשרים לך להבליט את הקבצים הבינאריים של OpenThread ללוחות nRF52840. עליך להתקין את ה-build המתאים של nRF5x-Command-Line-Tools-<OS> במחשב Linux.
החבילה של הפריט שחולצה נמצאת בתיקיית הבסיס ~/
התקנת ARM GNU Toolchain
הכלי ARM GNU Toolchain משמש לבנייה.
מומלץ למקם את הארכיון שחולץ ב-/opt/gnu-mcu-eclipse/arm-none-eabi-gcc/
במחשב Linux שלך. יש לפעול לפי ההוראות שבקובץ readme.txt
שבארכיון כדי לקבל הוראות התקנה.
התקנת מסך (אופציונלי)
המסך הוא כלי פשוט לגישה למכשירים המחוברים ליציאה טורית. ב-Codelab הזה נעשה שימוש ב-Screen, אבל אפשר להשתמש בכל אפליקציה של מסוף טורי שרוצים.
$ sudo apt-get install screen
3. שכפול מאגרים
OpenThread
שכפול והתקנה של OpenThread. הפקודות script/bootstrap
מוודאות שארגז הכלים מותקן ושהסביבה מוגדרת כראוי:
$ mkdir -p ~/src $ cd ~/src $ git clone --recursive https://github.com/openthread/openthread.git $ cd openthread $ ./script/bootstrap
גרסת build של OpenThread דימון:
$ script/cmake-build posix -DOT_DAEMON=ON
עכשיו הכול מוכן ליצירה ולפלאש של OpenThread ללוחות nRF52840.
4. הגדרת חיבור ל-RCP
בנייה והבהוב
בונים את הדוגמה של OpenThread nRF52840 עם פונקציונליות מובנית של חיבור ל-USB. מכשיר משתמש בתפקיד המחבר כדי לבצע אימות מאובטח ולהזמין אותו לרשת שרשור. USB מקורי מאפשר להשתמש ב-USB CDC ACM בתור העברה טורית בין ה-nRF52840 למארח.
לפני שפותחים rm -rf build
, צריך לנקות את רשימת ה-builds הקודמים.
$ cd ~/src $ git clone --recursive https://github.com/openthread/ot-nrf528xx.git $ cd ot-nrf528xx $ script/build nrf52840 USB_trans
מנווטים לספרייה עם הקובץ הבינארי של OpenThread RCP וממירים אותו לפורמט הקסדצימלי:
$ cd ~/src/ot-nrf528xx/build/bin $ arm-none-eabi-objcopy -O ihex ot-rcp ot-rcp.hex
מחברים את כבל ה-USB ליציאת ניפוי הבאגים של מיקרו USB ליד סיכת החשמל החיצונית בלוח nRF52840, ולאחר מכן מחברים אותו למחשב Linux. מעבירים את המתג של מקור המתח ב-NRF ללוח ה-nRF52840 למצב VDD. אם החיבור תקין, LED5 פועל.
אם זה לוח העריכה הראשון שמחובר למחשב Linux, הוא מופיע כיציאה טורית /dev/ttyACM0
(כל לוחות ה-nRF52840 משתמשים ב-ttyACM
כמזהה של יציאה טורית).
$ ls /dev/ttyACM* /dev/ttyACM0
יש לציין את המספר הסידורי של לוח nRF52840 המשמש ל-RCP:
עוברים למיקום של כלי שורת הפקודה nRFx, והופכים את הקובץ ההקסדצימלי של OpenThread RCP ללוח nRF52840 באמצעות המספר הסידורי של הלוח. חשוב לזכור שאם לא מסמנים את הדגל --verify
, תופיע הודעת אזהרה על כך שתהליך הפלאש עלול להיכשל ללא שגיאה.
$ cd ~/nrfjprog/ $ ./nrfjprog -f nrf52 -s 683704924 --verify --chiperase --program \ ~/src/ot-nrf528xx/build/bin/ot-rcp.hex --reset
הפלט הבא נוצר בהצלחה:
Parsing hex file. Erasing user available code and UICR flash areas. Applying system reset. Checking that the area to write is not protected. Programing device. Applying system reset. Run.
סמנו את הלוח "RCP" כדי למנוע בלבול בין התפקידים בלוח.
התחברות ל-USB מקורי
מאחר שה-build של OpenThread RCP מאפשר שימוש ב-USB CDC ACM מקורי כתחבורה טורית, צריך להשתמש ביציאת nRF USB בלוח nRF52840 כדי לתקשר עם מארח ה-RCP (מכונת Linux).
מנתקים את הקצה המיקרו-USB של כבל ה-USB מיציאת ניפוי הבאגים של לוח ה-nRF52840 המהבהב ולאחר מכן מחברים אותו מחדש ליציאת ה-NRF USB של המיקרו-USB לצד הלחצן איפוס. מעבירים את המתג של מקור המתח ב-NRF למצב USB.
הפעלה של OpenThread Daemon
בעיצוב RCP, משתמשים ב-OpenThread Daemon כדי לתקשר עם מכשיר Thread ולנהל אותו. מפעילים את ot-daemon
עם הסימון המפורט -v
כדי שיהיה אפשר לראות פלט ביומן ולוודא שהוא פועל:
$ cd ~/src/openthread $ sudo ./build/posix/src/posix/ot-daemon -v \ 'spinel+hdlc+uart:///dev/ttyACM0?uart-baudrate=115200'
כשהפעולה מבוצעת בהצלחה, ot-daemon
במצב 'מילולי' יוצר פלט דומה לזה:
ot-daemon[12463]: Running OPENTHREAD/thread-reference-20200818-1938-g0f10480ed; POSIX; Aug 30 2022 10:55:05 ot-daemon[12463]: Thread version: 4 ot-daemon[12463]: Thread interface: wpan0 ot-daemon[12463]: RCP version: OPENTHREAD/thread-reference-20200818-1938-g0f10480ed; SIMULATION; Aug 30 2022 10:54:10
יש להשאיר את החלון הזה של המסוף פתוח כדי שיהיה אפשר לצפות ביומנים של ot-daemon
.
יש להשתמש ב-ot-ctl
כדי לתקשר עם צומת ה-RCP. ot-ctl
משתמש באותו CLI כמו אפליקציית OpenThread CLI, ולכן אפשר לשלוט בצמתים של ot-daemon
באותו אופן שבו משתמשים בסימולציה אחרת של מכשירי Thread.
בחלון שני של הטרמינל, מתחילים את ot-ctl
:
$ sudo ./build/posix/src/posix/ot-ctl >
בודקים את state
של צומת 2 (צומת ה-RCP) שהתחלתם עם ot-daemon
:
> state disabled Done
5. הגדרת FTD
שני צומתי השרשור האחרים שמשמשים ב-Codelab הזה הם מכשירים עם שרשור מלא (FTD) בעיצוב הרגיל של המערכת על שבב (SoC). בהגדרה בסביבת ייצור, אפשר להשתמש ב-wpantund
, מנהל התקן של רשת ברמת הייצור, כדי לשלוט במכונות של NCP ב-OpenThread, אבל ב-Codelab הזה נשתמש ב-ot-ctl
, ה-CLI של OpenThread.
מכשיר אחד משמש כנציב/ת הרשת, כדי לאמת מכשירים ולשריין אותם באופן מאובטח ברשת הזאת. המכשיר השני פועל כ-joiner שהנציב יכול לאמת לרשת ה-thread.
בנייה והבהוב
בונים את הדוגמה של OpenThread FTD לפלטפורמת nRF52840 עם התפקידים 'נציב' ו'מצרף':
$ cd ~/src/ot-nrf528xx $ rm -rf build $ script/build nrf52840 USB_trans -DOT_JOINER=ON -DOT_COMMISSIONER=ON
מנווטים לספרייה עם התוכנה הבינארית CLI של OpenThread (FTD) וממירים אותה לפורמט הקסדצימלי:
$ cd ~/src/ot-nrf528xx/build/bin $ arm-none-eabi-objcopy -O ihex ot-cli-ftd ot-cli-ftd.hex
מחברים את כבל ה-USB ליציאת המיקרו USB לצד סיכת החשמל החיצונית בלוח nRF52840, ולאחר מכן מחברים אותו למחשב Linux. אם ה-RCP עדיין מחובר למכונת ה-Linux, הלוח החדש אמור להופיע בתור יציאה טורית /dev/ttyACM1
(כל לוחות ה-nRF52840 משתמשים ב-ttyACM
כמזהה היציאה הטורית).
$ ls /dev/ttyACM* /dev/ttyACM0 /dev/ttyACM1
כמו בעבר, יש לשים לב למספר הסידורי של הלוח nRF52840 המשמש את ה-FTD:
מנווטים אל המיקום של כלי שורת הפקודה nRFx, והופכים את הקובץ ההקסדצימלי של OpenThread CLI FTD ללוח nRF52840, באמצעות המספר הסידורי של הלוח:
$ cd ~/nrfjprog/ $ ./nrfjprog -f nrf52 -s 683704924 --verify --chiperase --program \ ~/src/ot-nrf528xx/build/bin/ot-cli-ftd.hex --reset
מסמנים את הלוח בשם "Commitment".
התחברות ל-USB מקורי
מאחר שה-build של OpenThread FTD מאפשר שימוש ב-USB CDC ACM מקורי כהעברה טורית, עליכם להשתמש ביציאת nRF USB בלוח nRF52840 כדי לתקשר עם מארח ה-RCP (מכונת Linux).
מנתקים את הקצה המיקרו-USB של כבל ה-USB מיציאת ניפוי הבאגים של לוח ה-nRF52840 המהבהב ולאחר מכן מחברים אותו מחדש ליציאת ה-NRF USB של המיקרו-USB לצד הלחצן איפוס. מעבירים את המתג של מקור המתח ב-NRF למצב USB.
אימות גרסת ה-build
כדי לאמת build תקין, פותחים את ה-CLI של OpenThread דרך מסך ה-GNU מחלון הטרמינל. בלוחות מסוג nRF52840 נעשה שימוש בקצב שידור של 115200.
$ screen /dev/ttyACM1 115200
בחלון החדש, מקישים על 'Return' כמה פעמים כדי להציג את ההודעה של OpenThread CLI >
. מציגים את ממשק IPv6 ובודקים אם יש כתובות:
> ifconfig up Done > ipaddr fe80:0:0:0:1cd6:87a9:cb9d:4b1d Done
השתמשו ב-Ctrl+a ←
d
כדי להתנתק מהמסך של FTD Commissioner CLI ולחזור למסוף Linux כדי שיהיה אפשר להבליט את הלוח הבא. כדי להיכנס מחדש ל-CLI בכל שלב, אפשר להשתמש ב-screen -r
משורת הפקודה. אפשר לראות רשימה של מסכים זמינים באמצעות screen -ls
:
$ screen -ls There is a screen on: 74182.ttys000.mylinuxmachine (Detached) 1 Socket in /tmp/uscreens/S-username.
הגדרת רכיב FTD
חוזרים על התהליך שלמעלה כדי להבהב את לוח ה-nRF52840 השלישי, באמצעות ה-build הקיים של ot-cli-ftd.hex
. כשמסיימים, חשוב לחבר מחדש את הלוח למחשב באמצעות יציאת ה-NRF USB ולהגדיר את מתג nRF ההפעלה ל-VDD.
אם שני הצמתים האחרים מחוברים למחשב Linux כאשר הלוח השלישי הזה מחובר, הוא אמור להופיע בתור יציאה טורית /dev/ttyACM2
:
$ ls /dev/ttyACM* /dev/ttyACM0 /dev/ttyACM1 /dev/ttyACM2
מוסיפים ללוח את התווית 'JOINer'.
במהלך האימות באמצעות המסך, במקום ליצור מופע חדש של המסך משורת הפקודה, מצרפים אותו מחדש למסך הקיים ויוצרים בו חלון חדש (שבו השתמשתם בנציבות ה-FTD):
$ screen -r
יוצרים את החלון החדש במסך עם Ctrl+a ← c
.
תופיע שורת פקודה חדשה. נכנסים ל-OpenThread CLI של רכיב ה-FTD:
$ screen /dev/ttyACM2 115200
בחלון החדש הזה, מקישים על מקש Return במקלדת כמה פעמים כדי להציג את ההודעה של OpenThread CLI >
. מציגים את ממשק IPv6 ובודקים אם יש כתובות:
> ifconfig up Done > ipaddr fe80:0:0:0:6c1e:87a2:df05:c240 Done
עכשיו ה-CLI של חבר ה-FTD נמצא באותו מסך של ה-FTD Commissioner, כך שתוכלו לעבור ביניהם באמצעות Ctrl+a ← n
.
השתמשו ב-Ctrl+a ←
d
בכל שלב כדי לצאת מהמסך.
6. הגדרת חלון הטרמינל
מעתה ואילך, תהיה לך אפשרות להחליף בין מכשירי Thread לעיתים קרובות, לכן חשוב לוודא שכולם זמינים ונגישים בקלות. עד כה השתמשנו ב-Screen כדי לגשת לשני ה-FTD, והכלי הזה מאפשר גם פיצול מסך באותו חלון טרמינל. אפשר להשתמש ברכיב הזה כדי לראות איך צומת אחד מגיב לפקודות שהונפקו על גבי צומת אחר.
במצב אידיאלי, צריכים להיות לכם ארבעה חלונות זמינים:
- שירות / יומנים
ot-daemon
- מחבר RCP דרך
ot-ctl
- FTD Commissioner דרך OpenThread CLI
- FTD Shared דרך OpenThread CLI
אם ברצונך להשתמש במסוף או בתצורת יציאה טורית משלך, אפשר לדלג לשלב הבא. מגדירים את חלונות הטרמינל בכל המכשירים בדרך שהכי מתאימה לכם.
שימוש במסך
כדי להקל את השימוש, מומלץ להתחיל סשן אחד בלבד במסך. כבר צריך להיות לך אחד מהערכים האלה כשהגדרת את שני ה-FTD.
כל הפקודות במסך מתחילות ב-Ctrl+a.
פקודות מסך בסיסיות:
צירוף מחדש לסשן במסך (משורת הפקודה) |
|
יציאה מהפעלת המסך | Ctrl+a ← |
יצירת חלון חדש בסשן המסך | Ctrl+a ← |
מעבר בין חלונות באותו סשן מסך | Ctrl+a ← |
ביטול החלון הנוכחי בסשן המסך | Ctrl+a ← |
מסך מפוצל
באמצעות המסך, אפשר לפצל את המסוף לכמה חלונות:
אפשר לגשת לפקודות ב-screen
באמצעות המקשים Ctrl+a. כל פקודה צריכה להתחיל בשילוב של מפתח הגישה הזה.
אם עקבתם אחרי ה-Codelab בדיוק, אתם צריכים להשתמש בשני חלונות (FTD Commissioner, FTD Shareder) באותו מכונת מסך. כדי לפצל את המסך בין שני המסכים, קודם מזינים את הסשן הקיים במסך:
$ screen -r
עליכם להיות באחד ממכשירי ה-FTD. פועלים לפי השלבים הבאים במסך:
- Ctrl+a ←
S
לפיצול החלון באופן אופקי - Ctrl+a ←
Tab
כדי להעביר את הסמן לחלון הריק החדש - Ctrl+a ←
n
כדי להעביר את החלון החדש לחלון הבא - אם הוא זהה לחלון העליון, יש להקיש שוב על Ctrl+a ←
n
כדי להציג את מכשיר ה-FTD האחר
עכשיו ניתן לראות את שניהם. אפשר לעבור ביניהם באמצעות Ctrl+a ← Tab
. מומלץ ליצור מחדש כל חלון באמצעות הקשה על Ctrl+a ← A
כדי למנוע בלבול.
שימוש מתקדם
כדי לפצל את המסך עוד יותר לרבעונים ולהציג את יומני ot-daemon
ואת רכיב RCP ot-ctl
. יש להפעיל את השירותים האלה באותו מופע של המסך. לשם כך יש לעצור את ot-daemon
, לצאת מ-ot-ctl
ולהפעיל אותו מחדש בחלונות מסך חדשים (Ctrl+a ← c
).
ההגדרה הזו לא נדרשת, ותמשיך להיות תרגיל למשתמש.
פיצול וניווט בין חלונות באמצעות הפקודות הבאות:
יצירת חלון חדש | Ctrl+a ← |
פיצול החלון במאונך | Ctrl+a ← |
פיצול החלון באופן אופקי | Ctrl+a ← |
מעבר לחלון הבא שמוצג | Ctrl+a ← |
העברת החלון המוצג קדימה או אחורה | Ctrl+a ← |
שינוי השם של החלון הנוכחי | Ctrl+a ← |
בכל שלב אפשר לצאת מהמסך הזה באמצעות Ctrl+a ← d
, ולצרף מחדש את הפקודה screen -r
משורת הפקודה.
למידע נוסף על המסך, ניתן לעיין בחומר העזר המהיר בנושא מסך GNU.
7. יצירת הרשת של Thread
סיימת להגדיר את כל החלונות והמסכים של המסוף, ועכשיו עליך ליצור את רשת ה-Thread שלנו. ב-FTD Commission, יוצרים מערך נתונים תפעולי חדש ומגדירים אותו כמערך הפעיל. מערך הנתונים התפעולי הוא התצורה של רשת השרשורים שיוצרים.
## FTD Commissioner ## ---------------------- > dataset init new Done > dataset Active Timestamp: 1 Channel: 11 Channel Mask: 07fff800 Ext PAN ID: c0de7ab5c0de7ab5 Mesh Local Prefix: fdc0:de7a:b5c0/64 Network Key: 1234c0de7ab51234c0de7ab51234c0de Network Name: OpenThread-c0de PAN ID: 0xc0de PSKc: ebb4f2f8a68026fc55bcf3d7be3e6fe4 Security Policy: 0, onrcb Done
יש לשים לב למפתח הרשת 1234c0de7ab51234c0de7ab51234c0de
שישמש מאוחר יותר.
מגדירים את מערך הנתונים הזה כמערך הפעיל:
> dataset commit active Done
מציגים את ממשק IPv6:
> ifconfig up Done
הפעלה של פרוטוקול Thread:
> thread start Done
לאחר כמה רגעים, כדאי לבדוק את מצב המכשיר. הסוכנות צריכה להיות להוביל. שלחו גם את ה-RLOC16 לשימוש עתידי.
## FTD Commissioner ## ---------------------- > state leader Done > rloc16 0c00 Done
צריך לבדוק את כתובות ה-IPv6 של המכשיר:
## FTD Commissioner ## ---------------------- > ipaddr fdc0:de7a:b5c0:0:0:ff:fe00:fc00 # Leader Anycast Locator (ALOC) fdc0:de7a:b5c0:0:0:ff:fe00:c00 # Routing Locator (RLOC) fdc0:de7a:b5c0:0:6394:5a75:a1ad:e5a # Mesh-Local EID (ML-EID) fe80:0:0:0:1cd6:87a9:cb9d:4b1d # Link-Local Address (LLA)
הרשת "Codelab" גלויה עכשיו כשהיא נסרקת ממכשירי Thread אחרים.
מ-ot-ctl
במחבר ה-RCP:
## RCP Joiner ## ---------------- > scan | PAN | MAC Address | Ch | dBm | LQI | +------+------------------+----+-----+-----+ | c0de | 1ed687a9cb9d4b1d | 11 | -36 | 232 |
ב-OpenThread CLI ב-FTD Adder:
## FTD Joiner ## ---------------- > scan | PAN | MAC Address | Ch | dBm | LQI | +------+------------------+----+-----+-----+ | c0de | 1ed687a9cb9d4b1d | 11 | -38 | 229 |
אם הרשת "Codelab" לא מופיעה ברשימה, צריך לנסות לסרוק שוב.
8. הוספת המחבר של ה-RCP
הזמנת שרשורים לא פעילה ברשת. פירוש הדבר הוא שנצטרך להוסיף את מחבר ה-RCP לרשת השרשורים שיצרנו עכשיו באמצעות תהליך הקצאה מחוץ למסגרת.
בנציבות ה-FTD, הוספנו הערה לגבי מפתח הרשת, לדוגמה 1234c0de7ab51234c0de7ab51234c0de
. אם רוצים לחפש שוב את מפתח הרשת, מריצים את הפקודה הבאה ב-FTD Commissioner:
## FTD Commissioner ## > dataset networkkey 1234c0de7ab51234c0de7ab51234c0de Done
בשלב הבא, במחבר ה-RCP, מגדירים את מפתח הרשת הפעיל של מערך הנתונים כמפתח רשת ה-FTD Commissioner:
## RCP Joiner ## ---------------- > dataset networkkey 1234c0de7ab51234c0de7ab51234c0de Done > dataset commit active Done
צריך לבדוק את מערך הנתונים כדי לוודא שהוא מוגדר כהלכה.
## RCP Joiner ## ---------------- > dataset Network Key: 1234c0de7ab51234c0de7ab51234c0de
מציגים את השרשור כדי שה-RCP joiner יצטרף לרשת "codelab". ממתינים כמה שניות ומוודאים שהמדינה, RLOC16 וכתובות ה-IPv6 שלה:
## RCP Joiner ## ---------------- > ifconfig up Done > thread start Done > state child Done > rloc16 0c01 Done > ipaddr fdc0:de7a:b5c0:0:0:ff:fe00:0c01 # Routing Locator (RLOC) fdc0:de7a:b5c0:0:66bf:99b9:24c0:d55f # Mesh-Local EID (ML-EID) fe80:0:0:0:18e5:29b3:a638:943b # Link-Local Address (LLA) Done
מומלץ לשים לב לכתובת Mesh-Local IPv6 (fdc0:de7a:b5c0:0:66bf:99b9:24c0:d55f
כאן) כדי להשתמש בה.
חוזרים אל FTD Commissioner, בודקים את הנתב ואת טבלאות הצאצאים ומוודאים ששני המכשירים הם באותה רשת. השתמשו ב-RLOC16 כדי לזהות את מחבר ה-RCP.
## FTD Commissioner ## ---------------------- > router table | ID | RLOC16 | Next Hop | Path Cost | LQ In | LQ Out | Age | Extended MAC | +----+--------+----------+-----------+-------+--------+-----+------------------+ | 3 | 0x0c00 | 3 | 0 | 0 | 0 | 35 | 1ed687a9cb9d4b1d | Done > child table | ID | RLOC16 | Timeout | Age | LQ In | C_VN |R|S|D|VER| Extended MAC | +-----+--------+------------+------------+-------+------+-+-+-+---+------------------+ | 1 | 0x0c01 | 240 | 25 | 3 | 89 |1|1|1| 2| 1ae529b3a638943b | Done
כדי לאמת את הקישוריות, יש לשלוח פינג לכתובת המקומית של חיבור ה-RCP (כתובת הרשת המקומית שהתקבלה מהפלט של ה-RCP של ipaddr
).
## FTD Commissioner ## ---------------------- > ping fdc0:de7a:b5c0:0:66bf:99b9:24c0:d55f > 8 bytes from fdc0:de7a:b5c0:0:66bf:99b9:24c0:d55f: icmp_seq=1 hlim=64 time=40ms
עכשיו יש לנו רשת Thread עם שני צמתים, כפי שמתואר בתרשים הטופולוגיה:
תרשימי טופולוגיה
במהלך העבודה על שאר Codelab נציג תרשים טופולוגיה חדש של שרשור בכל פעם שמצב הרשת משתנה. תפקידי הצומת מצוינים באופן הבא:
נתבים הם תמיד מחומשים, ומכשירי סיום הם תמיד מעגלים. המספרים בכל צומת מייצגים את מזהה הנתב או את מזהה הצאצא שמוצג בפלט ה-CLI, בהתאם לתפקיד ולמצב הנוכחיים של כל צומת באותו זמן.
9. מצטרפים ל-FTD
עכשיו נוסיף את מכשיר ה-thread השלישי לרשת "Codelab". הפעם נעשה שימוש בתהליך מאובטח יותר של הזמנת תדרים, ונאפשר רק לאיחוד ה-FTD להצטרף.
בצירוף FTD, יש לקבל את eui64
, כדי שנציב ה-FTD יוכל לזהות אותו:
## FTD Joiner ## ---------------- > eui64 2f57d222545271f1 Done
ב-FTD Commissioner, מפעילים את הנציב ומציינים את ה-eui64
של המכשיר שיכול להצטרף, יחד עם פרטי ההתחברות, לדוגמה J01NME
. פרטי הכניסה לאיחוד הם מחרוזת ספציפית למכשיר של כל התווים האלפאנומריים (0-9 ו-A-Y, לא כולל את הפונקציות I, O, Q ו-Z שניתן לקרוא), באורך של 6 עד 32 תווים.
## FTD Commissioner ## ---------------------- > commissioner start Done > commissioner joiner add 2f57d222545271f1 J01NME Done
עוברים אל FTDer joiner. מחלקים את תפקיד המחבר באישור הכניסה שצירפתם לוועדת ה-FTD:
## FTD Joiner ## ---------------- > ifconfig up Done > joiner start J01NME Done
בתוך כדקה, יתקבל אישור על אימות מוצלח:
## FTD Joiner ## ---------------- > Join success
מציגים את השרשור כדי שחבר ה-FTD יצטרף לרשת "Codelab", ויבדוק מיד את המצב ואת RLOC16:
## FTD Joiner ## ---------------- > thread start Done > state child Done > rloc16 0c02 Done
צריך לבדוק את כתובות ה-IPv6 של המכשיר. שימו לב שאין ALOC. הסיבה לכך היא שהמכשיר הזה אינו מוביל, ואינו כולל תפקיד ספציפי ב-Everycast שדורש ALOC.
## FTD Joiner ## ---------------- > ipaddr fdc0:de7a:b5c0:0:0:ff:fe00:c02 # Routing Locator (RLOC) fdc0:de7a:b5c0:0:3e2e:66e:9d41:ebcd # Mesh-Local EID (ML-EID) fe80:0:0:0:e4cd:d2d9:3249:a243 # Link-Local Address (LLA)
עוברים מיד אל FTD Commissioner ובודקים את הנתב ואת טבלאות הצאצאים כדי לוודא ששלושה מכשירים קיימים ברשת "codelab":
## FTD Commissioner ## ---------------------- > router table | ID | RLOC16 | Next Hop | Path Cost | LQ In | LQ Out | Age | Extended MAC | +----+--------+----------+-----------+-------+--------+-----+------------------+ | 3 | 0x0c00 | 3 | 0 | 0 | 0 | 50 | 1ed687a9cb9d4b1d | > child table | ID | RLOC16 | Timeout | Age | LQ In | C_VN |R|S|D|N| Extended MAC | +-----+--------+------------+------------+-------+------+-+-+-+-+------------------+ | 1 | 0x0c01 | 240 | 25 | 3 | 89 |1|1|1|1| 1ae529b3a638943b | | 2 | 0x0c02 | 240 | 15 | 3 | 44 |1|1|1|1| e6cdd2d93249a243 | Done
על סמך ה-RLOC16, מחבר ה-FTD צורף לרשת כמכשיר קצה (ילד). הטופולוגיה המעודכנת שלנו:
10. השרשור בפעולה
מכשירי Thread ב-Codelab הזה הם סוג ספציפי של מכשיר עם שרשור מלא (FTD) שנקרא מכשיר קצה כשיר לנתב (REED). כלומר, הם יכולים לשמש כנתב או כמכשיר קצה ולקדם את עצמם ממכשיר קצה לנתב.
החוט יכול לתמוך בעד 32 נתבים, אבל הוא מנסה לשמור על מספר הנתבים בין 16 ל-23. אם REED מתחבר כמכשיר קצה (ילד) ומספר הנתבים נמוך מ-16, לאחר פרק זמן אקראי בתוך שתי דקות, הוא מקדם את עצמו באופן אוטומטי לנתב.
אם היו לכם שני ילדים ברשת ה-thread אחרי שהוספתם את מתקן ה-FTD, יש להמתין לפחות שתי דקות, ולאחר מכן לבדוק שוב את הנתב ואת טבלת הצאצא בנציבות ה-FTD:
## FTD Commissioner ## ---------------------- > router table | ID | RLOC16 | Next Hop | Path Cost | LQ In | LQ Out | Age | Extended MAC | +----+--------+----------+-----------+-------+--------+-----+------------------+ | 3 | 0x0c00 | 3 | 0 | 0 | 0 | 50 | 1ed687a9cb9d4b1d | | 46 | 0xb800 | 63 | 0 | 3 | 3 | 1 | e6cdd2d93249a243 | > child table | ID | RLOC16 | Timeout | Age | LQ In | C_VN |R|S|D|N| Extended MAC | +-----+--------+------------+------------+-------+------+-+-+-+-+------------------+ | 1 | 0x0c01 | 240 | 61 | 3 | 89 |1|1|1|1| 1ae529b3a638943b | Done
המחבר של FTD (קוד MAC מורחב = e6cdd2d93249a243
) קידם את עצמו לנתב. לתשומת ליבך, RLOC16 שונה (b800
במקום 0c02
). הסיבה לכך היא שמזהה RLOC16 מבוסס על מזהה הנתב ועל מזהה הצאצא. כשעוברים מ'מכשיר קצה' ל'נתב', הערכים של מזהה הנתב ומזהה הצאצא שלו משתנים, וכך גם RLOC16.
מאשרים את המצב החדש ואת RLOC16 בFTD Adder:
## FTD Joiner ## ---------------- > state router Done > rloc16 b800 Done
שדרוג לאחור של חיבור FTD
כדי לבדוק את ההתנהגות הזו, ניתן לשדרג לאחור את מחבר ה-FTD מנתב חזרה למכשיר קצה. משנים את המצב לילדים ובודקים את RLOC16:
## FTD Joiner ## ---------------- > state child Done > rloc16 0c03 Done
בחזרה בFTD Commissioner, נגן ה-FTD אמור להופיע בטבלת הצאצא (מזהה = 3). היא עשויה להופיע בשתיהן במהלך המעבר:
## FTD Commissioner ## ---------------------- > router table | ID | RLOC16 | Next Hop | Path Cost | LQ In | LQ Out | Age | Extended MAC | +----+--------+----------+-----------+-------+--------+-----+------------------+ | 3 | 0x0c00 | 3 | 0 | 0 | 0 | 50 | 1ed687a9cb9d4b1d | | 46 | 0xb800 | 63 | 0 | 3 | 3 | 1 | e6cdd2d93249a243 | > child table | ID | RLOC16 | Timeout | Age | LQ In | C_VN |R|S|D|N| Extended MAC | +-----+--------+------------+------------+-------+------+-+-+-+-+------------------+ | 1 | 0x0c01 | 240 | 61 | 3 | 89 |1|1|1|1| 1ae529b3a638943b | | 3 | 0x0c03 | 240 | 16 | 3 | 94 |1|1|1|1| e6cdd2d93249a243 | Done
לאחר זמן מה, היא תחזור לנתב עם RLOC של b800
.
הסרת המנהיג
המנהיג בוחר באופן עצמאי בין כל נתבי השרשור. כלומר, אם הליד הנוכחי יוסר מרשת Thread, אחד מהנתבים האחרים יהפוך ל-Leader החדש.
ב-FTD Commissioner, משביתים את Thread כדי להסיר אותו מרשת Thread:
## FTD Commissioner ## ---------------------- > thread stop Done > ifconfig down Done
תוך שתי דקות, תוסף ה-FTD הופך למנהיג השרשורים החדש. צריך לבדוק את המדינה ואת כתובות IPv6 של מחבר FTD כדי לאמת:
## FTD Joiner ## ---------------- > state leader Done > ipaddr fdc0:de7a:b5c0:0:0:ff:fe00:fc00 # Now it has the Leader ALOC! fdc0:de7a:b5c0:0:0:ff:fe00:b800 fdc0:de7a:b5c0:0:3e2e:66e:9d41:ebcd fe80:0:0:0:e4cd:d2d9:3249:a243 Done
בודקים את טבלת הצאצא. שימו לב שיש גרסה חדשה של RLOC16. זהו מחבר RCP, כפי שצוין על ידי המזהה שלו ו-MAC מורחב. כדי לשמור על רשת ה-Thread יחד, הוא החליף את הנתבים הראשיים מ-FTD Commissioner ל-FTD Shareder. כתוצאה מכך מתקבל RLOC16 חדש למחבר ה-RCP (כי מזהה הנתב השתנה מ-3 ל-46).
## FTD Joiner ## ---------------- > child table | ID | RLOC16 | Timeout | Age | LQ In | C_VN |R|S|D|N| Extended MAC | +-----+--------+------------+------------+-------+------+-+-+-+-+------------------+ | 1 | 0xb801 | 240 | 27 | 3 | 145 |1|1|1|1| 1ae529b3a638943b | Done
יכול להיות שתצטרכו להמתין כמה דקות עד שנגן ה-RCP יצטרף ל-FTDמר כילד. בודקים את המדינה ואת RLOC16 כדי לוודא את הפרטים הבאים:
## RCP Joiner ## -------------- > state child > rloc16 b801
צירוף מחדש של נציבות ה-FTD
רשת שרשורים עם שני צמתים לא כיף. בואו נחזיר את נציב ה-FTD לאינטרנט.
ב-FTD Commissioner, מפעילים מחדש את Thread:
## FTD Commissioner ## ---------------------- > ifconfig up Done > thread start Done
תוך שתי דקות, המכשיר מתחבר אוטומטית לרשת "Codelab" כמכשיר קצה, ולאחר מכן הוא מקדם את עצמו לנתב.
## FTD Commissioner ## ---------------------- > state router Done
בדקו את הנתב ואת טבלאות הצאצא ב-FTD Shareder כדי לוודא:
## FTD Joiner ## ---------------- > router table | ID | RLOC16 | Next Hop | Path Cost | LQ In | LQ Out | Age | Extended MAC | +----+--------+----------+-----------+-------+--------+-----+------------------+ | 3 | 0x0c00 | 63 | 0 | 3 | 3 | 0 | 1ed687a9cb9d4b1d | | 46 | 0xb800 | 46 | 0 | 0 | 0 | 15 | e6cdd2d93249a243 | > child table | ID | RLOC16 | Timeout | Age | LQ In | C_VN |R|S|D|N| Extended MAC | +-----+--------+------------+------------+-------+------+-+-+-+-+------------------+ | 1 | 0xb801 | 240 | 184 | 3 | 145 |1|1|1|1| 1ae529b3a638943b | Done
רשת השרשורים שלנו מורכבת משלושה צמתים שוב.
11. פתרון בעיות
ניהול רשת של Thread עם מספר מכשירים במסוף או בחלונות מסך שונים יכול להיות מורכב. אם נתקלתם בבעיות, תוכלו להיעזר בטיפים האלה כדי "לאפס" את המצב של הרשת או של סביבת העבודה.
מסך
אם אי פעם תאבד את ההגדרה (יותר מדי חלונות מסך, או מסכים בתוך המסך), המשך להרוג חלונות מסך עם Ctrl+a ← k עד שלא יהיה קיים, ו-screen -ls
יופיע בשורת הפקודה No Sockets found
. לאחר מכן יוצרים מחדש את חלונות המסך עבור כל מכשיר. מצבי המכשיר נשמרים גם כשמסך מת.
צמתי שרשורים
אם הטופולוגיה של רשת ה-thread לא כפי שמתואר ב-Codelab הזה, או שהצמתים מתנתקים מסיבה כלשהי (אולי בגלל שמכונת ה-Linux גרמה להם לעבור למצב שינה), עדיף להסיר את ה-thread, לנקות את פרטי הכניסה של הרשת ולהתחיל שוב מהשלב יצירת רשת Thread.
כדי לאפס את ה-FTD:
## FTD Commissioner or FTD Joiner ## ------------------------------------ > thread stop Done > ifconfig down Done > factoryreset Done
ניתן לאפס את ה-RCP באותה דרך דרך ot-ctl
:
## RCP Joiner ## ---------------- > thread stop Done > ifconfig down Done > factoryreset Done
12. באמצעות מולטיקאסט
מולטיקאסט משמש להעברת מידע לקבוצה של מכשירים בבת אחת. ברשת של Thread, כתובות ספציפיות נשמרות לשימוש של כמה שידורים בקבוצות שונות של מכשירים, בהתאם להיקף.
כתובת IPv6 | היקף | נמסרו אל |
| קישור מקומי | כל ה-FEDs וה-EDED |
| קישור מקומי | כל ה-FTD ונתבי הגבולות |
| רשת מקומית | כל ה-FEDs וה-EDED |
| רשת מקומית | כל ה-FTD ונתבי הגבולות |
מכיוון שאנחנו לא משתמשים בנתב גבול ב-Codelab הזה, נתמקד בשתי הכתובות של FTD ו-MED.
קישור מקומי
ההיקף של קישור מקומי מכיל את כל ממשקי השרשור שניתן להגיע אליהם באמצעות שידור רדיו יחיד, או "קפיצה" אחת. הטופולוגיה של הרשת קובעת אילו מכשירים מגיבים לפינג לכתובת ff02::1
של מולטיקאסט.
פינג ff02::1
מנציב ה-FTD:
## FTD Commissioner ## ---------------------- > ping ff02::1 > 8 bytes from fe80:0:0:0:e4cd:d2d9:3249:a243: icmp_seq=2 hlim=64 time=9ms
יש שני מכשירים אחרים ברשת (שותף FTD ומחבר RCP), אבל נציב FTD קיבל רק תגובה אחת, מכתובת הקישור של חבר ה-FTD (LLA). המשמעות היא שמחבר ה-FTD הוא המכשיר היחיד שאליו יכול להגיע הנציב ב-FTD בצעד אחד.
שליחת פינג עכשיו ff02::1
מFTD המגבלה:
## FTD Joiner ## ---------------- > ping ff02::1 > 8 bytes from fe80:0:0:0:1cd6:87a9:cb9d:4b1d: icmp_seq=1 hlim=64 time=11ms 8 bytes from fe80:0:0:0:18e5:29b3:a638:943b: icmp_seq=1 hlim=64 time=24ms
שתי תגובות! נבדוק את כתובות ה-IPv6 עבור המכשירים האחרים, כדי לראות את הראשונה (שמסתיימת ב-4b1d
) עם ה-LLA של נציב ה-FTD. הראשונה (שמסתיימת ב-943b
) היא ה-LLA של מבצע ה-RCP.
המשמעות היא שצירוף ה-FTD מקושר ישירות לנציבות ה-FTD ולחבר ה-RCP, המאשר את הטופולוגיה שלנו.
רשת מקומית
ההיקף של Mesh-Local כולל את כל ממשקי Thread שניתן לגשת אליהם באותה רשת Thread. נראה את התשובות לגבי פינג לכתובת ff03::1
של מולטיקאסט.
פינג ff03::1
מנציב ה-FTD:
## FTD Commissioner ## ---------------------- > ping ff03::1 > 8 bytes from fdc0:de7a:b5c0:0:0:ff:fe00:b800: icmp_seq=3 hlim=64 time=9ms 8 bytes from fdc0:de7a:b5c0:0:66bf:99b9:24c0:d55f: icmp_seq=3 hlim=64 time=68ms
הפעם הנציבות של FTD קיבלה שתי תגובות, אחת ממאתר הניתוב של חבר ה-FTD (RLOC, מסתיימת ב-b800
) והשנייה מ-Mesh-Local EID (ML-EID, מסתיים ב-d55f
) של המנוי ל-FTD. הסיבה לכך היא שהיקף הרשת המקומית מורכב מרשת Thread כולה. לא משנה איפה ברשת נמצא מכשיר, המכשיר יירשם לכתובת ff03::1
.
פינג ff03::1
מחבר ה-FTD כדי לאשר את אותה התנהגות:
## FTD Joiner ## ---------------- > ping ff03::1 > 8 bytes from fdc0:de7a:b5c0:0:0:ff:fe00:c00: icmp_seq=2 hlim=64 time=11ms 8 bytes from fdc0:de7a:b5c0:0:66bf:99b9:24c0:d55f: icmp_seq=2 hlim=64 time=23ms
שימו לב לזמן התגובה של ה-RCP Shareder בשתי היציאות. משך הזמן עד לציר ה-RCP (28 אלפיות השנייה) על מנת להגיע לנציב ה-FTD. הסיבה לכך היא שצריך לעשות כמה פעמים כדי להגיע אל וועדת ה-FTD, בהשוואה לקפיצה אחת של FTD הערוצים.
כמו כן, ייתכן שהפינגים של מספר רשתות מקומיות מגיבים ל-RLOC רק לשני ה-FTD – לא ל-RCP המגבלה. הסיבה לכך היא שה-FTDs הם נתבים בתוך הרשת, וה-RCP הוא מכשיר קצה.
בודקים את המצב של תוסף ה-RCP כדי לוודא:
## RCP Joiner ## ---------------- > state child
13. שליחת הודעות באמצעות UDP
אחד משירותי האפליקציה שמספקת OpenThread הוא פרוטוקול Data Datagram (UDP), שהוא Transport Layer Layer. אפליקציה שנוצרה ב-OpenThread יכולה להשתמש ב-UDP API כדי להעביר הודעות בין צמתים ברשת Thread, או למכשירים אחרים ברשת חיצונית (כמו האינטרנט, אם רשת ה-Thread כוללת נתב גבולות).
שקעי UDP נחשפים דרך CLI של OpenThread. נשתמש בו כדי להעביר הודעות בין שני ה-FTD.
מורידים את הכתובת של Mesh-Local EID של FTD joiner. אנחנו משתמשים בכתובת הזו כי ניתן לגשת אליה מכל מקום ברשת Thread.
## FTD Joiner ## ---------------- > ipaddr fdc0:de7a:b5c0:0:0:ff:fe00:fc00 # Leader Anycast Locator (ALOC) fdc0:de7a:b5c0:0:0:ff:fe00:b800 # Routing Locator (RLOC) fe80:0:0:0:e4cd:d2d9:3249:a243 # Link-Local Address (LLA) fdc0:de7a:b5c0:0:3e2e:66e:9d41:ebcd # Mesh-Local EID (ML-EID) Done
מפעילים את UDP ומכפיפים אותו לשקע עבור כל כתובת IPv6:
## FTD Joiner ## ---------------- > udp open Done > udp bind :: 1212
עוברים ל-FTD Commissioner, מתחילים ב-UDP ומתחברים לשקע שהגדרתם ב-FTD Shareder באמצעות ה-ML-EID שלו:
## FTD Commissioner ## ---------------------- > udp open Done > udp connect fdc0:de7a:b5c0:0:3e2e:66e:9d41:ebcd 1212 Done
חיבור ה-UDP צריך להיות פעיל בין שני הצמתים. שליחת הודעה מהנציב של ה-FTD:
## FTD Commissioner ## ---------------------- > udp send hellothere Done
ב-FTD Shared נשלחה הודעת ה-UDP.
## FTD Joiner ## ---------------- > 10 bytes from fdc0:de7a:b5c0:0:0:ff:fe00:c00 49153 hellothere
14. מזל טוב!
יצרת רשת פרוטוקולים פיזית!
עכשיו אתם יודעים:
- ההבדל בין מכשירים, תפקידים והיקפים של Thread
- איך מכשירים עם שרשורים מנהלים את המצבים שלהם בתוך הרשת
- איך להעביר הודעות פשוטות בין צמתים באמצעות UDP
השלבים הבאים
על סמך Codelab הזה, נסו את התרגילים הבאים:
- מחזירים את הלוח של קהילת FTD כ-MTD באמצעות הקובץ הבינארי
ot-cli-mtd
, ומציינים שהוא אף פעם לא משדרג את עצמו לנתב או מנסה להפוך למנהיג - הוסיפו עוד מכשירים (נסו פלטפורמה אחרת!) לרשת ושרטטו את הטופולוגיה באמצעות נתב וטבלאות צאצאים, לצד פינגים לכתובות מרובות ההעברות
- שימוש ב-pispinel לשליטה ב-NCP
- ממירים את ה-NCP לנתב גבול באמצעות Openthread Border Router ומחברים את רשת ה-Thread לאינטרנט
קריאה נוספת
ב-openthread.io וב-GitHub יש מגוון משאבים של OpenThread, כולל:
- פלטפורמות נתמכות – כל הפלטפורמות התומכות ב-OpenThread
- Open OpenThread — פרטים נוספים על יצירה והגדרה של OpenThread
- Thread Primer – מכסה את כל הקונספטים של שרשור שמוצגים ב-Codelab הזה
עיון: