Google używa technologii AI do tłumaczenia treści na Twój preferowany język. Tłumaczenia wygenerowane przez AI mogą zawierać błędy.

Tworzenie sieci typu Thread za pomocą platformy B91 Development Board i OpenThread

1. Wprowadzenie

OpenThread to implementacja open source protokołu sieciowego Thread®, który jest niezawodnym i bezpiecznym protokołem bezprzewodowej sieci kratowej przeznaczonym dla urządzeń internetu rzeczy (IoT). OpenThread został opracowany przez zespół Nest w Google i jest bezpłatnie dostępny dla społeczności programistów jako projekt open source.

Specyfikacja Thread określa niezawodny, bezpieczny i energooszczędny protokół komunikacji bezprzewodowej dla urządzeń o ograniczonych zasobach, które są powszechnie używane w inteligentnych domach i budynkach komercyjnych. OpenThread obejmuje pełny zakres warstwy sieciowej w protokole Thread, np. IPv6, 6LoWPAN, IEEE 802.15.4 z zabezpieczeniami MAC, tworzenie połączeń w sieci mesh i routing w sieci mesh.

Firma Telink zintegrowała implementację OpenThread z systemem operacyjnym czasu rzeczywistego Zephyr, co zapewnia pełną zgodność ze sprzętem Telink. Kod źródłowy tej integracji jest łatwo dostępny na GitHub i jest też udostępniany jako pakiet SDK.

Z tego ćwiczenia dowiesz się, jak zaprogramować OpenThread na rzeczywistym sprzęcie, utworzyć sieć Thread i zarządzać nią oraz wymieniać wiadomości między węzłami. Ilustracja poniżej przedstawia konfigurację sprzętu, w tym router graniczny OT (OTBR) i 1 urządzenie Thread w ramach laboratorium.

Czego się nauczysz

Aby skonfigurować implementację OpenThread za pomocą środowiska programistycznego Telink Zephyr.
Aby skompilować przykłady interfejsu wiersza poleceń OpenThread (ot-cli-ftd i ot-rcp) i wgrać je na płytki deweloperskie Telink B91.
Aby skonfigurować router graniczny OpenThread (OTBR) za pomocą Dockera na Raspberry Pi 3B+ lub nowszym.
Aby utworzyć sieć Thread na OTBR:
Aby dodawać urządzenia do sieci Thread za pomocą debugowania poza pasmem.
Aby sprawdzić połączenie między węzłami w sieci Thread za pomocą interfejsu wiersza poleceń:

Czego potrzebujesz

Sprzęt:

2 płytki rozwojowe B91.
Raspberry Pi 3B+ lub nowszy z obrazem systemu operacyjnego Raspbian.
Komputer z Linuksem z co najmniej 2 portami USB.
Przełącznik (lub router) z dostępem do internetu i kilka kabli Ethernet.

Oprogramowanie:

Narzędzie do wypalania i debugowania Telink – LinuxBDT.
Narzędzie terminala portu szeregowego, np. PuTTY.
Inne narzędzia, takie jak Git i West.

2. Wymagania wstępne

Pojęcia związane z Thread i interfejs wiersza poleceń OpenThread

Zanim zaczniesz wykonywać zadania z tego ćwiczenia, warto zapoznać się z podstawowymi pojęciami dotyczącymi protokołu Thread i interfejsu wiersza poleceń OpenThread, wykonując ćwiczenie z programowania dotyczące symulacji OpenThread.

Komputer z systemem Linux

Urządzenie z systemem Linux (Ubuntu w wersji 20.04 LTS lub nowszej) pełni funkcję maszyny kompilującej, na której można skonfigurować środowisko programistyczne Telink Zephyr i flashować wszystkie płytki deweloperskie Thread. Aby wykonać te zadania, urządzenie z systemem Linux musi mieć 2 dostępne porty USB i połączenie z internetem.

Połączenie portu szeregowego i terminale

Możesz podłączyć urządzenie bezpośrednio do portu USB na komputerze z Linuksem. Do uzyskania dostępu do urządzeń potrzebne będzie też narzędzie terminala portu szeregowego.

W tym ćwiczeniu do sterowania urządzeniem FTD Joiner i Raspberry Pi używane jest narzędzie terminalowe PuTTY. Zawiera on omówienie jego użycia, ale można też używać innego oprogramowania terminala.

Zestaw deweloperski Telink B91

To ćwiczenie wymaga 2 zestawów deweloperskich B91. Na zdjęciu poniżej widać minimalny zestaw wymaganych komponentów.

Jeden z tych zestawów będzie używany jako RCP (Radio Co-Processor), a drugi jako FTD (Full Thread Device). Jeśli nie masz jeszcze zestawu, więcej informacji znajdziesz na oficjalnej stronie Telink. Oto niektóre komponenty, których możesz użyć:

Indeks	Nazwa
1	Płytka rozwojowa Telink B91
2	Telink Burning Board
3	Antena 2,4 GHz
4	Kabel USB (USB-A na mini USB)

Raspberry Pi 3B+ lub nowszy z obrazem systemu operacyjnego Raspbian

W tym laboratorium potrzebny jest Raspberry Pi 3B+ lub nowszy z obrazem systemu operacyjnego Raspbian Bullseye Lite lub Raspbian Bullseye z Desktop. Jest połączony z internetem przez Ethernet i będzie skonfigurowany jako host dla routera granicznego OpenThread (OTBR).

Połączenie sieciowe

Przełącznik (lub router) z dostępem do internetu i kilka kabli Ethernet. Służą one do łączenia Raspberry Pi z komputerem z systemem Linux, co ułatwia użytkownikowi konfigurowanie Raspberry Pi za pomocą hosta.

LinuxBDT

Telink Burning and Debugging Tool (BDT), które ma zastosowanie do wszystkich serii układów Telink, umożliwia wymazywanie i flashowanie oprogramowania OpenThread na płytach deweloperskich Telink B91. Zainstaluj na komputerze z Linuksem wersję linuxBDT dla Linuksa opartego na architekturze X86.

Inne

Git do konfigurowania środowiska programistycznego Telink Zephyr.
West do zarządzania projektem Zephyr i kompilowania plików binarnych OpenThread.

3. Konfigurowanie oprogramowania układowego

Konfigurowanie środowiska programistycznego Telink Zephyr

Na komputerze z Linuksem otwórz terminal interfejsu wiersza poleceń i zacznij od wykonania tych poleceń, aby upewnić się, że APT jest aktualny.

$ sudo apt update
$ sudo apt upgrade

Gdy to zrobisz, wykonaj te czynności.

Zainstaluj zależności.

$ wget https://apt.kitware.com/kitware-archive.sh
$ sudo bash kitware-archive.sh
$ sudo apt install --no-install-recommends git cmake ninja-build \
gperf ccache dfu-util device-tree-compiler python3-dev python3-pip \
python3-setuptools python3-tk python3-wheel xz-utils file make gcc \
gcc-multilib g++-multilib libsdl2-dev

Zephyr wymaga obecnie minimalnych wersji głównych zależności, takich jak CMake (3.20.0), Python3 (3.6) i Devicetree Compiler (1.4.6).

$ cmake --version
$ python3 --version
$ dtc --version

Zanim przejdziesz do następnych kroków, sprawdź zainstalowane wersje w systemie. Jeśli wersje są nieprawidłowe, przełącz serwer APT na stabilny i aktualny serwer lub ręcznie zaktualizuj te zależności.

Zainstaluj na zachodzie.

$ pip3 install --user -U west
$ echo 'export PATH=~/.local/bin:"$PATH"' >> ~/.bashrc
$ source ~/.bashrc

Upewnij się, że ~/.local/bin znajduje się w zmiennej środowiskowej $PATH.

Pobierz kod źródłowy projektu Zephyr.

$ west init ~/zephyrproject
$ cd ~/zephyrproject
$ west update
$ west blobs fetch hal_telink
$ west zephyr-export

Zainstaluj dodatkowe zależności Pythona dla Zephyr.

$ pip3 install --user -r ~/zephyrproject/zephyr/scripts/requirements.txt

Skonfiguruj łańcuch narzędzi Zephyr. Pobierz łańcuch narzędzi Zephyr (około 1–2 GB) do katalogu lokalnego, aby móc flashować większość płytek.

$ wget https://github.com/zephyrproject-rtos/sdk-ng/releases/download/v0.16.1/zephyr-sdk-0.16.1_linux-x86_64.tar.xz
$ wget -O - https://github.com/zephyrproject-rtos/sdk-ng/releases/download/v0.16.1/sha256.sum | shasum --check --ignore-missing

Pobierz pakiet Zephyr SDK i umieść go w zalecanej ścieżce, jak pokazano poniżej.

$HOME/zephyr-sdk[-x.y.z]
$HOME/.local/zephyr-sdk[-x.y.z]
$HOME/.local/opt/zephyr-sdk[-x.y.z]
$HOME/bin/zephyr-sdk[-x.y.z]
/opt/zephyr-sdk[-x.y.z]
/usr/zephyr-sdk[-x.y.z]
/usr/local/zephyr-sdk[-x.y.z]

gdzie [-x.y.z] to tekst opcjonalny, który może być dowolnym tekstem, np. -0.16.1. Po zainstalowaniu pakietu SDK nie można przenieść katalogu. Następnie zainstaluj łańcuch narzędzi Zephyr.

$ tar xvf zephyr-sdk-0.16.1_linux-x86_64.tar.xz
$ cd zephyr-sdk-0.16.1
$ ./setup.sh -t riscv64-zephyr-elf -h -c

Zbuduj przykład Hello World. Najpierw sprawdź, czy oficjalna konfiguracja projektu Zephyr jest prawidłowa, korzystając z przykładu Hello World, a następnie skonfiguruj projekt niestandardowy.
```
$ cd ~/zephyrproject/zephyr
$ west build -p auto -b tlsr9518adk80d samples/hello_world
```
Użyj polecenia West build, aby utworzyć przykład hello_world z katalogu głównego repozytorium Zephyr. Oprogramowanie o nazwie zephyr.bin znajdziesz w sekcji build/zephyr directory.

Dodaj skrypt środowiska Zephyr do ~/.bashrc. Uruchom te polecenia.

$ echo "source ~/zephyrproject/zephyr/zephyr-env.sh" >> ~/.bashrc
$ source ~/.bashrc

Dodaj zdalne repozytorium Telink Zephyr. Pobierz lokalnie repozytorium Telink jako gałąź deweloperską i zaktualizuj je.

$ cd ~/zephyrproject/zephyr
$ git remote add telink-semi https://github.com/telink-semi/zephyr
$ git fetch telink develop
$ git checkout develop
$ west update
$ west blobs fetch hal_telink

Więcej informacji znajdziesz w przewodniku dla początkujących Zephyr Doc.

Konfigurowanie Telink LinuxBDT

Pobierz narzędzie Telink LinuxBDT i wyodrębnij je do lokalnego katalogu na komputerze z systemem Linux, np. do katalogu domowego ~, aby umożliwić flashowanie oprogramowania na płytce deweloperskiej B91.

$ cd ~
$ wget http://wiki.telink-semi.cn/tools_and_sdk/Tools/BDT/LinuxBDT.tar.bz2
$ tar -vxf LinuxBDT.tar.bz2

Podłącz Burning Board do komputera z Linuksem za pomocą interfejsu USB, a następnie wpisz te polecenia.

$ cd LinuxBDT
$ sudo ./bdt lsusb -v
Bus 002 Device 001: ID 1d6b:0003 xHCI Host Controller
Bus 001 Device 003: ID 0bda:565a Integrated_Webcam_HD
Bus 001 Device 023: ID 413c:301a Dell MS116 USB Optical Mouse
Bus 001 Device 037: ID 248a:826a Telink Web Debugger v3.6
Bus 001 Device 001: ID 1d6b:0002 xHCI Host Controller

Jeśli zobaczysz komunikat „Telink Web Debugger v3.6”, oznacza to, że programator BDT połączył się z maszyną z systemem Linux.

Kompilacja oprogramowania układowego

W tym laboratorium utworzymy 2 rodzaje oprogramowania OpenThread:

ot-cli-ftd,
i ot-rcp.

Metody kompilacji są następujące:

Radio Co-Processor（ot-rcp)

$ cd ~/zephyrproject
$ rm -rf build_ot_coprocessor
$ west build -b tlsr9518adk80d -d build_ot_coprocessor zephyr/samples/net/openthread/coprocessor -- -DDTC_OVERLAY_FILE="usb.overlay" -DOVERLAY_CONFIG=overlay-rcp-usb-telink.conf

W pełni funkcjonalne urządzenie Thread z interaktywnym wierszem poleceń (ot-cli-ftd)

$ cd ~/zephyrproject
$ rm -rf build_ot_cli_ftd
$ west build -b tlsr9518adk80d -d build_ot_cli_ftd zephyr/samples/net/openthread/cli -- -DOVERLAY_CONFIG=overlay-telink-fixed-mac.conf -DCONFIG_OPENTHREAD_FTD=y

Flashowanie oprogramowania układowego

Podłącz płytkę deweloperską B91 do płytki programującej za pomocą kabla USB, jak pokazano na ilustracji poniżej.

W wierszu poleceń wykonaj te polecenia, aby przeprowadzić flashowanie oprogramowania sprzętowego (na przykładzie flashowania oprogramowania ot-cli-ftd).

$ cd ~/zephyrproject/build_ot_cli_ftd/zephyr
$ cp zephyr.bin ~/LinuxBDT/bin/ot-cli-ftd.bin
$ cd ~/LinuxBDT
$ sudo ./bdt 9518 ac
 Activate OK!
$ sudo ./bdt 9518 wf 0 -i bin/ot-cli-ftd.bin
 EraseSectorsize...
 Total Time: 2181 ms
 Flash writing...
 [100%][-] [##################################################]
 File Download to Flash at address 0x000000: 491700 bytes
 Total Time: 30087 ms

Metoda flashowania w przypadku ot-rcp jest w zasadzie taka sama jak w przypadku ot-cli-ftd. Ścieżki i nazwy oprogramowania sprzętowego różnią się jednak od siebie.

Po flashowaniu odróżnij 2 płytki deweloperskie B91, oznaczając je odpowiednio. Oznacz tablicę z ot-cli-ftd jako „FTD Joiner”, a tablicę z ot-rcp jako „RCP”.

4. Konfigurowanie konsoli szeregowej na urządzeniu przyłączającym FTD

Jak pokazano na ilustracji, podłącz złącze FTD bezpośrednio do portu USB urządzenia z systemem Linux.

Po podłączeniu urządzenia FTD Joiner do komputera z systemem Linux otwórz PuTTY. Następnie utwórz nowy terminal, ustaw informacje o porcie szeregowym i otwórz port szeregowy.

Dokumentacja wiersza poleceń OpenThread jest dostępna tutaj: OpenThread CLI Reference (Dokumentacja wiersza poleceń OpenThread). Pamiętaj, aby przed każdym poleceniem wpisać znak ot.

Przykłady:

> ot state
disabled
Done
> ot channel
11
Done
>

5. Konfigurowanie Raspberry Pi jako routera granicznego OpenThread

Router graniczny OpenThread to urządzenie składające się z 2 głównych części:

Raspberry Pi zawiera wszystkie usługi i oprogramowanie sprzętowe wymagane do działania jako router brzegowy (BR).
Za komunikację w sieci Thread odpowiada RCP.

Radio Co-Processor（RCP）

Aby wgrać oprogramowanie układowe ot-rcp, wykonaj te same czynności co w przypadku oprogramowania układowego ot-cli-ftd. Podłącz płytkę deweloperską B91 do portu USB na Raspberry Pi, jak pokazano na ilustracji poniżej.

Raspberry Pi

Sprawdź, czy obraz systemu operacyjnego Raspbian Bullseye Lite lub Raspbian Bullseye z desktopem został prawidłowo zapisany na karcie SD.
Możesz połączyć się z Raspberry Pi za pomocą SSH lub pracować bezpośrednio na pulpicie Raspbian. W tym laboratorium użyjemy SSH.
Zanim przejdziesz do instalacji OTBR Dockera w następnym kroku, najpierw zaktualizuj lokalne repozytorium i menedżera pakietów.
```
$ sudo apt-get update
$ sudp apt-get upgrade
```

Zainstaluj Dockera

Jeśli w poprzednim kroku zaktualizujesz tylko lokalne repozytorium i menedżera pakietów APT, uruchom ponownie Raspberry Pi, a następnie otwórz okno terminala SSH.

Zainstaluj Dockera:

$ curl -sSL https://get.docker.com | sh

Umieść bieżące konto w grupie Docker, aby przyznać uprawnienia, dzięki czemu przed każdym poleceniem nie trzeba będzie dodawać znaku sudo.
```
$ sudo usermod -aG docker $USER
```
Aby zmiany zostały zastosowane, musisz ponownie uruchomić Raspberry Pi.
Jeśli Docker nie został uruchomiony, uruchom go:
```
$ sudo dockerd
```
Skrypty zapory sieciowej OTBR generują reguły w kontenerze Dockera. Przed tym wykonaj modprobe, aby wczytać moduł jądra iptables.
```
$ sudo modprobe ip6table_filter
```

Konfigurowanie i uruchamianie Dockera

W tym ćwiczeniu OTBR Docker Image jest pobierany bezpośrednio z OpenThread Docker Hub. Ten obraz został przetestowany i zweryfikowany przez zespół OpenThread.

Pobierz najnowszy obraz:
```
$ docker pull openthread/otbr:latest
```

Sprawdź listę obrazów w kontenerze Dockera:

$ docker images
REPOSITORY        TAG       IMAGE ID       CREATED      SIZE
openthread/otbr   latest    db081f4de15f   6 days ago   766MB

Określ nazwę portu szeregowego urządzenia RCP, sprawdzając /dev. ttyACM0 oznacza, że urządzenie RCP jest prawidłowo podłączone.
```
$ ls /dev/tty*
...
/dev/ttyACM0
... 
```

Uruchom OTBR Docker po raz pierwszy i odwołaj się do portu szeregowego RCP (ttyACM0). Jeśli chcesz nadal używać tego OTBR Docker, użyj polecenia docker start otbr.

$ docker run --name "otbr" --sysctl "net.ipv6.conf.all.disable_ipv6=0 net.ipv4.conf.all.forwarding=1 net.ipv6.conf.all.forwarding=1" -p 8080:80 --dns=127.0.0.1 -it --volume /dev/ttyACM0:/dev/ttyACM0 --privileged openthread/otbr --radio-url spinel+hdlc+uart:///dev/ttyACM0

Otwórz nowe okno terminala SSH, aby przetestować łączność między Raspberry Pi a RCP.
```
$ docker exec -ti otbr sh -c "sudo ot-ctl"
> state 
disabled
Done
```

Opcjonalne polecenia Dockera:

Uzyskaj informacje o uruchomionym kontenerze Dockera:
```
$ docker ps -aq
```
Zatrzymaj Dockera OTBR:
```
$ docker stop otbr
```
Usuń OTBR Docker:
```
$ docker rm otbr
```
Ponowne wczytanie Dockera OTBR:
```
$ docker restart otbr
```

Na tym etapie urządzenie FTD Joiner i OTBR są gotowe. Możesz przejść do następnego kroku, aby utworzyć sieć Thread.

6. Tworzenie sieci Thread

Tworzenie sieci Thread na RCP

Aby utworzyć sieć Thread, używamy powłoki ot-ctl na OTBR. Jeśli w ostatniej sekcji zamknięto powłokę, wpisz to polecenie, aby ponownie uruchomić ją w terminalu SSH:

$ docker exec -ti otbr sh -c "sudo ot-ctl"

Następnie wpisz polecenia w kolejności podanej w tabeli i przed przejściem do następnego kroku upewnij się, że każdy z nich daje oczekiwany rezultat.

Indeks	Polecenie	Wprowadzenie	Oczekiwana odpowiedź
1	`dataset init new`	Utwórz nowy losowy zbiór danych sieci.	Gotowe
2	`dataset commit active`	Zatwierdź nowy zbiór danych w aktywnym operacyjnym zbiorze danych w pamięci trwałej.	Gotowe
3	`ifconfig up`	Wyświetl interfejs IPv6.	Gotowe
4	`thread start`	włączyć protokół Thread i dołączyć do sieci Thread,	Gotowe
			Poczekaj 10 sekund, aż interfejs Thread będzie gotowy.
5	`state`	Sprawdź stan urządzenia.To polecenie można wywoływać wielokrotnie, dopóki urządzenie nie stanie się liderem i nie przejdzie do następnego kroku.	lider Gotowe
6	`dataset active`	Sprawdź pełny aktywny zbiór danych operacyjnych i zarejestruj klucz sieciowy.	Active Timestamp: 1 Channel: 13 Channel Mask: 0x07fff800 Ext PAN ID: b07476e168eda4fc Mesh Local Prefix: fd8c:60bc:a98:c7ba::/64 Network Key: c312485187484ceb5992d2343baaf93d Network Name: OpenThread-599c PAN ID: 0x599c PSKc: 04f79ad752e8401a1933486c95299f60 Security Policy: 672 onrc 0 Done

Klucz sieciowy wygenerowany losowo przez OTBR podczas tworzenia sieci będzie używany, gdy urządzenia ot-cli-ftd dołączą do tej sieci Thread.

Dodawanie urządzenia FTD Joiner do sieci Thread za pomocą konfiguracji poza pasmem

Uruchamianie poza pasmem odnosi się do przesyłania danych uwierzytelniających sieci do urządzeń oczekujących na dołączenie do sieci za pomocą metod bezprzewodowych (np. ręczne wpisywanie w interfejsie wiersza poleceń OpenThread). Wpisz w konsoli szeregowej te polecenia w podanej kolejności, aby dołączyć urządzenie FTD.

Indeks	Polecenie	Wprowadzenie	Oczekiwane odpowiedzi
1	`ot dataset networkkey c312485187484ceb5992d2343baaf93d`	Aby urządzenie mogło połączyć się z siecią Thread, potrzebny jest tylko klucz sieciowy.	Gotowe
2	`ot dataset commit active`	Zatwierdź nowy zbiór danych w aktywnym operacyjnym zbiorze danych w pamięci trwałej.	Gotowe
3	`ot ifconfig up`	Wyświetl interfejs IPv6.	Gotowe
4	`ot thread start`	włączyć protokół Thread i dołączyć do sieci Thread,	Gotowe
			Poczekaj 20 sekund, aż urządzenie dołączy do sieci i się skonfiguruje.
5	`ot state`	Sprawdź stan urządzenia.	child/router Gotowe

Topologia

Wpisz w terminalu SSH polecenia takie jak ipaddr, child table czy router table, aby uzyskać odpowiedzi podobne do tych w poniższych fragmentach kodu.

> ipaddr rloc
fd8c:60bc:a98:c7ba:0:ff:fe00:b000
Done
> child table
| ID  | RLOC16 | Timeout    | Age        | LQ In | C_VN |R|D|N|Ver|CSL|QMsgCnt|Suprvsn| Extended MAC     |
+-----+--------+------------+------------+-------+------+-+-+-+---+---+-------+-------+------------------+
|   1 | 0xb001 |        240 |         23 |     3 |   51 |1|1|1|  3| 0 |     0 |   129 | 82bc12fbe783468e |

Done
> router table
| ID | RLOC16 | Next Hop | Path Cost | LQ In | LQ Out | Age | Extended MAC     | Link |
+----+--------+----------+-----------+-------+--------+-----+------------------+------+
| 44 | 0xb000 |       63 |         0 |     0 |      0 |   0 | 7ae354109d611f7e |    0 |

Done
...
> child table
| ID  | RLOC16 | Timeout    | Age        | LQ In | C_VN |R|D|N|Ver|CSL|QMsgCnt|Suprvsn| Extended MAC     |
+-----+--------+------------+------------+-------+------+-+-+-+---+---+-------+-------+------------------+

Done
> router table
| ID | RLOC16 | Next Hop | Path Cost | LQ In | LQ Out | Age | Extended MAC     | Link |
+----+--------+----------+-----------+-------+--------+-----+------------------+------+
| 33 | 0x8400 |       63 |         0 |     3 |      3 |  13 | e61487c1cda940a6 |    1 |
| 44 | 0xb000 |       63 |         0 |     0 |      0 |   0 | 7ae354109d611f7e |    0 |

Done

Wartość RLOC16 OTBR wynosi 0xb000, a wartość RLOC16 FTD Joiner wynosi początkowo 0xb001. Po uzyskaniu identyfikatora routera identyfikator FTD Joiner's RLOC16 zmienia się w 0x8400. Widać, że urządzenie FTD Joiner zostało przekształcone z urządzenia podrzędnego w wzmacniacz sieci mesh.

Obecna sieć Thread zawiera 2 węzły, a jej topologia jest przedstawiona na rysunku poniżej.

7. Komunikacja między urządzeniami Thread

Komunikacja ICMPv6

Używamy polecenia ping, aby sprawdzić, czy urządzenia Thread w tej samej sieci mogą się ze sobą komunikować. Najpierw użyj polecenia ipaddr, aby uzyskać RLOC urządzenia.

> ipaddr
fd8c:60bc:a98:c7ba:0:ff:fe00:fc11
fdbd:7274:649c:1:1d19:9613:f705:a5af
fd8c:60bc:a98:c7ba:0:ff:fe00:fc10
fd8c:60bc:a98:c7ba:0:ff:fe00:fc38
fd8c:60bc:a98:c7ba:0:ff:fe00:fc00
fd8c:60bc:a98:c7ba:0:ff:fe00:b000       # Routing Locator (RLOC)
fd8c:60bc:a98:c7ba:5249:34ab:26d1:aff6
fe80:0:0:0:78e3:5410:9d61:1f7e
Done

Wpisz to polecenie w konsoli szeregowej urządzenia FTD Joiner, aby wykonać operację pingowania.

> ot ping fd8c:60bc:a98:c7ba:0:ff:fe00:b000
16 bytes from fd8c:60bc:a98:c7ba:0:ff:fe00:b000: icmp_seq=1 hlim=64 time=19ms
1 packets transmitted, 1 packets received. Packet loss = 0.0%. Round-trip min/avg/max = 19/19.0/19 ms.
Done

Odpowiedź z portu szeregowego wskazuje, że OTBR otrzymał żądanie pingowania, a FTD Joiner otrzymał odpowiedź na pingowanie zwróconą przez OTBR. Komunikacja między tymi urządzeniami przebiega prawidłowo.

Komunikacja UDP

Usługi aplikacji udostępniane przez OpenThread obejmują też UDP. Za pomocą interfejsu UDP API możesz przekazywać informacje między węzłami w sieci Thread lub przekazywać informacje do sieci zewnętrznych za pomocą routera brzegowego. Szczegółowe wprowadzenie do interfejsu UDP API OpenThread znajdziesz w artykule OpenThread CLI – przykład UDP. W tym ćwiczeniu użyjemy niektórych interfejsów API do przesyłania informacji między OTBR a FTD Joiner.

Najpierw pobierz lokalny identyfikator EID sieci Mesh OTBR. Ten adres jest też jednym z adresów IPv6 urządzenia Thread i może być używany do uzyskiwania dostępu do urządzeń Thread w tej samej partycji sieci Thread.

> ipaddr mleid
fd8c:60bc:a98:c7ba:5249:34ab:26d1:aff6
Done

W terminalu SSH wpisz te polecenia, aby włączyć OTBR UDP i powiązać port 1022 urządzenia.

> udp open
Done
> udp bind :: 1022
Done

Wpisz w konsoli szeregowej te polecenia i włącz UDP urządzenia FTD Joiner. Powiąż port 1022 urządzenia, a następnie wyślij do OTBR 5-bajtową wiadomość hello.

> ot udp open 
Done
> ot udp bind :: 1022
Done
> ot udp send fd8c:60bc:a98:c7ba:5249:34ab:26d1:aff6 1022 hello
Done

Terminal SSH wyświetli te informacje. OTBR otrzymuje wiadomość hello od urządzenia FTD Joiner, co oznacza, że komunikacja UDP przebiega prawidłowo.

> 5 bytes from fd8c:60bc:a98:c7ba:9386:63cf:19d7:5a61 1022 hello

8. Gratulacje

Utworzyliśmy prostą sieć Thread i sprawdziliśmy komunikację w jej obrębie.

Wiesz już:

Jak utworzyć i używać środowiska programistycznego Telink Zephyr.
Jak utworzyć pliki binarne ot-cli-ftd i ot-rcp oraz wgrać je na płytki deweloperskie Telink B91.
Jak skonfigurować Raspberry Pi 3B+ lub nowszą wersję jako router graniczny OpenThread (OTBR) za pomocą Dockera.
Jak utworzyć sieć Thread na OTBR.
Jak dodawać urządzenia do sieci Thread za pomocą konfiguracji poza pasmem.
Jak sprawdzić połączenie między węzłami w sieci Thread.

Więcej informacji

Na stronach openthread.io i GitHub znajdziesz różne materiały dotyczące OpenThread, m.in.:

Obsługiwane platformy – poznaj wszystkie platformy, które obsługują OpenThread.
Kompilowanie OpenThread – więcej informacji o kompilowaniu i konfigurowaniu OpenThread.
Wprowadzenie do Threada – omówienie wszystkich koncepcji związanych z Threadem, które pojawiają się w tych ćwiczeniach z programowania.

Dokumenty referencyjne: