Utwórz sieć Thread z tablicami nRF52840 i OpenThread

1. Wstęp

Wersja OpenThread opublikowana przez Google to implementacja open source protokołu sieciowego Thread®. Google Nest udostępnia platformę OpenThread, by umożliwić szerszemu udostępnianiu technologii używanych w produktach Nest w celu przyspieszenia rozwoju produktów dla połączonego domu.

Specyfikacja wątku definiuje niezawodny, bezpieczny i bezemisyjny protokół komunikacyjny między urządzeniami z wykorzystaniem protokołu IPv6. OpenThread implementuje wszystkie warstwy sieci Thread, w tym IPv6, 6LoWPAN, IEEE 802.15.4 z zabezpieczeniami MAC, łączeniem sieci typu mesh i routingiem sieci typu mesh.

Dzięki nim możesz uczestniczyć w programie OpenThread na prawdziwym sprzęcie, tworzyć sieć Thread i zarządzać nią oraz przekazywać wiadomości między węzłami.

Czego się nauczysz

• Tworzenie i błyskanie plików binarnych wiersza poleceń OpenThread na tablicach deweloperskich
• utworzenie RCP w systemie Linux i w wersji dla deweloperów.
• Komunikacja z platformą RCP przy użyciu demona OpenThread i ot-ctl
• Ręczne zarządzanie węzłami w wątkach za pomocą ekranu GNU i interfejsu wiersza poleceń OpenThread
• Bezpieczne przekazywanie urządzeń na sieć Thread
• Jak działa multiemisja IPv6
• Przekazywanie wiadomości między węzłami wątków z użyciem UDP

Czego potrzebujesz

Sprzęt:

• 3 płyty północnoprzewodnikowe nRF52840
• 3 kable USB do micro USB, aby połączyć płytki
• Maszyna z systemem Linux i co najmniej 3 portami USB

Oprogramowanie:

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

2. Pierwsze kroki

Symulacja OpenThread

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

Terminale portów szeregowych

Musisz się dowiedzieć, jak połączyć się z portem szeregowym przez terminal. Ćwiczenia z programowania korzystają z ekranu GNU i opisują użycie, ale możesz użyć dowolnego innego oprogramowania terminalowego.

Maszyna z systemem Linux

Ten ćwiczenia z programowania zostały zaprojektowane do używania maszyny z systemem Linux i386 lub x86, która jest hostem na urządzeniu z procesorem Radio-Cosoror (RCP) i płynnymi tablicami programistycznymi. Wszystkie kroki zostały przetestowane na systemie Ubuntu 14.04.5 LTS (Trusty Tahr).

Płyty nordyckie nRF52840

Ćwiczenia z programowania oparte są na 3 tablicach nRF52840 PDK.

Zainstaluj SEGGER J-Link

Do programowania płyt nRF52840 stosujemy SEGGER J-Link, które mają wbudowane moduły JTAG. Zainstaluj go na komputerze z systemem Linux.

file_downloadPobierz pakiet oprogramowania i dokumentacji J-Link

Pobierz odpowiedni pakiet dla komputera i zainstaluj go w odpowiednim miejscu. W systemie Linux jest to /opt/SEGGER/JLink.

Zainstaluj narzędzia wiersza poleceń nRF5x

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

file_downloadPobierz narzędzia nRF5x Command Line

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

Zainstaluj łańcuch narzędzi ARM GNU

Łańcuch narzędzi ARM GNU jest używany do tworzenia budynków.

file_downloadPobierz archiwum przenośne ARM GNU Toolchain

Zalecamy umieszczenie wyodrębnionego archiwum w systemie /opt/gnu-mcu-eclipse/arm-none-eabi-gcc/ na komputerze z systemem Linux. Postępuj zgodnie z instrukcjami 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. Ć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

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

$ 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 już utworzyć i uruchomić wtyczkę OpenThread na tablicach nRF52840.

4. Skonfiguruj łącznik RCP

Kompilacja i błyskawica

utworzyć przykładowy plik OpenThread nRF52840 z funkcją łączenia i natywnym urządzeniem USB; Urządzenie używa roli Łącznika do bezpiecznego uwierzytelniania i uruchamiania na potrzeby sieci Thread. Natywny kabel USB umożliwia używanie USB typu ASC jako portu szeregowego między nRF52840 a hostem.

Zawsze usuwaj najpierw 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 OpenThread RCP 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 kabla zasilającego na płycie nRF52840, a następnie podłącz go do komputera z systemem Linux. Ustaw przełącznik źródła zasilania nRF na płytce nRF52840 na VDD. Po podłączeniu urządzenia LED5 będzie włączone.

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

$ ls /dev/ttyACM*
/dev/ttyACM0

Zwróć uwagę na numer seryjny płyty nRF52840 używanej na potrzeby RCP:

Przejdź do lokalizacji narzędzi wiersza poleceń nRFx i uruchom plik szesnastkowy OpenThread na tablicy nRF52840 za pomocą numeru seryjnego tablicy. Jeśli pominiesz flagę --verify, zobaczysz ostrzeżenie z informacją, że proces Flash może się nie udać.

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

Po sukcesie są generowane 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ę &RCP, aby później nie zmylić jej roli.

Połącz się z natywnym portem USB

Kompilacja RCP OpenThread pozwala na korzystanie z natywnego dysku USB CDC ACM jako portu szeregowego, dlatego do komunikacji z hostem RCP (maszyną Linux) musisz używać portu nRF USB na płytce nRF52840.

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

Uruchom demona OpenThread

W projekcie RCP używaj demona OpenThread, aby komunikować się z urządzeniem Thread i zarządzać nim. Uruchom ot-daemon z flagą -v, by zobaczyć 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=115200'

Jeśli operacja się uda, ot-daemon w trybie szczegółowym 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 móc 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 OpenThread CLI. Dlatego możesz kontrolować węzły ot-daemon w taki sam sposób jak inne symulowane urządzenia 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), który rozpoczął się od ot-daemon:

> state
disabled
Done

5. Skonfiguruj FTD

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

1 urządzenie działa jako komisarz, aby bezpiecznie uwierzytelniać urządzenia i przekazywać je do tej sieci. Drugie urządzenie działa jako połączenie, które może uwierzytelniać w sieci Thread.

Kompilacja i błyskawica

Utwórz przykład FTD OpenThread dla platformy nRF52840 z włączonymi rolami Commissioner i Connector:

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

Przejdź do katalogu z plikiem binarnym wiersza poleceń OpenThread Full Thread (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 kabla zasilającego na płycie nRF52840, a następnie podłącz go do komputera z systemem Linux. Jeśli RCP jest nadal podłączony do komputera z systemem Linux, nowa karta powinna być widoczna jako port szeregowy /dev/ttyACM1 (wszystkie płyty główne nRF52840 używają identyfikatora ttyACM).

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

Tak jak wcześniej, zwróć uwagę na numer seryjny płyty nRF52840 używanej do obsługi FTD:

Przejdź do lokalizacji narzędzi wiersza poleceń nRFx i wczytaj plik szesnastkowy OpenThread CLI FTD na tablicy nRF52840 za pomocą numeru seryjnego tablicy:

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

Oznacz płytę "Commissioner."

Połącz się z natywnym portem USB

Kompilacja OpenThread FTD zezwala na używanie natywnego portu USB CDC ACM jako portu szeregowego, dlatego musisz komunikować się z hostem RCP (komputerem z systemem Linux) za pomocą portu nRF USB na płytie nRF52840.

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

Weryfikowanie kompilacji

Sprawdź, czy kompilacja się powiodła, otwierając 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 Enter na klawiaturze, aby wyświetlić wiersz poleceń OpenThread >. Otwórz interfejs IPv6 i sprawdź adresy:

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

Ctrl + A →

d odłącz się od ekranu wiersza poleceń FTD i powróć do terminala z Linuksem, aby można było migać następną tablicę. Aby w dowolnym momencie ponownie wpisać wiersz poleceń, użyj wiersza poleceń screen -r. Aby zobaczyć listę dostępnych ekranów, otwórz 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 migać trzecią tablicę nRF52840 za pomocą istniejącej kompilacji ot-cli-ftd.hex. Po zakończeniu podłącz ponownie płytkę do komputera za pomocą portu USB nRF i ustaw przełącznik nRF zasilania na VDD.

Jeśli pozostałe 2 węzły są podłączone do komputera z systemem Linux i dołączone jest ta trzecia karta, powinna ona być widoczna jako port szeregowy /dev/ttyACM2:

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

Oznacz tablicę &połączenia."

Podczas weryfikacji z użyciem opcji Screen (zamiast utworzenia nowego wiersza z wiersza poleceń) ponownie dołącz do istniejącego i utwórz w nim nowe okno (używane przez komisarza FTD):

$ screen -r

Otwórz nowe okno na ekranie, naciskając Ctrl + A → c.

Pojawi się nowy wiersz poleceń. Otwórz interfejs wiersza poleceń OpenThread dla oprogramowania sprzęgającego FTD:

$ screen /dev/ttyACM2 115200

W nowym oknie naciśnij kilka razy Enter na klawiaturze, aby wyświetlić wiersz poleceń OpenThread >. Otwórz interfejs IPv6 i sprawdź adresy:

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

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

Ctrl + A →

d w dowolnym momencie, aby zamknąć ekran.

6. Konfiguracja okna terminala

Od tej pory będziemy często przełączać się między urządzeniami Thread, dlatego zadbaj o to, by wszystkie były aktywne i łatwo dostępne. Do tej pory używaliśmy Ekranu, aby uzyskać dostęp do dwóch urządzeń FTD, a to narzędzie umożliwia też podzielony ekran w tym samym oknie terminala. Użyj tego ustawienia, aby sprawdzić, jak dany węzeł reaguje na polecenia wysyłane na inny.

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

1. ot-daemon usługa / dzienniki
2. Dołączący RCP przez ot-ctl
3. Komisarz FTD za pomocą interfejsu wiersza poleceń OpenThread
4. Łącznik FTD za pomocą interfejsu wiersza poleceń OpenThread

Jeśli chcesz użyć własnego terminala / konfiguracji portu szeregowego lub narzędzia, przejdź do następnego kroku. Skonfiguruj dla wszystkich urządzeń okna terminali w najlepszy dla siebie sposób.

Korzystanie z ekranu

Aby ułatwić sobie korzystanie z usługi, rozpocznij tylko jedną sesję ekranu. Powinien on być już skonfigurowany.

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

Podstawowe polecenia ekranu:

Podziel ekran

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

Aby uzyskać dostęp do poleceń w pliku screen, naciśnij Ctrl+a. Każde polecenie powinno zaczynać się od tego kombinacji klawiszy dostępu.

Jeśli dokładnie śledzisz ćwiczenia z programowania, do tej samej instancji ekranu powinny zostać przypisane 2 okna (komisarz FTD, łącznik FTD). Aby podzielić ekran między dwa, najpierw wpisz istniejącą sesję ekranu:

$ screen -r

Musisz korzystać z urządzenia FTD. Wykonaj te czynności na ekranie:

1. Ctrl + A → S, aby podzielić okno w poziomie
2. Aby przenieść kursor do nowego pustego okna, naciśnij Ctrl+a → Tab
3. Ctrl + A → n, aby przełączyć to nowe okno do następnego
4. Jeśli jest on taki sam jak górny okno, naciśnij Ctrl+a → n, aby wyświetlić inne urządzenie FTD

Są teraz widoczne. Aby się między nimi przełączyć, 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 element łączący RCP ot-ctl, usługi muszą być uruchomione w 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 pozostaje tylko ćwiczeniem dla użytkownika.

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

W każdej chwili możesz wyjść z ekranu, naciskając Ctrl + A → d i później dołączyć ekran z poziomu wiersza poleceń, używając polecenia screen -r.

Więcej informacji o ekranie znajdziesz w krótkim artykule na temat ekranu GNU.

7. Tworzenie sieci Thread

Masz już skonfigurowane wszystkie okna i ekrany terminali, a my utworzysz sieć Thread. W komisarzu ds. usług transportu publicznego utwórz nowy zbiór danych operacyjnych 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.

Prześlij ten zbiór danych jako aktywny:

> dataset commit active
Done

Wyświetl interfejs IPv6:

> ifconfig up
Done

Uruchom operację protokołu Thread:

> thread start
Done

Po chwili sprawdź stan urządzenia. Powinien być liderem. Oprócz tego pobierz RLOC16 na przyszłość.

## 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" aktualnie widoczna jest po zeskanowaniu z innych urządzeń Thread.

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 na łączniku FTD:

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

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

Jeśli sieć &&lab nie jest widoczna na liście, spróbuj ponownie przeskanować.

8. Dodaj łącznik RCP

Prowizja wątku nie jest aktywna w sieci, co oznacza, że musimy dodać łącznik RCP do utworzonej przed chwilą wątków w ramach procesu prowizji.

W komisji FTD zanotowaliśmy klucz sieciowy, np. 1234c0de7ab51234c0de7ab51234c0de. Jeśli musisz ponownie wyszukać klucz sieci, uruchom to polecenie w komisarzu FTD:

## FTD Commissioner ##

> dataset networkkey
1234c0de7ab51234c0de7ab51234c0de
Done

Następnie w narzędziu Łącznik RCP ustaw klucz sieciowy aktywnego zbioru danych na klucz sieci FTD Commissioner:

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

> dataset networkkey 1234c0de7ab51234c0de7ab51234c0de
Done
> dataset commit active
Done

Sprawdź zbiór danych i upewnij się, że jest poprawnie ustawiony.

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

> dataset
Network Key: 1234c0de7ab51234c0de7ab51234c0de

Otwórz wątek, aby oprogramowanie sprzęgające RCP dołączyło do sieci "codelab". Zaczekaj chwilę, 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 lokalny adres IPv6 sieci Mesh (fdc0:de7a:b5c0:0:66bf:99b9:24c0:d55f) tutaj. Będzie on potrzebny później.

Wróć do komisatora FTD, sprawdź w routerze i podrzędnych tabelach, czy oba urządzenia należą do tej samej sieci. Aby zidentyfikować łącznik RCP, użyj RLOC16.

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

Pinguj lokalny adres sieci typu mesh w przypadku połączenia RCP (są to adresy sieci typu mesh uzyskane z oprogramowania sprzęgającego RCP) w celu weryfikacji połączenia:

## 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 przedstawiona na tym diagramie topologii:

Diagramy topologii

Gdy wykonasz pozostałe ćwiczenia z ćwiczeń z programowania, po każdej zmianie stanu sieci wyświetli się nowy diagram topologii wątków. Role węzłów są określane w następujący sposób:

Routery zawsze są pięciokątne, a urządzenia końcowe zawsze. Liczby w każdym węźle reprezentują identyfikator routera lub identyfikator podrzędny widoczny w wynikach wiersza poleceń, w zależności od bieżącej roli i stanu każdego węzła.

9. Połącz konto FTD

Teraz dodaj trzecie urządzenie z wątkami do sieci &codelab&quot. Tym razem będziemy korzystać z bezpieczniejszego procesu prowizji w paśmie i zezwolić na dołączanie tylko osobom łączącym FTD.

W narzędziu łączącym FTD pobierz eui64, aby komisarz FTD mógł je zidentyfikować:

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

> eui64
2f57d222545271f1
Done

W komisorze FTD uruchom inspektora i podaj eui64 urządzenia, które może dołączyć, wraz z danymi logowania uczestnika, na przykład J01NME. Dane logowania – połączenie składające się ze wszystkich znaków alfanumerycznych pisanech wielkimi literami (0–9 i A–Y, z wyjątkiem odczytu I, O, Q i Z, o czytelności) o długości od 6 do 32 znaków.

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

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

Przełącz na łącznik FTD. Rozpocznij rolę złącza za pomocą danych logowania skonfigurowanych przed chwilą w komisji FTD:

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

> ifconfig up
Done
> joiner start J01NME
Done

Mniej więcej w ciągu minuty otrzymasz potwierdzenie pomyślnego uwierzytelnienia:

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

>
Join success

Otwórz wątek, aby łącznik FTD dołączył do sieci "codelab" i od razu sprawdź stan oraz RLOC16:

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

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

Sprawdź adresy IPv6 urządzenia. Zwróć uwagę, że nie występuje zdarzenie ALOC. To urządzenie nie jest repliką lidera ani nie ma roli związanej z aplikacją, 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 przejdź do komisatora FTD i sprawdź tabele routera i podrzędnego, aby upewnić się, że w sieci &codet&codet; znajdują się trzy 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 zostało przyłączone do sieci jako urządzenie końcowe (podrzędne). Oto zaktualizowana topologia:

10. Wątek w działaniu

Urządzenia z wątkami w tych ćwiczeniach z programowania to konkretny rodzaj urządzenia z pełnym wątkiem (FTD) zwanego urządzeniem routera REED. Oznacza to, że mogą działać jako router lub urządzenie końcowe i mogą promować się z urządzenia końcowego do routera.

Thread może obsługiwać maksymalnie 32 routery, ale stara się utrzymać liczbę routerów z przedziału 16–23. Jeśli urządzenie REED jest dołączone jako urządzenie końcowe (podrzędne) i liczba routerów jest mniejsza niż 16, po losowym czasie w ciągu 2 minut automatycznie promuje się on na routerze.

Jeśli po dodaniu łącznika FTD masz w sieci 2 dzieci podrzędne, odczekaj co najmniej 2 minuty, a następnie ponownie sprawdź tabele routera i elementu podrzędnego 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 MAC = e6cdd2d93249a243) awansował się do routera. Pamiętaj, że RLOC16 jest inny (b800 zamiast 0c02). Dzieje się tak, ponieważ identyfikator RLOC16 jest określany na podstawie identyfikatora routera i identyfikatora podrzędnego urządzenia. Po przejściu z urządzenia końcowego na router jego wartości routera i identyfikatora obiektu podrzędnego zmieniają się, podobnie jak wartość RLOC16.

Potwierdź nowy stan i RLOC16 w połączeniu FTD:

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

> state
router
Done
> rloc16
b800
Done

Zmniejsz połączenie usługi FTD

Aby przetestować to działanie, zmień ręcznie łącznik usługi FTP z routera na urządzenie końcowe. Zmień stan na podrzędny i sprawdź listę RLOC16:

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

> state child
Done
> rloc16
0c03
Done

W komisorze FTD element łączący FTD powinien być teraz widoczny w tabeli podrzędnej (identyfikator = 3). Podczas przenoszenia mogą występować nawet w obu tych miejscach:

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

Usuwanie lidera

Lider jest wybierany samodzielnie wśród wszystkich routerów z wątkami. Oznacza to, że jeśli obecny lider zostanie usunięty z sieci Thread, jeden z routerów zostanie nowym liderem.

W Fundatorze FTD wyłącz Thread, aby usunąć go z sieci Thread:

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

> thread stop
Done
> ifconfig down
Done

W ciągu 2 minut łącznik FTD stanie się nowym liderem wątku. Sprawdź stan i adresy IPv6 oprogramowania sprzęgającego 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

Sprawdź tabelę podrzędną. Uwaga: udostępniliśmy nowy RLOC16. To jest połączenie usługi RCP, co wskazuje na identyfikator i rozszerzony adres MAC. Aby można było utrzymywać sieć w wątkach, przełączono routery nadrzędnego z komisarza FTD na połączenie FTD. W rezultacie powstaje nowy kod RLOC16 dla oprogramowania sprzęgającego RCP (z powodu jego zmiany 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 być konieczne odczekanie kilku minut, aż osoba łącząca RCP zostanie przyłączona 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ć z 2 węzłami nie jest zbyt fajna. Połączmy komisarza FTD online z powrotem.

W FCS Commissioner ponownie uruchom wątek:

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

> ifconfig up
Done
> thread start
Done

W ciągu 2 minut automatycznie łączy się ponownie z siecią „ćwiczenia z programowania” jako urządzenie końcowe, a następnie awansuje się do routera.

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

> state
router
Done

Sprawdź tabele routera i 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

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

11. Rozwiązywanie problemów

Zarządzanie siecią Thread – z kilkoma urządzeniami przy różnych terminalach lub oknach ekranu może być trudne. Te wskazówki pomogą Ci &"reset" stan sieci lub obszaru roboczego w przypadku problemów.

Ekran

Jeśli zgubisz się w konfiguracji (zbyt wiele okien ekranu lub ekran w ekranie), zamknij okno ekranu, naciskając Ctrl + A → k, aż nie będzie żadnego, a screen -ls w wierszu poleceń wynikowym No Sockets found. Następnie utwórz ponownie 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 zgodna z opisem w tym ćwiczeniu z programowania lub węzły są rozłączane z jakiegoś powodu (np. z systemu Linux, na którym zostały przełączone w tryb uśpienia), najlepiej jest usunąć Thread, wyczyścić dane logowania do sieci i rozpocząć od kroku Utwórz sieć Thread.

Aby zresetować FTD:

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

> thread stop
Done
> ifconfig down
Done
> factoryreset
Done

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

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

> thread stop
Done
> ifconfig down
Done
> factoryreset
Done

12. Korzystanie z multicastu

Tryb Multicast służy do przekazywania informacji do grupy urządzeń jednocześnie. W sieci typu Thread określone adresy są zarezerwowane do użytku w trybie multicastu dla różnych grup urządzeń (w zależności od zakresu).

Ponieważ w ćwiczeniach z tego programowania nie korzystamy z routera granicznego, skupimy się na 2 adresach multicastu i MED.

Link lokalny

Zakres Link-Local obejmuje wszystkie interfejsy Thread, do których można dotrzeć przez jedną transmisję radiową, lub pojedynczy &hop." Topologia sieci określa, które urządzenia reagują na ping do adresu multicastu ff02::1.

Użyj polecenia ping ff02::1 w rozmowie z FTD Commission:

## 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 jedną odpowiedź z lokalnego adresu linka FTD. Oznacza to, że jest to jedyne urządzenie, do którego prowadzi FTD za pomocą jednego przeskoku.

Teraz polecenie ping ff02::1 w połączeniu 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! Sprawdzić adresy IPv6 dla innych urządzeń i zobaczyć, że pierwszy (skończony w 4b1d) adresat to FTD Commissioner, a drugi (na końcu adresu 943b) to kod połączenia RCP.

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

System lokalny typu mesh

Zakres Mesh-Local obejmuje wszystkie interfejsy Thread, które są dostępne w tej samej sieci Thread. Sprawdź odpowiedzi na ping do adresu multicastu ff03::1.

Użyj polecenia ping ff03::1 w rozmowie z FTD Commission:

## 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 FTD (numer kończący się na b800) i drugą z łącznika RCP Mesh-Local o numerze kończącym się cyframi d55f. Ponieważ ten lokalny zakres obejmuje całą sieć Thread. Bez względu na to, w którym miejscu w sieci znajduje się urządzenie, będzie on subskrybować adres ff03::1.

Pinguj ff03::1 w przyłączniku FTD, 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

Zwróć uwagę na czas odpowiedzi serwera połączeń RCP w obu wynikach pingu. Połączenie z RCP trwało znacznie dłużej (68 ms) niż połączenie z FTD (23 ms). To dlatego, że trzeba wykonać dwa przeskoki do komisarza FTD, w porównaniu z jednym przeskokiem łącznika FTD.

Zauważasz też, że ping multicastu w sieci typu mesh i odpowiedzi RLOC dotyczą tylko 2 FTD, a nie łączenia elementów RCP. Dzieje się tak, ponieważ w przypadku FTD routery są routerami 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

Jedna z usług aplikacji oferowanych przez OpenThread to User Datagram Protocol (UDP), czyli protokół Transport Layer. Aplikacja oparta na OpenThread może używać interfejsu UDP API do przesyłania 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ć Threadline zawiera router graniczny).

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

Uzyskaj adres EID lokalnego systemu Mesh dla łącznika FTD. 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 połącz go z gniazdem dowolnego adresu IPv6:

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

> udp open
Done
> udp bind :: 1212

Przełącz się na komisarz FTD, uruchom UDP i połącz się z gniazdem skonfigurowanym w połączeniu FTD za pomocą jego 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 komisji FTD:

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

> udp send hellothere
Done

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

Teraz już wiesz:

• różnica między typami urządzeń z wątkami, rolami i zakresami;
• jak urządzenia w wątkach zarządzają swoimi 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:

• Obsadzaj tablicę łącznika FTD jako MDM za pomocą pliku binarnego ot-cli-mtd i zauważ, że nigdy nie zmienia się na router lub nie próbuje zostać liderem.
• Dodaj więcej urządzeń (wypróbuj inną platformę) do sieci i naszkicuj topologię za pomocą tabel routera i elementu podrzędnego oraz pingów do adresów multicast
• Kontroluj NCP za pomocą narzędzia pyspinel
• Zmień NCP w router graniczny za pomocą OpenThread Border Router i połącz swoją sieć Thread z internetem.

Więcej informacji

Zajrzyj na stronę openthread.io i GitHub, gdzie znajdziesz wiele zasobów OpenThread, w tym:

• Obsługiwane platformy – odkrywaj wszystkie platformy obsługujące OpenThread.
• Build OpenThread – więcej szczegółów o tworzeniu i konfigurowaniu OpenThread
• Wprowadzenie do wątku – obejmuje wszystkie zagadnienia związane z wątkami opisane w tym ćwiczeniu z programowania.

Odwołanie:

• Dokumentacja wiersza poleceń OpenThread
• Dokumentacja wiersza poleceń UDP Open
• Porównanie demonów OpenThread
• Dokumentacja interfejsu OpenThread UDP API
• Krótkie informacje o ekranie GNU