1. Wprowadzenie
Opublikowana przez Google implementacja OpenThread to implementacja protokołu sieciowego Thread® typu open source. Firma Google Nest udostępniła rozwiązanie OpenThread, aby udostępnić deweloperom technologię wykorzystywaną w produktach Nest i przyspieszyć proces opracowywania produktów do domów inteligentnych.
Specyfikacja Thread definiuje oparty na protokole IPv6 niezawodny, bezpieczny i oszczędny, bezprzewodowy protokół komunikacyjny między urządzeniami domowymi. OpenThread implementuje wszystkie warstwy sieciowe Thread, w tym IPv6, 6LoWPAN, IEEE 802.15.4 z zabezpieczeniami MAC, ustanowieniem linku mesh i routingiem sieci typu mesh.
W ramach tego ćwiczenia w Codelabs zaprogramujesz OpenThread na prawdziwym sprzęcie, utworzysz sieć Thread i nią zarządzasz, a także przekażesz komunikaty między węzłami.
Czego się nauczysz
- Tworzenie i migracja plików binarnych interfejsu wiersza poleceń OpenThread do tablic deweloperskich
- Tworzenie RCP składającego się z komputera z systemem Linux i płytki programistycznej
- Komunikacja z RCP przy użyciu demona OpenThread i
ot-ctl - Ręczne zarządzanie węzłami Thread za pomocą GNU Screen i interfejsu OpenThread CLI
- Bezpieczne uruchamianie urządzeń w sieci Thread
- Jak działa multicast IPv6
- Przekazywanie wiadomości między węzłami wątków przy użyciu protokołu UDP
Czego potrzebujesz
Sprzęt:
- 3 płytki deweloperskie Nordic Semiconductor nRF52840
- 3 kable USB na micro USB do połączenia tablic
- Komputer 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 ćwiczeniem z programowania symulacji OpenThread, aby zapoznać się z podstawowymi pojęciami dotyczącymi Thread i interfejsem wiersza poleceń OpenThread.
Złącza portów szeregowych
Musisz wiedzieć, jak połączyć się z portem szeregowym przez terminal. Ćwiczenia z programowania korzystają z aplikacji GNU Screen i zawierają ogólne informacje o użytkowaniu aplikacji, ale można w nich używać dowolnego innego oprogramowania terminala.
Komputer z systemem Linux
To ćwiczenia z programowania zostały opracowane z myślą o użyciu maszyny z systemem i386 lub x86 z systemem Linux, która pełni funkcję hosta urządzenia z procesorem koprocesorowym (RCP) Thread i do obsługi we wszystkich płytach deweloperskich Thread. Wszystkie kroki zostały przetestowane w systemie Ubuntu 14.04.5 LTS (Trusty Tahr).
Płyty skandynawskie półprzewodnikowe nRF52840
W tym ćwiczeniu z programowania używane są 3 płyty PDK nRF52840.
Zainstaluj SEGGER J-Link
Do programowania płyt nRF52840, które mają moduły JTAG, używamy SEGGER J-Link. Zainstaluj je na komputerze z systemem Linux.
Pobierz odpowiedni pakiet dla swojego komputera i zainstaluj go w odpowiednim miejscu. W Linuksie jest to /opt/SEGGER/JLink.
Zainstaluj narzędzia wiersza poleceń nRF5x
Narzędzia wiersza poleceń nRF5x umożliwiają flashowanie plików binarnych OpenThread na płytkach nRF52840. Zainstaluj odpowiednią wersję nRF5x-Command-Line-Tools-<OS> na komputerze z Linuksem.
Umieść wyodrębniony pakiet w folderze głównym ~/
Instalowanie łańcucha narzędzi ARM GNU Toolchain
Do tworzenia obiektów używa się łańcucha narzędzi ARM GNU Toolchain.
Zalecamy umieszczenie wyodrębnionego archiwum w folderze /opt/gnu-mcu-eclipse/arm-none-eabi-gcc/ na komputerze z systemem Linux. Aby przeprowadzić instalację, postępuj zgodnie z instrukcjami w pliku readme.txt archiwum.
Zainstaluj ekran (opcjonalnie)
Screen to proste narzędzie do uzyskiwania dostępu do urządzeń połączonych przez port szeregowy. Te ćwiczenia w Codelabs korzystają z aplikacji Screen, ale możesz użyć dowolnej aplikacji terminala z portami szeregowymi.
$ sudo apt-get install screen
3. Klonowanie repozytoriów
OpenThread
Skopiuj i zainstaluj OpenThread. Polecenia script/bootstrap pozwalają sprawdzić, 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
Skompiluj demona OpenThread:
$ script/cmake-build posix -DOT_DAEMON=ON
Teraz możesz utworzyć i zainstalować OpenThread na płytkach nRF52840.
4. Konfigurowanie łączenia RCP
Tworzenie i flashowanie
Utwórz przykład OpenThread nRF52840 z użyciem Joiner i natywnej funkcji USB. Urządzenie używa roli Łącznik, aby bezpiecznie uwierzytelniać się i wysyłać do sieci Thread. Natywny interfejs USB umożliwia używanie USB CDC ACM jako łącza szeregowego między nRF52840 a hostem.
Zawsze najpierw czyść repozytorium wcześniejszych 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 RCP OpenThread i przekonwertuj go na format szesnastkowy:
$ cd ~/src/ot-nrf528xx/build/bin $ arm-none-eabi-objcopy -O ihex ot-rcp ot-rcp.hex
Podłącz kabel USB do portu debugowania micro USB obok zewnętrznego styku zasilania na płytce nRF52840, a następnie do komputera z systemem Linux. Ustaw przełącznik źródła zasilania nRF na płytce nRF52840 na VDD. Po prawidłowym podłączeniu dioda LED5 się świeci.
Jeśli jest to pierwsza płyta podłączona do komputera z systemem Linux, będzie ona wyświetlana jako port szeregowy /dev/ttyACM0 (wszystkie płytki nRF52840 używają identyfikatora ttyACM jako identyfikatora portu szeregowego).
$ ls /dev/ttyACM* /dev/ttyACM0
Zapisz numer seryjny płytki nRF52840 używanej na potrzeby RCP:
Przejdź do lokalizacji narzędzi wiersza poleceń nRFx i prześlij plik szesnastkowy OpenThread RCP na płytkę nRF52840, podając jej numer seryjny. Pamiętaj, że jeśli pominiesz flagę --verify, zobaczysz ostrzeżenie z informacją, ż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 pomyślnym zakończeniu generowania zostaną wygenerowane 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ę jako „RCP”. aby później nie pomylić ról na tablicy.
Połącz z natywnym portem USB
Kompilacja RCP OpenThread umożliwia użycie natywnego interfejsu USB CDC ACM jako transportu szeregowego, dlatego do komunikowania się z hostem RCP (na komputerze z systemem Linux musisz używać portu nRF USB na płytce nRF52840).
Odłącz końcówkę micro USB kabla USB od portu debugowania płytki nRF52840, a następnie podłącz ją z powrotem do portu micro-USB nRF USB obok przycisku RESETUJ. Ustaw przełącznik źródła zasilania nRF na USB.
Uruchom demona OpenThread
W projekcie RCP używaj Demon OpenThread do komunikacji z urządzeniem Thread i zarządzania nim. Rozpocznij polecenie ot-daemon od flagi szczegółowej -v, aby wyświetlić dane wyjściowe dzienników i sprawdzić, czy są uruchomione:
$ 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 generuje dane wyjściowe podobne do tych:
ot-daemon[12463]: Running OPENTHREAD/thread-reference-20200818-1938-g0f10480ed; POSIX; Aug 30 2022 10:55:05 ot-daemon[12463]: Thread version: 4 ot-daemon[12463]: Thread interface: wpan0 ot-daemon[12463]: RCP version: OPENTHREAD/thread-reference-20200818-1938-g0f10480ed; SIMULATION; Aug 30 2022 10:54:10
Pozostaw to okno terminala otwarte, aby można było wyświetlać logi z ot-daemon.
Użyj ot-ctl do komunikacji z węzłem RCP. ot-ctl używa tego samego interfejsu wiersza poleceń co aplikacja interfejsu wiersza poleceń OpenThread. Dlatego możesz sterować ot-daemon węzłami w taki sam sposób jak w przypadku innych symulowanych urządzeń Thread.
W drugim oknie terminala uruchom ot-ctl:
$ sudo ./build/posix/src/posix/ot-ctl >
Sprawdź state w węźle 2 (węzła RCP), który został uruchomiony dla ot-daemon:
> state disabled Done
5. Konfiguracja punktów początkowych
Pozostałe 2 węzły Thread używane w tym ćwiczeniu to urządzenia w pełni wątkowe (FTD) w standardowej konstrukcji układu SOC. W środowisku produkcyjnym do sterowania instancjami NCP OpenThread można używać wpantund – sterownika interfejsu sieciowego klasy produkcyjnej. Jednak w tym ćwiczeniu z programowania użyjemy ot-ctl – interfejsu wiersza poleceń OpenThread.
Jedno urządzenie działa jako komisarz, który bezpiecznie uwierzytelnia i udostępnia urządzenia w tej sieci. Drugie urządzenie działa jako Joiner, którego komisarz może uwierzytelnić w sieci Thread.
Tworzenie i flashowanie
Utwórz przykładowy plik danych OpenThread FTD 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 z plikiem binarnym interfejsu 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 styku zasilania na płytce nRF52840, a następnie do komputera z systemem Linux. Jeśli RCP jest nadal podłączony do komputera z systemem Linux, nowa płytka powinna być oznaczona jako port szeregowy /dev/ttyACM1 (wszystkie płytki nRF52840 używają identyfikatora ttyACM jako identyfikatora portu szeregowego).
$ ls /dev/ttyACM* /dev/ttyACM0 /dev/ttyACM1
Tak jak wcześniej, zapisz numer seryjny płyty nRF52840 używanej na potrzeby FTD:
Przejdź do lokalizacji narzędzi wiersza poleceń nRFx i prześlij plik szesnastkowy FTD interfejsu wiersza poleceń OpenThread na płytkę nRF52840, używając jej numeru seryjnego:
$ cd ~/nrfjprog/
$ ./nrfjprog -f nrf52 -s 683704924 --verify --chiperase --program \
~/src/ot-nrf528xx/build/bin/ot-cli-ftd.hex --reset
Nadaj tablicy etykietę „Komisarz”.
Połącz z natywnym portem USB
Kompilacja OpenThread FTD umożliwia użycie natywnego interfejsu USB CDC ACM jako transportu szeregowego, dlatego do komunikowania się z hostem RCP (na komputerze z systemem Linux musisz używać portu nRF USB na płytce nRF52840).
Odłącz końcówkę micro USB kabla USB od portu debugowania płytki nRF52840, a następnie podłącz ją z powrotem do portu micro-USB nRF USB obok przycisku RESETUJ. Ustaw przełącznik źródła zasilania nRF na USB.
Zweryfikuj kompilację
Sprawdź udaną kompilację, otwierając interfejs wiersza poleceń OpenThread za pomocą narzędzia GNU Screen z okna terminala. W przypadku płyt nRF52840 szybkość transmisji bitów wynosi 115 200.
$ screen /dev/ttyACM1 115200
W nowym oknie naciśnij kilka razy Return na klawiaturze, aby wyświetlić prompt > interfejsu wiersza poleceń OpenThread. Otwórz interfejs IPv6 i sprawdź adresy:
> ifconfig up Done > ipaddr fe80:0:0:0:1cd6:87a9:cb9d:4b1d Done
Naciśnij Ctrl + A →
d, aby odłączyć się od ekranu wiersza poleceń FTD Commissioner i wrócić do terminala Linuksa, aby można było wyświetlić następną tablicę. Aby w dowolnym momencie ponownie wpisać interfejs wiersza poleceń, użyj screen -r z poziomu wiersza poleceń. Aby zobaczyć listę dostępnych ekranów, użyj elementu screen -ls:
$ screen -ls
There is a screen on:
74182.ttys000.mylinuxmachine (Detached)
1 Socket in /tmp/uscreens/S-username.
Konfigurowanie usługi łączenia FTD
Powtórz powyższy proces, aby wetknąć trzecią płytkę nRF52840, używając istniejącej kompilacji ot-cli-ftd.hex. Gdy skończysz, ponownie podłącz płytkę do komputera, używając portu USB nRF, i ustaw przełącznik źródła zasilania nRF na VDD.
Jeśli po podłączeniu tej trzeciej płytki do komputera z systemem Linux są podłączone pozostałe 2 węzły, powinny być one widoczne jako port szeregowy /dev/ttyACM2:
$ ls /dev/ttyACM* /dev/ttyACM0 /dev/ttyACM1 /dev/ttyACM2
Oznacz tablicę jako „Łącznik”.
Jeśli przeprowadzasz weryfikację za pomocą aplikacji Screen, zamiast tworzyć nową instancję aplikacji Screen z poziomu wiersza poleceń, podłącz ją ponownie do istniejącej i utwórz w niej nowe okno (używane w przypadku komisarza FTD):
$ screen -r
Otwórz nowe okno na ekranie, naciskając Ctrl + A → c.
Pojawi się nowy wiersz poleceń. Uzyskaj dostęp do interfejsu wiersza poleceń OpenThread dla usługi łączenia FTD:
$ screen /dev/ttyACM2 115200
W nowym oknie naciśnij kilka razy Return na klawiaturze, aby wyświetlić prompt > interfejsu wiersza poleceń OpenThread. Otwórz interfejs IPv6 i sprawdź adresy:
> ifconfig up Done > ipaddr fe80:0:0:0:6c1e:87a2:df05:c240 Done
Interfejs wiersza poleceń FTD Joiner CLI znajduje się już w tym samym wystąpieniu Ekranu co komisarz FTD, więc możesz się między nimi przełączać, naciskając Ctrl + a → n.
Naciśnij Ctrl + A →
d w dowolnym momencie, aby zamknąć ekran.
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 działają i łatwo dostępne. Do tej pory korzystaliśmy z aplikacji Screen, aby uzyskać dostęp do 2 przyłączy FTD. To narzędzie umożliwia też podział ekranu w tym samym oknie terminala. Dzięki temu możesz zobaczyć, jak jeden węzeł reaguje na polecenia wydane w innym.
Najlepiej udostępnić cztery okna:
ot-daemon– usługa lub logi- Łącznik RCS przez
ot-ctl - Komisarz FTD przez interfejs wiersza poleceń OpenThread
- Łącznik FTD za pomocą interfejsu wiersza poleceń OpenThread
Jeśli chcesz użyć własnego terminala / portu szeregowego lub narzędzia, możesz przejść do następnego kroku. Skonfiguruj okna terminala na wszystkich urządzeniach w sposób, który najbardziej Ci odpowiada.
Używanie ekranu
Aby ułatwić sobie korzystanie z urządzenia, rozpocznij tylko jedną sesję ekranu. Jeden z nich powinien być już dostępny w momencie konfiguracji obydwu serwerów FTD.
Wszystkie polecenia na ekranie zaczynają się od Ctrl + A.
Podstawowe polecenia na ekranie:
Załącz ponownie do sesji ekranu (z poziomu wiersza 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 → |
Wyłącz bieżące okno w sesji ekranu | Ctrl + A → |
Podzielony ekran
Za pomocą aplikacji Screen możesz podzielić terminal na kilka okien:
Do poleceń w usłudze screen otwiera się po naciśnięciu Ctrl + A. Każde polecenie powinno zaczynać się od tej kombinacji klawiszy dostępu.
Jeśli dokładnie wykonujesz ćwiczenia z Codelabs, powinny się w nim znajdować 2 okna (FTD Commissioner, FTD Joiner) w tej samej instancji ekranu. Aby podzielić ekran między te 2 ekrany, najpierw wprowadź bieżącą sesję ekranu:
$ screen -r
Musisz korzystać z jednego z urządzeń FTD. Wykonaj te czynności na ekranie Ekran:
- Ctrl+A →
S, aby podzielić okno poziomo - Ctrl + A →
Tab, aby przenieść kursor do nowego pustego okna - Ctrl + A →
n, aby przełączyć nowe okno do następnego - Jeśli jest to samo co w górnym oknie, naciśnij ponownie Ctrl + a →
n, aby wyświetlić drugie urządzenie FTD.
Oba są widoczne. Możesz przełączać się między nimi, naciskając Ctrl + A → Tab. Zalecamy zmianę tytułu każdego okna za pomocą skrótu Ctrl + a → A, aby uniknąć pomyłek.
Zaawansowane użycie
Aby można było dalej podzielić ekran na ćwiartki i wyświetlić logi ot-daemon oraz narzędzie RCP Joiner ot-ctl, te usługi muszą być uruchomione w tej samej instancji ekranu. Aby to zrobić, zatrzymaj ot-daemon i zamknij ot-ctl. Uruchom je ponownie w nowych oknach ekranowych (Ctrl + A → c).
Ta konfiguracja nie jest wymagana i pozostaje jako ćwiczenie dla użytkownika.
Możesz dzielić okna i przechodzić między nimi za pomocą tych poleceń:
Utwórz nowe okno | Ctrl + A → |
Podziel okno w pionie | Ctrl + A → |
Podziel okno poziomo | Ctrl + A → |
Przejdź do następnego wyświetlonego okna | Ctrl + A → |
Przełącz wyświetlane okno do przodu lub do tyłu | Ctrl+a → |
Zmień nazwę bieżącego okna | Ctrl + A → |
W każdej chwili możesz opuścić ekran, naciskając Ctrl + a → d i dołączać go ponownie za pomocą polecenia screen -r z poziomu wiersza poleceń.
Więcej informacji o wyświetlaniu na ekranie znajdziesz w krótkim dokumencie GNU Screen.
7. Tworzenie sieci Thread
Masz już skonfigurowane wszystkie okna i ekrany terminali, czas utworzyć sieć Thread. Na stronie FTD Commissioner utwórz nowy zbiór danych operacyjnych i zatwierdź go jako aktywny. Działający zbiór danych 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
Zanotuj klucz sieci 1234c0de7ab51234c0de7ab51234c0de, którego użyjesz później.
Zatwierdź ten zbiór danych jako aktywny:
> dataset commit active Done
Wyświetl interfejs IPv6:
> ifconfig up Done
Rozpoczynanie operacji protokołu Thread:
> thread start Done
Za chwilę sprawdź stan urządzenia. To powinien być lider. Pobierz też RLOC16 – do użytku w przyszłości.
## FTD Commissioner ## ---------------------- > state leader Done > rloc16 0c00 Done
Sprawdź adresy IPv6 urządzenia:
## FTD Commissioner ## ---------------------- > ipaddr fdc0:de7a:b5c0:0:0:ff:fe00:fc00 # Leader Anycast Locator (ALOC) fdc0:de7a:b5c0:0:0:ff:fe00:c00 # Routing Locator (RLOC) fdc0:de7a:b5c0:0:6394:5a75:a1ad:e5a # Mesh-Local EID (ML-EID) fe80:0:0:0:1cd6:87a9:cb9d:4b1d # Link-Local Address (LLA)
Ćwiczenia z programowania Sieć jest teraz widoczna podczas skanowania z innych urządzeń Thread.
Źródło: ot-ctl w narzędziu RCP Joiner:
## RCP Joiner ## ---------------- > scan | PAN | MAC Address | Ch | dBm | LQI | +------+------------------+----+-----+-----+ | c0de | 1ed687a9cb9d4b1d | 11 | -36 | 232 |
W interfejsie wiersza poleceń OpenThread w narzędziu FTD Joiner:
## FTD Joiner ## ---------------- > scan | PAN | MAC Address | Ch | dBm | LQI | +------+------------------+----+-----+-----+ | c0de | 1ed687a9cb9d4b1d | 11 | -38 | 229 |
Jeśli „laboratorium” sieci nie ma na liście, spróbuj jeszcze raz uruchomić skanowanie.
8. Dodawanie łącznika RCP
Przekazywanie wątków nie jest aktywne w sieci, co oznacza, że musimy dodać narzędzie RCP Joiner do sieci Thread, którą właśnie utworzyliśmy, w ramach procesu uruchamiania poza zakresem.
Na stronie komisarza FTD zanotowaliśmy klucz sieci, na przykład 1234c0de7ab51234c0de7ab51234c0de. Jeśli chcesz ponownie wyszukać klucz sieci, uruchom to polecenie na stronie FTD Commissioner (komisarza FTD):
## FTD Commissioner ## > dataset networkkey 1234c0de7ab51234c0de7ab51234c0de Done
Następnie w narzędziu RCP Joiner ustaw aktywny klucz sieciowy zbioru danych na klucz sieciowy komisarza FTD:
## RCP Joiner ## ---------------- > dataset networkkey 1234c0de7ab51234c0de7ab51234c0de Done > dataset commit active Done
Sprawdź, czy zbiór danych jest prawidłowo skonfigurowany.
## RCP Joiner ## ---------------- > dataset Network Key: 1234c0de7ab51234c0de7ab51234c0de
Wywołaj Thread, aby łącznik RCP dołączył do „laboratorium” Zaczekaj kilka sekund, sprawdź stan RLOC16 i jego adresy IPv6:
## RCP Joiner ## ---------------- > ifconfig up Done > thread start Done > state child Done > rloc16 0c01 Done > ipaddr fdc0:de7a:b5c0:0:0:ff:fe00:0c01 # Routing Locator (RLOC) fdc0:de7a:b5c0:0:66bf:99b9:24c0:d55f # Mesh-Local EID (ML-EID) fe80:0:0:0:18e5:29b3:a638:943b # Link-Local Address (LLA) Done
Zanotuj lokalny adres IPv6 sieci typu mesh (fdc0:de7a:b5c0:0:66bf:99b9:24c0:d55f tutaj), którego użyjesz później.
Na stronie FTD Commissioner sprawdź w tabelach routera i podrzędnych, czy oba urządzenia należą do tej samej sieci. Do identyfikacji osoby łączącej RCP użyj parametru 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
Wyślij ping na lokalny adres sieci typu mesh osoby łączącej RCP (adres lokalny w sieci typu mesh uzyskany z danych wyjściowych ipaddr narzędzia RCP), aby sprawdzić połączenie:
## 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
Sieć Thread składa się z 2 węzłów, co przedstawiono na tym schemacie topologii:
Diagramy topologii
W trakcie wykonywania pozostałych ćwiczeń z programowania w Codelabs będziemy wyświetlać nowy diagram topologii wątków. Role węzłów są oznaczone w ten sposób:
Routery to zawsze pięciokąty, a urządzenia końcowe zawsze są okręgami. Liczby w każdym węźle odpowiadają identyfikatorowi routera lub identyfikatorowi podrzędnemu wyświetlanemu w danych wyjściowych interfejsu wiersza poleceń, w zależności od bieżącej roli i stanu każdego węzła w danym momencie.
9. Zlecenie połączenia FTD
Dodajmy teraz trzecie urządzenie Thread do ćwiczenia w programowaniu. Tym razem użyjemy bezpieczniejszego procesu uruchamiania w paśmie i umożliwimy dołączenie tylko osobie, która dołączyła do FTD.
Na stronie FTD Joiner znajdź identyfikator eui64, by komisarz FTD mógł go zidentyfikować:
## FTD Joiner ## ---------------- > eui64 2f57d222545271f1 Done
Na stronie FTD Commissioner uruchom konto komisarza i podaj eui64 urządzenia, które może dołączyć, oraz dane logowania komisarza, na przykład J01NME. Dane logowania łączenia
## FTD Commissioner ## ---------------------- > commissioner start Done > commissioner joiner add 2f57d222545271f1 J01NME Done
Przełącz się na panel FTD Joiner. Rozpocznij rolę łączenia za pomocą danych logowania skonfigurowanych przed chwilą na stronie komisarza FTD:
## FTD Joiner ## ---------------- > ifconfig up Done > joiner start J01NME Done
Po około minucie otrzymasz potwierdzenie udanego uwierzytelnienia:
## FTD Joiner ## ---------------- > Join success
Wyświetl Thread, aby łącznik FTD dołączył do ćwiczenia z programowania i natychmiast sprawdź stan oraz RLOC16:
## FTD Joiner ## ---------------- > thread start Done > state child Done > rloc16 0c02 Done
Sprawdź adresy IPv6 urządzenia. Zwróć uwagę, że brakuje parametru ALOC. Dzieje się tak, ponieważ to urządzenie nie jest liderem ani nie ma przypisanej roli typu 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 poziom FTD Commissioner (komisarz FTD) i sprawdź tabele routera i tabele podrzędne, aby upewnić się, że w „ćwiczeniu z programowania” istnieją 3 urządzenia. sieć:
## 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
Zgodnie z zasadą RLOC16 narzędzie FTD Joiner połączyło się z siecią jako urządzenie końcowe (element podrzędny). Oto zaktualizowana topologia:
10. Wątek w akcji
Urządzenia Thread tego ćwiczenia to specyficzny rodzaj urządzenia z pełnym wątkiem (FTD), który jest nazywany urządzeniem końcowym uprawnionym do routera (REED). Oznacza to, że mogą one działać zarówno jako router, jak i urządzenie końcowe, a także przenieść się z urządzenia końcowego do routera.
Thread może obsługiwać do 32 routerów, ale stara się utrzymać ich liczbę między 16 a 23. Jeśli REED podłącza się jako urządzenie końcowe (element podrzędny), a liczba routerów jest mniejsza niż 16, po losowym przedziale czasu w ciągu dwóch minut automatycznie zmieni się w router.
Jeśli po dodaniu elementu FTD Joiner w sieci Thread 2 elementy podrzędne były aktywne, odczekaj co najmniej 2 minuty, a następnie sprawdź tabele routera i podrzędne w komisarzu 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ę na router. Pamiętaj, że RLOC16 jest inny (b800 zamiast 0c02). Wynika to z faktu, że wartość RLOC16 opiera się na identyfikatorze routera i identyfikatorze podrzędnym urządzenia. Podczas przenoszenia z urządzenia końcowego do routera zmieniają się jego wartości identyfikatora routera i identyfikatora podrzędnego, a także wartość RLOC16.
Potwierdź nowy stan i wartość RLOC16 w narzędziu FTD Joiner:
## FTD Joiner ## ---------------- > state router Done > rloc16 b800 Done
Zmiana poziomu połączenia FTD
Możesz przetestować to zachowanie, ręcznie zmieniając ustawienie FTD Joiner z routera z powrotem na urządzenie końcowe. Zmień stan na podrzędne i sprawdź RLOC16:
## FTD Joiner ## ---------------- > state child Done > rloc16 0c03 Done
W sekcji Komisarz FTD element łączący FTD powinien pojawić się w tabeli podrzędnej (identyfikator = 3). Podczas przenoszenia może nawet znajdować się 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 urządzenie przełączy się z powrotem na router z wartością RLOC b800.
Usuń lidera
Lider jest wybierany samodzielnie spośród wszystkich routerów wątków. Oznacza to, że jeśli obecny lider zostanie usunięty z sieci Thread, jeden z pozostałych routerów stanie się nowym routerem.
Na stronie FTD Commissioner wyłącz usługę Thread, aby usunąć ją z sieci Thread:
## FTD Commissioner ## ---------------------- > thread stop Done > ifconfig down Done
W ciągu 2 minut FTD Joiner stanie się nowym liderem wątku. Sprawdź stan i adresy IPv6 narzędzia do łączenia FTD:
## 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ę, że pojawiła się nowa wersja RLOC16. Jest to łącznik RCP, na który wskazują jego identyfikator i rozszerzony adres MAC. Aby utrzymać sieć Thread, przełączała routery nadrzędne z komisarza FTD na łącznik FTD. Powoduje to zmianę wartości RLOC16 dla połączenia RCP (ponieważ identyfikator routera zmienił się z 3 na 46).
## FTD Joiner ## ---------------- > child table | ID | RLOC16 | Timeout | Age | LQ In | C_VN |R|S|D|N| Extended MAC | +-----+--------+------------+------------+-------+------+-+-+-+-+------------------+ | 1 | 0xb801 | 240 | 27 | 3 | 145 |1|1|1|1| 1ae529b3a638943b | Done
Może być konieczne odczekanie kilku minut na dołączenie elementu RCP Joiner do dołączenia do FTD Joiner jako użytkownik podrzędny. Sprawdź stan i wskaźnik RLOC16, aby potwierdzić, że:
## RCP Joiner ## -------------- > state child > rloc16 b801
Dołącz ponownie komisarza FTD
Sieć Thread z 2 węzłami nie jest fajna. Wróćmy do trybu online komisarza FTD.
Na stronie FTD Commissioner uruchom ponownie Thread:
## FTD Commissioner ## ---------------------- > ifconfig up Done > thread start Done
W ciągu 2 minut automatycznie powtarza się do ćwiczenia w roli urządzenia końcowego, a potem promuje się jako router.
## FTD Commissioner ## ---------------------- > state router Done
Sprawdź tabele routera i podrzędne w narzędziu FTD Joiner, aby upewnić się, że:
## 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 znów składa się z 3 węzłów.
11. Rozwiązywanie problemów
Zarządzanie siecią Thread z kilkoma urządzeniami na różnych terminalach lub oknami ekranowymi może być skomplikowane. Skorzystaj z tych wskazówek, aby „zresetować” stan sieci lub obszaru roboczego, jeśli występują problemy.
Ekran
Jeśli zgubisz się w konfiguracji (za dużo okien lub ekranów na ekranie), zamykaj okna ekranowe, naciskając Ctrl + a → k, aż żaden nie istnieje, a screen -ls w wierszu poleceń wyświetli No Sockets found. Następnie utwórz ponownie okna ekranów na każdym urządzeniu. Stany urządzenia są zachowywane nawet po wyłączeniu ekranu.
Węzły wątków
Jeśli topologia sieci Thread nie jest zgodna z opisem w tym ćwiczeniu lub węzły z jakiegoś powodu rozłączają się (na przykład komputer z systemem Linux, na którym zostały uśpione), najlepiej wyłączyć usługę Thread, wyczyścić dane logowania do sieci i zacząć od nowa od kroku Tworzenie sieci Thread.
Aby zresetować punkty wyjścia:
## FTD Commissioner or FTD Joiner ## ------------------------------------ > thread stop Done > ifconfig down Done > factoryreset Done
RCP można zresetować w ten sam sposób za pomocą ot-ctl:
## RCP Joiner ## ---------------- > thread stop Done > ifconfig down Done > factoryreset Done
12. Używanie multiemisji
Multicast służy do przekazywania informacji do grupy urządzeń jednocześnie. W sieci Thread określone adresy są zarezerwowane do użytku w trybie multicast z różnymi grupami urządzeń w zależności od zakresu.
Adres IPv6 | Zakres | Dostarczono do |
| Link lokalny | Wszystkie FTD i MED |
| Link lokalny | Wszystkie FTD i routery graniczne |
| Sieć typu mesh – lokalna | Wszystkie FTD i MED |
| Sieć typu mesh – lokalna | Wszystkie FTD i routery graniczne |
Ponieważ w tym ćwiczeniach z programowania nie korzystamy z routera granicznego, skupmy się na 2 adresach grupowych FTD i MED.
Link lokalny
Zakres połączenia lokalnego obejmuje wszystkie interfejsy Thread, do których można dotrzeć za pomocą pojedynczej transmisji radiowej lub pojedynczego przeskoku. Topologia sieci określa, które urządzenia reagują na ping na adres multiemisji ff02::1.
Ping ff02::1 od komisarza FTD:
## FTD Commissioner ## ---------------------- > ping ff02::1 > 8 bytes from fe80:0:0:0:e4cd:d2d9:3249:a243: icmp_seq=2 hlim=64 time=9ms
W sieci są jeszcze 2 inne urządzenia (FTD Joiner i RCP Joiner), ale komisarz FTD otrzymał tylko jedną odpowiedź z połączenia z lokalnym adresem firmy FTD Joiner's Link-Local Address (LLA). Oznacza to, że komisarz FTD Joiner jest jedynym urządzeniem, do którego może dotrzeć z jednym przeskokiem.
Teraz wyślij ping do użytkownika ff02::1 od osoby, która łączy 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 pozostałych urządzeń widzimy, że pierwszy z nich (kończący się na 4b1d) to LLA komisarza FTD, a drugi (kończący się na 943b) to LLA połączenia RCP.
Oznacza to, że usługa FTD Joiner jest bezpośrednio połączona z komisarzem FTD i RCP Joiner, co potwierdza naszą topologię.
Sieć typu mesh – lokalna
Zakres sieci typu mesh-Local obejmuje wszystkie interfejsy Thread dostępne w tej samej sieci Thread. Zobaczmy odpowiedzi na ping na adres transmisji grupowej ff03::1.
Ping ff03::1 od komisarza FTD:
## FTD Commissioner ## ---------------------- > ping ff03::1 > 8 bytes from fdc0:de7a:b5c0:0:0:ff:fe00:b800: icmp_seq=3 hlim=64 time=9ms 8 bytes from fdc0:de7a:b5c0:0:66bf:99b9:24c0:d55f: icmp_seq=3 hlim=64 time=68ms
Tym razem komisarz FTD otrzymał 2 odpowiedzi: jedną od Lokalizatora routingu FTD Joiner's Routing Locator (RLOC z końcówką b800), a drugą z identyfikatora EID usługi mesh-Local Mesh (ML-EID o numerze kończącym się cyframi d55f) osoby RCP. Dzieje się tak, ponieważ zakres sieci typu mesh obejmuje całą sieć Thread. Urządzenie będzie subskrybowane z adresu ff03::1 niezależnie od tego, w którym miejscu w sieci się znajduje.
Wyślij ping na konto ff03::1 z konsoli FTD Joiner, aby potwierdzić to samo zachowanie:
## FTD Joiner ## ---------------- > ping ff03::1 > 8 bytes from fdc0:de7a:b5c0:0:0:ff:fe00:c00: icmp_seq=2 hlim=64 time=11ms 8 bytes from fdc0:de7a:b5c0:0:66bf:99b9:24c0:d55f: icmp_seq=2 hlim=64 time=23ms
Zwróć uwagę na czas odpowiedzi narzędzia RCP Joiner w obu danych wyjściowych pingu. Osoba łącząca RCP zajęła dużo więcej czasu na dotarcie do komisarza FTD (68 ms) niż do połączenia z FTD Joiner (23 ms). Wynika to z faktu, że aby dotrzeć do komisarza FTD, trzeba wykonać dwa przeskoki, a nie jeden przeskok dla komisarza FTD.
Być może zauważyłeś również, że ping lokalnego multiemisji w sieci typu mesh odpowiadał przy użyciu RLOC tylko dla dwóch FTD, a nie RCP Joiner. Dzieje się tak, ponieważ FTD to routery w sieci, a RCP – urządzeniem końcowym.
Sprawdź stan narzędzia RCP Joiner, aby potwierdzić:
## RCP Joiner ## ---------------- > state child
13. Wysyłaj wiadomości przy użyciu UDP
Jedną z usług aplikacji udostępnianych przez OpenThread jest protokół User Datagram Protocol (UDP), czyli protokół Transport Layer. Aplikacja utworzona w OpenThread może używać interfejsu UDP API do przekazywania wiadomości między węzłami w sieci Thread lub do innych urządzeń w sieci zewnętrznej (np. do internetu, jeśli sieć Thread obsługuje router graniczny).
Gniazda UDP są udostępniane przez interfejs wiersza poleceń OpenThread. Użyjmy go do przekazywania wiadomości między dwoma serwerami FTD.
Uzyskaj lokalny adres EID sieci typu mesh dla elementu FTD Joiner. Używamy tego adresu, ponieważ jest on osiągalny z dowolnego miejsca w sieci Thread.
## FTD Joiner ## ---------------- > ipaddr fdc0:de7a:b5c0:0:0:ff:fe00:fc00 # Leader Anycast Locator (ALOC) fdc0:de7a:b5c0:0:0:ff:fe00:b800 # Routing Locator (RLOC) fe80:0:0:0:e4cd:d2d9:3249:a243 # Link-Local Address (LLA) fdc0:de7a:b5c0:0:3e2e:66e:9d41:ebcd # Mesh-Local EID (ML-EID) Done
Uruchom UDP i powiąż go z gniazdem dla dowolnego adresu IPv6:
## FTD Joiner ## ---------------- > udp open Done > udp bind :: 1212
Przełącz się na poziom FTD Commissioner, uruchom UDP i połącz się z gniazdem skonfigurowanym w FTD Joiner, używając jego identyfikatora ML-EID:
## FTD Commissioner ## ---------------------- > udp open Done > udp connect fdc0:de7a:b5c0:0:3e2e:66e:9d41:ebcd 1212 Done
Między 2 węzłami powinno być aktywne połączenie UDP. Wyślij wiadomość od komisarza FTD:
## FTD Commissioner ## ---------------------- > udp send hellothere Done
W narzędziu FTD Joiner otrzymano komunikat UDP.
## FTD Joiner ## ---------------- > 10 bytes from fdc0:de7a:b5c0:0:0:ff:fe00:c00 49153 hellothere
14. Gratulacje!
Udało Ci się utworzyć fizyczną sieć Thread.
Wiesz już:
- różnica między typami, rolami i zakresami urządzeń Thread
- jak urządzenia Thread zarządzają stanami w sieci
- jak przekazywać proste komunikaty między węzłami przy użyciu UDP
Dalsze kroki
Opierając się na tym ćwiczeniu z programowania, spróbuj wykonać następujące ćwiczenia:
- Ponownie utwórz tablicę FTD Joiner jako MTD, używając pliku binarnego
ot-cli-mtd, i obserwuj, że nigdy nie zmienia się ona na router ani nie próbuje zostać liderem. - Dodaj do sieci więcej urządzeń (spróbuj użyć innej platformy) i szkicuj topologię, korzystając z tabel routerów i podrzędnych oraz pingów dotyczących adresów grupowania.
- Używaj pyspinel do sterowania NCP.
- Przekonwertuj NCP na router graniczny za pomocą routera granic OpenThread i połącz swoją sieć Thread z internetem.
Więcej informacji
Na stronach openthread.io i GitHub znajdziesz różne zasoby OpenThread, w tym:
- Obsługiwane platformy – poznaj wszystkie platformy obsługujące OpenThread.
- Utwórz OpenThread – więcej informacji o tworzeniu i konfigurowaniu OpenThread.
- Thread Primer – obejmuje wszystkie pojęcia związane z Thread ćwiczenia z programowania;
Numer referencyjny: