דף זה תורגם על ידי Cloud Translation API.

בניית רשת Thread עם לוחות nRF52840 ו-OpenThread

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).

אימות גרסת ה-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.

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

צירוף מחדש לסשן במסך (משורת הפקודה)	`screen -r`
יציאה מהפעלת המסך	Ctrl+a ← `d`
יצירת חלון חדש בסשן המסך	Ctrl+a ← `c`
מעבר בין חלונות באותו סשן מסך	Ctrl+a ← `n` (הבא) Ctrl+a ← `p` (הקודם)
ביטול החלון הנוכחי בסשן המסך	Ctrl+a ← `k`

מסך מפוצל

באמצעות המסך, אפשר לפצל את המסוף לכמה חלונות:

אפשר לגשת לפקודות ב-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 ← `c`
פיצול החלון במאונך	Ctrl+a ←
פיצול החלון באופן אופקי	Ctrl+a ← `S`
מעבר לחלון הבא שמוצג	Ctrl+a ← `Tab`
העברת החלון המוצג קדימה או אחורה	Ctrl+a ← `n` או `p`
שינוי השם של החלון הנוכחי	Ctrl+a ← `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	היקף	נמסרו אל
`ff02::1`	קישור מקומי	כל ה-FEDs וה-EDED
`ff02::2`	קישור מקומי	כל ה-FTD ונתבי הגבולות
`ff03::1`	רשת מקומית	כל ה-FEDs וה-EDED
`ff03::2`	רשת מקומית	כל ה-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 הזה

עיון: