1. Wprowadzenie
OpenThread to udostępniona przez Google implementacja open source protokołu sieciowego Thread. Google Nest udostępnił 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, ustanawianie połączeń siatkowych i routing siatkowy.
W tym samouczku dowiesz się, jak symulować sieć Thread na symulowanych urządzeniach.
Czego się nauczysz
- Konfigurowanie łańcucha narzędzi do kompilacji OpenThread
- Symulowanie sieci Thread
- Jak uwierzytelniać węzły Thread
- Jak zarządzać siecią Thread za pomocą demona OpenThread
Czego potrzebujesz
- git
- podstawowa wiedza o systemie Linux i routingu sieciowym;
2. Konfigurowanie systemu kompilacji
Git
Aby ukończyć to ćwiczenie, musisz mieć zainstalowany Git. Pobierz i zainstaluj go, zanim przejdziesz dalej.
Po zainstalowaniu postępuj zgodnie z instrukcjami dotyczącymi konkretnego systemu operacyjnego, aby pobrać i skompilować OpenThread.
XCode na Mac OS X
XCode jest wymagany do zainstalowania i skompilowania OpenThread na Mac OS X.
Po zainstalowaniu Xcode zainstaluj narzędzia wiersza poleceń Xcode:
$ xcode-select --install
Kompilowanie w systemie Linux lub Mac OS X
Te instrukcje instalacji zostały przetestowane na serwerze Ubuntu 14.04 LTS i systemie Mac OS X Sierra 10.12.6.
Zainstaluj OpenThread. Polecenia 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
Korzystanie z systemu Windows
Jeśli wolisz system Windows, zalecamy wypróbowanie wersji tych ćwiczeń z programowania dla Dockera.
3. Tworzenie aplikacji OpenThread
Po zakończeniu instalacji skompiluj przykładową aplikację OpenThread. W tym laboratorium używamy przykładu symulacji.
$ cd ~/src/openthread $ ./script/cmake-build simulation
Teraz skompiluj demona OpenThread:
$ ./script/cmake-build posix -DOT_DAEMON=ON
4. Symulowanie sieci Thread
Przykładowa aplikacja, której użyjesz w tym module, to minimalna aplikacja OpenThread, która udostępnia interfejsy konfiguracji i zarządzania OpenThread za pomocą podstawowego interfejsu wiersza poleceń.
To ćwiczenie pokazuje minimalne kroki wymagane do pingowania jednego symulowanego urządzenia Thread z innego symulowanego urządzenia Thread.
Rysunek poniżej przedstawia podstawową topologię sieci Thread. W tym ćwiczeniu zasymulujemy 2 węzły w zielonym okręgu: lidera sieci Thread i router Thread z pojedynczym połączeniem między nimi.
Pingowanie węzła
1. Uruchamianie węzła 1
Przejdź do katalogu openthread i uruchom proces interfejsu wiersza poleceń dla symulowanego urządzenia Thread za pomocą pliku binarnego ot-cli-ftd.
$ cd ~/src/openthread $ ./build/simulation/examples/apps/cli/ot-cli-ftd 1
Uwaga: jeśli po uruchomieniu tego polecenia nie widzisz prompta >, naciśnij enter.
Ten plik binarny implementuje urządzenie OpenThread symulowane na platformie POSIX. Sterownik radiowy IEEE 802.15.4 jest zaimplementowany na podstawie protokołu UDP (ramki IEEE 802.15.4 są przekazywane w ładunkach UDP).
Argumentem funkcji 1 jest deskryptor pliku, który reprezentuje najmniej znaczące bity „przypisanego fabrycznie” identyfikatora IEEE EUI-64 dla symulowanego urządzenia. Ta wartość jest też używana podczas wiązania z portem UDP na potrzeby emulacji radia IEEE 802.15.4 (port = 9000 + deskryptor pliku). Każde wystąpienie symulowanego urządzenia Thread w tym laboratorium będzie używać innego deskryptora pliku.
Uwaga: podczas tworzenia procesu dla symulowanego urządzenia używaj tylko deskryptorów plików o wartości 1 lub większej, jak podano w tym Codelabie. Deskryptor pliku 0 jest zarezerwowany do innego użytku.
Utwórz nowy zbiór danych operacyjnych i zatwierdź go jako aktywny. Zbiór danych operacyjnych to konfiguracja tworzonej sieci Thread.
> dataset init new Done > dataset Active Timestamp: 1 Channel: 20 Channel Mask: 07fff800 Ext PAN ID: d6263b6d857647da Mesh Local Prefix: fd61:2344:9a52:ede0/64 Network Key: e4344ca17d1dca2a33f064992f31f786 Network Name: OpenThread-c169 PAN ID: 0xc169 PSKc: ebb4f2f8a68026fc55bcf3d7be3e6fe4 Security Policy: 0, onrcb Done
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
Odczekaj kilka sekund i sprawdź, czy urządzenie stało się liderem sieci Thread. Lider to urządzenie odpowiedzialne za zarządzanie przypisywaniem identyfikatorów routera.
> state leader Done
Wyświetl adresy IPv6 przypisane do interfejsu Thread węzła 1 (dane wyjściowe będą inne):
> ipaddr fd61:2344:9a52:ede0:0:ff:fe00:fc00 fd61:2344:9a52:ede0:0:ff:fe00:5000 fd61:2344:9a52:ede0:d041:c5ba:a7bc:5ce6 fe80:0:0:0:94da:92ea:1353:4f3b Done
Zwróć uwagę na konkretne typy adresów IPv6:
- Zaczyna się od
fd= mesh-local - Zaczyna się od
fe80= połączenie lokalne
Typy adresów lokalnych sieci mesh są dalej klasyfikowane:
- Zawiera
ff:fe00= lokalizator routera (RLOC) - Nie zawiera
ff:fe00= identyfikator punktu końcowego (EID)
Znajdź identyfikator EID w danych wyjściowych konsoli i zapisz go, aby użyć go później. W przykładowych danych wyjściowych powyżej identyfikator EID to:
fd61:2344:9a52:ede0:d041:c5ba:a7bc:5ce6
2. Węzeł początkowy 2
Otwórz nowy terminal i przejdź do katalogu openthread, a następnie uruchom proces interfejsu CLI. To jest drugie symulowane urządzenie Thread:
$ cd ~/src/openthread $ ./build/simulation/examples/apps/cli/ot-cli-ftd 2
Uwaga: jeśli po uruchomieniu tego polecenia nie widzisz prompta >, naciśnij enter.
Skonfiguruj klucz sieci Thread i identyfikator PAN, używając tych samych wartości co w przypadku operacyjnego zbioru danych węzła 1:
> dataset networkkey e4344ca17d1dca2a33f064992f31f786 Done > dataset panid 0xc169 Done
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
Urządzenie zostanie zainicjowane jako urządzenie dziecka. Urządzenie podrzędne Thread jest odpowiednikiem urządzenia końcowego, czyli urządzenia Thread, które przesyła i odbiera ruch unicast tylko z urządzeniem nadrzędnym.
> state child Done
W ciągu 2 minut stan powinien zmienić się z child na router. Router Thread może kierować ruch między urządzeniami Thread. Jest on również nazywany rodzicem.
> state router Done
Weryfikowanie sieci
Łatwym sposobem na sprawdzenie sieci typu mesh jest przyjrzenie się tabeli routerów.
1. Sprawdź połączenie
Na węźle 2 pobierz RLOC16. RLOC16 to ostatnie 16 bitów adresu IPv6 RLOC urządzenia.
> rloc16 5800 Done
Na węźle 1 sprawdź w tabeli routera RLOC16 węzła 2. Najpierw upewnij się, że urządzenie Node 2 przełączyło się w stan routera.
> router table | ID | RLOC16 | Next Hop | Path Cost | LQI In | LQI Out | Age | Extended MAC | +----+--------+----------+----------+-------+---------+-----+------------------+ | 20 | 0x5000 | 63 | 0 | 0 | 0 | 0 | 96da92ea13534f3b | | 22 | 0x5800 | 63 | 0 | 3 | 3 | 23 | 5a4eb647eb6bc66c |
W tabeli znajduje się RLOC węzła 1 o wartości 0xa800, co potwierdza, że jest on połączony z siecią kratową.
2. Pingowanie węzła 1 z węzła 2
Sprawdź połączenie między 2 symulowanymi urządzeniami Thread. W węźle 2 ping identyfikator EID przypisany do węzła 1:
> ping fd61:2344:9a52:ede0:d041:c5ba:a7bc:5ce6 > 16 bytes from fd61:2344:9a52:ede0:d041:c5ba:a7bc:5ce6: icmp_seq=1 hlim=64 time=12ms
Naciśnij enter, aby wrócić do wiersza poleceń >.
Testowanie sieci
Skoro możesz już pingować 2 symulowane urządzenia Thread, przetestuj sieć typu mesh, wyłączając jeden węzeł.
Wróć do węzła 1 i zatrzymaj Thread:
> thread stop Done
Przejdź do węzła 2 i sprawdź stan. W ciągu 2 minut węzeł 2 wykryje, że węzeł 1 (lider) jest offline, i powinien przejść do roli leader w sieci:
> state router Done ... > state leader Done
Po potwierdzeniu zatrzymaj Thread i przywróć ustawienia fabryczne węzła 2, a następnie zamknij aplikację. Przywrócenie ustawień fabrycznych ma na celu zapewnienie, że dane logowania do sieci Thread użyte w tym ćwiczeniu nie zostaną przeniesione do następnego ćwiczenia.
> thread stop Done > factoryreset > > exit
Przywróć też do ustawień fabrycznych i zamknij węzeł 1:
> factoryreset > > exit
Aby poznać wszystkie dostępne polecenia interfejsu wiersza poleceń, zapoznaj się z dokumentacją OpenThread CLI.
5. Uwierzytelnianie węzłów za pomocą funkcji Commissioning
W poprzednim ćwiczeniu skonfigurowaliśmy sieć Thread z 2 symulowanymi urządzeniami i sprawdziliśmy połączenie. Umożliwia to jednak przesyłanie między urządzeniami tylko nieuwierzytelnionego ruchu IPv6 w połączeniu lokalnym. Aby kierować globalny ruch IPv6 między nimi (i Internetem za pomocą routera granicznego Thread), węzły muszą być uwierzytelnione.
Aby przeprowadzić uwierzytelnianie, jedno z urządzeń musi pełnić rolę komisarza. Komisarz to aktualnie wybrany serwer uwierzytelniania dla nowych urządzeń Thread i osoba upoważniona do udostępniania danych logowania do sieci wymaganych do dołączenia urządzeń do sieci.
W tym ćwiczeniu użyjemy tej samej topologii z 2 węzłami co wcześniej. Na potrzeby uwierzytelniania urządzenie Thread Leader będzie pełnić funkcję komisarza, a router Thread – funkcję urządzenia dołączającego.
1. Tworzenie sieci
Jeśli kontynuujesz poprzednie ćwiczenie, powinny być już otwarte 2 okna terminala. Jeśli nie, upewnij się, że 2 są otwarte i gotowe do użycia. Jeden będzie węzłem 1, a drugi węzłem 2.
W węźle 1 uruchom proces interfejsu wiersza poleceń:
$ cd ~/src/openthread $ ./build/simulation/examples/apps/cli/ot-cli-ftd 1
Uwaga: jeśli po uruchomieniu tego polecenia nie widzisz prompta >, naciśnij enter.
Utwórz nowy operacyjny zbiór danych, zatwierdź go jako aktywny i uruchom wątek:
> dataset init new Done > dataset Active Timestamp: 1 Channel: 12 Channel Mask: 07fff800 Ext PAN ID: e68d05794bf13052 Mesh Local Prefix: fd7d:ddf7:877b:8756/64 Network Key: a77fe1d03b0e8028a4e13213de38080e Network Name: OpenThread-8f37 PAN ID: 0x8f37 PSKc: f9debbc1532487984b17f92cd55b21fc Security Policy: 0, onrcb Done
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
Poczekaj kilka sekund i sprawdź, czy urządzenie stało się liderem sieci Thread:
> state leader Done
2. Rozpoczęcie roli komisarza
Na węźle 1 uruchom rolę komisarza:
> commissioner start Done
Zezwól każdemu urządzeniu dołączającemu (za pomocą symbolu wieloznacznego *) z J01NME danymi logowania urządzenia dołączającego na włączenie się do sieci. Urządzenie dołączające to urządzenie dodane przez administratora do uruchomionej sieci Thread.
> commissioner joiner add * J01NME Done
3. Rozpoczęcie roli dołączającego
W drugim oknie terminala uruchom nowy proces interfejsu wiersza poleceń. To jest węzeł 2.
$ cd ~/src/openthread $ ./build/simulation/examples/apps/cli/ot-cli-ftd 2
Na węźle 2 włącz rolę dołączającego za pomocą J01NME Joiner Credential.
> ifconfig up Done > joiner start J01NME Done
... poczekaj kilka sekund na potwierdzenie ...
Join success
Urządzenie (węzeł 2) zostało uwierzytelnione przez urządzenie pełniące rolę komisarza (węzeł 1) i otrzymało dane logowania do sieci Thread.
Po uwierzytelnieniu węzła 2 uruchom Thread:
> thread start Done
4. Weryfikowanie uwierzytelniania sieci
Sprawdź state na węźle 2, aby potwierdzić, że dołączył on do sieci. W ciągu 2 minut węzeł 2 przechodzi ze stanu child do stanu router:
> state child Done ... > state router Done
5. Resetuj konfigurację
Aby przygotować się do następnego ćwiczenia, zresetuj konfigurację. Na każdym węźle zatrzymaj Thread, przywróć ustawienia fabryczne i zamknij symulowane urządzenie Thread:
> thread stop Done > factoryreset > > exit
Po wykonaniu polecenia factoryreset może być konieczne kilkukrotne naciśnięcie klawisza enter, aby przywrócić prompt >.
6. Zarządzanie siecią za pomocą demona OpenThread
W tym ćwiczeniu zasymulujemy 1 instancję interfejsu CLI (jedno wbudowane urządzenie SoC Thread) i 1 instancję koprocesora radiowego (RCP).
ot-daemon to tryb aplikacji OpenThread Posix, który używa gniazda UNIX jako wejścia i wyjścia, dzięki czemu rdzeń OpenThread może działać jako usługa. Klient może komunikować się z tą usługą, łącząc się z gniazdem za pomocą interfejsu wiersza poleceń OpenThread jako protokołu.
ot-ctl to interfejs wiersza poleceń udostępniany przez ot-daemon do zarządzania platformą RCP i jej konfigurowania. W ten sposób połączymy RCP z siecią utworzoną przez urządzenie Thread.
Używanie ot-daemon
W tym ćwiczeniu użyjemy 3 okien terminala, które odpowiadają tym elementom:
- Instancja interfejsu wiersza poleceń symulowanego urządzenia Thread (węzeł 1)
- Proces usługi
ot-daemon - Instancja interfejsu wiersza poleceń
ot-ctl
Jeśli kontynuujesz poprzednie ćwiczenie, powinny być już otwarte 2 okna terminala. Otwórz trzecie okno, aby mieć 3 okna terminala na potrzeby tego ćwiczenia.
1. Uruchamianie węzła 1
W pierwszym oknie terminala uruchom proces interfejsu wiersza poleceń dla symulowanego urządzenia Thread:
$ cd ~/src/openthread $ ./build/simulation/examples/apps/cli/ot-cli-ftd 1
Uwaga: jeśli po uruchomieniu tego polecenia nie widzisz prompta >, naciśnij enter.
Utwórz nowy operacyjny zbiór danych, zatwierdź go jako aktywny i uruchom wątek:
> dataset init new Done > dataset Active Timestamp: 1 Channel: 13 Channel Mask: 07fff800 Ext PAN ID: 97d584bcd493b824 Mesh Local Prefix: fd55:cf34:dea5:7994/64 Network Key: ba6e886c7af50598df1115fa07658a83 Network Name: OpenThread-34e4 PAN ID: 0x34e4 PSKc: 38d6fd32c866927a4dfcc06d79ae1192 Security Policy: 0, onrcb Done
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
Wyświetl adresy IPv6 przypisane do interfejsu Thread węzła 1:
> ipaddr fd55:cf34:dea5:7994:0:ff:fe00:fc00 fd55:cf34:dea5:7994:0:ff:fe00:d000 fd55:cf34:dea5:7994:460:872c:e807:c4ab fe80:0:0:0:9cd8:aab6:482f:4cdc Done >
Jak wyjaśniono w kroku Symulowanie sieci Thread, jeden adres jest adresem lokalnym połączenia (fe80), a trzy są adresami lokalnymi siatki (fd). Identyfikator EID to adres lokalny siatki, który nie zawiera w adresie znaku ff:fe00. W tym przykładzie identyfikator EID to fd55:cf34:dea5:7994:460:872c:e807:c4ab.
Zidentyfikuj konkretny identyfikator EID z danych wyjściowych ipaddr, który będzie używany do komunikacji z węzłem.
2. Uruchomienie ot-daemon
W drugim oknie terminala przejdź do katalogu openthread i uruchom ot-daemon dla węzła RCP, który nazwiemy Węzeł 2. Użyj flagi -v verbose, aby wyświetlić dane wyjściowe logu i potwierdzić, że skrypt działa. Pamiętaj, aby użyć sudo:
$ cd ~/src/openthread
$ sudo ./build/posix/src/posix/ot-daemon -v \
'spinel+hdlc+forkpty://build/simulation/examples/apps/ncp/ot-rcp?forkpty-arg=2'
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 ten terminal otwarty i działający w tle. Nie będziesz w nim wpisywać żadnych innych poleceń.
3. Dołączanie do sieci za pomocą ot-ctl
Węzeł 2 (ot-daemon RCP) nie został jeszcze przypisany do żadnej sieci Thread. W tym momencie pojawia się ot-ctl. 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 trzecim oknie terminala uruchom ot-ctl:
$ sudo ./build/posix/src/posix/ot-ctl >
Uwaga: jeśli po uruchomieniu tego polecenia nie widzisz prompta >, naciśnij enter.
W tym trzecim oknie terminala użyjesz znaku ot-ctl do zarządzania węzłem 2 (węzłem RCP), który został uruchomiony w drugim oknie terminala za pomocą znaku ot-daemon. Sprawdź state węzła 2:
> state disabled Done
Pobierz eui64 węzła 2, aby ograniczyć możliwość dołączenia do konkretnego urządzenia:
> eui64 18b4300000000001 Done
Na węźle 1 (w pierwszym oknie terminala) uruchom urządzenie Commissioner i ogranicz możliwość dołączania tylko do tego identyfikatora eui64:
> commissioner start Done > commissioner joiner add 18b4300000000001 J01NME Done
Na węźle 2 (w trzecim oknie terminala) uruchom interfejs sieciowy i dołącz do sieci:
> ifconfig up Done > joiner start J01NME Done
... poczekaj kilka sekund na potwierdzenie ...
Join success
Urządzenie dołączające (węzeł 2) zostało pomyślnie uwierzytelnione przez urządzenie zarządzające (węzeł 1) i otrzymało dane logowania do sieci Thread.
Teraz połącz węzeł 2 z siecią Thread:
> thread start Done
4. Weryfikowanie uwierzytelniania sieci
Sprawdź state na węźle 2, aby potwierdzić, że dołączył on do sieci. W ciągu 2 minut węzeł 2 przechodzi ze stanu child do stanu router:
> state child Done ... > state router Done
5. Sprawdzanie połączenia
Zakończ działanie ot-ctl, używając Ctrl+D lub polecenia exit, a następnie w wierszu poleceń komputera hosta wyślij ping do węzła 1, używając jego identyfikatora EID z poleceniem ping6. Jeśli instancja ot-daemon RCP zostanie pomyślnie połączona z siecią Thread i będzie się z nią komunikować, pingowanie zakończy się powodzeniem:
$ ping6 -c 4 fd55:cf34:dea5:7994:460:872c:e807:c4ab PING fd55:cf34:dea5:7994:460:872c:e807:c4ab (fd55:cf34:dea5:7994:460:872c:e807:c4ab): 56 data bytes 64 bytes from fd55:cf34:dea5:7994:460:872c:e807:c4ab: icmp_seq=0 ttl=64 time=4.568 ms 64 bytes from fd55:cf34:dea5:7994:460:872c:e807:c4ab: icmp_seq=1 ttl=64 time=6.396 ms 64 bytes from fd55:cf34:dea5:7994:460:872c:e807:c4ab: icmp_seq=2 ttl=64 time=7.594 ms 64 bytes from fd55:cf34:dea5:7994:460:872c:e807:c4ab: icmp_seq=3 ttl=64 time=5.461 ms --- fd55:cf34:dea5:7994:460:872c:e807:c4ab ping statistics --- 4 packets transmitted, 4 packets received, 0% packet loss round-trip min/avg/max/stddev = 4.568/6.005/7.594/1.122 ms
7. Gratulacje!
Udało Ci się zasymulować pierwszą sieć Thread za pomocą OpenThread. Świetnie!
Z tego modułu dowiedzieliśmy się, jak:
- Konfigurowanie łańcucha narzędzi do kompilacji OpenThread
- Symulowanie sieci Thread
- Uwierzytelnianie węzłów Thread
- Zarządzanie siecią Thread za pomocą demona OpenThread
Jeśli chcesz dowiedzieć się więcej, zapoznaj się z tymi materiałami: