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

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

1. מבוא

26b7f4f6b3ea0700.png

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

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

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

4806d16a8c137c6d.jpeg

מה תלמדו

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

מה הדרישות כדי להצטרף לתוכנית?

חומרה:

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

תוכנה:

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

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

הדמיית OpenThread

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

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

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

מכונה עם Linux

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

לוחות SRiconicon NRF52840

ב-Codelab הזה יש שלושה NRF52840 לוחות PDK.

a6693da3ce213856.png

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

עליך להוריד את החבילה המתאימה למכשיר שלך ולהתקין אותה במיקום הנכון. ב-Linux: /opt/SEGGER/JLink.

התקנת כלי שורת הפקודה של nRF5x

כלי שורת הפקודה nRF5x מאפשרים להבהב את הקבצים הבינאריים של OpenThread ללוחות העריכה של nRF52840. מתקינים את ה-nRF5x-Command-Line-כלים-<OS> בונים במחשב ב-Linux.

מעבירים את החבילה שחולצה לתיקיית הבסיס ~/

התקנה של ARM GNU Toolchain

ארגז הכלים של ARM GNU משמש לבנייה.

מומלץ להציב את הארכיון שחולץ ב-/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 Daemon:

$ script/cmake-build posix -DOT_DAEMON=ON

עכשיו אפשר ליצור הבזק של OpenThread ומשחקי Flash ב-nRF52840.

4. הגדרת מחבר RCP

לבנות ולהבליט

כדי ליצור דוגמה ל-OpenThread nRF52840, אפשר להשתמש ב-הצטרפות או בפונקציונליות USB מקורית. מכשיר משתמש בתפקיד המחבר כדי לאמת באופן מאובטח ולהזמין אותו לרשת Thread. 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 פועל.

20a3b4b480356447.png

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

$ ls /dev/ttyACM*
/dev/ttyACM0

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

c00d519ebec7e5f0.jpeg

עוברים למיקום של כלי שורת הפקודה 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 מקורי

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

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

46e7b670d2464842.png

הפעלת 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 הזה הם מכשירי Thread מלאים (FTD) בעיצוב סטנדרטי של מערכת על שבב (SoC). בהגדרת ייצור, אפשר להשתמש ב-wpantund, מנהל ממשק רשת ברמת הייצור, כדי לשלוט במופעים של NCP ב-OpenThread, אבל במעבד הקוד הזה נשתמש ב-ot-ctl, ה-CLI של OpenThread.

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

לבנות ולהבליט

בונים את הדוגמה של 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:

c00d519ebec7e5f0.jpeg

עוברים למיקום של כלי שורת הפקודה 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

מסמנים את הלוח "Commissioner."

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

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

מנתקים את הקצה של מיקרו ה-USB בכבל ה-USB מיציאת ניפוי הבאגים של לוח ה-nRF52840 המהבהב ומחברים אותו מחדש ליציאת ה-nRF USB במיקרו 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 כדי להתנתק מהמסך של 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. לאחר מכן, יש לחבר מחדש את לוח ה-PC למחשב עם יציאת ה-nRF ב-USB ולהגדיר את מקור החשמל של ה-nRF לVDD.

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

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

מסמנים את הלוח "joiner."

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

$ 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

עכשיו ה-FTD joiner CLI נמצא באותו מופע של ה-FTD Commissioner, ולכן אפשר לעבור ביניהם בעזרת Ctrl+a ← n.

מקישים על Ctrl+a ←

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

6. הגדרת חלון הטרמינל

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

באופן אידיאלי, יש לפתוח ארבעה חלונות:

  1. ot-daemon שירות / יומנים
  2. מחבר RCP דרך 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 Connector) צריכים להיות באותו מופע של מסך. כדי לפצל את המסך בין שני המסכים, יש להזין תחילה את הפעלת המסך הקיימת:

$ 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 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 Commissioner, יוצרים מערך נתונים תפעולי חדש ומגדירים אותו כנכס הפעיל. מערך הנתונים התפעולי הוא התצורה של רשת השרשור שאתה יוצר.

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

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

> scan
| PAN  | MAC Address      | Ch | dBm | LQI |
+------+------------------+----+-----+-----+
| c0de | 1ed687a9cb9d4b1d | 11 | -38 | 229 |

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

8. הוספת רכיב RCP

התכונה 'שרשור שרשור' לא פעילה ברשת, כלומר נצטרך להוסיף את מחבר ה-RCP לרשת השרשורים שיצרנו לאחרונה באמצעות תהליך 'עמלות מחוץ למסגרת'.

ב-FTD Commissioner, רשמנו הערה לגבי מפתח הרשת, לדוגמה 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 מצטרף לרשת "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

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

חוזרים לנציבות FTD, בודקים את טבלאות הנתב והילדים כדי לוודא ששני המכשירים שייכים לאותה רשת. שימוש ב-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 (הכתובת Mesh-Local שהתקבלה מפלט ה-R&B של 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 שמורכבת משני צמתים, כפי שמתואר בתרשים הטופולוגיה הזו:

otcodelab_top01C_2nodes.png

תרשימי טופולוגיה

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

b75a527be4563215.png

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

9. מצטרפים ל-FTD

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

ב-FTD Connector, בודקים את ה-eui64 כדי שה-FTD Commissioner יוכל לזהות אותו:

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

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

otcodelab_top01C_ed01.png

10. שרשור במרחב המשותף

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

השרשור יכול לתמוך ב-32 נתבים, אבל כדאי לנסות לשמור על מספר הנתבים בין 16 ל-23. אם REED מצטרף כמכשיר קצה (ילד) ומספר הנתבים נמוך מ-16, אחרי פרק זמן אקראי תוך שתי דקות, הוא מקדם את עצמו באופן אוטומטי לנתב.

אם הוספתם שני ילדים ברשת השרשורים לאחר שהוספתם את מחבר ה-FTD, המתינו שתי דקות לפחות ולאחר מכן בדקו שוב את טבלאות הנתב והילד ב-FTD Commissioner:

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

otcodelab_top01C.png

מאשרים את המצב החדש ואת RLOC16 ב-FTD Connector:

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

> state
router
Done
> rloc16
b800
Done

שדרוג לאחור של קרן FTD

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

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

> state child
Done
> rloc16
0c03
Done

otcodelab_top01C_ed02.png

בחזרה ב-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.

otcodelab_top01C.png

הסרת המנהיג

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

ב-FTD Commissioner, משביתים את השרשור כדי להסיר אותו מרשת השרשורים:

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

otcodelab_top02C_01.png

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

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

> ifconfig up
Done
> thread start
Done

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

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

> state
router
Done

בודקים את טבלאות הנתב והילד ב-FTD Connector כדי לוודא:

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

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

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

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

מסך

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

צומתי שרשור

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

כדי לאפס את ה-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. שימוש בריבוי שידורים

מצב 'Multicast' משמש להעברת מידע לקבוצה של מכשירים בבת אחת. ברשת Thread, כתובות ספציפיות שמורות לשימוש בשידורים מרובים עם קבוצות שונות של מכשירים, בהתאם להיקף.

כתובת IPv6

היקף

נשלח אל

ff02::1

קישור מקומי

כל ה-FTD ו-MED

ff02::2

קישור מקומי

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

ff03::1

רשת מקומית

כל ה-FTD ו-MED

ff03::2

רשת מקומית

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

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

ההיקף של Link-Local מכיל את כל ממשקי השרשור שניתן להגיע אליהם באמצעות שידור רדיו יחיד, או &"hop.&quot יחיד. הטופולוגיה של הרשת קובעת אילו מכשירים מגיבים לפינג לכתובת 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 Connecter (LTD) של ה-FTD Connecter. המשמעות היא שמחבר ה-FTD הוא המכשיר היחיד שאליו יכול להגיע ה-FTD Commissioner בצעד אחד.

otcodelab_top02C_02_LL.png

פינג 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 של הצ'אט הנוסף.

otcodelab_top02C_02_LL02.png

המשמעות היא שמחבר ה-FTD מקושר ישירות ל-FTD Commissioner ול-RCP joiner, שמאשר את הטופולוגיה שלנו.

רשת מקומית

ההיקף 'Mesh-Local' מורכב מכל ממשקי ה-Thread שניתן להגיע אליהם באותה רשת Thread. ניתן לראות את התשובות לפינג של כתובת ה-Multicast של 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 Commissioner קיבל שתי תגובות, אחת מ-FTD joiner's Routing Locator (RLOC), שמסתיימת ב-b800) ואחת מ-RCP joiner's Mesh-Local EID (ML-EID, שמסתיימת ב-d55f). network&#shsh full. בכל מקום שבו המכשיר נמצא ברשת, הוא יירשם לכתובת 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 בשני הפלטים של פינג. משך ההצטרפות לרכיב RCP היה ארוך יותר מ-FTD Commissioner (68 אלפיות השנייה) מאשר היקף החשיפה ל-FTD Scheduler (23 אלפיות השנייה). הסיבה לכך היא שהיא צריכה לבצע שתי דילוגים כדי להגיע ל-FTD Commissioner, בהשוואה לצעד אחד של חבר ה-FTD.

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

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

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

> state
child

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

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

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

משיגים את כתובת ה-EID של רשת Me-Local עבור חייגן FTD. אנו משתמשים בכתובת זו מכיוון שניתן להגיע אליה מכל מקום ברשת 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 Connector, באמצעות ה-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 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 ושימו לב שהוא אף פעם לא משדרג את עצמו לנתב או מנסה להפוך למנהיג
  • מוסיפים עוד מכשירים (מנסים פלטפורמה אחרת!) ורושמים את הטופולוגיה באמצעות שולחנות עבודה של נתב וילדים, יחד עם פינגים לכתובות עם ריבוי שידורים.
  • שימוש ב-pyspinel לשליטה ב-NCP
  • אפשר להמיר את ה-NCP לנתב גבולות באמצעות OpenThread Border Router ולחבר את רשת השרשור לאינטרנט

קריאה נוספת

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

  • פלטפורמות נתמכות — כאן תוכלו לגלות את כל הפלטפורמות שתומכות ב-OpenThread
  • Build OpenThread – פרטים נוספים לגבי היצירה וההגדרה של OpenThread
  • Thread Primer – מכסה את כל מושגי השרשור שמוצגים ב-Codelab הזה

חומר עזר: