Ta strona została przetłumaczona przez Cloud Translation API.

Utwórz sieć Thread z tablicami nRF52840 i OpenThread

1. Wprowadzenie

OpenThread to opracowane przez Google rozwiązanie open source, które pozwala wdrożyć protokół sieciowy Thread®. Firma Google Nest wydała platformę OpenThread, by umożliwić deweloperom szerokie udostępnienie technologii Nest w produktach, co przyspiesza tworzenie produktów do domów inteligentnych.

Specyfikacja Thread umożliwia określanie niezawodnego, bezpiecznego i bezpośredniego protokołu komunikacyjnego między urządzeniami w standardzie IPv6. OpenThread implementuje wszystkie warstwy sieciowe Thread, w tym IPv6, 6LoWPAN, IEEE 802.15.4 z zabezpieczeniami MAC, ustanowieniem połączenia sieci typu mesh i routingiem typu mesh.

W ramach tego ćwiczenia zaprogramujesz OpenThread na prawdziwym sprzęcie, utworzysz sieć Thread i będziesz nią zarządzać oraz przekażesz wiadomości między węzłami.

Czego się nauczysz

Tworzenie i miganie plików binarnych interfejsu wiersza poleceń OpenThread na tablicach programistycznych
Tworzenie platformy RCP składającej się z komputera z systemem Linux i tablicy programistycznej
Komunikacja z platformą RCP przy użyciu demona OpenThread i ot-ctl
Ręczne zarządzanie węzłami wątków za pomocą ekranu GNU i interfejsu wiersza poleceń OpenThread
Bezpieczne uruchamianie urządzeń w sieci typu Thread
Jak działa multiemisja IPv6
Przekazywanie wiadomości między węzłami wątków za pomocą protokołu UDP

Czego potrzebujesz

Sprzęt:

3 normy północnoprzewodowe nRF52840
3 kable USB do micro-USB do podłączenia płyt
komputer z systemem Linux z co najmniej 3 portami USB,

Oprogramowanie:

Łańcuch narzędzi GNU
Narzędzia wiersza poleceń nRF5x
Oprogramowanie Segger J-Link
OpenThread
Git

2. Pierwsze kroki

Symulacja OpenThread

Zanim rozpoczniesz, możesz zapoznać się z Ćwiczeniami z symulacji języka OpenThread, aby zapoznać się z podstawowymi pojęciami dotyczącymi narzędzia Thread i interfejsem wiersza poleceń OpenThread.

Terminal portów szeregowych

Musisz wiedzieć, jak połączyć się z portem szeregowym przez terminal. To ćwiczenia z programowania korzystają z ekranu GNU i mają opis wykorzystania, ale można użyć dowolnego innego oprogramowania terminala.

Maszyna z systemem Linux

To ćwiczenie z programowania zostało stworzone z myślą o korzystaniu z komputera z systemem Linux i386 lub x86, aby obsługiwać go jako host na urządzeniu z protokołem RCP (Radio Co-Processor Thread) i przekazywać tablice programistyczne. Wszystkie kroki zostały przetestowane na systemie Ubuntu 14.04.5 LTS (Trusty Tahr).

Deski północnonordowe nRF52840

Te ćwiczenia z programowania obejmują 3 płytki nRF52840 PDK.

Zainstaluj SEGGER J-Link

Używamy płyt SEGGER J-Link do tworzenia płyt nRF52840, które zawierają wbudowane moduły JTAG. Zainstaluj ten program na komputerze z systemem Linux.

Pobierz pakiet dla odpowiedniego komputera i zainstaluj go w odpowiedniej lokalizacji. W systemie Linux jest to /opt/SEGGER/JLink.

Instalowanie narzędzi wiersza poleceń nRF5x

Narzędzia wiersza poleceń nRF5x pozwalają przesłać pliki binarne OpenThread na tablice nRF52840. Zainstaluj na komputerze z systemem Linux kompilację nRF5x-Command-Line-Tools-<OS>.

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

Zainstaluj łańcuch narzędzi ARM GNU

Do tworzenia budynków służy łańcuch 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)

Ekran to proste narzędzie umożliwiające dostęp do urządzeń połączonych przez port szeregowy. To ćwiczenia z programowania korzystają z ekranu, ale możesz użyć dowolnej aplikacji terminala portów szeregowych.

$ sudo apt-get install screen

3. Klonuj repozytoria

OpenThread

Skopiuj i zainstaluj OpenThread. Polecenia script/bootstrap zapewniają, że ł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 demon OpenThread:

$ script/cmake-build posix -DOT_DAEMON=ON

Teraz możesz już tworzyć i konwertować OpenThread na tablice nRF52840.

4. Skonfiguruj łącznik RCP

Kompilacja i błysk

Utwórz przykład interfejsu OpenThread nRF52840 z wykorzystaniem łączących i natywnych urządzeń USB. Urządzenie używa roli Łącznika, aby bezpiecznie uwierzytelniać się w wątkach i otrzymywać polecenia w ramach tej sieci. Natywny port USB umożliwia wykorzystanie portu USB CDC ACM jako portu szeregowego między nRF52840 a hostem.

Zawsze czyść repozytorium 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

Przejdź do katalogu z plikiem binarnym OpenCP RCP i przekonwertuj go na format szesnastkowy:

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

Kabel USB podłącza się do portu debugowania micro USB obok zewnętrznego gniazda zasilania na płytce nRF52840, a następnie włączasz do komputera z systemem Linux. Ustaw przełącznik źródło zasilania nRF na płytce nRF52840 na VDD. Po prawidłowym podłączeniu urządzenie LED5 jest włączone.

Jeśli jest to pierwsza płyta podłączona do komputera z systemem Linux, widoczna jako port szeregowy /dev/ttyACM0 (wszystkie tablice nRF52840 używają ttyACM jako identyfikatora portu szeregowego).

$ ls /dev/ttyACM*
/dev/ttyACM0

Numer seryjny płyty nRF52840 używanej na potrzeby RCP:

Przejdź do lokalizacji narzędzi nRFx Command Line i uruchom plik szesnastkowy OpenCP na tablicy nRF52840, używając numeru seryjnego tablicy. Jeśli pominiesz flagę --verify, pojawi się ostrzeżenie, że proces Flash może zakończyć się niepowodzeniem bez błędów.

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

Po wykonaniu tych czynności dane wyjściowe są generowane:

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ę „RCP”, aby później nie zmylić jej roli.

Połącz się z natywnym portem USB

Kompilacja OpenCP RCP umożliwia użycie natywnego portu USB CDC ACM, dlatego do komunikacji z hostem RCP (maszyną z systemem Linux) musisz używać portu nRF USB na płycie nRF52840.

Odłącz kabel USB USB-USB od portu debugowania płyty nRF52840, a następnie podłącz go do portu nRF micro USB obok przycisku RESET. Ustaw przełącznik źródło zasilania nRF na USB.

46e7b670d2464842

Uruchom demon OpenThread

W projekcie RCP użyj demoem OpenThread, aby komunikować się z urządzeniem Thread i nim zarządzać. Uruchom ot-daemon z wyszczególnioną flagą -v, aby wyświetlić dane wyjściowe logu i potwierdzić, że działa on:

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

Jeśli operacja się uda, ot-daemon w trybie szczegółów 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 wyświetlić logi z: ot-daemon.

Użyj ot-ctl, aby komunikować się z węzłem RCP. ot-ctl używa tego samego interfejsu wiersza poleceń co aplikacja wiersza poleceń OpenThread. Dlatego możesz sterować węzłami ot-daemon w taki sam sposób jak inne symulowane urządzenia z wątkami.

W drugim oknie terminala uruchom ot-ctl:

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

Sprawdź state węzła 2 (węzła RCP) rozpoczętego w ot-daemon:

> state
disabled
Done

5. Konfigurowanie funkcji przenoszenia numerów

Dwa pozostałe węzły typu Thread używane w tym ćwiczeniu z programowania to urządzenia z pełnym wątkiem (FTD) według standardowego projektu układu SOC. W środowisku produkcyjnym można używać wpantund – sterownika interfejsu sieciowego klasy produkcyjnej do sterowania instancjami OpenCP NCP, ale w tym ćwiczeniu z programowania użyjemy ot-ctl interfejsu wiersza poleceń OpenThread.

Jedno urządzenie pełni funkcję komisarza, aby bezpiecznie uwierzytelniać urządzenia w tej sieci i przekazywać do nich prowizje. Drugie urządzenie pełni funkcję moderatora, który może sprawdzić w sieci typu Thread.

Kompilacja i błysk

Utwórz przykładowy plik FTD OpenThread dla platformy nRF52840 z włączonymi rolami komisarza i łącznika:

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

Przejdź do katalogu za pomocą pliku binarnego wiersza poleceń 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 gniazdka zasilającego na płytce nRF52840, a następnie podłącz go do komputera z systemem Linux. Jeśli RCP jest nadal podłączony do maszyny z systemem Linux, ta nowa płyta powinna być widoczna jako port szeregowy /dev/ttyACM1 (wszystkie tablice nRF52840 używają ttyACM jako identyfikatora portu szeregowego).

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

Tak jak wcześniej, zwróć uwagę na numer seryjny tablicy nRF52840 używanej dla FTD:

Przejdź do lokalizacji narzędzi wiersza poleceń nRFx i umieść na tablicy nRF52840 plik szesnastkowy OpenThread CLI, używając numeru seryjnego tablicy:

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

Oznacz tablicę „Komisarzem”.

Połącz się z natywnym portem USB

Kompilacja FTD OpenThread umożliwia wykorzystanie natywnego portu USB CDC ACM, dlatego do komunikacji z hostem RCP (komputerem z systemem Linux) użyj portu nRF USB na płytie nRF52840.

46e7b670d2464842

Weryfikowanie kompilacji

Aby sprawdzić, czy kompilacja się powiodła, otwórz interfejs wiersza poleceń OpenThread za pomocą ekranu GNU w oknie terminala. Płyty nRF52840 korzystają z szybkości transmisji bitów 115 200.

$ screen /dev/ttyACM1 115200

W nowym oknie naciśnij kilka razy klawisz Enter na klawiaturze, aby wyświetlić interfejs wiersza poleceń OpenThread >. Wyświetl 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 wiersza poleceń FTD i powrócić do terminala z Linuksem, co pozwoli dodać kolejną tablicę. Aby w dowolnym momencie ponownie wpisać wiersz poleceń, użyj screen -r w wierszu poleceń. Aby zobaczyć listę dostępnych ekranów, użyj narzędzia screen -ls:

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

Skonfiguruj łącznik FTD

Powtórz powyższy proces, aby migrować trzecią tablicę nRF52840, używając istniejącej kompilacji ot-cli-ftd.hex. Pamiętaj, aby ponownie podłączyć płytę do komputera przez port USB nRF i ustawić przełącznik źródło zasilania nRF na VDD.

Jeśli do maszyny z systemem Linux są podłączone pozostałe 2 węzły, powinny być wyświetlane jako port szeregowy /dev/ttyACM2:

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

Oznacz tablicę „Łącznik”.

Podczas weryfikacji za pomocą Screena nie musisz tworzyć nowego wystąpienia ekranu z poziomu wiersza poleceń, a następnie ponownie dołączaj do istniejącego wiersza i twórz w nim nowe okno (użyte dla komisarza FTD):

$ screen -r

Aby utworzyć nowe okno, naciśnij Ctrl + A → c.

Pojawi się nowy wiersz poleceń. Otwórz interfejs wiersza poleceń OpenThread dla łącznika FTD:

$ screen /dev/ttyACM2 115200

W nowym oknie naciśnij kilka razy klawisz Return na klawiaturze, aby wyświetlić interfejs wiersza poleceń OpenThread >. Wyświetl interfejs IPv6 i sprawdź adresy:

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

Gdy interfejs wiersza poleceń FTD znajduje się w tej samej instancji ekranu co komisarz FTD, możesz przełączać się między nimi, naciskając Ctrl+a → n.

Użyj Ctrl + A →

d w dowolnym momencie, aby wyjść z ekranu.

6. Konfiguracja 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ą aktywne i łatwo dostępne. Do tej pory wykorzystywaliśmy ekran do uzyskiwania dostępu do dwóch funkcji FTD, a to narzędzie umożliwia też podzielony ekran w tym samym oknie terminala. Umożliwia sprawdzenie, jak dany węzeł reaguje na polecenia wydane na innym.

Najlepiej jest mieć po 4 okna:

Usługa / logi ot-daemon
Łącznik RCP przez ot-ctl
FTD Commissioner za pomocą interfejsu wiersza poleceń OpenThread
Łącznik FTD za pomocą interfejsu wiersza poleceń OpenThread

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

Korzystanie z ekranu

Aby ułatwić sobie korzystanie z aplikacji, rozpocznij tylko jedną sesję ekranu. Konto to powinno być już skonfigurowane podczas konfigurowania FTD.

Wszystkie polecenia na ekranie zaczynają się od Ctrl + A.

Podstawowe polecenia na ekranie:

Dołącz ponownie do sesji Ekran (w wierszu poleceń)	`screen -r`
Opuść sesję ekranu	Ctrl + A → `d`
Utwórz nowe okno w ramach sesji ekranu	Ctrl + A → `c`
Przełączanie się między oknami w ramach tej samej sesji ekranu	Ctrl+A → `n` (do przodu) Ctrl+a → `p` (wstecz)
Zabicie bieżącego okna w sesji ekranu	Ctrl + A → `k`

Podzielony ekran

Ekran możesz podzielić na wiele okien:

Dostęp do poleceń w języku screen można uzyskać, naciskając klawisze Ctrl+a. Każde polecenie powinno zaczynać się od tego klucza dostępu.

Jeśli dokładnie wykonujesz ćwiczenia z programowania, w tej samej instancji ekranu powinny wyświetlić się 2 okna (komisarz FTD, łącznik FTD). Aby podzielić ekran między oba, najpierw wpisz trwającą sesję ekranu:

$ screen -r

Powinno to być na jednym z urządzeń FTD. Wykonaj te czynności na ekranie:

Ctrl + A → S, aby podzielić okno w poziomie
Ctrl + A → Tab, aby przenieść kursor do nowego pustego okna
Ctrl + A → n, aby przełączyć to okno do następnego
Jeśli opcja jest taka sama jak okno u góry, Ctrl + A → n ponownie, aby wyświetlić drugie urządzenie FTD

Oba elementy są widoczne. Aby się między nimi przełączać, naciśnij Ctrl + A → Tab. Zalecamy zmianę nazwy każdego okna za pomocą kombinacji klawiszy Ctrl+A → A, aby uniknąć nieporozumień.

Zaawansowane użycie

Aby podzielić ekran na kwartyle i wyświetlić logi ot-daemon oraz łącznik RCP ot-ctl, należy uruchomić te usługi 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 ekranu (Ctrl+a → c).

Ta konfiguracja nie jest wymagana i pozostanie jedynie ćwiczeniem dla użytkownika.

Podział i przechodzenie między oknami za pomocą tych poleceń:

Utwórz nowe okno	Ctrl + A → `c`
Podziel okno w pionie	Ctrl + A →
Podziel okno w poziomie	Ctrl + A → `S`
Przejdź do następnego wyświetlonego okna	Ctrl + A → `Tab`
Przełącz wyświetlane okno do przodu i do tyłu	Ctrl+A → `n` lub `p`
Zmień nazwę bieżącego okna	Ctrl + A → `A`

W dowolnym momencie możesz wyjść z ekranu, naciskając Ctrl + A → d, i ponownie dołączyć go, naciskając screen -r w wierszu poleceń.

Więcej informacji o ekranie znajdziesz w krótkim przewodniku po ekranie GNU.

7. Tworzenie sieci Thread

Teraz, gdy masz już skonfigurowane wszystkie okna i ekrany terminala, utworzymy sieć Thread. W FTD Commissioner utwórz nowy zbiór operacyjny i zatwierdź go jako aktywny. operacyjny zbiór danych to konfiguracja tworzonej sieci typu 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

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

Zatwierdź ten zbiór danych jako aktywny:

> dataset commit active
Done

Wyświetl interfejs IPv6

> ifconfig up
Done

Uruchomienie protokołu Thread:

> thread start
Done

Po chwili sprawdź stan urządzenia. Powinno to być lider. Aby móc korzystać z tej funkcji w przyszłości, zapoznaj się też z listą RLOC16.

## 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 przy skanowaniu z innych urządzeń z wątkami.

Od ot-ctl w łączniku RCP:

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

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

W interfejsie wiersza poleceń OpenThread w oprogramowaniu łączącym FTD:

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

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

Jeśli sieci „codelab” nie ma na liście, spróbuj jeszcze raz przeprowadzić skanowanie.

8. Dodaj łącznik RCP

Strategia Prowizje do wątków nie jest aktywna w sieci, co oznacza, że musimy dodać łącznik RCP do utworzonej przed chwilą sieci typu Thread przy użyciu procedury prowizji poza zakresem.

W komisorze FTD zanotowaliśmy klucz sieciowy, na przykład 1234c0de7ab51234c0de7ab51234c0de. Jeśli musisz ponownie sprawdzić klucz sieciowy, uruchom to polecenie w FTD Commissioner:

## FTD Commissioner ##

> dataset networkkey
1234c0de7ab51234c0de7ab51234c0de
Done

Następnie w łączniku RCP ustaw aktywny klucz sieciowy zbioru danych na klucz sieci FTD Commissioner:

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

> dataset networkkey 1234c0de7ab51234c0de7ab51234c0de
Done
> dataset commit active
Done

Sprawdź zbiór danych, aby upewnić się, że jest poprawnie skonfigurowany.

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

> dataset
Network Key: 1234c0de7ab51234c0de7ab51234c0de

Wyświetl wątek, by oprogramowanie sprzęgające RCP mogło dołączyć do sieci „codelab”. Poczekaj kilka sekund. Sprawdź stan, RLOC16 i 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 lokalnej typu mesh (fdc0:de7a:b5c0:0:66bf:99b9:24c0:d55f) – użyjesz go później.

W komunikacji FTD sprawdź router i tabele podrzędne, aby upewnić się, że oba urządzenia należą do tej samej sieci. Użyj RLOC16, aby zidentyfikować łącznik 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

Wyślij ping na lokalny adres sieci typu mesh połączenia RCP łącznika RSH (sieci typu mesh-lokalnego uzyskanego z danych wyjściowych ipaddr łącznika RCP):

## 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ć wątków składającą się z 2 węzłów. Ilustracja jest przedstawiona na tym diagramie topologii:

otcodelab_top01C_2węzły.png

Schematy topologii

W pozostałych częściach ćwiczeń z programowania będziemy wyświetlać nowy diagram topologii wątków, gdy tylko zmieni się stan sieci. Role węzłów są oznaczone w ten sposób:

Routery są zawsze pięciokątne, a urządzenia końcowe zawsze są kółkami. Liczby w każdym węźle odpowiadają identyfikatorowi routera lub identyfikatora podrzędnego wyświetlanemu w danych wyjściowych interfejsu wiersza poleceń w zależności od bieżącej roli i stanu danego węzła.

9. Łączący usługę FTD

Teraz dodaj trzecie urządzenie z wątkiem do sieci „codelab”. Tym razem użyjemy bezpieczniejszej procedury prowizji w zakresie i zezwalamy tylko na dołączenie FTD.

W Łączniku FTD pobierz eui64, aby komisarz FTD mógł go zidentyfikować:

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

> eui64
2f57d222545271f1
Done

W FTD Commissioner uruchom komisję i określ eui64 urządzenia, które może dołączyć, oraz dane logowania złącza, na przykład J01NME. Łącznik to ciąg znaków składający się z wielu wielkich znaków alfanumerycznych (0–9 i A–Y, z wyłączeniem I, O, Q i Z), które mogą mieć długość od 6 do 32 znaków.

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

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

Użyj funkcji Łącznik FTD. Rolę złącza możesz rozpocząć od danych logowania skonfigurowanych dla komisarza FTD:

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

> ifconfig up
Done
> joiner start J01NME
Done

W ciągu około minuty otrzymasz potwierdzenie udanego uwierzytelnienia:

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

>
Join success

Wyświetl wątek, aby łącznik FTD dołączał do sieci „codelab” i od razu sprawdzał 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 faktu, że to urządzenie nie jest liderem ani nie ma przypisanej roli Anycast, która wymaga 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)

Natychmiast przełącz się na narzędzie FTD Commissioner i sprawdź tabele routera i podrzędnego, 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 oprogramowanie sprzęgające FTD podłączało się do sieci jako urządzenie końcowe (element podrzędny). Oto zaktualizowana topologia:

otcodelab_top01C_ed01.png,

10. Wątek w praktyce

Urządzenia z wątkami w tym ćwiczeniu z programowania są specyficznym rodzajem urządzenia z pełnym wątkiem (FTD) nazywanego urządzeniem spełniającym warunki routera (REED). Oznacza to, że mogą pełnić funkcję routera lub urządzenia końcowego i mogą promować się jako urządzenie końcowe do routera.

Thread może obsługiwać do 32 routerów, ale stara się utrzymać ich liczbę między 16 a 23. Jeśli urządzenie REED zostanie podłączone jako urządzenie końcowe (podrzędne), a liczba routerów nie przekracza 16, w ciągu 2 minut od losowego okresu urządzenie automatycznie przeniesie się do routera.

Jeśli po dodaniu złącza FTD 2 sieci podrzędnych ma 2 dzieci, odczekaj co najmniej 2 minuty, a potem sprawdź tabele routera i podrzędnego routera w komisorze 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

Łącznik FTD (rozszerzony adres MAC = e6cdd2d93249a243) awansował się do routera. Pamiętaj, że RLOC16 jest inny (b800 zamiast 0c02). Dzieje się tak, ponieważ identyfikator RLOC16 jest oparty na identyfikatorze routera i podrzędnym urządzeniu. Po przejściu z urządzenia końcowego na router jego wartości identyfikatora routera i identyfikatora podrzędnego zmieniają się, podobnie jak RLOC16.

otcodelab_top01C.png,

Potwierdź nowy stan i RLOC16 w programie łączącym FTD:

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

> state
router
Done
> rloc16
b800
Done

Zmniejsz połączenie narzędzia FTD

Możesz przetestować to zachowanie, ręcznie obniżając łącznik FTD z routera do urządzenia końcowego. Zmień stan na podrzędny i sprawdź listę RLOC16:

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

> state child
Done
> rloc16
0c03
Done

otcodelab_top01C_ed02.png,

Po powrocie do komisarza FTD łącznik FTD powinien się teraz pojawić w tabeli podrzędnej (identyfikator = 3). Może się ona znajdować zarówno w jednym, jak i w obu przypadkach:

## 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 zostanie przełączony z powrotem na router z RLOC o wartości b800.

otcodelab_top01C.png,

Usuń lidera

Lider jest wybierany przez wszystkich routerów Thread. Oznacza to, że jeśli z sieci Thread zostanie usunięty obecny lider, jeden z innych routerów zostanie nowym Liderem.

W komisorze FTD wyłącz wątek, aby usunąć go z sieci Thread:

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

> thread stop
Done
> ifconfig down
Done

W ciągu dwóch minut łącznik FTD stanie się nowym liderem wątku. Sprawdź stan i adresy IPv6 łącznika FTD, 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ę na nową listę RLOC16. Jest to łącznik RCP (zgodnie z jego identyfikatorem i rozszerzoną wartością MAC). Aby sieć Thread mogła działać razem, zmieniła router nadrzędny routera z komisarza FTD na łącznik FTD. Powoduje to utworzenie nowego parametru RLOC16 dla oprogramowania sprzęgającego RCP (ponieważ jego identyfikator routera został zmieniony 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 oprogramowanie sprzęgające RCP zostanie podłączone do oprogramowania sprzęgającego FTD jako dziecko. Sprawdź stan i RLOC16, aby potwierdzić, że:

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

> state
child
> rloc16
b801

Ponownie załącz komisarza FTD

Sieć typu Thread z 2 węzłami nie jest fajna. Ponownie włączymy funkcję FTD Commissioner.

W FTD Commissioner uruchom ponownie Thread:

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

> ifconfig up
Done
> thread start
Done

W ciągu dwóch minut automatycznie dołącza ono ponownie do sieci ćwiczeń z programowania jako urządzenie końcowe, a następnie awansuje się do routera.

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

> state
router
Done

Przejrzyj tabele routera i routera podrzędnego w łączniku FTD, aby zweryfikować:

## 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 składa się z 3 węzłów.

11. Rozwiązywanie problemów

Zarządzanie siecią wątków przy użyciu wielu urządzeń z różnymi terminalami lub oknami ekranu może być skomplikowane. Skorzystaj z tych wskazówek, by w razie problemów „zresetować” stan sieci lub swojego obszaru roboczego.

Ekran

Jeśli zgubisz się w konfiguracji (zbyt wiele okien ekranu lub ekrany w ekranie), zamknij wszystkie okna za pomocą kombinacji klawiszy Ctrl + A → K, aż żaden nie istnieje, a screen -ls w wierszu poleceń zwróci wartość No Sockets found. Następnie ponownie utwórz okna na każdym urządzeniu. Stany urządzeń są zachowywane nawet po zamknięciu ekranu.

Węzły wątków

Jeśli topologia sieci Thread nie jest opisana w tym ćwiczeniu z programowania lub węzły z jakiegoś powodu zostały rozłączone (np. z powodu błędu maszyny wirtualnej z systemem Linux), musisz usunąć wątek, wyczyścić dane logowania w sieci i rozpocząć od początku z poziomu kroku Tworzenie sieci Thread.

Aby zresetować usługę FTD:

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

> thread stop
Done
> ifconfig down
Done
> factoryreset
Done

Możesz go zresetować w ten sam sposób za pomocą polecenia ot-ctl:

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

> thread stop
Done
> ifconfig down
Done
> factoryreset
Done

12. Korzystanie z multiemisji

Multicast służy do jednoczesnego przekazywania informacji do kilku urządzeń. W sieci typu Thread określone adresy są zarezerwowane do użytku w trybie multicast w zależności od grupy urządzeń.

Adres IPv6	Zakres	Dostarczono do
`ff02::1`	Link-lokalny	Wszystkie FTD i MED
`ff02::2`	Link-lokalny	Wszystkie FTD i routery graniczne
`ff03::1`	Sieć lokalna typu mesh	Wszystkie FTD i MED
`ff03::2`	Sieć lokalna typu mesh	Wszystkie FTD i routery graniczne

W tym ćwiczeniu z programowania nie korzystamy z routera granicznego, więc skupmy się na dwóch adresach multicast FTD i MED.

Link-lokalny

Zakres Link-Local składa się z wszystkich interfejsów Thread, do których można dotrzeć przez jedną transmisję radiową lub pojedynczy „przeskok”. Topologia sieci określa, które urządzenia reagują na ping na adres multicast ff02::1.

Wyślij ping ff02::1 do 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ą 2 inne urządzenia (łącznik FTD i łącznik RCP), ale komisarz FTD otrzymał tylko 1 odpowiedź z lokalnego adresu linku. Oznacza to, że łącznik FTD to jedyne urządzenie, do którego może dotrzeć jednym przeskokiem.

otcodelab_top02C_02_LL.png,

Wyślij ping do ff02::1 za pomocą łącznika 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

Dwie odpowiedzi! Po sprawdzeniu adresów IPv6 innych urządzeń widzimy, że pierwszy z nich (z końcówką 4b1d) to plik LLA komisarza FTD, a drugi z końcówką 943b – fragment adresu LAB ustalającego połączenie RCP.

otcodelab_top02C_02_LL02.png,

Oznacza to, że łącznik FTD jest bezpośrednio połączony z instytucją FTD i łącznikiem RCP, co potwierdza naszą topologię.

Sieć lokalna typu mesh

Zakres sieci typu mesh-local obejmuje wszystkie interfejsy Thread dostępne w tej samej sieci Thread. Sprawdźmy odpowiedzi na ping na adres multicast ff03::1.

Wyślij ping ff03::1 do 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ł dwie odpowiedzi – jedną z Lokalizatora tras FTD (RLOC o numerze kończącym się na b800) i jedną z identyfikatora ESH-Local Mesh-Local EID (ML-EID), który kończy się na d55f. Dzieje się tak, ponieważ cały zakres sieci lokalnej typu mesh składa się z całego wątku. Bez względu na to, w jakiej sieci znajduje się urządzenie, będzie ono subskrybowane z adresem ff03::1.

otcodelab_top02C_02_ML.png,

Użyj polecenia ping, aby skontaktować się z operatorem FTD Connector (ff03::1), 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 łącznika RCP na oba dane wyjściowe ping. Złączenie FTD (68 ms) trwało znacznie dłużej niż połączenie z FTD (23 ms). Dzieje się tak dlatego, że musi on dokonać dwóch podejść do komisarza FTD, a następnie jednego przeskoku dla łącznika FTD.

Możesz też zauważyć, że ping lokalny typu mesh w lokalnym środowisku sieciowym odpowiedział tylko na żądanie RLOC tylko dla dwóch FTD, a nie RCP Connector. Dzieje się tak, ponieważ FTD to routery w sieci, a RCP to urządzenie końcowe.

Sprawdź stan łącznika RCP, aby potwierdzić:

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

> state
child

13. Wysyłanie wiadomości przez UDP

Jedną z usług udostępnianych przez OpenThread jest User Datagram Protocol (UDP), czyli protokół Transport Layer. Aplikacja utworzona na platformie OpenThread może korzystać z interfejsu UDP API, aby przekazywać wiadomości między węzłami w sieci typu Thread lub do innych urządzeń w sieci zewnętrznej (np. internetu, jeśli sieć typu Thread zawiera router graniczny).

Gniazda UDP są udostępniane przez interfejs wiersza poleceń OpenThread. Użyjmy go do przekazywania wiadomości między FTD.

Uzyskaj adres EID sieci lokalnej typu mesh dla łącznika FTD. Używamy tego adresu, ponieważ jest on dostępny w dowolnym miejscu 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 podłącz go do gniazda dla dowolnego adresu IPv6:

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

> udp open
Done
> udp bind :: 1212

Przełącz się na FTD Commissioner, uruchom UDP i połącz się z gniazdem skonfigurowanym w łączniku FTD za pomocą jego identyfikatora ML-EID:

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

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

Połączenie między węzłami UDP powinno być aktywne. Wyślij wiadomość od FTD:

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

> udp send hellothere
Done

W łączniku FTD została odebrana 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ć wątków

Teraz wiesz już:

Różnica między typami urządzeń z wątkami, rolami i zakresami
jak urządzenia z wątkami zarządzają stanami w sieci
jak przekazywać proste wiadomości między węzłami przy użyciu UDP.

Dalsze kroki

Na podstawie tych ćwiczeń z programowania wypróbuj te ćwiczenia:

Ponownie zamontuj tablicę łącznika FTD za pomocą pliku binarnego ot-cli-mtd i zauważ, że nigdy nie zmienia się na router ani nie próbuje zostać liderem.
Dodaj więcej urządzeń (wypróbuj inną platformę) do sieci i naszkicuj topologię, korzystając z tabel i routerów podrzędnych oraz pingów do adresów multicast.
Kontroluj NCP za pomocą pyspinel
Przekształć NCP w router graniczny za pomocą OpenThread Border Router i połącz sieć Thread z internetem

Więcej informacji

Odwiedź strony openthread.io i GitHub, aby sprawdzić różne zasoby OpenThread, w tym:

Obsługiwane platformy – poznaj wszystkie platformy obsługujące OpenThread
Build OpenThread – więcej informacji o tworzeniu i konfigurowaniu OpenThread
Thread Primer – obejmuje wszystkie pojęcia związane z wątkami przedstawione w tym ćwiczeniu z programowania.

Materiały referencyjne: