1. Wprowadzenie
OpenThread to opublikowana przez Google implementacja open source protokołu sieciowego Thread®. Google Nest udostępniło 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, Mesh Link Establishment i Mesh Routing.
W tym laboratorium kodowania zaprogramujesz OpenThread na prawdziwym sprzęcie, utworzysz sieć Thread i będziesz nią zarządzać oraz przesyłać wiadomości między węzłami.
Czego się nauczysz
- Tworzenie i wgrywanie plików binarnych interfejsu wiersza poleceń OpenThread na płytki deweloperskie
- Tworzenie RCP składającego się z komputera z systemem Linux i płytki deweloperskiej
- Komunikacja z RCP za pomocą demona OpenThread i
ot-ctl - Ręczne zarządzanie węzłami Thread za pomocą GNU Screen i interfejsu wiersza poleceń OpenThread
- Bezpieczne wdrażanie urządzeń w sieci Thread
- Jak działa multicast IPv6
- Przekazywanie wiadomości między węzłami Thread za pomocą protokołu UDP
Czego potrzebujesz
Sprzęt:
- 3 płytki deweloperskie Nordic Semiconductor nRF52840
- 3 kable USB do micro USB do podłączenia tablic
- komputer z systemem Linux i co najmniej 3 portami USB;
Oprogramowanie:
- GNU Toolchain
- Narzędzia wiersza poleceń Nordic nRF5x
- Oprogramowanie Segger J-Link
- OpenThread
- Git
2. Pierwsze kroki
Symulacja OpenThread
Zanim zaczniesz, zapoznaj się z samouczkiem OpenThread Simulation Codelab, aby poznać podstawowe pojęcia związane z Thread i interfejsem wiersza poleceń OpenThread.
Terminale portu szeregowego
Musisz wiedzieć, jak połączyć się z portem szeregowym za pomocą terminala. W tym laboratorium używamy GNU Screen i przedstawiamy jego omówienie, ale można użyć dowolnego innego oprogramowania terminala.
Urządzenie z systemem Linux
Ten Codelab został zaprojektowany z myślą o używaniu komputera z systemem Linux opartego na architekturze i386 lub x86 jako hosta dla urządzenia z wątkiem RCP (Radio Co-Processor) oraz do flashowania wszystkich płytek deweloperskich Thread. Wszystkie kroki zostały przetestowane w systemie Ubuntu 14.04.5 LTS (Trusty Tahr).
Płytki Nordic Semiconductor nRF52840
W tym ćwiczeniu w Codelabs używane są 3 płytki nRF52840 PDK.
Instalowanie SEGGER J-Link
Do programowania płytek nRF52840, które mają wbudowane moduły JTAG, używamy SEGGER J-Link. Zainstaluj go na komputerze z Linuksem.
Pobierz odpowiedni pakiet na swoje urządzenie i zainstaluj go w odpowiednim miejscu. W systemie Linux jest to /opt/SEGGER/JLink.
Instalowanie narzędzi wiersza poleceń nRF5x
Narzędzia wiersza poleceń nRF5x umożliwiają flashowanie plików binarnych OpenThread na płytach nRF52840. Zainstaluj odpowiednią kompilację nRF5x-Command-Line-Tools-<OS> na komputerze z systemem Linux.
Umieść wyodrębniony pakiet w folderze głównym ~/.
Instalowanie zestawu narzędzi ARM GNU
Do kompilacji używany jest zestaw 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)
Screen to proste narzędzie do uzyskiwania dostępu do urządzeń podłączonych przez port szeregowy. W tym przewodniku używamy aplikacji Screen, ale możesz użyć dowolnej aplikacji terminala portu szeregowego.
$ sudo apt-get install screen
3. Klonowanie repozytoriów
OpenThread
Sklonuj i zainstaluj OpenThread. Polecenia script/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
Utwórz demona OpenThread:
$ script/cmake-build posix -DOT_DAEMON=ON
Teraz możesz skompilować i wgrać OpenThread na płytki nRF52840.
4. Konfigurowanie tagu łączącego RCP
Kompilowanie i programowanie
Skompiluj przykład OpenThread nRF52840 z funkcją Joiner i natywną funkcją USB. Urządzenie korzysta z roli dołączającego, aby bezpiecznie uwierzytelnić się i zostać włączone do sieci Thread. Natywne USB umożliwia używanie USB CDC ACM jako transportu szeregowego między nRF52840 a hostem.
Zawsze najpierw czyść repozytorium z 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
Otwórz katalog z binarnym plikiem 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 pinu zasilania na płytce nRF52840, a następnie podłącz go do urządzenia z systemem Linux. Ustaw przełącznik nRF power source na płytce nRF52840 w pozycji VDD. Gdy połączenie jest prawidłowe, LED5 świeci.
Jeśli jest to pierwsza płytka podłączona do urządzenia z systemem Linux, pojawi się ona jako port szeregowy /dev/ttyACM0 (wszystkie płytki nRF52840 używają identyfikatora portu szeregowego ttyACM).
$ ls /dev/ttyACM* /dev/ttyACM0
Zapisz numer seryjny płytki nRF52840 używanej w przypadku RCP:
Przejdź do lokalizacji narzędzi wiersza poleceń nRFx i wgraj plik szesnastkowy OpenThread RCP na płytę nRF52840, używając numeru seryjnego płyty. Pamiętaj, że jeśli pominiesz flagę --verify, pojawi się komunikat ostrzegawczy informujący, że proces flashowania może się nie powieść bez zgłaszania błędów.
$ cd ~/nrfjprog/
$ ./nrfjprog -f nrf52 -s 683704924 --verify --chiperase --program \
~/src/ot-nrf528xx/build/bin/ot-rcp.hex --reset
Jeśli operacja się powiedzie, pojawią się 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ę etykietą „RCP”, aby później nie pomylić ról na tablicy.
Połącz z natywnym USB
Ponieważ kompilacja OpenThread RCP umożliwia korzystanie z natywnego protokołu USB CDC ACM jako transportu szeregowego, do komunikacji z hostem RCP (komputerem z systemem Linux) musisz użyć portu nRF USB na płytce nRF52840.
Odłącz końcówkę micro-USB kabla USB od portu debugowania zaprogramowanej płytki nRF52840, a następnie podłącz ją ponownie do portu micro-USB nRF USB obok przycisku RESET. Ustaw przełącznik Źródło zasilania nRF na USB.
Uruchamianie demona OpenThread
W przypadku projektu RCP użyj demona OpenThread do komunikacji z urządzeniem Thread i zarządzania nim. Uruchom polecenie ot-daemon z flagą -v verbose, aby wyświetlić dane wyjściowe logu i potwierdzić, że działa:
$ cd ~/src/openthread
$ sudo ./build/posix/src/posix/ot-daemon -v \
'spinel+hdlc+uart:///dev/ttyACM0?uart-baudrate=460800'
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 to okno terminala otwarte, aby można było wyświetlać logi z ot-daemon.
Użyj ot-ctl, aby komunikować się z węzłem RCP. 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 drugim oknie terminala uruchom ot-ctl:
$ sudo ./build/posix/src/posix/ot-ctl >
Sprawdź state węzła 2 (węzła RCP) uruchomionego za pomocą polecenia ot-daemon:
> state disabled Done
5. Konfigurowanie urządzeń FTD
Pozostałe 2 węzły Thread używane w tym laboratorium to urządzenia Thread o pełnej funkcjonalności (FTD) oparte na standardowym układzie SoC (System-on-Chip). Jedno urządzenie pełni funkcję komisarza, który bezpiecznie uwierzytelnia i wdraża urządzenia w tej sieci. Drugie urządzenie działa jako urządzenie dołączające, które może zostać uwierzytelnione w sieci Thread przez urządzenie zarządzające.
Kompilowanie i programowanie
Skompiluj przykład OpenThread FTD dla platformy nRF52840 z włączonymi rolami Komisarza i Dołączającego:
$ cd ~/src/ot-nrf528xx $ rm -rf build $ script/build nrf52840 USB_trans -DOT_JOINER=ON -DOT_COMMISSIONER=ON
Otwórz katalog z binarnym plikiem CLI urządzenia 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 pinu zasilania na płytce nRF52840, a następnie podłącz go do urządzenia z systemem Linux. Jeśli RCP jest nadal podłączony do komputera z systemem Linux, nowa płytka powinna być widoczna jako port szeregowy /dev/ttyACM1 (wszystkie płytki nRF52840 używają identyfikatora portu szeregowego ttyACM).
$ ls /dev/ttyACM* /dev/ttyACM0 /dev/ttyACM1
Jak wcześniej, zanotuj numer seryjny płytki nRF52840 używanej do FTD:
Przejdź do lokalizacji narzędzi wiersza poleceń nRFx i wgraj plik szesnastkowy OpenThread CLI FTD na płytę nRF52840, używając numeru seryjnego płyty:
$ cd ~/nrfjprog/
$ ./nrfjprog -f nrf52 -s 683704924 --verify --chiperase --program \
~/src/ot-nrf528xx/build/bin/ot-cli-ftd.hex --reset
Nazwij tablicę „Komisarz”.
Połącz z natywnym USB
W przypadku kompilacji OpenThread FTD można używać natywnego USB CDC ACM jako transportu szeregowego, dlatego do komunikacji z hostem RCP (maszyną z systemem Linux) musisz użyć portu nRF USB na płytce nRF52840.
Odłącz końcówkę micro-USB kabla USB od portu debugowania zaprogramowanej płytki nRF52840, a następnie podłącz ją ponownie do portu micro-USB nRF USB obok przycisku RESET. Ustaw przełącznik Źródło zasilania nRF na USB.
Weryfikowanie kompilacji
Sprawdź, czy kompilacja się powiodła, uzyskując dostęp do interfejsu wiersza poleceń OpenThread za pomocą GNU Screen z okna terminala.
$ screen /dev/ttyACM1
W nowym oknie naciśnij kilka razy klawisz Return, aby wyświetlić wiersz poleceń OpenThread CLI >. Uruchom 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 FTD Commissioner CLI i wrócić do terminala Linuxa, aby można było wgrać oprogramowanie na kolejną płytkę. Aby w dowolnym momencie ponownie otworzyć interfejs wiersza poleceń, użyj polecenia screen -r. Aby wyświetlić listę dostępnych ekranów, użyj screen -ls:
$ screen -ls
There is a screen on:
74182.ttys000.mylinuxmachine (Detached)
1 Socket in /tmp/uscreens/S-username.
Konfigurowanie narzędzia FTD Joiner
Powtórz powyższy proces, aby wgrać oprogramowanie na trzecią płytkę nRF52840, używając istniejącej kompilacji ot-cli-ftd.hex. Po zakończeniu podłącz płytkę z powrotem do komputera za pomocą portu USB nRF i ustaw przełącznik nRF power source (Źródło zasilania nRF) w pozycji VDD.
Jeśli pozostałe 2 węzły są podłączone do urządzenia z systemem Linux, gdy podłączysz trzecią płytkę, powinna ona pojawić się jako port szeregowy /dev/ttyACM2:
$ ls /dev/ttyACM* /dev/ttyACM0 /dev/ttyACM1 /dev/ttyACM2
Oznacz tablicę jako „Joiner”.
Jeśli weryfikujesz za pomocą narzędzia Screen, zamiast tworzyć nową instancję narzędzia Screen w wierszu poleceń, ponownie dołącz do istniejącej instancji i utwórz w niej nowe okno (którego używasz w przypadku FTD Commissioner):
$ screen -r
Utwórz nowe okno w programie Screen, naciskając Ctrl+a → c.
Pojawi się nowy wiersz polecenia. Uzyskaj dostęp do interfejsu wiersza poleceń OpenThread dla urządzenia FTD Joiner:
$ screen /dev/ttyACM2
W nowym oknie naciśnij kilka razy klawisz Return, aby wyświetlić wiersz poleceń OpenThread CLI >. Uruchom interfejs IPv6 i sprawdź adresy:
> ifconfig up Done > ipaddr fe80:0:0:0:6c1e:87a2:df05:c240 Done
Teraz, gdy interfejs wiersza poleceń urządzenia FTD Joiner znajduje się w tej samej instancji ekranu co urządzenie FTD Commissioner, możesz przełączać się między nimi za pomocą kombinacji klawiszy Ctrl+a → n.
Użyj Ctrl+A →
d w dowolnym momencie, aby zamknąć ekran.
6. Konfigurowanie 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ą włączone i łatwo dostępne. Do tej pory używaliśmy narzędzia Screen, aby uzyskać dostęp do 2 urządzeń FTD. Umożliwia ono też podzielenie ekranu w tym samym oknie terminala. Dzięki temu możesz sprawdzić, jak jeden węzeł reaguje na polecenia wydawane w innym węźle.
Najlepiej, aby były dostępne 4 okna:
ot-daemonusługa / logi- RCP Joiner przez
ot-ctl - Komisarz FTD za pomocą interfejsu wiersza poleceń OpenThread
- FTD Joiner za pomocą interfejsu wiersza poleceń OpenThread
Jeśli chcesz użyć własnej konfiguracji terminala lub portu szeregowego albo własnego narzędzia, możesz przejść do następnego kroku. Skonfiguruj okna terminala na wszystkich urządzeniach w sposób, który najbardziej Ci odpowiada.
Korzystanie z ekranu
Aby ułatwić sobie pracę, uruchom tylko jedną sesję Screen. Powinna być już dostępna, ponieważ została utworzona podczas konfigurowania obu urządzeń FTD.
Wszystkie polecenia w programie Screen zaczynają się od Ctrl+a.
Podstawowe polecenia ekranu:
Ponowne dołączanie do sesji Screen (z wiersza poleceń) |
|
Opuszczanie sesji Screen | Ctrl+a → |
Tworzenie nowego okna w sesji Screen | Ctrl+a → |
Przełączanie się między oknami w tej samej sesji Screen | Ctrl+a → |
Zamknięcie bieżącego okna w sesji Screen | Ctrl+a → |
Podzielony ekran
Za pomocą programu Screen możesz podzielić terminal na kilka okien:
Polecenia w screen są dostępne po naciśnięciu Ctrl+a. Każde polecenie powinno zaczynać się od tej kombinacji klawiszy dostępu.
Jeśli postępujesz zgodnie z instrukcjami w tym laboratorium, powinny być widoczne 2 okna (FTD Commissioner, FTD Joiner) w tej samej instancji Screen. Aby podzielić ekran na 2 części, najpierw otwórz istniejącą sesję Screen:
$ screen -r
Musisz korzystać z jednego z urządzeń FTD. Wykonaj te czynności w sekcji Ekran:
- Ctrl+a →
S, aby podzielić okno w poziomie. - Ctrl+a →
Tab, aby przenieść kursor do nowego pustego okna. - Ctrl+a →
n, aby przełączyć nowe okno na następne - Jeśli jest taka sama jak w górnym oknie, naciśnij Ctrl+a →
n, aby wyświetlić inne urządzenie FTD.
Oba są teraz widoczne. Przełączaj się między nimi za pomocą kombinacji Ctrl+a → Tab. Aby uniknąć pomyłek, zalecamy zmianę nazwy każdego okna za pomocą skrótu Ctrl+a → A.
Zaawansowane użycie
Aby podzielić ekran na kwadranty i wyświetlić ot-daemon logi oraz RCP Joiner ot-ctl, te usługi muszą być uruchomione 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 Screen (Ctrl+a → c).
Ta konfiguracja nie jest wymagana i pozostawiamy ją użytkownikowi do samodzielnego wykonania.
Dziel i przełączaj okna za pomocą tych poleceń:
Utwórz nowe okno | Ctrl+a → |
Podziel okno pionowo | Ctrl+A → |
Podziel okno poziomo | Ctrl+a → |
Przejście do następnego wyświetlanego okna | Ctrl+a → |
Przełączanie wyświetlanego okna 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, a następnie ponownie go dołączyć, wpisując screen -r w wierszu poleceń.
Więcej informacji o programie Screen znajdziesz w tym dokumencie.
7. Tworzenie sieci Thread
Po skonfigurowaniu wszystkich okien terminala i ekranów utwórzmy sieć Thread. Na urządzeniu FTD Commissioner utwórz nowy operacyjny zbiór danych i zatwierdź go jako aktywny. Zbiór danych operacyjnych to konfiguracja tworzonej sieci Thread.
## FTD Commissioner ## ---------------------- > dataset init new Done > dataset Active Timestamp: 1 Channel: 11 Channel Mask: 07fff800 Ext PAN ID: c0de7ab5c0de7ab5 Mesh Local Prefix: fdc0:de7a:b5c0/64 Network Key: 1234c0de7ab51234c0de7ab51234c0de Network Name: OpenThread-c0de PAN ID: 0xc0de PSKc: ebb4f2f8a68026fc55bcf3d7be3e6fe4 Security Policy: 0, onrcb Done
Zapisz klucz sieciowy 1234c0de7ab51234c0de7ab51234c0de, który będzie potrzebny później.
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
Po chwili sprawdź stan urządzenia. Powinien być liderem. Zapisz też kod RLOC16, aby móc z niego skorzystać 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)
Sieć „codelab” jest teraz widoczna podczas skanowania z innych urządzeń Thread.
Na stronie RCP Joiner:ot-ctl
## RCP Joiner ## ---------------- > scan | PAN | MAC Address | Ch | dBm | LQI | +------+------------------+----+-----+-----+ | c0de | 1ed687a9cb9d4b1d | 11 | -36 | 232 |
W interfejsie wiersza poleceń OpenThread na urządzeniu FTD Joiner:
## FTD Joiner ## ---------------- > scan | PAN | MAC Address | Ch | dBm | LQI | +------+------------------+----+-----+-----+ | c0de | 1ed687a9cb9d4b1d | 11 | -38 | 229 |
Jeśli sieć „codelab” nie pojawia się na liście, spróbuj ponownie wyszukać sieci.
8. Dodawanie łącznika RCP
W sieci nie jest aktywna funkcja Thread Commissioning, co oznacza, że musimy dodać urządzenie RCP Joiner do utworzonej przez nas sieci Thread za pomocą procesu konfiguracji poza pasmem.
Na stronie FTD Commissioner (Komisarz FTD) zanotowaliśmy klucz sieci, np. 1234c0de7ab51234c0de7ab51234c0de. Jeśli musisz ponownie wyszukać klucz sieciowy, uruchom to polecenie na FTD Commissioner:
## FTD Commissioner ## > dataset networkkey 1234c0de7ab51234c0de7ab51234c0de Done
Następnie na urządzeniu RCP Joiner ustaw aktywny zbiór danych Klucz sieciowy na Klucz sieciowy urządzenia FTD Commissioner:
## 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
Uruchom Thread, aby urządzenie RCP Joiner dołączyło do sieci „codelab”. Poczekaj 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 adres IPv6 sieci Mesh (fdc0:de7a:b5c0:0:66bf:99b9:24c0:d55f), będzie on potrzebny później.
Wróć do FTD Commissioner i sprawdź tabele routera i urządzeń podrzędnych, aby potwierdzić, że oba urządzenia należą do tej samej sieci. Użyj RLOC16, aby zidentyfikować RCP Joiner.
## 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 adres lokalny sieci RCP Joiner (adres lokalny sieci uzyskany z danych wyjściowych ipaddr RCP Joiner), aby sprawdzić łączność:
## 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ć Thread składającą się z 2 węzłów, co ilustruje ten diagram topologii:
Diagramy topologii
W dalszej części tego laboratorium pokażemy nowy diagram topologii sieci Thread za każdym razem, gdy zmieni się stan sieci. Role węzłów są oznaczane w ten sposób:
Routery są zawsze pięciokątami, a urządzenia końcowe – okręgami. Liczby w każdym węźle reprezentują identyfikator routera lub identyfikator urządzenia podrzędnego widoczny w danych wyjściowych interfejsu CLI, w zależności od bieżącej roli i stanu każdego węzła.
9. Uruchomienie urządzenia FTD Joiner
Teraz dodajmy trzecie urządzenie Thread do sieci „codelab”. Tym razem użyjemy bezpieczniejszego procesu w pasmie i zezwalimy na dołączenie tylko urządzenia FTD Joiner.
Na FTD Joiner uzyskaj eui64, aby komisarz FTD mógł go zidentyfikować:
## FTD Joiner ## ---------------- > eui64 2f57d222545271f1 Done
Na urządzeniu FTD Commissioner uruchom urządzenie Commissioner i określ eui64 urządzenia, które może dołączyć, wraz z poświadczeniami Joiner Credential, np. J01NME. Klucz dostępu urządzenia to ciąg znaków alfanumerycznych składający się z samych wielkich liter (0–9 i A–Y, z wyłączeniem I, O, Q i Z ze względu na czytelność) o długości od 6 do 32 znaków.
## FTD Commissioner ## ---------------------- > commissioner start Done > commissioner joiner add 2f57d222545271f1 J01NME Done
Przełącz na FTD Joiner (Narzędzie złączające FTD). Uruchom rolę dołączającego za pomocą danych logowania dołączającego, które zostały skonfigurowane na urządzeniu FTD Commissioner:
## FTD Joiner ## ---------------- > ifconfig up Done > joiner start J01NME Done
Po około minucie otrzymasz potwierdzenie udanego uwierzytelniania:
## FTD Joiner ## ---------------- > Join success
Uruchom Thread, aby urządzenie FTD Joiner dołączyło do sieci „codelab”, a następnie od razu sprawdź 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 tego, że to urządzenie nie jest liderem ani nie pełni roli związanej z Anycast, która wymaga adresu 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)
Od razu przełącz się na FTD Commissioner i sprawdź tabele routera i dziecka, 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 urządzenie FTD Joiner zostało dołączone do sieci jako urządzenie końcowe (podrzędne). Oto zaktualizowana topologia:
10. Wątek w akcji
Urządzenia Thread w tym laboratorium to specjalny rodzaj urządzenia FTD (Full Thread Device) o nazwie REED (Router Eligible End Device). Oznacza to, że mogą pełnić funkcję routera lub urządzenia końcowego i mogą przekształcić się z urządzenia końcowego w router.
Sieć Thread może obsługiwać do 32 routerów, ale staramy się, aby ich liczba wynosiła od 16 do 23. Jeśli urządzenie REED zostanie podłączone jako urządzenie końcowe (podrzędne), a liczba routerów będzie mniejsza niż 16, po losowym czasie trwającym maksymalnie 2 minuty automatycznie przekształci się w router.
Jeśli po dodaniu urządzenia FTD Joiner w sieci Thread masz 2 dzieci, poczekaj co najmniej 2 minuty, a następnie ponownie sprawdź tabele routerów i dzieci na urządzeniu FTD Commissioner:
## 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
Urządzenie FTD Joiner (Extended MAC = e6cdd2d93249a243) zostało awansowane na router. Zwróć uwagę, że RLOC16 jest inny (b800 zamiast 0c02). Dzieje się tak, ponieważ RLOC16 jest oparty na identyfikatorze routera i identyfikatorze urządzenia podrzędnego. Gdy urządzenie końcowe przechodzi w tryb routera, zmieniają się wartości identyfikatora routera i identyfikatora urządzenia podrzędnego, a także RLOC16.
Sprawdź nowy stan i RLOC16 na urządzeniu FTD Joiner:
## FTD Joiner ## ---------------- > state router Done > rloc16 b800 Done
Obniżanie wersji urządzenia FTD Joiner
Możesz przetestować to działanie, ręcznie obniżając wersję FTD Joiner z routera do urządzenia końcowego. Zmień stan na „child” (dziecko) i sprawdź RLOC16:
## FTD Joiner ## ---------------- > state child Done > rloc16 0c03 Done
W FTD Commissioner w tabeli podrzędnej powinien być teraz widoczny FTD Joiner (ID = 3). Może nawet znajdować się w obu usługach w okresie przejściowym:
## 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 wróci do routera z RLOC b800.
Usuwanie lidera
Lider jest wybierany samodzielnie spośród wszystkich routerów Thread. Oznacza to, że jeśli bieżący lider zostanie usunięty z sieci Thread, jeden z pozostałych routerów stanie się nowym liderem.
Na urządzeniu FTD Commissioner wyłącz Thread, aby usunąć go z sieci Thread:
## FTD Commissioner ## ---------------------- > thread stop Done > ifconfig down Done
W ciągu 2 minut FTD Joiner staje się nowym liderem wątku. Sprawdź stan i adresy IPv6 urządzenia FTD Joiner, 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ę, że pojawił się nowy identyfikator RLOC16. Jest to urządzenie RCP Joiner, na co wskazują jego identyfikator i rozszerzony adres MAC. Aby utrzymać spójność sieci Thread, zmieniło routery nadrzędne z FTD Commissioner na FTD Joiner. W rezultacie dla urządzenia RCP Joiner powstaje nowy RLOC16 (ponieważ jego 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 minąć kilka minut, zanim RCP Joiner zostanie dołączony do FTD Joiner jako węzeł podrzędny. Sprawdź stan i RLOC16, aby potwierdzić, że:
## RCP Joiner ## -------------- > state child > rloc16 b801
Ponownie podłącz komisarza FTD
Sieć Thread z 2 węzłami nie jest zbyt przydatna. Przywróćmy komisarza FTD do trybu online.
Na FTD Commissioner uruchom ponownie Thread:
## FTD Commissioner ## ---------------------- > ifconfig up Done > thread start Done
W ciągu 2 minut automatycznie ponownie połączy się z siecią „codelab” jako urządzenie końcowe, a następnie zostanie przekształcone w router.
## FTD Commissioner ## ---------------------- > state router Done
Sprawdź router i tablice podrzędne na stronie FTD Joiner, aby potwierdzić:
## 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 ponownie składa się z 3 węzłów.
11. Rozwiązywanie problemów
Zarządzanie siecią Thread z wieloma urządzeniami w różnych oknach terminala lub ekranu może być skomplikowane. Jeśli napotkasz problemy, skorzystaj z tych wskazówek, aby „zresetować” stan sieci lub obszaru roboczego.
Ekran
Jeśli kiedykolwiek zgubisz się w konfiguracji (zbyt wiele okien ekranu lub ekranów w ekranie), zamykaj okna ekranu za pomocą skrótu Ctrl+a → k, aż nie będzie ich więcej, a w wierszu poleceń pojawi się screen -ls.No Sockets found Następnie ponownie utwórz okna Screen na każdym urządzeniu. Stany urządzenia są zachowywane nawet po zamknięciu ekranu.
Węzły Thread
Jeśli topologia sieci Thread nie jest zgodna z opisem w tym samouczku lub węzły rozłączają się z jakiegoś powodu (np. z powodu przejścia w stan uśpienia urządzenia z systemem Linux, które je zasila), najlepiej wyłączyć sieć Thread, wyczyścić dane logowania i zacząć od nowa od kroku Tworzenie sieci Thread.
Aby zresetować FTD:
## 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. Korzystanie z multicastu
Multicast służy do przekazywania informacji do grupy urządzeń jednocześnie. W sieci Thread określone adresy są zarezerwowane do transmisji grupowej w różnych grupach urządzeń w zależności od zakresu.
Adres IPv6 | Zakres | Dostarczono do |
| Link-Local | Wszystkie FTD i MED |
| Link-Local | Wszystkie urządzenia FTD i routery graniczne |
| Mesh-Local | Wszystkie FTD i MED |
| Mesh-Local | Wszystkie urządzenia FTD i routery graniczne |
W tym laboratorium nie używamy routera brzegowego, więc skupmy się na 2 adresach multicastowych FTD i MED.
Link-Local
Zakres Link-Local obejmuje wszystkie interfejsy Thread, do których można dotrzeć za pomocą jednej transmisji radiowej lub jednego „skoku”. Topologia sieci określa, które urządzenia odpowiadają na ping do adresu połączenia grupowego 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 urządzenia (FTD Joiner i RCP Joiner), ale FTD Commissioner otrzymał tylko 1 odpowiedź – z adresu lokalnego połączenia (LLA) urządzenia FTD Joiner. Oznacza to, że urządzenie FTD Joiner jest jedynym urządzeniem, do którego urządzenie FTD Commissioner może dotrzeć za pomocą jednego przeskoku.
Teraz wyślij ping ff02::1 z FTD Joiner:
## 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! Sprawdzając adresy IPv6 innych urządzeń, widzimy, że pierwszy z nich (kończący się na 4b1d) to adres LLA komisarza FTD, a drugi (kończący się na 943b) to adres LLA urządzenia RCP Joiner.
Oznacza to, że urządzenie FTD Joiner jest bezpośrednio połączone zarówno z urządzeniem FTD Commissioner, jak i z urządzeniem RCP Joiner, co potwierdza naszą topologię.
Mesh-Local
Zakres Mesh-Local obejmuje wszystkie interfejsy Thread dostępne w tej samej sieci Thread. Zobaczmy odpowiedzi na ping wysłany na adres multiemisji 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ą z lokalizatora routingu (RLOC) urządzenia dołączającego FTD (końcówka b800) i jedną z lokalnego identyfikatora EID (ML-EID) urządzenia dołączającego RCP (końcówka d55f). Dzieje się tak, ponieważ zasięg lokalny sieci mesh obejmuje całą sieć Thread. Niezależnie od tego, gdzie w sieci znajduje się urządzenie, będzie ono subskrybować adres ff03::1.
Wyślij ping do ff03::1 z 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 w przypadku RCP Joiner w obu wynikach pingowania. Dotarcie do komisarza FTD (68 ms) zajęło RCP Joiner znacznie więcej czasu niż dotarcie do RCP Joiner (23 ms). Dzieje się tak, ponieważ musi wykonać 2 przeskoki, aby dotrzeć do komisarza FTD, podczas gdy urządzenie dołączające FTD wykonuje tylko 1 przeskok.
Możesz też zauważyć, że ping rozgłoszeniowy w sieci mesh zwrócił RLOC tylko w przypadku 2 urządzeń FTD, a nie urządzenia RCP Joiner. Dzieje się tak, ponieważ urządzenia FTD są routerami w sieci, a RCP jest urządzeniem końcowym.
Sprawdź stan RCP Joiner, aby potwierdzić:
## RCP Joiner ## ---------------- > state child
13. Wysyłanie wiadomości za pomocą protokołu UDP
Jedną z usług aplikacji, które udostępnia OpenThread, jest protokół UDP (User Datagram Protocol), czyli protokół warstwy transportowej. Aplikacja oparta na 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. w internecie, jeśli sieć Thread ma router graniczny).
Gniazda UDP są udostępniane za pomocą interfejsu wiersza poleceń OpenThread. Użyjmy go do przesyłania wiadomości między dwoma urządzeniami FTD.
Uzyskaj adres Mesh-Local EID dla FTD Joiner. Używamy tego adresu, ponieważ jest on dostępny z dowolnego miejsca w sieci Thread.
## FTD Joiner ## ---------------- > ipaddr fdc0:de7a:b5c0:0:0:ff:fe00:fc00 # Leader Anycast Locator (ALOC) fdc0:de7a:b5c0:0:0:ff:fe00:b800 # Routing Locator (RLOC) fe80:0:0:0:e4cd:d2d9:3249:a243 # Link-Local Address (LLA) fdc0:de7a:b5c0:0:3e2e:66e:9d41:ebcd # Mesh-Local EID (ML-EID) Done
Uruchom UDP i powiąż go z gniazdem dla dowolnego adresu IPv6:
## FTD Joiner ## ---------------- > udp open Done > udp bind :: 1212
Przejdź do FTD Commissioner, uruchom UDP i połącz się z gniazdem skonfigurowanym na urządzeniu FTD Joiner, używając jego ML-EID:
## FTD Commissioner ## ---------------------- > udp open Done > udp connect fdc0:de7a:b5c0:0:3e2e:66e:9d41:ebcd 1212 Done
Połączenie UDP powinno być aktywne między dwoma węzłami. Wysyłanie wiadomości od komisarza FTD:
## FTD Commissioner ## ---------------------- > udp send hellothere Done
Na urządzeniu FTD Joiner odebrano wiadomość UDP.
## FTD Joiner ## ---------------- > 10 bytes from fdc0:de7a:b5c0:0:0:ff:fe00:c00 49153 hellothere
14. Gratulacje!
Udało Ci się utworzyć fizyczną sieć Thread.
Wiesz już:
- różnice między typami, rolami i zakresami urządzeń Thread;
- jak urządzenia Thread zarządzają swoimi stanami w sieci,
- jak przekazywać proste wiadomości między węzłami za pomocą protokołu UDP,
Dalsze kroki
Wykonaj te ćwiczenia, korzystając z tego samouczka:
- Ponownie wgraj oprogramowanie na płytę FTD Joiner jako MTD za pomocą pliku binarnego
ot-cli-mtdi sprawdź, czy nigdy nie aktualizuje się do wersji Router ani nie próbuje zostać liderem. - Dodaj do sieci więcej urządzeń (wypróbuj inną platformę!) i naszkicuj topologię, korzystając z tabel routera i urządzeń podrzędnych oraz pingów do adresów multiemisji.
- Użyj pyspinel, aby sterować NCP
- Przekształć NCP w router graniczny za pomocą OpenThread Border Router i połącz sieć Thread z internetem.
Więcej informacji
Na stronach openthread.io i GitHub znajdziesz różne materiały dotyczące OpenThread, w tym:
- Obsługiwane platformy – poznaj wszystkie platformy, które obsługują OpenThread.
- Kompilowanie OpenThread – więcej informacji o kompilowaniu i konfigurowaniu OpenThread.
- Podstawy protokołu Thread – omówienie wszystkich koncepcji protokołu Thread przedstawionych w tym ćwiczeniu z programowania.
Źródło: