Tworzenie sieci wątków przy użyciu platformy programistycznej B91 i OpenThread

1. Wprowadzenie

OpenThread to rozwiązanie open source protokołu Thread®, które jest solidnym i bezpiecznym protokołem sieci bezprzewodowej sieci typu mesh zaprojektowanym dla urządzeń z internetem rzeczy (IoT). OpenThread został opracowany przez zespół Google Nest i jest dostępny bezpłatnie dla społeczności programistów w ramach projektu open source.

Specyfikacja Thread zapewnia niezawodny, bezpieczny i energooszczędny protokół komunikacyjny dla urządzeń z ograniczonym dostępem, które często występują w inteligentnych domach i obiektach komercyjnych. OpenThread zawiera pełny zakres warstw sieci w wątkach, np. IPv6, 6LoWPAN, IEEE 802.15.4 z zabezpieczeniami MAC, łączeniem sieci typu mesh i routingiem sieci typu mesh.

Telink zintegrował implementację OpenThread z aplikacją Zephyr RTOS, zapewniając bezproblemową zgodność ze sprzętem Telink. Kod źródłowy tej integracji jest łatwo dostępny w serwisie GitHub oraz jako pakiet SDK.

W ramach tego ćwiczenia zaprogramujesz OpenThread na rzeczywistym sprzęcie, utworzysz sieć typu Thread i będziesz nią zarządzać oraz wymieniać wiadomości między węzłami. Poniższa ilustracja przedstawia konfigurację sprzętu z routerem OTBR (Granicą) i jednym urządzeniem z wątkami w ćwiczeniach z programowania.

Czego się nauczysz

• Aby skonfigurować implementację OpenThread przy użyciu środowiska programistycznego Telink Zephyr.
• Aby utworzyć przykłady interfejsu wiersza poleceń OpenThread (ot-cli-ftd i ot-rcp), i umieścić je na tablicach programistycznych Telink B91
• Aby skonfigurować router OpenThread Border (OTBR) przy użyciu Dockera w wersji Raspberry Pi 3B lub nowszej.
• Utwórz sieć Thread na OTBR.
• Aby dodać urządzenia do sieci typu Thread przy użyciu debugowania poza zakresem.
• Aby sprawdzić połączenie między węzłami w sieci typu Thread przy użyciu interfejsu wiersza poleceń.

Czego potrzebujesz

Sprzęt:

• Dwie tablice programistyczne B91.
• Jeden pakiet Raspberry Pi 3B+ lub nowszy z obrazem systemu operacyjnego Raspbian.
• Maszyna z systemem Linux z co najmniej 2 portami USB.
• Przełącznik połączony z internetem (lub router) i kilka kabli Ethernet.

Oprogramowanie:

• Narzędzie Telink Burning and Debugging Tool – LinuxBDT.
• Narzędzie terminala z portem szeregowym, np. PuTTY.
• inne narzędzia, np. Git czy West.

2. Wymagania wstępne

Thread Concepts i interfejs wiersza poleceń OpenThread

Przed rozpoczęciem tego ćwiczenia warto zapoznać się z ćwiczeniami z symulacji OpenThread i poznać podstawowe pojęcia dotyczące narzędzia Thread.

Maszyna z systemem Linux

Maszyna z systemem Linux (Ubuntu v20.04 LTS lub nowsza) pełni rolę maszyny kompilacji, za pomocą której może skonfigurować środowisko programistyczne Telink Zephyr i umieścić na niej wszystkie płytki programistyczne Thread. Aby wykonać te zadania, komputer z systemem Linux wymaga dwóch dostępnych portów USB i połączenia z internetem.

Port i złącze portu szeregowego

Możesz podłączyć urządzenie bezpośrednio do portu USB komputera z systemem Linux. Potrzebujesz urządzenia z portem szeregowym, które umożliwia dostęp do urządzeń.

W ćwiczeniach z programowania możesz używać narzędzia terminalowego PuTTY do sterowania łącznikiem FTD i Raspberry Pi. Można w nim znaleźć ogólne informacje o jego wykorzystaniu, ale można też używać innych programów tego typu.

Zestaw dla programistów Telink B91

To ćwiczenie ćwiczeń wymaga dwóch zestawów zestawów narzędzi B91. Widoczne poniżej zdjęcie przedstawia minimalną wymaganą liczbę komponentów w jednym zestawie.

Jeden z tych zestawów będzie używany jako RCP (Radio Co-Processor), a drugi będzie działać jako FTD (Full Thread Device). Jeśli nie masz jeszcze tego zestawu, więcej szczegółów możesz uzyskać na oficjalnej stronie Telink. Oto wybrane komponenty:

Raspberry Pi 3B+ lub nowsza z Raspbian Image

Na potrzeby tego ćwiczenia potrzebujesz modułu Raspberry Pi 3B+ lub nowszego z obrazem Raspbian Bullseye Lite OS lub Raspbian Bullseye with Desktop. Jest połączony z internetem za pomocą sieci Ethernet i zostanie skonfigurowany jako host routera OpenThread Border Router (OTBR).

Połączenie sieciowe

Przełącznik (lub router) połączony z internetem i kilka kabli Ethernet. Są one używane do podłączenia Raspberry Pi do komputera z systemem Linux, co ułatwia konfigurację Raspberry Pi przez hosta.

LinuxBDT

Telink Burning and Debugging Tool (BDT), który obejmuje wszystkie serie Telink Chip, umożliwia wymazywanie i uruchamianie oprogramowania OpenThread na płytkach programisty Telink B91. Zainstaluj na komputerze z Linuksem wersję 8 systemu linuxBDT.

Inne

• Git do konfiguracji środowiska programistycznego Telink Zephyr.
• Zachód w przypadku zarządzania projektem Zephyr i tworzenia plików binarnych OpenThread.

3. Skonfiguruj oprogramowanie układowe

Konfigurowanie środowiska programistycznego Telink Zephyr

Na komputerze z Linuksem otwórz terminal wiersza poleceń i wykonaj te polecenia, aby sprawdzić, czy pakiet APT jest aktualny.

$ sudo apt update
$ sudo apt upgrade

Gdy to zrobisz, wykonaj te czynności.

1. 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 kolejnego kroku, sprawdź, jakie wersje są zainstalowane w Twoim systemie. Jeśli wersje są nieprawidłowe, zmień lustrzane wersje APT na stabilne i aktualne oprogramowanie lustrzane lub zaktualizuj te zależności ręcznie.
2. Zainstaluj w kierunku zachodnim.

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

   Upewnij się, że ~/.local/bin jest w zmiennej środowiskowej $PATH.
3. Pobierz kod źródłowy projektu Zephyr.

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

4. Zainstaluj dodatkowe zależności Pythona dla Zephyr.

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

5. Skonfiguruj łańcuch narzędzi Zephyr. Pobierz łańcuch narzędzi Zephyr (około 1~2 GB) do katalogu lokalnego, aby móc mignąć większość plansz.

   $ 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, tak 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] jest opcjonalnym tekstem, 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
   

6. Zbuduj przykład z Hello World. Najpierw sprawdź, czy oficjalna konfiguracja projektu Zephyr jest prawidłowa, korzystając z przykładu Hello World, a następnie kontynuuj konfigurowanie projektu niestandardowego.

   $ cd ~/zephyrproject/zephyr
   $ west build -p auto -b tlsr9518adk80d samples/hello_world
   

   Użyj polecenia kompilacji West, aby utworzyć przykład hello_world z katalogu głównego repozytorium Zephyr. Oprogramowanie układowe o nazwie zephyr.bin znajdziesz w sekcji build/zephyr directory.
7. Dodaj skrypt środowiska Zephyr do ~/.bashrc. Uruchom następujące polecenia.

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

8. Dodaj zdalne repozytorium Telink Zephyr. Pobierz lokalnie repozytorium Telink jako gałąź programowania 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.

Konfigurowanie Telink LinuxBDT

Pobierz narzędzie Telink LinuxBDT i rozpakuj je w lokalnym katalogu na komputerze z systemem Linux, np. w katalogu głównym ~, aby włączyć oprogramowanie Flash na płytce B91.

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

Podłącz tablicę Burning do komputera z systemem Linux przez interfejs USB, a następnie wpisz podane 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 w wersji 3.6”, oznacza to, że programista BDT został połączony z komputerem z systemem Linux.

Kompilacja oprogramowania

To ćwiczenie programowania spowoduje utworzenie 2 typów oprogramowania OpenThread:

• ot-cli-ftd,
• i ot-rcp.

Metody kompilacji są następujące:

1. Współprocesor radiowyot-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
   

   )
2. 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
   

Oprogramowanie Flash

Podłącz płytkę rozwojową B91 do płyty spalającej, używając kabla USB, jak pokazano na poniższej ilustracji.

W wierszu poleceń wykonaj podane niżej polecenia, aby rozpocząć spalanie oprogramowania (jak np. migając oprogramowanie 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 Flash ot-rcp jest zasadniczo taka sama jak w przypadku ot-cli-ftd. Występują jednak różnice w nazwach i ścieżkach oprogramowania układowego.

Po mignięciu rozróżnij dwie tablice programistyczne B91. Oznacz tablicę oznaczoną ikoną ot-cli-ftd jako „Łącznik FTD”, a tablica jako „RCP” = ot-rcp.

4. Konfigurowanie konsoli szeregowej dla urządzenia łączącego FTD

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

Po połączeniu urządzenia łączącego FTD z komputerem 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: Dokumentacja wiersza poleceń OpenThread. Pamiętaj, by na początku każdego polecenia wpisać ot.

Przykłady:

> ot state
disabled
Done
> ot channel
11
Done
>

5. Skonfiguruj Raspberry Pi jako router graniczny OpenThread

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

• Raspberry Pi zawiera wszystkie usługi i oprogramowanie układowe wymagane do działania jako router graniczny (BR).
• Za komunikację w wątku odpowiada RCP.

Współprocesor radiowy

Aby migać oprogramowanie układowe urządzenia ot-rcp, wykonaj te same czynności co w przypadku migania oprogramowania układowego ot-cli-ftd. Podłącz tablicę programową B91 do portu USB na Raspberry Pi, jak pokazano na poniższej ilustracji.

Malinowy Pi

1. Upewnij się, że obraz systemu Rallbian Bullseye Lite lub Raspbian Bullseye with Desktop jest prawidłowo zapisany na karcie SD.
2. Możesz połączyć się przez Raspberry Pi lub pracować bezpośrednio z Raspbian Desktop. To ćwiczenie programowania będzie korzystać z SSH.
3. Zanim przejdziesz do następnego etapu instalacji OTBR Docker, najpierw zaktualizuj lokalne repozytorium i menedżera pakietów.

   $ sudo apt-get update
   $ sudp apt-get upgrade
   

Zainstaluj Dockera

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

1. Zainstaluj Dockera:

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

2. Dodaj bieżące konto do grupy Dockera, aby przyznać mu uprawnienia, dzięki czemu sudo nie trzeba dodawać przed każdym poleceniem.

   $ sudo usermod -aG docker $USER
   

   Aby zastosować zmiany, musisz ponownie uruchomić Raspberry Pi.
3. Jeśli Docker jeszcze się nie uruchomił, uruchom go:

   $ sudo dockerd
   

4. Skrypty zapory sieciowej OTBR generują reguły w kontenerze Dockera. Wcześniej uruchom modprobe, aby wczytać moduł jądra.

   $ sudo modprobe ip6table_filter
   

Konfigurowanie i uruchamianie Dockera

Te ćwiczenia z programowania pobierają bezpośrednio obraz OTBR Dockera z OpenThread Docker Hub. Ten obraz został przetestowany i zweryfikowany przez zespół OpenThread.

1. Pobierz najnowszy obraz:

   $ docker pull openthread/otbr:latest
   

2. Sprawdź listę obrazów w kontenerze Dockera:

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

3. Aby sprawdzić nazwę portu szeregowego urządzenia RCP, zaznacz /dev, ttyACM0 wskazuje, że jest on poprawnie podłączony.

   $ ls /dev/tty*
   ...
   /dev/ttyACM0
   ... 
   

4. Uruchom OTBR Dockera po raz pierwszy i odwołaj się do portu szeregowego RCP (ttyACM0). Jeśli chcesz dalej korzystać z tego Dockera, 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
   

5. Otwórz nowe okno terminala SSH, aby przetestować połączenie między Raspberry Pi i 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 Docker Dockera:

  $ docker stop otbr
  

• Usuń Dockera OTBR:

  $ docker rm otbr
  

• Załaduj ponownie Dockera OTBR:

  $ docker restart otbr
  

W tym momencie urządzenie łączące FTD i urządzenie OTBR są gotowe i możesz przejść do kolejnego kroku, by zbudować sieć Thread.

6. Tworzenie sieci wątków

Tworzenie sieci wątków na platformie RCP

Do utworzenia sieci typu Thread używamy powłoki ot-ctl na pasku OTBR. Jeśli powłoka została zamknięta w ostatniej sekcji, wpisz to polecenie, aby ponownie uruchomić powłokę w terminalu SSH:

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

Następnie wpisz polecenia w kolejności określonej w tabeli i upewnij się, że każdy krok prowadzi do oczekiwanych wyników.

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

Dodaj łącznik FTD do wątku za pomocą zlecania poza zakresem

Prowizja poza zakresem odnosi się do przesyłania danych logowania w sieci do urządzeń oczekujących na dołączenie do sieci za pomocą metody bezprzewodowej (np. ręcznego wprowadzenia interfejsu wiersza poleceń OpenThread). Wpisz następujące polecenia w konsoli szeregowej do oprogramowania sprzęgającego FTD.

Topologia

Wpisz w terminalu SSH polecenia takie jak ipaddr, child table czy router table, aby uzyskać odpowiedzi takie jak te fragmenty 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

RLOC16 OTBR to 0xb000, a RLOC16 łącznika FTD początkowo to 0xb001. Potem RLOC16 złącza FTD staje się 0x8400 po uzyskaniu identyfikatora routera. Widać, że oprogramowanie sprzęgające FTD zostało uaktualnione z modelu dziecka do routera.

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

7. Komunikacja między urządzeniami z wątkami

Komunikacja ICMPv6

Użycie polecenia ping pozwala sprawdzić, czy urządzenia z wątkami w tej samej sieci mogą się ze sobą komunikować. Najpierw użyj polecenia ipaddr, aby pobrać 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 następujące polecenie w konsoli szeregowej łącznika FTD, aby wykonać operację ping.

> 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ź wyjściowa portu szeregowego wskazuje, że strona OTBR otrzymała żądanie ping, a łącznik FTD otrzymał odpowiedź ping zwracaną przez OTBR. Komunikacja między dwoma urządzeniami się powiodła.

Komunikacja UDP

Usługi aplikacji oferowane przez OpenThread także obejmują protokół UDP. Za pomocą interfejsu UDP API możesz przekazywać informacje między węzłami w sieci typu Thread lub przekazywać je do sieci zewnętrznych przez router graniczny. Szczegółowe wprowadzenie do interfejsu UDP UDP OpenThread opisaliśmy w OpenThread CLI – UDP Example. Te ćwiczenia z programowania będą wykorzystywać niektóre interfejsy API do przesyłania informacji między łącznikiem OTBR a łącznikiem FTD.

Najpierw pobierz identyfikator EOT sieci lokalnej OTBR. Ten adres jest także jednym z adresów IPv6 urządzenia z wątkami i może być używany do uzyskiwania dostępu do urządzeń Thread na tej samej partycji sieciowej.

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

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

> udp open
Done
> udp bind :: 1022
Done

Wpisz następujące polecenia w konsoli szeregowej i włącz UDP dla łącznika FTD. Powiąż port 1022 urządzenia, a następnie wyślij 5-bajtowy komunikat hello do OTBR.

> 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 poniższe informacje. Funkcja OTBR odbiera wiadomość hello od oprogramowania sprzęgającego FTD, co oznacza, że komunikacja UDP jest udana.

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

8. Gratulacje

Udało Ci się utworzyć prostą sieć Thread i zweryfikować komunikację w tej sieci.

Teraz wiesz już:

• Tworzenie i używanie środowiska programistycznego Telink Zephyr.
• Jak tworzyć pliki binarne ot-cli-ftd i ot-rcp, a następnie umieścić je na tablicach programistycznych Telink B91.
• Jak skonfigurować Raspberry Pi 3B+ lub nowszą wersję jako router graniczny OpenThread (OTBR) przy użyciu Dockera.
• Jak utworzyć sieć wątków przy użyciu OTBR.
• Jak dodawać urządzenia do sieci typu Thread przez zlecenie poza zakresem.
• Jak sprawdzić połączenie między węzłami w sieci Thread.

Więcej informacji

Zapoznaj się z materiałami openthread.io i GitHub, aby poznać różne zasoby OpenThread, w tym:

• Obsługiwane platformy – poznaj wszystkie platformy obsługujące OpenThread
• Build OpenThread – więcej informacji o tworzeniu i konfigurowaniu OpenThread
• Thread Primer – obejmuje wszystkie pojęcia związane z wątkami przedstawione w tym ćwiczeniu z programowania.

Dokumenty referencyjne:

• Dokumentacja wiersza poleceń OpenThread
• Dokumentacja wiersza poleceń UDP na potrzeby wątków
• Dokumentacja OpenOpen UDP API