Utwórz sieć wątków z płytami nRF52840 i OpenThread

1. Wstęp

26b7f4f6b3ea0700.png

OpenThread to stworzona przez Google implementacja typu open source protokołu sieciowego Thread®. Google Nest udostępnia OpenThread, dzięki czemu technologie wykorzystywane w produktach Nest są powszechnie dostępne dla deweloperów, co przyspiesza tworzenie produktów w inteligentnym domu.

Specyfikacja wątku definiuje oparty na protokole IPv6 niezawodny, bezpieczny i niski możliwości bezprzewodowego protokołu komunikacji między urządzeniami domowymi. OpenThread wdraża wszystkie warstwy sieci nici, w tym IPv6, 6LoWPAN, IEEE 802.15.4 z zabezpieczeniami MAC, trasą siatkową Mesh i trasą Mesh.

W tym ćwiczeniu z programowania dowiesz się, jak zaprogramować OpenThread na prawdziwym sprzęcie, utworzyć sieć wątków i nią zarządzać, a także przekazywać wiadomości między węzłami.

4806D16A8C137C6D.jpeg

Czego się dowiesz

  • Kompilowanie i miganie plików binarnych wiersza poleceń OpenThread do tablic deweloperskich
  • Tworzenie RCP składającego się z systemu Linux i płytki deweloperskiej
  • Komunikacja z RCP przy użyciu demon 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 wątków
  • Jak działa multiemisja IPv6
  • Przekazywanie wiadomości między węzłami wątków przez UDP

Niezbędne elementy

Sprzęt:

  • 3 nordic Semiconductor nRF52840 deweloperów
  • 3 kabel USB do micro USB do łączenia płyt
  • komputer z systemem Linux z co najmniej 3 portami USB;

Oprogramowanie:

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

2. Pierwsze kroki

Symulacja OpenThread

Zanim zaczniesz, możesz zapoznać się z ćwiczeniami z programowania symulacji OpenOpen, aby poznać podstawowe zagadnienia związane z wątkiem i interfejs wiersza poleceń OpenThread.

Terminale portów szeregowych

Musisz wiedzieć, jak połączyć się z portami szeregowymi przez terminal. Codewiczenia z programowania korzystają z ekranu GNU i dostarczają informacje o użytkowaniu, ale można używać dowolnego innego terminala.

Linux

To zadanie zostało zaprojektowane pod kątem korzystania z systemu Linux opartego na procesorach i386 lub x86, który będzie działał jako host urządzenia wątków z procesorem radiowym (RCP) i płynić wszystkie płytki programistyczne. Wszystkie kroki zostały przetestowane w systemie Ubuntu 14.04.5 LTS (Trusty Tahr).

Płytki półprzezroczystych norweskich nRF52840

Codewiczenia z programowania działają z 3 płytkami nRF52840 PDK.

a6693da3ce213856.png

Do programowania płyt nRF52840 z modułami JTAG używamy protokołu SEGGER J-Link. Zainstaluj ją na komputerze z systemem Linux.

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

Zainstaluj narzędzia wiersza poleceń nRF5x

Narzędzia wiersza poleceń nRF5x umożliwiają sformatowanie 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 ~/

Zainstaluj zestaw narzędzi ARM GNU

Do tworzenia budynków używany jest zestaw narzędzi ARM GNU.

Zalecamy umieszczenie wyodrębnionego archiwum na komputerze z systemem /opt/gnu-mcu-eclipse/arm-none-eabi-gcc/. Postępuj zgodnie z instrukcjami podanymi w pliku readme.txt archiwum.

Ekran instalacji (opcjonalnie)

Ekran to proste narzędzie do uzyskiwania dostępu do urządzeń podłączonych przez port szeregowy. Ten ćwiczenia z programowania korzystają z ekranu, ale możesz użyć dowolnej aplikacji terminala szeregowego.

$ sudo apt-get install screen

3. Kopiowanie repozytoriów

OpenThread

Skopiuj i zainstaluj OpenThread. Polecenia script/bootstrap dają pewność, ż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

Kompilacja demona OpenThread:

$ script/cmake-build posix -DOT_DAEMON=ON

Teraz możesz utworzyć i uruchomić FlashOpen na płytach nRF52840.

4. Konfigurowanie narzędzia RCP do łączenia kont

Kompilacja i Flash

Utwórz przykład OpenThread nRF52840 z funkcjami Joiner i natywnymi urządzeniami USB. Urządzenie korzysta z roli łączącego, aby być bezpiecznie uwierzytelniane i polecane w sieci wątków. Natywne porty USB umożliwiają używanie USBCC ACM jako przesyłania szeregowego między numerem nRF52840 a hostem.

Zawsze najpierw czyń repozytorium poprzednich kompilacji, uruchamiając polecenie 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 przy użyciu pliku binarnego 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 gniazda zasilania na płytce nRF52840, a następnie podłącz go do komputera z Linuksem. Ustaw przełącznik źródła zasilania nRF na karcie nRF52840 na VDD. Po prawidłowym połączeniu LED5 będzie włączony.

20a3b4b480356447.png

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

$ ls /dev/ttyACM*
/dev/ttyACM0

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

C00D519Ebec7e5f0.jpeg

Przejdź do lokalizacji narzędzi wiersza poleceń nRFx i w pliku szesnastkowym OpenThread RCP wpisz numer seryjny tablicy nRF52840. Pamiętaj, że jeśli opuścisz flagę --verify, zobaczysz ostrzeżenie z informacją, że proces Flash może się nie udać.

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

Po pomyślnym wygenerowaniu są generowane te dane:

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 nie mylić ról w tablicy.

Podłącz do natywnego USB

Kompilacja Open CP RCP umożliwia używanie natywnego USB CDC ACM jako transportu szeregowego, więc do komunikacji z hostem RCP (Linux) musisz użyć portu nRF USB na karcie nRF52840.

Odłącz końcówkę USB-USB od portu debugowania zmodyfikowanej płytki nRF52840, a następnie podłącz ją do portu USB USB nRF obok przycisku RESET. danych Ustaw przełącznik źródła zasilania nRF na USB.

46e7b670d2464842.png

Uruchom demona OpenThread

W projekcie RCP użyj OpenThread Daemon, aby komunikować się z urządzeniem Threads i nim zarządzać. Uruchom polecenie ot-daemon, używając szczegółowej flagi -v, aby wyświetlić dane wyjściowe dziennika i sprawdzić, czy jest uruchomiony:

$ cd ~/src/openthread
$ ./build/posix/src/posix/ot-daemon -v \
    'spinel+hdlc+uart:///dev/ttyACM0?uart-baudrate=115200'

Jeśli operacja się uda, ot-daemon w trybie szczegółowym wygeneruje dane wyjściowe podobne do tych:

ot-daemon[228024]: Running OPENTHREAD/20191113-00831-gfb399104; POSIX; Jun  7 2020 18:05:15
ot-daemon[228024]: Thread version: 2
ot-daemon[228024]: RCP version: OPENTHREAD/20191113-00831-gfb399104; SIMULATION; Jun  7 2020 18:06:08

Pozostaw to okno terminala otwarte, aby można było wyświetlać logi z instancji ot-daemon.

Do komunikacji z węzłem RCP używaj protokołu ot-ctl. ot-ctl korzysta z tego samego interfejsu wiersza poleceń co aplikacja wiersza poleceń OpenThread. Dzięki temu możesz kontrolować ot-daemon węzły w taki sam sposób jak inne symulowane urządzenia z wątkami.

W drugim oknie terminala uruchom polecenie ot-ctl:

$ ./build/posix/bin/ot-ctl
>

Sprawdź state węzła 2 (węzła RCP) rozpoczętego od ot-daemon:

> state
disabled
Done

5. Skonfiguruj FTD

Pozostałe 2 węzły wykorzystywane w tym ćwiczeniu z programowania to urządzenia z pełnym wątkiem w standardowym układzie SOC. W środowisku produkcyjnym można użyć wpantund, sterownika interfejsu sieciowego klasy produkcyjnej, do sterowania instancjami NCP OpenOpen, ale w tym ćwiczeniu z programowania wykorzystamy parametr ot-ctl, OpenThread interfejs wiersza poleceń.

Jedno z urządzeń działa jako Komisarz, by bezpiecznie uwierzytelniać urządzenia w tej sieci i komunikować się z nimi. Drugie urządzenie pełni rolę dołączenia, który może komunikować się przez Komisarza w sieci wątków.

Kompilacja i Flash

Utwórz przykład otwartej wątki 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 przy użyciu pliku wiersza poleceń CLI (OpenThread Full Thread Device) 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 gniazda zasilania na płytce nRF52840, a następnie podłącz go do komputera z Linuksem. Jeśli RCP jest nadal podłączony do komputera z Linuksem, nowa karta powinna być wyświetlana jako port szeregowy /dev/ttyACM1 (wszystkie karty nRF52840 używają ttyACM jako identyfikatora portu szeregowego).

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

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

C00D519Ebec7e5f0.jpeg

Przejdź do lokalizacji narzędzi wiersza poleceń nRFx i wklej plik szesnastkowy OpenThread CLI FTD na karcie nRF52840, korzystając z 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ę Komisarza.

Podłącz do natywnego USB

Kompilacja OpenThread FTD umożliwia używanie natywnego USB CDC ACM jako transportu szeregowego, dlatego do komunikacji z hostem RCP (portretem Linux) musisz używać portu nRF USB na karcie nRF52840.

Odłącz końcówkę USB-USB od portu debugowania zmodyfikowanej płytki nRF52840, a następnie podłącz ją do portu USB USB nRF obok przycisku RESET. danych Ustaw przełącznik źródła zasilania nRF na USB.

46e7b670d2464842.png

Zweryfikuj kompilację

Aby zweryfikować udaną kompilację, otwórz interfejs wiersza poleceń OpenThread, korzystając z ekranu GNU z okna terminala. Płyty nRF52840 mają szybkość transmisji wynoszącą 115200.

$ screen /dev/ttyACM1 115200

W nowym oknie naciśnij kilka razy klawisz Enter na klawiaturze, aby wyświetlić monit OpenLI CLI >. Wyświetl interfejs IPv6 i sprawdź adresy:

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

Ctrl+A →

d odłącz się od ekranu interfejsu wiersza poleceń FTD Commissioner i wróć do terminala Linuksa, aby móc uruchomić następną tablicę. W dowolnym momencie możesz ponownie wpisać interfejs wiersza poleceń, używając screen -r z wiersza poleceń. Aby wyświetlić listę dostępnych ekranów, użyj interfejsu screen -ls:

$ screen -ls
There is a screen on:
        74182.ttys000.mylinuxmachine        (Detached)
1 Socket in /tmp/uscreens/S-username.

Skonfiguruj narzędzie FTD Joiner

Powtórz powyższy proces, aby uruchomić trzeci element nRF52840 z użyciem istniejącej kompilacji ot-cli-ftd.hex. Po zakończeniu podłącz tablicę do komputera za pomocą portu USB nRF i ustaw przełącznik sourceródło zasilania nRF na VDD.

Jeśli pozostałe 2 węzły są podłączone do komputera z systemem Linux, gdy jest dołączona trzecia tablica, powinna być wyświetlana jako port szeregowy /dev/ttyACM2:

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

Oznacz tablicę stolarską.

Jeśli chcesz potwierdzić własność przy użyciu Screen, zamiast tworzyć nowe wystąpienie ekranu z wiersza poleceń, połącz je z istniejącym już elementem i utwórz w nim nowe okno (zgodnie z zasadami FTD Commissioner):

$ screen -r

Utwórz nowe okno na ekranie za pomocą skrótu Ctrl+a → c.

Pojawi się nowy wiersz polecenia. Otwórz interfejs wiersza poleceń OpenThread dla dołączenia do FTD:

$ screen /dev/ttyACM2 115200

W nowym oknie naciśnij kilka razy klawisz Enter na klawiaturze, aby wyświetlić monit OpenLI CLI >. Wyświetl interfejs IPv6 i sprawdź adresy:

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

Teraz interfejs wiersza poleceń FTD Joinal znajduje się w tym samym wystąpieniu ekranu, co FTD Komisarz. Możesz przełączać się między nimi, naciskając Ctrl+a → n.

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 z wątkami, więc wszystkie powinny być aktywne i łatwo dostępne. Do tej pory korzystaliśmy z ekranu, aby mieć dostęp do dwóch funkcji FTD. Narzędzie to umożliwia także dzielenie ekranu na tym samym oknie terminala. Dzięki temu zobaczysz, jak jeden węzeł reaguje na polecenia wydane w innym.

Najlepiej, gdyby okno było łatwo dostępne:

  1. Usługa / ot-daemon / logi
  2. Połączenie RCP z ot-ctl
  3. FTD Commissioner przez OpenThread CLI
  4. FTD Joiner – interfejs wiersza poleceń OpenThread

Jeśli chcesz użyć własnej konfiguracji terminala lub portu szeregowego, przejdź do następnego kroku. Skonfiguruj okna terminala dla wszystkich urządzeń w sposób, który najbardziej Ci odpowiada.

Korzystanie z ekranu

Aby wygodnie korzystać z urządzenia, rozpocznij tylko jedną sesję ekranu. Powinien on być już zarejestrowany w obu przypadkach.

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

Podstawowe polecenia na ekranie:

Ponowne dołączenie do sesji ekranu (z poziomu wiersza poleceń)

screen -r

Opuść sesję Ekran

Ctrl+A → d

Tworzenie nowego okna w ramach sesji Ekran

Ctrl+A → c

Przełączanie okien między tą samą sesją ekranu

Ctrl+a → n (do przodu)Ctrl+a → p (wstecz)

Zamknij bieżące okno sesji ekranu

Ctrl+A → k

Podziel ekran

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

f1cbf1258cf0a5a.png

Polecenia w języku screen są dostępne po naciśnięciu klawiszy Ctrl+a. Każde polecenie powinno zaczynać się od tej kombinacji klucza dostępu.

Jeśli będziesz dokładnie śledzić ćwiczenia z programowania, w tej samej instancji ekranu powinny znajdować się 2 okna (komisarz FTD i łącznik FTD). Aby podzielić ekran między te dwa urządzenia, najpierw otwórz istniejącą sesję:

$ screen -r

Musisz być na jednym z urządzeń FTD. Wykonaj te czynności na ekranie:

  1. Aby podzielić okno w poziomie, naciśnij Ctrl + A → S
  2. Ctrl + → Tab, by przenieść kursor do nowego pustego okna
  3. Naciśnij Ctrl + → n, aby przełączyć to okno na następne
  4. Jeśli jest taka sama jak górne okno, naciśnij Ctrl+a → n, by wyświetlić inne urządzenie FTD.

Oba te elementy są teraz widoczne. Aby się między nimi przełączać, naciśnij Ctrl+a → Tab. Zalecamy zmianę nazwy każdego okna za pomocą skrótu Ctrl+a → A, by uniknąć nieporozumień.

Zaawansowane użycie

Aby dalej podzielić ekran na kwadraty i wyświetlić logi ot-daemon oraz narzędzie do łączenia RCP ot-ctl, usługi te muszą być uruchomione w tej samej instancji Screen. Aby to zrobić, zatrzymaj ot-daemon i zamknij ot-ctl, a następnie uruchom je ponownie w nowych oknach ekranu (Ctrl+a → c).

Ta konfiguracja nie jest wymagana i pozostaje tylko ćwiczeniami dla użytkownika.

Podział i nawigowanie między oknami za pomocą następujących poleceń:

Utwórz nowe okno

Ctrl+A → c

Podziel okno pionowo

Ctrl+A →

Podziel okno poziomo

Ctrl+A → S

Przejdź do następnego wyświetlonego okna

Ctrl+A → Tab

Przełącz wyświetlone okno do przodu lub do tyłu

Ctrl+a → n lub p

Zmień nazwę bieżącego okna

Ctrl+A → A

W dowolnym momencie możesz opuścić ekran, naciskając Ctrl+a → d, i ponownie dołączyć polecenie screen -r przy użyciu wiersza poleceń.

Więcej informacji o ekranie znajdziesz w krótkim przewodniku o ekranie GNU.

7. Tworzenie sieci wątków

Po skonfigurowaniu wszystkich okien terminali i ekranów zajmijmy się siecią wątków. W FTD Komisarze utwórz nowy zbiór danych operacyjnych i zatwierdź go jako aktywny. Zbiór danych operacyjnych to konfiguracja tworzonej sieci wątków.

## 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 zostanie użyty później.

Zaakceptuj ten zbiór danych jako aktywny:

> dataset commit active
Done

Wyświetl interfejs IPv6:

> ifconfig up
Done

Rozpocznij operację protokołu w wątku:

> thread start
Done

Po chwili sprawdź stan urządzenia. Musi to być Lider. Prosimy także o udostępnienie RLOC16 na przyszłość.

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

> state
leader
Done
> rloc16
0c00
Done

Sprawdź adresy IPv6 urządzenia:

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

> ipaddr
fdc0:de7a:b5c0:0:0:ff:fe00:fc00        # Leader Anycast Locator (ALOC)
fdc0:de7a:b5c0:0:0:ff:fe00:c00         # Routing Locator (RLOC)
fdc0:de7a:b5c0:0:6394:5a75:a1ad:e5a    # Mesh-Local EID (ML-EID)
fe80:0:0:0:1cd6:87a9:cb9d:4b1d         # Link-Local Address (LLA)

Sieć „codewiczenia z programowania” jest teraz widoczna podczas skanowania z innych urządzeń typu Thread.

Od ot-ctl przy użyciu łącznika RCP:

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

> scan
| J | Network Name     | Extended PAN     | PAN  | MAC Address      | Ch | dBm | LQI |
+---+------------------+------------------+------+------------------+----+-----+-----+
| 0 | OpenThread-c0de  | c0de7ab5c0de7ab5 | c0de | 1ed687a9cb9d4b1d | 11 | -36 | 232 |

W interfejsie wiersza poleceń OpenThread na stronie FTD Joiner:

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

> scan
| J | Network Name     | Extended PAN     | PAN  | MAC Address      | Ch | dBm | LQI |
+---+------------------+------------------+------+------------------+----+-----+-----+
| 0 | OpenThread-c0de  | c0de7ab5c0de7ab5 | c0de | 1ed687a9cb9d4b1d | 11 | -38 | 229 |

Jeśli na liście nie ma sieci „laboratorium”, spróbuj ponownie zeskanować.

Zauważ, że w obu operacjach sieci nie można dołączyć (kolumna J w złączu RCP i złączu FTD). Oznacza to tylko, że przekazywanie wątków nie jest aktywne w sieci. Nadal można połączyć go poza pasmem, wpisując ręcznie klucz sieci w aplikacji łączącej.

8. Dodaj narzędzie RCP

Dodajmy scalający RCP do utworzonej przed chwilą sieci wątków przy użyciu procesu spoza pasma. Wyszukaj sieci przy użyciu łącznika RCP:

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

> scan
| J | Network Name     | Extended PAN     | PAN  | MAC Address      | Ch | dBm | LQI |
+---+------------------+------------------+------+------------------+----+-----+-----+
| 0 | OpenThread-c0de  | c0de7ab5c0de7ab5 | c0de | 1ed687a9cb9d4b1d | 11 | -38 | 229 |

Aby dołączyć, ustaw klucz sieciowy (uzyskany właśnie od komisarza FTD) dla usługi łączącej RCP w aktywnym zbiorze danych.

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

> dataset networkkey 1234c0de7ab51234c0de7ab51234c0de
Done
> dataset commit active
Done

Sprawdź, czy zbiór danych jest poprawnie skonfigurowany.

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

> dataset
Network Key: 1234c0de7ab51234c0de7ab51234c0de

Wyświetl wątek, aby narzędzie RCP Joint dołączył do sieci „laboratorium”. Zaczekaj kilka sekund. Sprawdź stan, RLOC16 i adresy IPv6:

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

> thread start
Done
> state
child
Done
> rloc16
0c01
Done
> ipaddr
fdc0:de7a:b5c0:0:0:ff:fe00:0c01         # Routing Locator (RLOC)
fdc0:de7a:b5c0:0:66bf:99b9:24c0:d55f    # Mesh-Local EID (ML-EID)
fe80:0:0:0:18e5:29b3:a638:943b          # Link-Local Address (LLA)
Done

Zanotuj lokalny adres IPv6 sieci Mesh (tutaj fdc0:de7a:b5c0:0:66bf:99b9:24c0:d55f), ponieważ użyjesz go później.

Wróć do tabeli FTD Commissioner. Sprawdź w routerze i tabelach podrzędnych, czy 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 typu RCP Joiner (adres sieci typu mesh uzyskany z danych wyjściowych ipaddr połączenia 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

Sieć wątków składa się teraz z 2 węzłów, jak widać na tym diagramie topologii:

otcodelab_top01C_2węzły.png

Diagramy topologii

W trakcie pozostałych ćwiczeń z programowania za każdym razem, gdy zmieni się stan sieci, wyświetlimy nowy schemat topologii wątków. Role węzłów są oznaczane w ten sposób:

b75a527be4563215.png

Routery to zawsze pięciokąty, a urządzenia końcowe to zawsze kręgi. Wartości w każdym węźle to identyfikator routera lub identyfikatora podrzędnego wyświetlany w danych wyjściowych wiersza poleceń, w zależności od bieżącej roli i stanu każdego węzła.

9. Prowizja do łącznika FTD

Dodajmy trzecie urządzenie Thread do sieci „codelab”. Tym razem zamierzamy skorzystać z bezpieczniejszego prowizji w paśmie. Na FTD Joiner wyszukaj sieć:

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

> scan
| J | Network Name     | Extended PAN     | PAN  | MAC Address      | Ch | dBm | LQI |
+---+------------------+------------------+------+------------------+----+-----+-----+
| 0 | OpenThread-c0de  | c0de7ab5c0de7ab5 | c0de | f65ae2853ff0c4e4 | 11 | -36 |  57 |

Wartość 0 w kolumnie J oznacza, że prowizja na wątki nie jest aktywna na urządzeniu.

W kolejnym uruchomieniu urządzenia określ konkretne opcje i dołącz do FTD Joiner. Pozostań przy uczestniku FTD i uzyskaj identyfikator eui64, aby komisarz FTD mógł go rozpoznać:

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

> eui64
2f57d222545271f1
Done

W FTD Komisarze uruchom komisarza i wskaż eui64 urządzenia, które może dołączyć, razem z danymi logowania dla uczestnika, np. J01NME. Dane logowania łączącego to przypisany do urządzenia ciąg znaków alfanumerycznych (0–9 i AY, z wyjątkiem I, O, Q i Z, który można odczytać) o długości od 6 do 32 znaków.

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

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

Przejdź do łącznika FTD i ponownie zeskanuj:

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

> scan
| J | Network Name     | Extended PAN     | PAN  | MAC Address      | Ch | dBm | LQI |
+---+------------------+------------------+------+------------------+----+-----+-----+
| 1 | OpenThread-c0de  | c0de7ab5c0de7ab5 | c0de | 1ed687a9cb9d4b1d | 11 | -45 | 196 |

Jak wskazuje 1 w kolumnie J, prowizja na wątki jest teraz aktywna w sieci. Zacznij od dołączenia do spotkania za pomocą danych uwierzytelniających, które zostały skonfigurowane przez Ciebie w komisarze FTD:

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

> ifconfig up
Done
> joiner start J01NME
Done

Po około minuty otrzymasz potwierdzenie pomyślnego uwierzytelnienia:

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

>
Join success

Otwórz Thread, aby złącznik FTD dołączył do sieci „codelab” i natychmiast sprawdź stan i RLOC16:

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

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

Sprawdź adresy IPv6 urządzenia. Zwróć uwagę na brak ALOC. Dzieje się tak, ponieważ to urządzenie nie jest liderem ani nie ma żadnej roli specyficznej dla Castcast, która wymaga ALOC.

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

> ipaddr
fdc0:de7a:b5c0:0:0:ff:fe00:c02         # Routing Locator (RLOC)
fdc0:de7a:b5c0:0:3e2e:66e:9d41:ebcd    # Mesh-Local EID (ML-EID)
fe80:0:0:0:e4cd:d2d9:3249:a243         # Link-Local Address (LLA)

Natychmiast przejdź do komisarza FTD i sprawdź tabele routera i podrzędnego, by upewnić się, że trzy urządzenia znajdują się w sieci „codelab”:

## 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 program FTD Joiner dołączył do sieci jako urządzenie końcowe (podrzędne). Nasza zaktualizowana topologia:

otcodelab_top01C_ed01.png

10. Wątek w działaniu

Urządzenia z wątkami w tym ćwiczeniu z programowania to rodzaj urządzenia FTD (Full Thread Device) zwanego urządzeniem końcowym routera (REED). Oznacza to, że mogą one działać jako router lub urządzenie końcowe i promować się z urządzenia końcowego na router.

Wątek może obsługiwać do 32 routerów, ale stara się utrzymać liczbę routerów od 16 do 23. Jeśli REED dołączy jako urządzenie końcowe (dziecko) i liczba routerów będzie niższa niż 16, po losowym okresie w ciągu 2 minut automatycznie promuje się on w routerze.

Jeśli po dodaniu usługi FTD Joiner masz dwójkę dzieci, poczekaj co najmniej 2 minuty, a potem ponownie sprawdź router i tabele podrzędne w komunikacie 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 (Extended MAC = e6cdd2d93249a243) przeniósł się do routera. Pamiętaj, że RLOC16 jest inny (b800 zamiast 0c02). Dzieje się tak, ponieważ RLOC16 jest oparty na identyfikatorze routera i identyfikatorze podrzędnym urządzenia. Po przejściu z urządzenia końcowego na router zmienia się jego identyfikator routera i identyfikatora podrzędnego, a także RLOC16.

otcodelab_top01C.png

Potwierdź nowy stan i RLOC16 w łączniku FTD:

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

> state
router
Done
> rloc16
b800
Done

Przechodzenie na wyższy łącznik FTD

Możesz przetestować to zachowanie, ręcznie przechodząc na niższą wersję FTD Joiner z routera na urządzenie końcowe. Zmień stan na podrzędny i sprawdź RLOC16:

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

> state child
Done
> rloc16
0c03
Done

otcodelab_top01C_ed02.png

Zgodnie z komisarzem FTD w tabeli podrzędnej powinien być teraz widoczny łącznik FTD (identyfikator = 3). W trakcie przenoszenia może znajdować się nawet w obu tych 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 Urządzenie przełączy się z powrotem na router o wartości RLOC wynoszącej b800.

otcodelab_top01C.png

Usuń lidera

Lider jest wybierany samodzielnie przez wszystkie routery wątków. Oznacza to, że jeśli bieżący lider zostanie usunięty z sieci wątków, jeden z innych routerów stanie się nowym liderem.

W sekcji FTD Commissioner wyłącz wątek, aby usunąć go z sieci wątków:

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

> thread stop
Done
> ifconfig down
Done

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

otcodelab_top02C_01.png

Sprawdź tabelę podrzędną. Zwróć uwagę na nowy RLOC16. Jest to złącze RCP wskazane przez identyfikator i rozszerzone adresy MAC. Aby zachować połączenie sieci nici, przełączyliśmy nadrzędne routery z komisarza FTD do usługi łączącej FTD. Spowoduje to utworzenie nowego RLOC16 dla programu łączącego numery RCP (ponieważ zmieniono jego router z 3 do 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

Poczekaj min. Sprawdź stan i RLOC16, aby upewnić się, że:

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

> state
child
> rloc16
b801

Dołączanie komisarza FTD

Sieć wątkowa z 2 węzłami nie jest zbyt dobra. Wróćmy do komisji FTD online.

Na stronie FTD Commissioner ponownie uruchom wątek:

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

> ifconfig up
Done
> thread start
Done

W ciągu 2 minut automatycznie łączy się on z siecią „laboratorium” jako urządzenie końcowe i przekazuje się do routera.

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

> state
router
Done

Aby sprawdzić, czy router i tabele podrzędne są połączone przy użyciu FTD Joiner, wykonaj te czynności:

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

otcodelab_top02C_02.png

Nasza sieć wątków ponownie składa się z 3 węzłów.

11. Rozwiązywanie problemów

Zarządzanie siecią wątkową z wieloma urządzeniami w różnych oknach terminala lub ekranie może być trudne. Skorzystaj z tych wskazówek, by zresetować stan sieci lub obszaru roboczego, jeśli napotkasz problemy.

Ekran

Jeśli w Twojej konfiguracji wystąpi któryś z nich (zbyt wiele okien lub ekranów na ekranie), staraj się zabijać okna za pomocą skrótu Ctrl+a → k, aż żadne nie pojawi się, a screen -ls w wierszu polecenia wpisz No Sockets found. Następnie utwórz ponowne okna dla każdego urządzenia. Stany urządzenia są zachowywane nawet po zamknięciu ekranu.

Węzły wątków

Jeśli topologia sieci wątków nie jest zgodna z opisem w tym ćwiczeniach lub węzły z jakiegoś powodu się rozłączają (na przykład komputer z systemem Linux obsługującym przejście w tryb uśpienia), najlepiej jest usunąć Thread, wyczyścić dane logowania do sieci i zacząć od nowaTworzenie sieci wątków kroku.

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 trybu multicast

Multicast służy do przekazywania informacji do grupy urządzeń jednocześnie. W sieci wątków konkretne adresy są zarezerwowane do użycia w multicastie z różnymi grupami urządzeń, w zależności od zakresu.

Adres IPv6

Scope (Zakres),

Dostarczono do

ff02::1

Link lokalny

Wszystkie wnioski FTD i MED

ff02::2

Link lokalny

Wszystkie routery FTD i Border Router

ff03::1

Siatki lokalne

Wszystkie wnioski FTD i MED

ff03::2

Siatki lokalne

Wszystkie routery FTD i Border Router

Ponieważ w tym ćwiczeniach w programie nie używamy routera Border, skupmy się na dwóch adresach multicast w FTD i MED.

Zakres linku lokalnego obejmuje wszystkie interfejsy wątków, do których można uzyskać dostęp za pomocą pojedynczej transmisji radiowej lub pojedynczego przeskoku. Topologia sieci określa, które urządzenia reagują na ping na adres grupowy 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 działają 2 inne urządzenia (złącze FTD i złącze RCP), ale komisarz FTD otrzymał tylko 1 odpowiedź z adresu lokalnego (LLA) firmy FTD. Oznacza to, że złącze FTD to jedyne urządzenie, do którego może dotrzeć jeden komisarz.

otcodelab_top02C_02_LL.png

Następnie pingujesz użytkownika ff02::1 z łą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 dla innych urządzeń widzimy pierwszy (zakończony na 4b1d) w języku LLA komisji FTD, a drugi (zakończony na 943b) to LLA dla złącza RCP.

otcodelab_top02C_02_LL02.png

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

Siatki lokalne

Zakres siatki lokalnej obejmuje wszystkie interfejsy wątków, do których można dotrzeć w tej samej sieci wątków. Zobaczmy odpowiedzi na ping na adres grupowy 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ł dwie odpowiedzi – jedną od lokalizatora tras FTD Joiner RL Locator (RLOC z końcem „b800”) i 1 identyfikatora Mesh-Local EID (ML-EID) RCP Joiner, który kończy się cyframi d55f. Dzieje się tak, ponieważ zakres „lokalna sieć typu mesh” obejmuje całą sieć wątków. Urządzenie otrzyma adres ff03::1 niezależnie od tego, gdzie w tej sieci jest urządzenie.

otcodelab_top02C_02_ML.png

Aby potwierdzić to samo zachowanie, wyślij polecenie ff03::1 z łącznika FTD.

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

otcodelab_top02C_02_LL02.png

Zwróć uwagę na czas odpowiedzi narzędzia RCP Joiner w obu wyjściach ping. Łącznik RCP dotarł do komisji FTD (68 ms) znacznie dłużej niż w przypadku łącznika FTD (23 ms). To dlatego, że do komisarza FTD muszą trafiać 2 przeskoczenia, w przeciwieństwie do 1 przeskoku w przypadku sprzedawcy FTD.

Zwróć uwagę, że ping wielopoziomowy typu mesh-local odpowiadał za pomocą RLOC tylko w przypadku dwóch FTD, a nie RCP Joiner. Wynika to z faktu, że 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 aplikacji, które udostępnia OpenThread, jest protokół User Datagram Protocol (UDP), Transport Layer Protocol. Aplikacja oparta na OpenThread może użyć interfejsu UDP API do przekazywania wiadomości między węzłami w sieci wątkiu lub do innych urządzeń w sieci zewnętrznej (np. internetu, jeśli sieć wątków ma router Border).

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

Uzyskaj adres e-mail sieci Mesh-Local EID dla łącznika FTD. Używamy tego adresu, ponieważ jest osiągalny z dowolnego miejsca w sieci wątków.

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

Utwórz UDP i połącz z gniazdkiem 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 utworzonym przez 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

Połączenie UDP powinno być aktywne między dwoma węzłami. Wyślij wiadomość 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!

Masz fizyczną sieć wątków.

b915c433e7027cc7.png

Teraz już wiesz:

  • Różnica między rodzajami urządzeń, rolami i zakresami wątków
  • jak urządzenia Threads zarządzają stanami w sieci,
  • jak przekazywać proste wiadomości między węzłami za pomocą UDP

Co dalej

W ramach ćwiczeń z programowania wykonaj te ćwiczenia:

  • Przekształć tablicę złączową FTD jako MTD przy użyciu pliku binarnego ot-cli-mtd i zauważ, że nigdy nie uaktualnia się do routera ani nie próbuje zostać liderem
  • Dodaj więcej urządzeń (wypróbuj inną platformę) do sieci i zarysuj topologię, korzystając z tabel i routerów podrzędnych oraz pingów do adresów grupowych.
  • Kontroluj NCP za pomocą pyspinela
  • Konwertuj NCP na router Border za pomocą routera Border wątki i połącz sieć Thread z internetem

Więcej informacji

W witrynach openthread.io i GitHub znajdziesz różne zasoby OpenThread, w tym:

  • Obsługiwane platformy – odkrywaj wszystkie platformy, które obsługują OpenThread.
  • Build OpenOpen – więcej informacji o tworzeniu i konfigurowaniu OpenOpen
  • Primer Thread – obejmuje wszystkie koncepcje związane z wątkami opisane w tych ćwiczeniach z programowania

Dokumentacja źródłowa: