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.
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.
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.
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ń) |
|
Opuść sesję ekranu | Ctrl + A → |
Utwórz nowe okno w ramach sesji ekranu | Ctrl + A → |
Przełączanie się między oknami w ramach tej samej sesji ekranu | Ctrl+A → |
Zabicie bieżącego okna w sesji ekranu | Ctrl + A → |
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 →
nponownie, 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 → |
Podziel okno w pionie | Ctrl + A → |
Podziel okno w poziomie | Ctrl + A → |
Przejdź do następnego wyświetlonego okna | Ctrl + A → |
Przełącz wyświetlane okno do przodu i do tyłu | Ctrl+A → |
Zmień nazwę bieżącego okna | Ctrl + 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:
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:
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.
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
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.
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
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
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 |
| Link-lokalny | Wszystkie FTD i MED |
| Link-lokalny | Wszystkie FTD i routery graniczne |
| Sieć lokalna typu mesh | Wszystkie FTD i MED |
| 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.
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.
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.
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
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-mtdi 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: