בנייה של רשת Thread באמצעות לוחות nRF52840 ו-OpenThread

1. מבוא

26b7f4f6b3ea0700.png

OpenThread ש-Google מפרסמת הוא יישום קוד פתוח של פרוטוקול הרשת Thread®. Google Nest השיקה את OpenThread כדי להפוך את הטכנולוגיה שבה נעשה שימוש במוצרי Nest לזמינה באופן נרחב למפתחים כדי להאיץ את פיתוח המוצרים לבית החכם.

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

ב-Codelab זה, מתכנתים את OpenThread בחומרה אמיתית, יוצרים ומנהלים רשת בשרשור ומעבירים הודעות בין צמתים.

4806d16a8c137c6d.jpeg

מה תלמדו

  • בנייה של קבצים בינאריים של OpenThread ולוחות מהבהבים ללוחות פיתוח
  • בניית RCP המורכבת ממחשב Linux ולוח פיתוח
  • תקשורת עם RCP באמצעות OpenThread Daemon ו-ot-ctl
  • ניהול ידני של צומתי Thread עם מסך GNU ו-OpenThread CLI
  • הזמנה מאובטחת של מכשירים לרשת בשרשור
  • כיצד עובד שידור לקבוצה ב-IPv6
  • העברת הודעות בין צומתי Thread באמצעות UDP

דרישות:

חומרה:

  • 3 לוחות נורדיים למוליכים למחצה nRF52840 פיתוח
  • 3 כבלים מסוג USB ל-USB לחיבור הלוחות
  • מחשב Linux עם 3 יציאות USB לפחות

תוכנה:

  • ארגז כלים של GNU
  • כלי שורת הפקודה של nRF5x נורדי
  • תוכנת Segger J-Link
  • OpenThread
  • Git

2. איך מתחילים

סימולציה של OpenThread

לפני שמתחילים, מומלץ לקרוא בעיון את OpenThread Simula Codelab כדי לשמוע על עקרונות הבסיס של Thread ואת ה-OpenThread CLI.

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

חשוב לדעת איך להתחבר ליציאה טורית דרך מסוף. ה-Codelab הזה משתמש ב-GNU Screen ומספק סקירה כללית של השימוש, אבל אפשר להשתמש בכל תוכנה אחרת של מסוף.

מחשב Linux

קוד Codelab זה נועד להשתמש במחשב Linux המבוסס על i386 או x86 כדי לשמש כמארח של התקן שרשור במעבד רדיו (RCP) וכדי להבהב את כל לוחות הפיתוח של שרשור. כל השלבים נבדקו ב-Ubuntu מגרסה 14.04.5 (Trusty Tahr).

לוחות מוליכים למחצה נורדיים מסוג nRF52840

ה-Codelab הזה משתמש בשלושה לוחות nDF52840 PDK.

a6693da3ce213856.png

אנחנו משתמשים ב-SEGGER J-Link כדי לתכנת את לוחות ה-nRF52840, שמצורפים אליהם מודולים של JTAG. התקנת במחשב של Linux.

הורד את החבילה המתאימה למחשב, והתקן אותה במיקום המתאים. ב-Linux, זה /opt/SEGGER/JLink.

התקנת nRF5x שורת פקודה

כלי הפקודות של nRF5x מאפשרים לכם להבהב את הקבצים הבינאריים של OpenThread ללוחות nRF52840. מתקינים את הדגם המתאים של ה-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 מוודאות שה-toolchain מותקן ושהסביבה מוגדרת כהלכה:

$ mkdir -p ~/src
$ cd ~/src
$ git clone --recursive https://github.com/openthread/openthread.git
$ cd openthread
$ ./script/bootstrap

בניית OpenThread Daemon:

$ script/cmake-build posix -DOT_DAEMON=ON

עכשיו אתם מוכנים ליצור ולהביע את OpenThread ללוחות nRF52840.

4. הגדרת ה-RCP Joiner

בנייה ופלאש

בנה את הדוגמה של OpenThread nRF52840 עם Joiner ו-USB מובנה. מכשיר משתמש בתפקיד המצטרף כדי לעבור אימות באופן מאובטח ולהיות מוזמן לרשת שרשור. USB מקומי מאפשר שימוש ב-USBC ACM כהעברה טורית בין ה-nRF52840 והמארח.

יש לנקות תמיד את המאגר של גרסאות ה-build הקודמות על ידי הפעלת rm -rf build.

$ 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 פועל.

20a3b4b480356447.png

אם זה הלוח הראשון המחובר למחשב Linux, הוא מופיע בתור יציאה טורית /dev/ttyACM0 (כל לוחות ה-nRF52840 משתמשים ב-ttyACM עבור מזהה יציאה טורית).

$ ls /dev/ttyACM*
/dev/ttyACM0

שימו לב למספר הסידורי של לוח ה-nRF52840 שבו נעשה שימוש ל-RCP:

c00d519ebec7e5f0.jpeg

נכנסים למיקום של כלי שורת הפקודות של nRFx, ומעתיקים את קובץ ה-RCP של OpenThread אל לוח ה-nRF52840 בעזרת המספר הסידורי של הלוח. לתשומת ליבכם, אם לא תסמנו את האפשרות בסטטוס --verify, תוצג לכם הודעת אזהרה על כך שתהליך ה-Flash עלול להיכשל ללא שגיאה.

$ 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 מקורי

מאחר שגרסת ה-RCP של OpenThread RCP מאפשרת שימוש ב-CDC ACM מקומי כהעברה טורית, עליך להשתמש ביציאת ה-nRF USB בלוח nRF52840 כדי ליצור קשר עם מארח ה-RCP (מכונת ה-Linux).

נתק את קצה ה-Micro-USB של כבל ה-USB מיציאת ניפוי הבאגים של לוח nRF52840 המהבהב, ולאחר מכן חבר אותו מחדש אל המיקרו USBnRF USB לידמאופס לחצן. מגדירים את המתג מקור כוח nRF ל-USB.

46e7b670d2464842.png

הפעלת OpenThread Daemon

בעיצוב RCP, משתמשים ב-OpenThread Daemon כדי לתקשר עם מכשיר ה-Tread ולנהל אותו. הפעל את ot-daemon עם הדגל -v במלל כדי שתוכל לראות פלט יומן ולאשר שהוא פועל:

$ cd ~/src/openthread
$ ./build/posix/src/posix/ot-daemon -v \
    'spinel+hdlc+uart:///dev/ttyACM0?uart-baudrate=115200'

כשהפעולה מצליחה, הפונקציה ot-daemon במצב עם דרגת מלל יוצרת פלט הדומה לזה:

ot-daemon[228024]: Running OPENTHREAD/20191113-00831-gfb399104; POSIX; Jun  7 2020 18:05:15
ot-daemon[228024]: Thread version: 2
ot-daemon[228024]: RCP version: OPENTHREAD/20191113-00831-gfb399104; SIMULATION; Jun  7 2020 18:06:08

יש להשאיר את חלון המסוף פתוח כדי שניתן יהיה להציג יומנים מ-ot-daemon.

ot-ctl משמש לתקשורת עם צומת RCP. ot-ctl משתמש באותו CLI כמו באפליקציית OpenThread CLI. לכן, ניתן לשלוט בצמתים של ot-daemon באותו אופן כמו בסימולציות של שרשורים אחרים.

בחלון מסוף שני, מתחילים את ot-ctl:

$ ./build/posix/bin/ot-ctl
>

בדוק את state של צומת 2 (צומת RCP) שהתחלת עם ot-daemon:

> state
disabled
Done

5. הגדרת FTD

שני צומתי Thread האחרים המשמשים ב-Codelab הזה הם התקני Full Thread (FTD) בעיצוב הסטנדרטי של המערכת. בהגדרת Production, אפשר להשתמש ב-wpantund, מנהל התקן של ממשק רשת ברמת ייצור, כדי לשלוט במופעים של OpenThread NCP. אבל במעבדת קוד זה, נשתמש ב-ot-ctl, ה-OpenThread CLI.

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

בנייה ופלאש

בנה את הדוגמה של OpenThread FTD עבור פלטפורמת nRF52840, שבה מופעלים 'תפקיד הנציב' ו'מתקין':

$ cd ~/src/ot-nrf528xx
$ rm -rf build
$ script/build nrf52840 USB_trans -DOT_JOINER=ON -DOT_COMMISSIONER=ON

עוברים לספרייה באמצעות הקובץ הבינארי של OpenThread Full Thread Device (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:

c00d519ebec7e5f0.jpeg

עוברים אל המיקום של כלי שורת הפקודה של nRFx, ומכניסים את קובץ הקוד ההקסדצימלי COpen FTD של OpenThread אל לוח ה-nRF52840, באמצעות המספר הסידורי של הלוח:

$ cd ~/nrfjprog/
$ ./nrfjprog -f nrf52 -s 683704924 --verify --chiperase --program \
       ~/src/ot-nrf528xx/build/bin/ot-cli-ftd.hex --reset

מסמנים את הלוח כ "נציב".

חיבור ל-USB מקורי

מאחר שה-FTD של FTD של OpenThread מאפשר שימוש ב-CDC ACM מקומי בתור העברה טורית, עליך להשתמש ביציאת ה-nRF USB בלוח nRF52840 כדי ליצור קשר עם מארח ה-RCP (מכונת ה-Linux).

נתק את קצה ה-Micro-USB של כבל ה-USB מיציאת ניפוי הבאגים של לוח nRF52840 המהבהב, ולאחר מכן חבר אותו מחדש אל המיקרו USBnRF USB לידמאופס לחצן. מגדירים את המתג מקור כוח nRF ל-USB.

46e7b670d2464842.png

אימות build

ניתן לאמת גרסת build מוצלחת על ידי גישה אל OpenThread CLI באמצעות מסך 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 כדי להתנתק ממסך CLI של ה-FTD, ולחזור למסוף 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 Joiner

חוזרים על התהליך שלמעלה כדי להבהב את הלוח השלישי מסוג nRF52840, באמצעות ה-build הקיים של ot-cli-ftd.hex. לאחר שסיימת, יש לחבר מחדש את הלוח אל המחשב באמצעות יציאת ה-USB מסוג nRF ולהגדיר את מתג המקור nRF כ-VDD.

אם שני הצמתים האחרים מחוברים למחשב Linux כאשר הלוח השלישי מחובר, הוא אמור להופיע בתור יציאה טורית /dev/ttyACM2:

$ ls /dev/ttyACM*
/dev/ttyACM0  /dev/ttyACM1  /dev/ttyACM2

מסמנים את הלוח כ "הצטרפות".

בעת אימות באמצעות מסך, במקום ליצור מופע חדש של מסך משורת הפקודה, חברו מחדש למופע הקיים וצרו חלון חדש בתוכו (שבו השתמשתם עבור נציב ה-FTD):

$ screen -r

יצירת חלון חדש במסך באמצעות Ctrl+a → c.

תוצג שורת פקודה חדשה. גישה אל OpenThread CLI עבור ה-FTD Joiner:

$ screen /dev/ttyACM2 115200

בחלון החדש, מקישים על מקש Return במקלדת מספר פעמים כדי להציג את ההודעה OpenThread CLI >. העלו את ממשק IPv6 ובדקו אם יש כתובות:

> ifconfig up
Done
> ipaddr
fe80:0:0:0:6c1e:87a2:df05:c240
Done

עכשיו, כאשר CLI Joiner FTD נמצא באותו מופע של המסך שבו נמצא נציב ה-FTD, אפשר לעבור ביניהם באמצעות Ctrl+a → n.

שימוש ב-Ctrl+a →

d בכל זמן כדי לצאת מהמסך.

6. הגדרה של חלון מסוף

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

במצב אידיאלי, צריכים להיות לך ארבעה חלונות זמינים:

  1. שירות ot-daemon / יומנים
  2. RCP Joiner דרך ot-ctl
  3. FTD Commissioner דרך OpenThread CLI
  4. FTD Joiner דרך OpenThread CLI

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

שימוש במסך

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

כל הפקודות במסך מתחילות ב-Ctrl+a.

פקודות בסיסיות במסך:

צירוף מחדש לסשן המסך (משורת הפקודה)

screen -r

יציאה מפעילות המסך

Ctrl+A → d

יצירת חלון חדש בסשן המסך

Ctrl+A → c

מעבר בין חלונות באותו סשן מסך

Ctrl+a → n (קדימה) Ctrl+A → p (הקודם)

ביטול החלון הנוכחי בסשן המסך

Ctrl+A → k

מסך מפוצל

במסך, ניתן לפצל את הטרמינל לכמה חלונות:

f1cbf1258cf0a5a.png

ניתן לגשת אל פקודות ב-screen באמצעות Ctrl+a. כל פקודה צריכה להתחיל בשילוב עם מפתח הגישה.

אם עקבתם בדיוק אחרי Codelab, עליכם לציין שני חלונות באותו נציב: FTD Commissioner, FTD Joiner). כדי לפצל את המסך בין השתיים, תחילה היכנס לסשן מסך קיים:

$ screen -r

עליך להיות באחד ממכשירי ה-FTD. פועלים לפי השלבים האלה במסך:

  1. Ctrl+a → S לפיצול החלון אופקית
  2. Ctrl+a → Tab כדי להעביר את הסמן לחלון הריק החדש
  3. Ctrl+a → n כדי לעבור לחלון החדש
  4. אם הוא זהה לחלון העליון, מקישים שוב על Ctrl+a → n כדי להציג את המכשיר השני בתחום ה-FTD

עכשיו שניהם גלויים. מעבר ביניהם באמצעות Ctrl+a → Tab. מומלץ להגדיר מחדש כל חלון ב-Ctrl+a → A כדי למנוע בלבול.

שימוש מתקדם

כדי לפצל את המסך עוד יותר לריבועים ולהציג את יומני ot-daemon ואת ה-RCP Joiner ot-ctl, השירותים האלה חייבים להתחיל באותו מופע מסך. כדי לעשות זאת, יש לעצור את ot-daemon ולצאת מ-ot-ctl ולהפעיל אותו מחדש בחלונות חדשים של מסך (Ctrl+a → c).

הגדרה זו אינה נדרשת ונשארת כתרגול עבור המשתמש.

פיצול וניווט בין חלונות באמצעות הפקודות הבאות:

יצירת חלון חדש

Ctrl+A → c

חלון מפוצל

Ctrl+a →

חלון מפוצל אופקית

Ctrl+A → S

דילוג לחלון המוצג הבא

Ctrl+A → Tab

העברת החלון המוצג קדימה או אחורה

Ctrl+A → n או p

שינוי שם החלון הנוכחי

Ctrl+A → A

ניתן לצאת מהמסך בכל שלב באמצעות Ctrl+a → d ולצרף מחדש עם screen -r משורת הפקודה.

למידע נוסף על מסך, ניתן לעיין בחומר העזר המהיר בנושא מסך GNU.

7. יצירה של רשת שרשור

עכשיו שאתם מגדירים את כל החלונות והמסכים של המסוף, בואו ניצור את רשת Thread שלנו. בנציב/ת ה-FTD, יוצרים מערך נתונים תפעולי חדש ומגדירים אותו כפעיל. מערך הנתונים התפעוליים הוא התצורה של רשת ה-thread שאתם יוצרים.

## 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 Joiner:

## RCP Joiner ##
----------------

> scan
| J | Network Name     | Extended PAN     | PAN  | MAC Address      | Ch | dBm | LQI |
+---+------------------+------------------+------+------------------+----+-----+-----+
| 0 | OpenThread-c0de  | c0de7ab5c0de7ab5 | c0de | 1ed687a9cb9d4b1d | 11 | -36 | 232 |

מ-OpenThread CLI בכלי ההצטרפות ל-FTD:

## FTD Joiner ##
----------------

> scan
| J | Network Name     | Extended PAN     | PAN  | MAC Address      | Ch | dBm | LQI |
+---+------------------+------------------+------+------------------+----+-----+-----+
| 0 | OpenThread-c0de  | c0de7ab5c0de7ab5 | c0de | 1ed687a9cb9d4b1d | 11 | -38 | 229 |

אם הרשת "codelab" לא מופיעה ברשימה, יש לנסות לסרוק שוב.

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

8. הוספה של ה-RCP Joiner

בואו נוסיף את ה-RCP Joiner ל-thread שזה עתה יצרנו, באמצעות תהליך מחוץ למסגרת. סורקים לאיתור רשתות ב-RCP Joiner:

## RCP Joiner ##
----------------

> scan
| J | Network Name     | Extended PAN     | PAN  | MAC Address      | Ch | dBm | LQI |
+---+------------------+------------------+------+------------------+----+-----+-----+
| 0 | OpenThread-c0de  | c0de7ab5c0de7ab5 | c0de | 1ed687a9cb9d4b1d | 11 | -38 | 229 |

כדי להצטרף, יש להגדיר את מפתח הרשת (שאנחנו מקבלים עכשיו מנציב ה-FTD) על ה-RCP Joiner במערך הנתונים הפעיל שלו.

## RCP Joiner ##
----------------

> dataset networkkey 1234c0de7ab51234c0de7ab51234c0de
Done
> dataset commit active
Done

בודקים את מערך הנתונים כדי לוודא שהוא מוגדר נכון.

## RCP Joiner ##
----------------

> dataset
Network Key: 1234c0de7ab51234c0de7ab51234c0de

מפעילים את 'שרשור' כדי להצטרף ל-RCP Joiner לרשת "codelab". המתן מספר שניות. בדוק את המדינה, RLOC16 וכתובות IPv6 שלה:

## RCP Joiner ##
----------------

> 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

יש לרשום את כתובת ה-IPv6 המקומית של Mesh-(fdc0:de7a:b5c0:0:66bf:99b9:24c0:d55f כאן), ניתן להשתמש בה מאוחר יותר.

חוזרים לנציב/ת ה-FTD ובודקים את הנתב ואת טבלאות הצאצאים כדי לוודא ששני המכשירים שייכים לאותה רשת. משתמשים ב-RLOC16 כדי לזהות את ה-RCP Joiner.

## 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 (הכתובת Mesh-Local, שהתקבלה מפלט ה-ipaddr של ה-RCP Joiner).

## 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

יש לנו עכשיו רשת שרשורים המורכבת משני צמתים, כפי שניתן לראות בתרשים הטופולוגיה הבא:

otcodelab_top01C_2nodes.png

דיאגרמות טופולוגיה

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

b75a527be4563215.png

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

9. עמלת FTD

עכשיו נוסיף את המכשיר של Thread השלישי לרשת "codelab". הפעם נשתמש בתהליך ההזמנה המאובטח יותר של המוצר. סורקים לאיתור הרשת ב-FTD Joiner:

## FTD Joiner ##
----------------

> scan
| J | Network Name     | Extended PAN     | PAN  | MAC Address      | Ch | dBm | LQI |
+---+------------------+------------------+------+------------------+----+-----+-----+
| 0 | OpenThread-c0de  | c0de7ab5c0de7ab5 | c0de | f65ae2853ff0c4e4 | 11 | -36 |  57 |

הסמל 0 בעמודה J מציין שהעמלה על שרשורים לא פעילה במכשיר.

נהיה ספציפיים בעת ההזמנה במכשיר הבא ונאפשר רק למשתתף ב-FTD להצטרף. עדיין עליך להצטרף ל-FTD Joiner, כדי לקבל את eui64, כדי שנציב ה-FTD יוכל לזהות אותו:

## FTD Joiner ##
----------------

> eui64
2f57d222545271f1
Done

בנציב FTD, מפעילים את הנציב ומציינים את ה-eui64 של המכשיר שיכול להצטרף, יחד עם פרטי הכניסה של המשתתף, לדוגמה J01NME. פרטי הכניסה של המשתתף הם מחרוזת ספציפית למכשיר של כל התווים האלפאנומריים באותיות גדולות (0-9 ו-AY), למעט I, O, Q ו-Z עבור קריאות), עם אורך בין 6 ל-32 תווים.

## FTD Commissioner ##
----------------------

> commissioner start
Done
> commissioner joiner add 2f57d222545271f1 J01NME
Done

יש לעבור לכלי להצטרפות ל-FTD ולסרוק מחדש:

## FTD Joiner ##
----------------

> scan
| J | Network Name     | Extended PAN     | PAN  | MAC Address      | Ch | dBm | LQI |
+---+------------------+------------------+------+------------------+----+-----+-----+
| 1 | OpenThread-c0de  | c0de7ab5c0de7ab5 | c0de | 1ed687a9cb9d4b1d | 11 | -45 | 196 |

כפי שצוין בעמודה 1 בעמודה J, עמלת שרשור פעילה עכשיו ברשת. כדי להתחיל את תפקיד המצטרף עם פרטי הכניסה להצטרפות שהגדרתם ב'נציב/ת ה-FTD:

## FTD Joiner ##
----------------

> ifconfig up
Done
> joiner start J01NME
Done

בערך בעוד דקה תקבלו אישור לאימות מוצלח:

## FTD Joiner ##
----------------

>
Join success

מעלים את ה-Tread כדי להצטרף לתוכנית FTD ברשת "codelab" ובודקים מיד את המדינה ואת RLOC16:

## FTD Joiner ##
----------------

> thread start
Done
> state
child
Done
> rloc16
0c02
Done

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

otcodelab_top01C_ed01.png

10. שרשור בפעולה

התקני Thread ב-Codelab הזה הם סוג של מכשיר עם Thread מלא (FTD) שנקרא Router Eligible End End (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 Joiner (Extended MAC = e6cdd2d93249a243) קידם את עצמו לנתב. לתשומת ליבך, ה-RLOC16 שונה (b800 במקום 0c02). הסיבה לכך היא שה-RLOC16 מבוסס על מזהה הנתב ועל מזהה הצאצא של מכשיר. כשעוברים מ'מכשיר קצה' ל'נתב', הערכים של מזהה הנתב ומזהה הצאצא משתנים וכך גם RLOC16.

otcodelab_top01C.png

יש לאשר את המדינה החדשה ואת RLOC16 בכלי להצטרפות ל-FTD:

## FTD Joiner ##
----------------

> state
router
Done
> rloc16
b800
Done

שדרוג לאחור של שותף FTD

אפשר לבדוק את ההתנהגות הזו על ידי שדרוג לאחור של כלי ההצטרפות ל-FTD מנתב בחזרה למכשיר קצה. יש לשנות את המדינה לילד או לילדה ולבדוק את RLOC16:

## FTD Joiner ##
----------------

> state child
Done
> rloc16
0c03
Done

otcodelab_top01C_ed02.png

בחזרה לנציב ה-FTD, ה-FTD Joiner אמור להופיע בטבלת הצאצא (מזהה = 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.

otcodelab_top01C.png

הסרת המנהיג

המנהיג מוביל בעצמו מתוך כל נתבי השרשורים. אם ה-Leader הנוכחי יוסר מרשת Thread, אחד מהנתבים האחרים יהפוך ל-Leader החדש.

בנציב FTD, משביתים את שרשור התגובות כדי להסיר אותו מרשת Thread:

## FTD Commissioner ##
----------------------

> thread stop
Done
> ifconfig down
Done

בתוך שתי דקות, FTD Joiner יהיה המוביל החדש של Thread. יש לבדוק את המדינה ואת כתובות ה-IPv6 של ה-FTD Joiner כדי לאמת:

## 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

otcodelab_top02C_01.png

בודקים את טבלת הצאצא. שים לב שיש RLOC16 חדש. זהו להצטרפות באמצעות RCP, כפי שמצוין במזהה שלו וב-MAC המורחב. כדי שרשת ה-Tread ישכבה יחד, היא החליפה את נתבי האב, מ-FTD Commissioner ועד ל-FTD Joiner. התוצאה היא RLOC16 חדש ל-RCP Joiner (כי המזהה של הנתב השתנה מ-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 Joiner יצטרף כמשתתף ב-FTD. יש לבדוק את המדינה ואת ה-RLOC16 כדי לוודא ש:

## RCP Joiner ##
--------------

> state
child
> rloc16
b801

יש לצרף מחדש את נציב ה-FTD

שרשור של שני צמתים לא ממש כיף. אפשר להחזיר את נציב ה-FTD למצב אונליין.

בנציב/ת ה-FTD, הפעל מחדש את השרשור:

## FTD Commissioner ##
----------------------

> ifconfig up
Done
> thread start
Done

תוך 2 דקות, הוא מתחבר מחדש לרשת "codelab" כמכשיר קצה ולאחר מכן מקדם את עצמו לנתב.

## FTD Commissioner ##
----------------------

> state
router
Done

בודקים את טבלאות הנתב והילד בכלי להצטרפות ל-FTD כדי לאמת:

## 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

otcodelab_top02C_02.png

רשת ה-thread שלנו מכילה שלושה צמתים שוב.

11. פתרון בעיות

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

מסך

אם אי פעם תאבד את התצורה שלך (יותר מדי חלונות מסך או מסכים בתוך המסך), המשך להרוג חלונות מסך עם Ctrl+a → k עד שלא קיים כלל ו-screen -ls בשורת הפקודה פלט No Sockets found. לאחר מכן יוצרים מחדש את מסכי המסך בכל מכשיר. מצבי המכשירים נשמרים גם אם המסך מושבת.

צמתים של שרשורים

אם הטופולוגיה של שרשור הרשת אינה מתוארת ב-Codelab הזה או שהצמתים מתנתקים מסיבה כלשהי (אולי בגלל שמכונת ה-Linux שמפעילה אותם עברה למצב שינה), כדאי להסיר את ה-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. שימוש בריבוי שידורים

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

כתובת IP6

היקף

נמסרה אל

ff02::1

קישור מקומי

כל FTD ו-MED

ff02::2

קישור מקומי

כל FTD ונתבי הגבול

ff03::1

רשת מקומית

כל FTD ו-MED

ff03::2

רשת מקומית

כל FTD ונתבי הגבול

מכיוון שאנחנו לא משתמשים בנתב גבול ב-Codelab הזה, בואו נתמקד בשתי כתובות ה-FTD וה-MED.

ההיקף של 'קישור מקומי' מורכב מכל ממשקי שרשורים שניתן להגיע אליהם דרך שידור רדיו יחיד, או "דילוג" אחד. הטופולוגיה של הרשת קובעת אילו מכשירים יגיבו ל-IP של הכתובת שנשלחה אל המספר של 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 Joiner ו-RCP Joiner), אבל המפקח של ה-FTD קיבל רק תגובה אחת מכתובת ה-FTD של ה-FTD. פירוש הדבר הוא שה-FTD Joiner הוא המכשיר היחיד שאליו יכול ה-FTD Commissioner יכול לבצע דילוג אחד.

otcodelab_top02C_02_LL.png

עכשיו נשלח פינג ל-ff02::1 מ-FTD Joiner:

## 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 Joiner.

otcodelab_top02C_02_LL02.png

כלומר, ה-FTD Joiner מקושר ישירות גם ל-FTD Commissioner וגם ל-RCP Joiner, מה שמאשר את הטופולוגיה שלנו.

רשת מקומית

היקף מסוג 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 של ה-RCP של השותף (ML-EID, המסתיים ב-d55f). הסיבה לכך היא שההיקף המקומי-רשת מורכב מכל רשת ה-thread. ללא קשר למיקום ברשת, מכשיר זה יירשם לכתובת ff03::1.

otcodelab_top02C_02_ML.png

שליחת פינג ל-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

otcodelab_top02C_02_LL02.png

שימו לב לזמן התגובה ל-RCP Joiner בשתי היציאות. ל-RCP Joiner נדרש זמן רב יותר להגיע לנציב ה-FTD (68 אלפיות השנייה), בהשוואה להגעה אל ה-FTD להצטרפות (23ms). הסיבה לכך היא שעליהם לבצע שני דילוגים כדי להגיע לנציב ה-FTD, בהשוואה לדילוג אחד למי שמצטרף ל-FTD.

ייתכן שהבחנתם גם שפינג מולטי-שידור מקומי הגיב באמצעות RLOC רק עבור שני מקורות ה-FTD – ולא בליגר ה-RCP. הסיבה לכך היא שה-FTD הם נתבים בתוך הרשת, וה-RCP הוא מכשיר קצה.

בודקים את מצב RCP Joiner כדי לאשר את הדברים הבאים:

## RCP Joiner ##
----------------

> state
child

13. שליחת הודעות עם UDP

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

שקעי UDP נחשפים באמצעות CLI של OpenThread. נשתמש בו כדי להעביר הודעות בין שני ה-FTD.

קבלת כתובת ה-EID של ה-Mesh-Local עבור ה-FTD Joiner. אנחנו משתמשים בכתובת הזו מפני שהיא נגישה מכל מקום ברשת שרשור.

## 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 Joiner באמצעות ML-EID:

## FTD Commissioner ##
----------------------

> udp open
Done
> udp connect fdc0:de7a:b5c0:0:3e2e:66e:9d41:ebcd 1212
Done

חיבור ה-UDP צריך להיות פעיל בין שני הצמתים. שליחת הודעה מה-FTD Commissioner:

## FTD Commissioner ##
----------------------

> udp send hellothere
Done

ה-FTD Joiner, הודעת ה-UDP התקבלה!

## FTD Joiner ##
----------------

> 10 bytes from fdc0:de7a:b5c0:0:0:ff:fe00:c00 49153 hellothere

14. מעולה!

יצרת רשת פיזית לשרשורים!

b915c433e7027cc7.png

עכשיו אתם יודעים:

  • ההבדל בין סוגי שרשורים, תפקידים והיקפים במכשיר
  • איך מכשירי Thread מנהלים את המצבים שלהם ברשת
  • איך להעביר הודעות פשוטות בין צמתים באמצעות UDP

השלבים הבאים

בהמשך ל-Codelab הזה אפשר לנסות את התרגילים הבאים:

  • החזרת הלוח של ה-FTD כ-MTD באמצעות הקובץ הבינארי של ot-cli-mtd, ושימו לב שהוא אף פעם לא משדרג את עצמו לנתב או מנסה להפוך למנהיג
  • הוסף עוד מכשירים (נסה פלטפורמה אחרת!) לרשת ורשום את הטופולוגיה באמצעות נתבים וטבלאות צאצא, יחד עם פינגים לכתובות ה-multicast
  • יש להשתמש ב-pyspinel כדי לשלוט ב-NCP
  • יש להמיר את ה-NCP לנתב גבול באמצעות נתב גבול פתוח ולחבר את רשת השרשור לאינטרנט

קריאה נוספת

כדאי לעיין ב-openthread.io וב-GitHub כדי לעיין במגוון משאבים של OpenThread, כולל:

עיון: