1. מבוא
השקת OpenThread של Google היא הטמעת קוד פתוח של פרוטוקול הרשת Thread. במסגרת Google Nest הושקה OpenThread כדי שהטכנולוגיה שמשמשת את מוצרי Nest תהיה זמינה באופן נרחב למפתחים, כדי לזרז את הפיתוח של מוצרים לבית המחובר.
מפרט פרוטוקול Thread מגדיר פרוטוקול תקשורת אלחוטי, אמין ומבוסס-IPv6, עבור אפליקציות ביתיות. OpenThread מיישמת את כל שכבות הרשת של פרוטוקול Thread, כולל IPv6, 6LoWPAN, IEEE 802.15.4 עם אבטחת MAC, הגדרות קישור רשת וניתוב רשת.
ה-Codelab הזה ילמד אותך איך לדמות רשת פרוטוקול Thread במכשירים מדומים.
מה תלמדו
- איך מגדירים את שרשרת הכלים לפיתוח גרסת build של OpenThread
- איך לדמות רשת פרוטוקול Thread
- איך לאמת צמתים של פרוטוקול Thread
- איך מנהלים רשת בפרוטוקול Thread באמצעות OpenThread Daemon
למה תזדקק?
- Git
- ידע בסיסי ב-Linux, ניתוב רשתות
2. הגדרה של מערכת ה-build
Git
כדי להשלים את ה-Codelab הזה צריך Git. לפני שממשיכים, צריך להוריד ולהתקין אותה.
אחרי ההתקנה, פועלים לפי ההוראות של מערכת ההפעלה הספציפית כדי להוריד ולפתח את OpenThread.
XCode ל-Mac OS X
נדרש XCode כדי להתקין ולפתח את OpenThread ב-Mac OS X.
לאחר התקנת ה-XCode, מתקינים את כלי שורת הפקודה של XCode:
$ xcode-select --install
פיתוח מערכת ב-Linux / Mac OS X
הוראות ההתקנה האלה נבדקו ב-Ubuntu Server 14.04 LTS וב-Mac OS X Sierra 10.12.6.
מתקינים את OpenThread. הפקודות bootstrap מוודאות שה-toolchain מותקן והסביבה מוגדרת כמו שצריך:
$ mkdir -p ~/src $ cd ~/src $ git clone --recursive https://github.com/openthread/openthread.git $ cd openthread $ ./script/bootstrap
שימוש ב-Windows
אם אתם מעדיפים את Windows, מומלץ לנסות את גרסת Docker של ה-Codelab הזה.
3. פיתוח אפליקציות OpenThread
בסיום ההתקנה, יוצרים את אפליקציית OpenThread לדוגמה. ב-Codelab הזה אנחנו משתמשים בסימולציה לדוגמה.
$ cd ~/src/openthread $ ./script/cmake-build simulation
עכשיו יוצרים את OpenThread Daemon:
$ ./script/cmake-build posix -DOT_DAEMON=ON
4. הדמיה של רשת פרוטוקול Thread
האפליקציה לדוגמה שבה תשתמשו ב-Codelab הזו מדגימה אפליקציית OpenThread מינימלית שחושפת את ממשקי התצורה והניהול של OpenThread באמצעות ממשק שורת פקודה בסיסי (CLI).
התרגיל הזה מנחה אתכם בצעדים המינימליים שנדרשים כדי לבצע פינג למכשיר מדומה אחד של פרוטוקול Thread ממכשיר סימולציה אחר של פרוטוקול Thread.
האיור הבא מתאר טופולוגיה בסיסית של רשת פרוטוקול Thread. לצורך התרגיל הזה, נדמה את שני הצמתים בתוך העיגול הירוק: מוביל שרשור ונתב שרשורים עם חיבור יחיד ביניהם.
לעשות פינג לצומת
1. התחלת צומת 1
מנווטים לספרייה openthread ומפעילים את תהליך ה-CLI להדמיה של מכשיר פרוטוקול Thread באמצעות הקובץ הבינארי ot-cli-ftd.
$ cd ~/src/openthread $ ./build/simulation/examples/apps/cli/ot-cli-ftd 1
הערה: אם ההודעה > לא מופיעה אחרי הרצת הפקודה הזו, צריך להקיש על enter.
הקובץ הבינארי הזה מיישם סימולציה של מכשיר OpenThread על גבי POSIX. מנהל התקן הרדיו IEEE 802.15.4 מיושם על גבי UDP (מסגרות IEEE 802.15.4 מועברות בתוך מטענים ייעודיים (payloads) של UDP).
הארגומנט של 1 הוא מתאר קובץ שמייצג את הביטים הנמוכים ביותר המשמעותיים של הערך 'הוקצתה על ידי מפעל' IEEE EUI-64 עבור המכשיר הסימולציה. הערך הזה משמש גם כשמקשרים ליציאת UDP עבור אמולציית רדיו של IEEE 802.15.4 (יציאה = 9000 + מתאר קובץ). כל מופע של מכשיר Thread מדומה ב-Codelab הזה ישתמש בתיאור קובץ שונה.
הערה: כשמריצים את התהליך במכשיר מדומה, צריך להשתמש בתיאורי קבצים של 1 ומעלה רק כפי שצוין ב-Codelab הזה. מתאר קובץ של 0 שמור לשימוש אחר.
יוצרים מערך נתונים תפעולי חדש ושומרים אותו בתור המערך הפעיל. מערך הנתונים התפעולי הוא ההגדרה של רשת פרוטוקול Thread שאתם יוצרים.
> dataset init new Done > dataset Active Timestamp: 1 Channel: 20 Channel Mask: 07fff800 Ext PAN ID: d6263b6d857647da Mesh Local Prefix: fd61:2344:9a52:ede0/64 Network Key: e4344ca17d1dca2a33f064992f31f786 Network Name: OpenThread-c169 PAN ID: 0xc169 PSKc: ebb4f2f8a68026fc55bcf3d7be3e6fe4 Security Policy: 0, onrcb Done
שומרים את מערך הנתונים הזה בתור מערך הנתונים הפעיל:
> dataset commit active Done
מציגים את ממשק IPv6:
> ifconfig up Done
התחלת פעולה של פרוטוקול Thread:
> thread start Done
ממתינים כמה שניות ומוודאים שהמכשיר הפך למוביל בשרשור. ה-Leader הוא המכשיר שאחראי לניהול הקצאת המזהים של הנתב.
> state leader Done
הצגת כתובות ה-IPv6 שהוקצו לממשק Thread של צומת 1 (הפלט שלכם יהיה שונה):
> ipaddr fd61:2344:9a52:ede0:0:ff:fe00:fc00 fd61:2344:9a52:ede0:0:ff:fe00:5000 fd61:2344:9a52:ede0:d041:c5ba:a7bc:5ce6 fe80:0:0:0:94da:92ea:1353:4f3b Done
שימו לב לסוגים הספציפיים של כתובות IPv6:
- מתחיל ב-
fd= רשת מקומית - מתחיל ב-
fe80= link-local
סוגי כתובות מקומיות ברשת מסווגים עוד יותר:
- מכיל
ff:fe00= מאתר הנתבים (RLOC) - לא מכיל
ff:fe00= מזהה של נקודת קצה (EID)
זהו את ה-EID בפלט של המסוף ורשמו אותו לשימוש מאוחר יותר. בפלט לדוגמה שלמעלה, ה-EID הוא:
fd61:2344:9a52:ede0:d041:c5ba:a7bc:5ce6
2. התחלת צומת 2
פותחים טרמינל חדש, עוברים לספרייה openthread ומפעילים את תהליך ה-CLI. זו הסימולציה השנייה של מכשיר פרוטוקול Thread:
$ cd ~/src/openthread $ ./build/simulation/examples/apps/cli/ot-cli-ftd 2
הערה: אם ההודעה > לא מופיעה אחרי הרצת הפקודה הזו, צריך להקיש על enter.
מגדירים את מפתח רשת ה-thread ואת מזהה ה-PAN, באמצעות אותם ערכים כמו במערך הנתונים התפעולי של הצומת 1:
> dataset networkkey e4344ca17d1dca2a33f064992f31f786 Done > dataset panid 0xc169 Done
שומרים את מערך הנתונים הזה בתור מערך הנתונים הפעיל:
> dataset commit active Done
מציגים את ממשק IPv6:
> ifconfig up Done
התחלת פעולה של פרוטוקול Thread:
> thread start Done
המכשיר יופעל כילד.
> state child Done
תוך 2 דקות אמור להופיע שינוי במצב מ-child ל-router. נתב פרוטוקול Thread יכול לנתב תעבורת נתונים בין מכשירים בפרוטוקול Thread. הוא נקרא גם 'הורה'.
> state router Done
אימות הרשת
דרך קלה לאמת את רשת האריג היא לבדוק את טבלת הנתבים.
1. צריך לבדוק את החיבור
ב-Node 2, מקבלים את RLOC16. ה-RLOC16 הוא 16 הביטים האחרונים של כתובת ה-IPv6 של המכשיר ב-RLOC.
> rloc16 5800 Done
בצומת 1, מחפשים בטבלת הנתבים את RLOC16 של הצומת 2. חשוב לוודא שצומת 2 עבר למצב הנתב.
> router table | ID | RLOC16 | Next Hop | Path Cost | LQI In | LQI Out | Age | Extended MAC | +----+--------+----------+----------+-------+---------+-----+------------------+ | 20 | 0x5000 | 63 | 0 | 0 | 0 | 0 | 96da92ea13534f3b | | 22 | 0x5800 | 63 | 0 | 3 | 3 | 23 | 5a4eb647eb6bc66c |
ה-RLOC של 0xa800 של צומת 1 מופיע בטבלה ומאשר שהוא מחובר לרשת.
2. פינג צומת 1 מצומת 2
צריך לאמת את הקישוריות בין שני מכשירי ה-thread. בצומת 2, ping ה-EID שהוקצה לצומת 1:
> ping fd61:2344:9a52:ede0:d041:c5ba:a7bc:5ce6 > 16 bytes from fd61:2344:9a52:ede0:d041:c5ba:a7bc:5ce6: icmp_seq=1 hlim=64 time=12ms
כדי לחזור להנחיה > של ה-CLI, מקישים על enter.
בדיקת הרשת
עכשיו אפשר לבצע פינג בין שני מכשירי Thread מדומים. עכשיו אפשר לבדוק את רשת האריג על ידי העברת צומת אחד למצב אופליין.
חוזרים לצומת 1 ומפסיקים את Thread:
> thread stop Done
עוברים לצומת 2 ובודקים את המצב. בתוך שתי דקות, צומת 2 מזהה שהמוביל (צומת 1) נמצא במצב אופליין, וצומת 2 אמור להופיע בתור ה-leader של הרשת:
> state router Done ... > state leader Done
לאחר האישור, מפסיקים את פרוטוקול Thread ואת איפוס צומת 2 להגדרות המקוריות לפני היציאה. איפוס להגדרות המקוריות כדי להבטיח שפרטי הכניסה של רשת פרוטוקול Thread שבהם השתמשנו בתרגיל הזה לא יועברו לתרגיל הבא.
> thread stop Done > factoryreset > > exit
בנוסף, יש לאפס להגדרות המקוריות ולצאת מצומת 1:
> factoryreset > > exit
בחומר העזר בנושא CLI של OpenThread תוכלו למצוא מידע על כל פקודות ה-CLI הזמינות.
5. אימות צמתים באמצעות עמלה
בתרגיל הקודם הגדרת רשת פרוטוקול Thread עם שני מכשירים מדומים וקישוריות מאומתת. עם זאת, ההגדרה הזו מאפשרת רק לתנועת קישורים מקומית של IPv6 לא מאומתת לעבור בין מכשירים. כדי לנתב תנועת IPv6 גלובלית ביניהם (ואת האינטרנט באמצעות נתב גבול מסוג Thread), יש לאמת את הצמתים.
כדי לבצע אימות, מכשיר אחד צריך לשמש כנציב. הנציב הוא שרת האימות שנבחר כרגע למכשירי פרוטוקול Thread חדשים, והוא המאשר לספק את פרטי הכניסה לרשת הנדרשים כדי שהמכשירים יצטרפו לרשת.
בתרגיל זה נשתמש באותה טופולוגיה בעלת שתי צמתים כמו קודם. לצורך אימות, ה-thread Leader ישמש בתור הנציב, נתב ה-thread בתור join.
1. יצירת רשת
אם ממשיכים מהתרגיל הקודם, אמורים כבר להיות לך שני חלונות מסוף פתוחים. אם לא, צריך לוודא ששניים פתוחים ומוכנים לשימוש. אחד ישמש כצומת 1 והשני ישמש כצומת 2.
בצומת 1, מתחילים את תהליך ה-CLI:
$ cd ~/src/openthread $ ./build/simulation/examples/apps/cli/ot-cli-ftd 1
הערה: אם ההודעה > לא מופיעה אחרי הרצת הפקודה הזו, צריך להקיש על enter.
יוצרים מערך נתונים תפעולי חדש, שומרים אותו כמערך פעיל ומפעילים את פרוטוקול Thread:
> dataset init new Done > dataset Active Timestamp: 1 Channel: 12 Channel Mask: 07fff800 Ext PAN ID: e68d05794bf13052 Mesh Local Prefix: fd7d:ddf7:877b:8756/64 Network Key: a77fe1d03b0e8028a4e13213de38080e Network Name: OpenThread-8f37 PAN ID: 0x8f37 PSKc: f9debbc1532487984b17f92cd55b21fc Security Policy: 0, onrcb Done
שומרים את מערך הנתונים הזה בתור מערך הנתונים הפעיל:
> dataset commit active Done
מציגים את ממשק IPv6:
> ifconfig up Done
התחלת פעולה של פרוטוקול Thread:
> thread start Done
ממתינים כמה שניות ומוודאים שהמכשיר הפך למנהל שרשור:
> state leader Done
2. התחלת התפקיד 'נציב'
בזמן שהם נמצאים בצומת 1, מתחילים את תפקיד ה'נציב':
> commissioner start Done
אפשר לכל מצטרפים (באמצעות התו הכללי לחיפוש *) עם פרטי הכניסה של J01NME לבצע עמלה ברשת. הצטרפות הוא מכשיר שאדמין אנושי מוסיף לרשת Thread שהוזמנה.
> commissioner joiner add * J01NME Done
3. התחלת התפקיד 'הצטרפות'
בחלון הטרמינל השני, נוצר תהליך CLI חדש. זה צומת 2.
$ cd ~/src/openthread $ ./build/simulation/examples/apps/cli/ot-cli-ftd 2
בצומת 2, מפעילים את התפקיד 'מצרף' באמצעות פרטי הכניסה של J01NME.
> ifconfig up Done > joiner start J01NME Done
... עליך להמתין כמה שניות עד לאישור ...
Join success
בתור מצטרפים חדשים, המכשיר (צומת 2) אומת בהצלחה מול הנציב (Node 1) וקיבל את פרטי הכניסה של רשת פרוטוקול Thread.
עכשיו, לאחר שצומת 2 מאומת, מתחילים את פרוטוקול Thread:
> thread start Done
4. אימות אימות הרשת
בודקים את state ב-Node 2 כדי לוודא שהוא הצטרף לרשת. תוך שתי דקות, צומת 2 עובר מ-child ל-router:
> state child Done ... > state router Done
5. איפוס ההגדרות האישיות
כדי להתכונן לתרגיל הבא, אפסו את ההגדרות האישיות. בכל צומת, עוצרים את פרוטוקול Thread, מבצעים איפוס להגדרות המקוריות ויוצאים ממכשיר ה-Thread המדומה:
> thread stop Done > factoryreset > > exit
יכול להיות שיהיה צורך להקיש על enter כמה פעמים כדי להחזיר את ההנחיה > אחרי פקודת factoryreset.
6. ניהול הרשת באמצעות OpenThread Daemon
בתרגיל הזה נדמות מופע של CLI אחד (מכשיר SoC Thread מוטמע אחד) ומכונה אחת במעבד רדיו משותף (RCP).
ot-daemon הוא מצב באפליקציית OpenThread Posix שמשתמש בשקע UNIX כקלט וכפלט, כדי שהליבת OpenThread תוכל לפעול כשירות. לקוח יכול לתקשר עם השירות הזה על ידי התחברות לשקע באמצעות OpenThread CLI כפרוטוקול.
ot-ctl הוא CLI שמסופק על ידי ot-daemon כדי לנהל ולהגדיר את ה-RCP. כך נחבר את ה-RCP לרשת שנוצרה במכשיר פרוטוקול Thread.
שימוש ב-ot-daemon
בתרגיל הזה ייעשה שימוש בשלושה חלונות מסוף, בהתאם לדברים הבאים:
- מופע CLI של סימולציה של מכשיר Thread (צומת 1)
- תהליך אחד (
ot-daemon) ot-ctlמופע של CLI
אם ממשיכים מהתרגיל הקודם, כבר אמורים להיות לך שני חלונות טרמינל פתוחים. פתחו מכשיר שלישי כדי לוודא שיש לכם שלושה חלונות מסוף זמינים לתרגיל הזה.
1. התחלת צומת 1
בחלון הטרמינל הראשון, מפעילים את תהליך ה-CLI להדמיה של מכשיר פרוטוקול Thread:
$ cd ~/src/openthread $ ./build/simulation/examples/apps/cli/ot-cli-ftd 1
הערה: אם ההודעה > לא מופיעה אחרי הרצת הפקודה הזו, צריך להקיש על enter.
יוצרים מערך נתונים תפעולי חדש, שומרים אותו כמערך פעיל ומפעילים את פרוטוקול Thread:
> dataset init new Done > dataset Active Timestamp: 1 Channel: 13 Channel Mask: 07fff800 Ext PAN ID: 97d584bcd493b824 Mesh Local Prefix: fd55:cf34:dea5:7994/64 Network Key: ba6e886c7af50598df1115fa07658a83 Network Name: OpenThread-34e4 PAN ID: 0x34e4 PSKc: 38d6fd32c866927a4dfcc06d79ae1192 Security Policy: 0, onrcb Done
שומרים את מערך הנתונים הזה בתור מערך הנתונים הפעיל:
> dataset commit active Done
מציגים את ממשק IPv6:
> ifconfig up Done
התחלת פעולה של פרוטוקול Thread:
> thread start Done
צפייה בכתובות ה-IPv6 שהוקצו לממשק Thread של צומת 1:
> ipaddr fd55:cf34:dea5:7994:0:ff:fe00:fc00 fd55:cf34:dea5:7994:0:ff:fe00:d000 fd55:cf34:dea5:7994:460:872c:e807:c4ab fe80:0:0:0:9cd8:aab6:482f:4cdc Done >
כמו שמוסבר בשלב Simulate a Thread Network (סימולציה של רשת בפרוטוקול Thread), כתובת אחת היא מסוג link-local (fe80) ושלוש הן מחוברות לרשת מקומית (fd). ה-EID הוא כתובת מקומית ברשת שלא מכילה את ff:fe00 בכתובת. בפלט לדוגמה הזה, ה-EID הוא fd55:cf34:dea5:7994:460:872c:e807:c4ab.
צריך לזהות את ה-EID הספציפי מהפלט ipaddr, שישמש לתקשורת עם הצומת.
2. הפעלת ot-daemon
בחלון הטרמינל השני, עוברים לספרייה openthread ומפעילים את ot-daemon עבור צומת RCP, שאותו נקרא לצומת 2. השתמשו בדגל המפורט של -v כדי לראות את פלט היומן ולוודא שהוא פועל ולהשתמש ב-sudo:
$ cd ~/src/openthread
$ sudo ./build/posix/src/posix/ot-daemon -v \
'spinel+hdlc+forkpty://build/simulation/examples/apps/ncp/ot-rcp?forkpty-arg=2'
לאחר השלמת הפעולה, הפקודה 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
צריך להשאיר את הטרמינל פתוח ולפעול ברקע. לא תזינו בה פקודות נוספות.
3. אפשר להשתמש במקש ot-ctl כדי להצטרף לרשת
עדיין לא הזמנתם את Node 2 (ה-RCP של ot-daemon) לאף רשת בפרוטוקול Thread. כאן ot-ctl נכנס. ה-CLI של ot-ctl זהה לזה של אפליקציית OpenThread CLI. לכן אפשר לשלוט בצמתים של ot-daemon באותו אופן כמו שאר מכשירי פרוטוקול Thread.
בחלון טרמינל שלישי, מפעילים את ot-ctl:
$ sudo ./build/posix/src/posix/ot-ctl >
הערה: אם ההודעה > לא מופיעה אחרי הרצת הפקודה הזו, צריך להקיש על enter.
בחלון הטרמינל השלישי, משתמשים ב-ot-ctl כדי לנהל את צומת 2 (צומת ה-RCP) שהתחלתם בחלון הטרמינל השני באמצעות ot-daemon. צריך לבדוק את state של צומת 2:
> state disabled Done
מקבלים את eui64 של צומת 2, כדי להגביל את ההצטרפות ל-joiner הספציפי:
> eui64 18b4300000000001 Done
בצומת 1 (חלון הטרמינל הראשון), מפעילים את הנציב ומגבילים את ההצטרפות ל-eui64 הזה בלבד:
> commissioner start Done > commissioner joiner add 18b4300000000001 J01NME Done
בצומת 2 (חלון הטרמינל השלישי), מציגים את ממשק הרשת ומצטרפים לרשת:
> ifconfig up Done > joiner start J01NME Done
... עליך להמתין כמה שניות עד לאישור ...
Join success
בתור מצטרפים חדשים, ה-RCP (צומת 2) אימת את עצמו מול הנציב (Node 1) וקיבל את פרטי הכניסה של רשת פרוטוקול Thread.
עכשיו מצטרפים לצומת 2 לרשת של פרוטוקול Thread:
> thread start Done
4. אימות אימות הרשת
בודקים את state ב-Node 2 כדי לוודא שהוא הצטרף לרשת. תוך שתי דקות, צומת 2 עובר מ-child ל-router:
> state child Done ... > state router Done
5. אימות הקישוריות
צא מ-ot-ctl באמצעות הפקודה Ctrl+D או exit, ובשורת הפקודה במחשב המארח שלך, פינג Node 1, באמצעות ה-EID שלו באמצעות הפקודה ping6. אם מכונת ה-RCP ot-daemon מחוברת לרשת Thread ומתקשרת איתה בהצלחה, הפינג יצליח:
$ ping6 -c 4 fd55:cf34:dea5:7994:460:872c:e807:c4ab PING fd55:cf34:dea5:7994:460:872c:e807:c4ab (fd55:cf34:dea5:7994:460:872c:e807:c4ab): 56 data bytes 64 bytes from fd55:cf34:dea5:7994:460:872c:e807:c4ab: icmp_seq=0 ttl=64 time=4.568 ms 64 bytes from fd55:cf34:dea5:7994:460:872c:e807:c4ab: icmp_seq=1 ttl=64 time=6.396 ms 64 bytes from fd55:cf34:dea5:7994:460:872c:e807:c4ab: icmp_seq=2 ttl=64 time=7.594 ms 64 bytes from fd55:cf34:dea5:7994:460:872c:e807:c4ab: icmp_seq=3 ttl=64 time=5.461 ms --- fd55:cf34:dea5:7994:460:872c:e807:c4ab ping statistics --- 4 packets transmitted, 4 packets received, 0% packet loss round-trip min/avg/max/stddev = 4.568/6.005/7.594/1.122 ms
7. מעולה!
סיימת ליצור סימולציה של רשת פרוטוקול Thread הראשונה באמצעות OpenThread. מדהים!
ב-Codelab הזה למדת איך:
- הגדרת שרשרת הכלים לפיתוח גרסת build של OpenThread
- הדמיה של רשת פרוטוקול Thread
- אימות צמתים של פרוטוקולי Thread
- ניהול רשת בפרוטוקול Thread באמצעות OpenThread Daemon
רוצה לקבל מידע נוסף? אפשר לעיין במקורות המידע האלה: