Tworzenie sieci Thread z kartami nRF52840 i OpenThread

Informacje o tym ćwiczeniu (w Codelabs)
schedule88 minut
subjectOstatnia aktualizacja: 15 sierpnia 2025
account_circleAutorzy: Jeff Bumgardner

26b7f4f6b3ea0700.png

OpenThread to opublikowana przez Google implementacja open source protokołu sieciowego Thread®. Google Nest udostępniło OpenThread, aby technologia używana w produktach Nest była szeroko dostępna dla deweloperów i przyspieszała tworzenie produktów do domów inteligentnych.

Specyfikacja Thread definiuje niezawodny, bezpieczny i energooszczędny protokół komunikacji bezprzewodowej między urządzeniami oparty na IPv6, przeznaczony do zastosowań domowych. OpenThread implementuje wszystkie warstwy sieciowe Thread, w tym IPv6, 6LoWPAN, IEEE 802.15.4 z zabezpieczeniami MAC, Mesh Link Establishment i Mesh Routing.

W tym laboratorium kodowania zaprogramujesz OpenThread na prawdziwym sprzęcie, utworzysz sieć Thread i będziesz nią zarządzać oraz przesyłać wiadomości między węzłami.

4806d16a8c137c6d.jpeg

  • Tworzenie i wgrywanie plików binarnych interfejsu wiersza poleceń OpenThread na płytki deweloperskie
  • Tworzenie RCP składającego się z komputera z systemem Linux i płytki deweloperskiej
  • Komunikacja z RCP za pomocą demona OpenThread i ot-ctl
  • Ręczne zarządzanie węzłami Thread za pomocą GNU Screen i interfejsu wiersza poleceń OpenThread
  • Bezpieczne wdrażanie urządzeń w sieci Thread
  • Jak działa multicast IPv6
  • Przekazywanie wiadomości między węzłami Thread za pomocą protokołu UDP

Czego potrzebujesz

Sprzęt:

  • 3 płytki deweloperskie Nordic Semiconductor nRF52840
  • 3 kable USB do micro USB do podłączenia tablic
  • komputer z systemem Linux i co najmniej 3 portami USB;

Oprogramowanie:

  • GNU Toolchain
  • Narzędzia wiersza poleceń Nordic nRF5x
  • Oprogramowanie Segger J-Link
  • OpenThread
  • Git

2. Pierwsze kroki

Symulacja OpenThread

Zanim zaczniesz, zapoznaj się z samouczkiem OpenThread Simulation Codelab, aby poznać podstawowe pojęcia związane z Thread i interfejsem wiersza poleceń OpenThread.

Terminale portu szeregowego

Musisz wiedzieć, jak połączyć się z portem szeregowym za pomocą terminala. W tym laboratorium używamy GNU Screen i przedstawiamy jego omówienie, ale można użyć dowolnego innego oprogramowania terminala.

Urządzenie z systemem Linux

Ten Codelab został zaprojektowany z myślą o używaniu komputera z systemem Linux opartego na architekturze i386 lub x86 jako hosta dla urządzenia z wątkiem RCP (Radio Co-Processor) oraz do flashowania wszystkich płytek deweloperskich Thread. Wszystkie kroki zostały przetestowane w systemie Ubuntu 14.04.5 LTS (Trusty Tahr).

Płytki Nordic Semiconductor nRF52840

W tym ćwiczeniu w Codelabs używane są 3 płytki nRF52840 PDK.

a6693da3ce213856.png

Do programowania płytek nRF52840, które mają wbudowane moduły JTAG, używamy SEGGER J-Link. Zainstaluj go na komputerze z Linuksem.

Pobierz odpowiedni pakiet na swoje urządzenie i zainstaluj go w odpowiednim miejscu. W systemie Linux jest to /opt/SEGGER/JLink.

Instalowanie narzędzi wiersza poleceń nRF5x

Narzędzia wiersza poleceń nRF5x umożliwiają flashowanie plików binarnych OpenThread na płytach nRF52840. Zainstaluj odpowiednią kompilację nRF5x-Command-Line-Tools-<OS> na komputerze z systemem Linux.

Umieść wyodrębniony pakiet w folderze głównym ~/.

Instalowanie zestawu narzędzi ARM GNU

Do kompilacji używany jest zestaw narzędzi ARM GNU.

Zalecamy umieszczenie wyodrębnionego archiwum w folderze /opt/gnu-mcu-eclipse/arm-none-eabi-gcc/ na komputerze z systemem Linux. Postępuj zgodnie z instrukcjami instalacji w pliku readme.txt archiwum.

Ekran instalacji (opcjonalnie)

Screen to proste narzędzie do uzyskiwania dostępu do urządzeń podłączonych przez port szeregowy. W tym przewodniku używamy aplikacji Screen, ale możesz użyć dowolnej aplikacji terminala portu szeregowego.

$ sudo apt-get install screen

3. Klonowanie repozytoriów

OpenThread

Sklonuj i zainstaluj OpenThread. Polecenia script/bootstrap sprawdzają, czy łańcuch narzędzi jest zainstalowany, a środowisko jest prawidłowo skonfigurowane:

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

Utwórz demona OpenThread:

$ script/cmake-build posix -DOT_DAEMON=ON

Teraz możesz skompilować i wgrać OpenThread na płytki nRF52840.

4. Konfigurowanie tagu łączącego RCP

Kompilowanie i programowanie

Skompiluj przykład OpenThread nRF52840 z funkcją Joiner i natywną funkcją USB. Urządzenie korzysta z roli dołączającego, aby bezpiecznie uwierzytelnić się i zostać włączone do sieci Thread. Natywne USB umożliwia używanie USB CDC ACM jako transportu szeregowego między nRF52840 a hostem.

Zawsze najpierw czyść repozytorium z poprzednich kompilacji, uruchamiając rm -rf build.

$ cd ~/src
$ git clone --recursive https://github.com/openthread/ot-nrf528xx.git
$ cd ot-nrf528xx
$ script/build nrf52840 USB_trans

Otwórz katalog z binarnym plikiem RCP OpenThread i przekonwertuj go na format szesnastkowy:

$ cd ~/src/ot-nrf528xx/build/bin
$ arm-none-eabi-objcopy -O ihex ot-rcp ot-rcp.hex

Podłącz kabel USB do portu debugowania micro USB obok zewnętrznego pinu zasilania na płytce nRF52840, a następnie podłącz go do urządzenia z systemem Linux. Ustaw przełącznik nRF power source na płytce nRF52840 w pozycji VDD. Gdy połączenie jest prawidłowe, LED5 świeci.

20a3b4b480356447.png

Jeśli jest to pierwsza płytka podłączona do urządzenia z systemem Linux, pojawi się ona jako port szeregowy /dev/ttyACM0 (wszystkie płytki nRF52840 używają identyfikatora portu szeregowego ttyACM).

$ ls /dev/ttyACM*
/dev/ttyACM0

Zapisz numer seryjny płytki nRF52840 używanej w przypadku RCP:

c00d519ebec7e5f0.jpeg

Przejdź do lokalizacji narzędzi wiersza poleceń nRFx i wgraj plik szesnastkowy OpenThread RCP na płytę nRF52840, używając numeru seryjnego płyty. Pamiętaj, że jeśli pominiesz flagę --verify, pojawi się komunikat ostrzegawczy informujący, że proces flashowania może się nie powieść bez zgłaszania błędów.

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

Jeśli operacja się powiedzie, pojawią się te dane wyjściowe:

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.

Oznacz tablicę etykietą „RCP”, aby później nie pomylić ról na tablicy.

Połącz z natywnym USB

Ponieważ kompilacja OpenThread RCP umożliwia korzystanie z natywnego protokołu USB CDC ACM jako transportu szeregowego, do komunikacji z hostem RCP (komputerem z systemem Linux) musisz użyć portu nRF USB na płytce nRF52840.

Odłącz końcówkę micro-USB kabla USB od portu debugowania zaprogramowanej płytki nRF52840, a następnie podłącz ją ponownie do portu micro-USB nRF USB obok przycisku RESET. Ustaw przełącznik Źródło zasilania nRF na USB.

46e7b670d2464842.png

Uruchamianie demona OpenThread

W przypadku projektu RCP użyj demona OpenThread do komunikacji z urządzeniem Thread i zarządzania nim. Uruchom polecenie ot-daemon z flagą -v verbose, aby wyświetlić dane wyjściowe logu i potwierdzić, że działa:

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

Jeśli polecenie ot-daemon w trybie szczegółowym zakończy się powodzeniem, wygeneruje dane wyjściowe podobne do tych:

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

Pozostaw to okno terminala otwarte, aby można było wyświetlać logi z ot-daemon.

Użyj ot-ctl, aby komunikować się z węzłem RCP. ot-ctl korzysta z tego samego interfejsu wiersza poleceń co aplikacja OpenThread CLI. Dlatego możesz sterować węzłami ot-daemon w taki sam sposób jak innymi symulowanymi urządzeniami Thread.

W drugim oknie terminala uruchom ot-ctl:

$ sudo ./build/posix/src/posix/ot-ctl
>

Sprawdź state węzła 2 (węzła RCP) uruchomionego za pomocą polecenia ot-daemon:

> state
disabled
Done

5. Konfigurowanie urządzeń FTD

Pozostałe 2 węzły Thread używane w tym laboratorium to urządzenia Thread o pełnej funkcjonalności (FTD) oparte na standardowym układzie SoC (System-on-Chip). Jedno urządzenie pełni funkcję komisarza, który bezpiecznie uwierzytelnia i wdraża urządzenia w tej sieci. Drugie urządzenie działa jako urządzenie dołączające, które może zostać uwierzytelnione w sieci Thread przez urządzenie zarządzające.

Kompilowanie i programowanie

Skompiluj przykład OpenThread FTD dla platformy nRF52840 z włączonymi rolami Komisarza i Dołączającego:

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

Otwórz katalog z binarnym plikiem CLI urządzenia OpenThread Full Thread Device (FTD) i przekonwertuj go na format szesnastkowy:

$ cd ~/src/ot-nrf528xx/build/bin
$ arm-none-eabi-objcopy -O ihex ot-cli-ftd ot-cli-ftd.hex

Podłącz kabel USB do portu micro USB obok zewnętrznego pinu zasilania na płytce nRF52840, a następnie podłącz go do urządzenia z systemem Linux. Jeśli RCP jest nadal podłączony do komputera z systemem Linux, nowa płytka powinna być widoczna jako port szeregowy /dev/ttyACM1 (wszystkie płytki nRF52840 używają identyfikatora portu szeregowego ttyACM).

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

Jak wcześniej, zanotuj numer seryjny płytki nRF52840 używanej do FTD:

c00d519ebec7e5f0.jpeg

Przejdź do lokalizacji narzędzi wiersza poleceń nRFx i wgraj plik szesnastkowy OpenThread CLI FTD na płytę nRF52840, używając numeru seryjnego płyty:

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

Nazwij tablicę „Komisarz”.

Połącz z natywnym USB

W przypadku kompilacji OpenThread FTD można używać natywnego USB CDC ACM jako transportu szeregowego, dlatego do komunikacji z hostem RCP (maszyną z systemem Linux) musisz użyć portu nRF USB na płytce nRF52840.

Odłącz końcówkę micro-USB kabla USB od portu debugowania zaprogramowanej płytki nRF52840, a następnie podłącz ją ponownie do portu micro-USB nRF USB obok przycisku RESET. Ustaw przełącznik Źródło zasilania nRF na USB.

46e7b670d2464842.png

Weryfikowanie kompilacji

Sprawdź, czy kompilacja się powiodła, uzyskując dostęp do interfejsu wiersza poleceń OpenThread za pomocą GNU Screen z okna terminala.

$ screen /dev/ttyACM1

W nowym oknie naciśnij kilka razy klawisz Return, aby wyświetlić wiersz poleceń OpenThread CLI >. Uruchom interfejs IPv6 i sprawdź adresy:

> ifconfig up
Done
> ipaddr
fe80:0:0:0:1cd6:87a9:cb9d:4b1d
Done

Użyj Ctrl+A →

d aby odłączyć się od ekranu interfejsu FTD Commissioner CLI i wrócić do terminala Linuxa, aby można było wgrać oprogramowanie na kolejną płytkę. Aby w dowolnym momencie ponownie otworzyć interfejs wiersza poleceń, użyj polecenia screen -r. Aby wyświetlić listę dostępnych ekranów, użyj screen -ls:

$ screen -ls
There is a screen on:
        74182.ttys000.mylinuxmachine        (Detached)
1 Socket in /tmp/uscreens/S-username.

Konfigurowanie narzędzia FTD Joiner

Powtórz powyższy proces, aby wgrać oprogramowanie na trzecią płytkę nRF52840, używając istniejącej kompilacji ot-cli-ftd.hex. Po zakończeniu podłącz płytkę z powrotem do komputera za pomocą portu USB nRF i ustaw przełącznik nRF power source (Źródło zasilania nRF) w pozycji VDD.

Jeśli pozostałe 2 węzły są podłączone do urządzenia z systemem Linux, gdy podłączysz trzecią płytkę, powinna ona pojawić się jako port szeregowy /dev/ttyACM2:

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

Oznacz tablicę jako „Joiner”.

Jeśli weryfikujesz za pomocą narzędzia Screen, zamiast tworzyć nową instancję narzędzia Screen w wierszu poleceń, ponownie dołącz do istniejącej instancji i utwórz w niej nowe okno (którego używasz w przypadku FTD Commissioner):

$ screen -r

Utwórz nowe okno w programie Screen, naciskając Ctrl+a → c.

Pojawi się nowy wiersz polecenia. Uzyskaj dostęp do interfejsu wiersza poleceń OpenThread dla urządzenia FTD Joiner:

$ screen /dev/ttyACM2

W nowym oknie naciśnij kilka razy klawisz Return, aby wyświetlić wiersz poleceń OpenThread CLI >. Uruchom interfejs IPv6 i sprawdź adresy:

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

Teraz, gdy interfejs wiersza poleceń urządzenia FTD Joiner znajduje się w tej samej instancji ekranu co urządzenie FTD Commissioner, możesz przełączać się między nimi za pomocą kombinacji klawiszy Ctrl+a → n.

Użyj Ctrl+A →

d w dowolnym momencie, aby zamknąć ekran.

6. Konfigurowanie okna terminala

W przyszłości będziesz często przełączać się między urządzeniami Thread, więc upewnij się, że wszystkie są włączone i łatwo dostępne. Do tej pory używaliśmy narzędzia Screen, aby uzyskać dostęp do 2 urządzeń FTD. Umożliwia ono też podzielenie ekranu w tym samym oknie terminala. Dzięki temu możesz sprawdzić, jak jeden węzeł reaguje na polecenia wydawane w innym węźle.

Najlepiej, aby były dostępne 4 okna:

  1. ot-daemon usługa / logi
  2. RCP Joiner przez ot-ctl
  3. Komisarz FTD za pomocą interfejsu wiersza poleceń OpenThread
  4. FTD Joiner za pomocą interfejsu wiersza poleceń OpenThread

Jeśli chcesz użyć własnej konfiguracji terminala lub portu szeregowego albo własnego narzędzia, możesz przejść do następnego kroku. Skonfiguruj okna terminala na wszystkich urządzeniach w sposób, który najbardziej Ci odpowiada.

Korzystanie z ekranu

Aby ułatwić sobie pracę, uruchom tylko jedną sesję Screen. Powinna być już dostępna, ponieważ została utworzona podczas konfigurowania obu urządzeń FTD.

Wszystkie polecenia w programie Screen zaczynają się od Ctrl+a.

Podstawowe polecenia ekranu:

Ponowne dołączanie do sesji Screen (z wiersza poleceń)

screen -r

Opuszczanie sesji Screen

Ctrl+a → d

Tworzenie nowego okna w sesji Screen

Ctrl+a → c

Przełączanie się między oknami w tej samej sesji Screen

Ctrl+a → n (do przodu)Ctrl+a → p (do tyłu)

Zamknięcie bieżącego okna w sesji Screen

Ctrl+a → k

Podzielony ekran

Za pomocą programu Screen możesz podzielić terminal na kilka okien:

f1cbf1258cf0a5a.png

Polecenia w screen są dostępne po naciśnięciu Ctrl+a. Każde polecenie powinno zaczynać się od tej kombinacji klawiszy dostępu.

Jeśli postępujesz zgodnie z instrukcjami w tym laboratorium, powinny być widoczne 2 okna (FTD Commissioner, FTD Joiner) w tej samej instancji Screen. Aby podzielić ekran na 2 części, najpierw otwórz istniejącą sesję Screen:

$ screen -r

Musisz korzystać z jednego z urządzeń FTD. Wykonaj te czynności w sekcji Ekran:

  1. Ctrl+a → S, aby podzielić okno w poziomie.
  2. Ctrl+a → Tab, aby przenieść kursor do nowego pustego okna.
  3. Ctrl+a → n, aby przełączyć nowe okno na następne
  4. Jeśli jest taka sama jak w górnym oknie, naciśnij Ctrl+a → n, aby wyświetlić inne urządzenie FTD.

Oba są teraz widoczne. Przełączaj się między nimi za pomocą kombinacji Ctrl+a → Tab. Aby uniknąć pomyłek, zalecamy zmianę nazwy każdego okna za pomocą skrótu Ctrl+a → A.

Zaawansowane użycie

Aby podzielić ekran na kwadranty i wyświetlić ot-daemon logi oraz RCP Joiner ot-ctl, te usługi muszą być uruchomione w ramach tej samej instancji ekranu. Aby to zrobić, zatrzymaj ot-daemon i zamknij ot-ctl, a następnie uruchom je ponownie w nowych oknach Screen (Ctrl+a → c).

Ta konfiguracja nie jest wymagana i pozostawiamy ją użytkownikowi do samodzielnego wykonania.

Dziel i przełączaj okna za pomocą tych poleceń:

Utwórz nowe okno

Ctrl+a → c

Podziel okno pionowo

Ctrl+A →

Podziel okno poziomo

Ctrl+a → S

Przejście do następnego wyświetlanego okna

Ctrl+a → Tab

Przełączanie wyświetlanego okna do przodu lub do tyłu

Ctrl+a → n lub p

Zmień nazwę bieżącego okna

Ctrl+a → A

W każdej chwili możesz opuścić ekran, naciskając Ctrl+a → d, a następnie ponownie go dołączyć, wpisując screen -r w wierszu poleceń.

Więcej informacji o programie Screen znajdziesz w tym dokumencie.

7. Tworzenie sieci Thread

Po skonfigurowaniu wszystkich okien terminala i ekranów utwórzmy sieć Thread. Na urządzeniu FTD Commissioner utwórz nowy operacyjny zbiór danych i zatwierdź go jako aktywny. Zbiór danych operacyjnych to konfiguracja tworzonej sieci 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

Zapisz klucz sieciowy 1234c0de7ab51234c0de7ab51234c0de, który będzie potrzebny później.

Zatwierdź ten zbiór danych jako aktywny:

> dataset commit active
Done

Włącz interfejs IPv6:

> ifconfig up
Done

Rozpocznij operację protokołu Thread:

> thread start
Done

Po chwili sprawdź stan urządzenia. Powinien być liderem. Zapisz też kod RLOC16, aby móc z niego skorzystać w przyszłości.

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

> state
leader
Done
> rloc16
0c00
Done

Sprawdź adresy IPv6 urządzenia:

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

Sieć „codelab” jest teraz widoczna podczas skanowania z innych urządzeń Thread.

Na stronie RCP Joiner:ot-ctl

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

> scan
| PAN  | MAC Address      | Ch | dBm | LQI |
+------+------------------+----+-----+-----+
| c0de | 1ed687a9cb9d4b1d | 11 | -36 | 232 |

W interfejsie wiersza poleceń OpenThread na urządzeniu FTD Joiner:

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

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

Jeśli sieć „codelab” nie pojawia się na liście, spróbuj ponownie wyszukać sieci.

8. Dodawanie łącznika RCP

W sieci nie jest aktywna funkcja Thread Commissioning, co oznacza, że musimy dodać urządzenie RCP Joiner do utworzonej przez nas sieci Thread za pomocą procesu konfiguracji poza pasmem.

Na stronie FTD Commissioner (Komisarz FTD) zanotowaliśmy klucz sieci, np. 1234c0de7ab51234c0de7ab51234c0de. Jeśli musisz ponownie wyszukać klucz sieciowy, uruchom to polecenie na FTD Commissioner:

## FTD Commissioner ##

> dataset networkkey
1234c0de7ab51234c0de7ab51234c0de
Done

Następnie na urządzeniu RCP Joiner ustaw aktywny zbiór danych Klucz sieciowy na Klucz sieciowy urządzenia FTD Commissioner:

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

> dataset networkkey 1234c0de7ab51234c0de7ab51234c0de
Done
> dataset commit active
Done

Sprawdź, czy zbiór danych jest prawidłowo skonfigurowany.

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

> dataset
Network Key: 1234c0de7ab51234c0de7ab51234c0de

Uruchom Thread, aby urządzenie RCP Joiner dołączyło do sieci „codelab”. Poczekaj kilka sekund, sprawdź stan, RLOC16 i jego adresy 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

Zanotuj adres IPv6 sieci Mesh (fdc0:de7a:b5c0:0:66bf:99b9:24c0:d55f), będzie on potrzebny później.

Wróć do FTD Commissioner i sprawdź tabele routera i urządzeń podrzędnych, aby potwierdzić, że oba urządzenia należą do tej samej sieci. Użyj RLOC16, aby zidentyfikować 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

Wyślij ping na adres lokalny sieci RCP Joiner (adres lokalny sieci uzyskany z danych wyjściowych ipaddr RCP Joiner), aby sprawdzić łączność:

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

Mamy teraz sieć Thread składającą się z 2 węzłów, co ilustruje ten diagram topologii:

otcodelab_top01C_2nodes.png

Diagramy topologii

W dalszej części tego laboratorium pokażemy nowy diagram topologii sieci Thread za każdym razem, gdy zmieni się stan sieci. Role węzłów są oznaczane w ten sposób:

b75a527be4563215.png

Routery są zawsze pięciokątami, a urządzenia końcowe – okręgami. Liczby w każdym węźle reprezentują identyfikator routera lub identyfikator urządzenia podrzędnego widoczny w danych wyjściowych interfejsu CLI, w zależności od bieżącej roli i stanu każdego węzła.

9. Uruchomienie urządzenia FTD Joiner

Teraz dodajmy trzecie urządzenie Thread do sieci „codelab”. Tym razem użyjemy bezpieczniejszego procesu w pasmie i zezwalimy na dołączenie tylko urządzenia FTD Joiner.

Na FTD Joiner uzyskaj eui64, aby komisarz FTD mógł go zidentyfikować:

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

> eui64
2f57d222545271f1
Done

Na urządzeniu FTD Commissioner uruchom urządzenie Commissioner i określ eui64 urządzenia, które może dołączyć, wraz z poświadczeniami Joiner Credential, np. J01NME. Klucz dostępu urządzenia to ciąg znaków alfanumerycznych składający się z samych wielkich liter (0–9 i A–Y, z wyłączeniem I, O, Q i Z ze względu na czytelność) o długości od 6 do 32 znaków.

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

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

Przełącz na FTD Joiner (Narzędzie złączające FTD). Uruchom rolę dołączającego za pomocą danych logowania dołączającego, które zostały skonfigurowane na urządzeniu FTD Commissioner:

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

> ifconfig up
Done
> joiner start J01NME
Done

Po około minucie otrzymasz potwierdzenie udanego uwierzytelniania:

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

>
Join success

Uruchom Thread, aby urządzenie FTD Joiner dołączyło do sieci „codelab”, a następnie od razu sprawdź stan i RLOC16:

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

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

Sprawdź adresy IPv6 urządzenia. Zwróć uwagę, że nie ma ALOC. Wynika to z tego, że to urządzenie nie jest liderem ani nie pełni roli związanej z Anycast, która wymaga adresu 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)

Od razu przełącz się na FTD Commissioner i sprawdź tabele routera i dziecka, aby potwierdzić, że w sieci „codelab” znajdują się 3 urządzenia:

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

Na podstawie RLOC16 urządzenie FTD Joiner zostało dołączone do sieci jako urządzenie końcowe (podrzędne). Oto zaktualizowana topologia:

otcodelab_top01C_ed01.png

10. Wątek w akcji

Urządzenia Thread w tym laboratorium to specjalny rodzaj urządzenia FTD (Full Thread Device) o nazwie REED (Router Eligible End Device). Oznacza to, że mogą pełnić funkcję routera lub urządzenia końcowego i mogą przekształcić się z urządzenia końcowego w router.

Sieć Thread może obsługiwać do 32 routerów, ale staramy się, aby ich liczba wynosiła od 16 do 23. Jeśli urządzenie REED zostanie podłączone jako urządzenie końcowe (podrzędne), a liczba routerów będzie mniejsza niż 16, po losowym czasie trwającym maksymalnie 2 minuty automatycznie przekształci się w router.

Jeśli po dodaniu urządzenia FTD Joiner w sieci Thread masz 2 dzieci, poczekaj co najmniej 2 minuty, a następnie ponownie sprawdź tabele routerów i dzieci na urządzeniu 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

Urządzenie FTD Joiner (Extended MAC = e6cdd2d93249a243) zostało awansowane na router. Zwróć uwagę, że RLOC16 jest inny (b800 zamiast 0c02). Dzieje się tak, ponieważ RLOC16 jest oparty na identyfikatorze routera i identyfikatorze urządzenia podrzędnego. Gdy urządzenie końcowe przechodzi w tryb routera, zmieniają się wartości identyfikatora routera i identyfikatora urządzenia podrzędnego, a także RLOC16.

otcodelab_top01C.png

Sprawdź nowy stan i RLOC16 na urządzeniu FTD Joiner:

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

> state
router
Done
> rloc16
b800
Done

Obniżanie wersji urządzenia FTD Joiner

Możesz przetestować to działanie, ręcznie obniżając wersję FTD Joiner z routera do urządzenia końcowego. Zmień stan na „child” (dziecko) i sprawdź RLOC16:

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

> state child
Done
> rloc16
0c03
Done

otcodelab_top01C_ed02.png

FTD Commissioner w tabeli podrzędnej powinien być teraz widoczny FTD Joiner (ID = 3). Może nawet znajdować się w obu usługach w okresie przejściowym:

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

Po pewnym czasie wróci do routera z RLOC b800.

otcodelab_top01C.png

Usuwanie lidera

Lider jest wybierany samodzielnie spośród wszystkich routerów Thread. Oznacza to, że jeśli bieżący lider zostanie usunięty z sieci Thread, jeden z pozostałych routerów stanie się nowym liderem.

Na urządzeniu FTD Commissioner wyłącz Thread, aby usunąć go z sieci Thread:

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

> thread stop
Done
> ifconfig down
Done

W ciągu 2 minut FTD Joiner staje się nowym liderem wątku. Sprawdź stan i adresy IPv6 urządzenia FTD Joiner, aby potwierdzić:

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

Sprawdź tabelę podrzędną. Zwróć uwagę, że pojawił się nowy identyfikator RLOC16. Jest to urządzenie RCP Joiner, na co wskazują jego identyfikator i rozszerzony adres MAC. Aby utrzymać spójność sieci Thread, zmieniło routery nadrzędne z FTD Commissioner na FTD Joiner. W rezultacie dla urządzenia RCP Joiner powstaje nowy RLOC16 (ponieważ jego identyfikator routera zmienił się z 3 na 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

Może minąć kilka minut, zanim RCP Joiner zostanie dołączony do FTD Joiner jako węzeł podrzędny. Sprawdź stan i RLOC16, aby potwierdzić, że:

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

> state
child
> rloc16
b801

Ponownie podłącz komisarza FTD

Sieć Thread z 2 węzłami nie jest zbyt przydatna. Przywróćmy komisarza FTD do trybu online.

Na FTD Commissioner uruchom ponownie Thread:

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

> ifconfig up
Done
> thread start
Done

W ciągu 2 minut automatycznie ponownie połączy się z siecią „codelab” jako urządzenie końcowe, a następnie zostanie przekształcone w router.

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

> state
router
Done

Sprawdź router i tablice podrzędne na stronie FTD Joiner, aby potwierdzić:

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

Nasza sieć Thread ponownie składa się z 3 węzłów.

11. Rozwiązywanie problemów

Zarządzanie siecią Thread z wieloma urządzeniami w różnych oknach terminala lub ekranu może być skomplikowane. Jeśli napotkasz problemy, skorzystaj z tych wskazówek, aby „zresetować” stan sieci lub obszaru roboczego.

Ekran

Jeśli kiedykolwiek zgubisz się w konfiguracji (zbyt wiele okien ekranu lub ekranów w ekranie), zamykaj okna ekranu za pomocą skrótu Ctrl+a → k, aż nie będzie ich więcej, a w wierszu poleceń pojawi się screen -ls.No Sockets found Następnie ponownie utwórz okna Screen na każdym urządzeniu. Stany urządzenia są zachowywane nawet po zamknięciu ekranu.

Węzły Thread

Jeśli topologia sieci Thread nie jest zgodna z opisem w tym samouczku lub węzły rozłączają się z jakiegoś powodu (np. z powodu przejścia w stan uśpienia urządzenia z systemem Linux, które je zasila), najlepiej wyłączyć sieć Thread, wyczyścić dane logowania i zacząć od nowa od kroku Tworzenie sieci Thread.

Aby zresetować FTD:

## FTD Commissioner or FTD Joiner ##
------------------------------------

> thread stop
Done
> ifconfig down
Done
> factoryreset
Done

RCP można zresetować w ten sam sposób za pomocą ot-ctl:

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

> thread stop
Done
> ifconfig down
Done
> factoryreset
Done

12. Korzystanie z multicastu

Multicast służy do przekazywania informacji do grupy urządzeń jednocześnie. W sieci Thread określone adresy są zarezerwowane do transmisji grupowej w różnych grupach urządzeń w zależności od zakresu.

Adres IPv6

Zakres

Dostarczono do

ff02::1

Link-Local

Wszystkie FTD i MED

ff02::2

Link-Local

Wszystkie urządzenia FTD i routery graniczne

ff03::1

Mesh-Local

Wszystkie FTD i MED

ff03::2

Mesh-Local

Wszystkie urządzenia FTD i routery graniczne

W tym laboratorium nie używamy routera brzegowego, więc skupmy się na 2 adresach multicastowych FTD i MED.

Zakres Link-Local obejmuje wszystkie interfejsy Thread, do których można dotrzeć za pomocą jednej transmisji radiowej lub jednego „skoku”. Topologia sieci określa, które urządzenia odpowiadają na ping do adresu połączenia grupowego ff02::1.

Ping ff02::1 od komisarza FTD:

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

> ping ff02::1
> 8 bytes from fe80:0:0:0:e4cd:d2d9:3249:a243: icmp_seq=2 hlim=64 time=9ms

W sieci są jeszcze 2 urządzenia (FTD Joiner i RCP Joiner), ale FTD Commissioner otrzymał tylko 1 odpowiedź – z adresu lokalnego połączenia (LLA) urządzenia FTD Joiner. Oznacza to, że urządzenie FTD Joiner jest jedynym urządzeniem, do którego urządzenie FTD Commissioner może dotrzeć za pomocą jednego przeskoku.

otcodelab_top02C_02_LL.png

Teraz wyślij ping ff02::1FTD 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

Dwie odpowiedzi! Sprawdzając adresy IPv6 innych urządzeń, widzimy, że pierwszy z nich (kończący się na 4b1d) to adres LLA komisarza FTD, a drugi (kończący się na 943b) to adres LLA urządzenia RCP Joiner.

otcodelab_top02C_02_LL02.png

Oznacza to, że urządzenie FTD Joiner jest bezpośrednio połączone zarówno z urządzeniem FTD Commissioner, jak i z urządzeniem RCP Joiner, co potwierdza naszą topologię.

Mesh-Local

Zakres Mesh-Local obejmuje wszystkie interfejsy Thread dostępne w tej samej sieci Thread. Zobaczmy odpowiedzi na ping wysłany na adres multiemisji ff03::1.

Ping ff03::1 od komisarza 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

Tym razem komisarz FTD otrzymał 2 odpowiedzi: jedną z lokalizatora routingu (RLOC) urządzenia dołączającego FTD (końcówka b800) i jedną z lokalnego identyfikatora EID (ML-EID) urządzenia dołączającego RCP (końcówka d55f). Dzieje się tak, ponieważ zasięg lokalny sieci mesh obejmuje całą sieć Thread. Niezależnie od tego, gdzie w sieci znajduje się urządzenie, będzie ono subskrybować adres ff03::1.

otcodelab_top02C_02_ML.png

Wyślij ping do ff03::1FTD Joiner, aby potwierdzić to samo zachowanie:

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

Zwróć uwagę na czas odpowiedzi w przypadku RCP Joiner w obu wynikach pingowania. Dotarcie do komisarza FTD (68 ms) zajęło RCP Joiner znacznie więcej czasu niż dotarcie do RCP Joiner (23 ms). Dzieje się tak, ponieważ musi wykonać 2 przeskoki, aby dotrzeć do komisarza FTD, podczas gdy urządzenie dołączające FTD wykonuje tylko 1 przeskok.

Możesz też zauważyć, że ping rozgłoszeniowy w sieci mesh zwrócił RLOC tylko w przypadku 2 urządzeń FTD, a nie urządzenia RCP Joiner. Dzieje się tak, ponieważ urządzenia FTD są routerami w sieci, a RCP jest urządzeniem końcowym.

Sprawdź stan RCP Joiner, aby potwierdzić:

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

> state
child

13. Wysyłanie wiadomości za pomocą protokołu UDP

Jedną z usług aplikacji, które udostępnia OpenThread, jest protokół UDP (User Datagram Protocol), czyli protokół warstwy transportowej. Aplikacja oparta na OpenThread może używać interfejsu UDP API do przekazywania wiadomości między węzłami w sieci Thread lub do innych urządzeń w sieci zewnętrznej (np. w internecie, jeśli sieć Thread ma router graniczny).

Gniazda UDP są udostępniane za pomocą interfejsu wiersza poleceń OpenThread. Użyjmy go do przesyłania wiadomości między dwoma urządzeniami FTD.

Uzyskaj adres Mesh-Local EID dla FTD Joiner. Używamy tego adresu, ponieważ jest on dostępny z dowolnego miejsca w sieci 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

Uruchom UDP i powiąż go z gniazdem dla dowolnego adresu IPv6:

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

> udp open
Done
> udp bind :: 1212

Przejdź do FTD Commissioner, uruchom UDP i połącz się z gniazdem skonfigurowanym na urządzeniu FTD Joiner, używając jego ML-EID:

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

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

Połączenie UDP powinno być aktywne między dwoma węzłami. Wysyłanie wiadomości od komisarza FTD:

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

> udp send hellothere
Done

Na urządzeniu FTD Joiner odebrano wiadomość UDP.

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

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

14. Gratulacje!

Udało Ci się utworzyć fizyczną sieć Thread.

b915c433e7027cc7.png

Wiesz już:

  • różnice między typami, rolami i zakresami urządzeń Thread;
  • jak urządzenia Thread zarządzają swoimi stanami w sieci,
  • jak przekazywać proste wiadomości między węzłami za pomocą protokołu UDP,

Dalsze kroki

Wykonaj te ćwiczenia, korzystając z tego samouczka:

  • Ponownie wgraj oprogramowanie na płytę FTD Joiner jako MTD za pomocą pliku binarnego ot-cli-mtd i sprawdź, czy nigdy nie aktualizuje się do wersji Router ani nie próbuje zostać liderem.
  • Dodaj do sieci więcej urządzeń (wypróbuj inną platformę!) i naszkicuj topologię, korzystając z tabel routera i urządzeń podrzędnych oraz pingów do adresów multiemisji.
  • Użyj pyspinel, aby sterować NCP
  • Przekształć NCP w router graniczny za pomocą OpenThread Border Router i połącz sieć Thread z internetem.

Więcej informacji

Na stronach openthread.ioGitHub znajdziesz różne materiały dotyczące OpenThread, w tym:

Źródło: