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

1. Wprowadzenie

OpenThread to implementacja protokołu open source Thread®, solidnego i bezpiecznego protokołu sieci bezprzewodowej typu mesh zaprojektowanego z myślą o urządzeniach korzystających z internetu rzeczy (IoT). Program OpenThread został opracowany przez zespół Nest w Google i jest bezpłatnie dostępny dla społeczności programistów jako projekt open source.

Thread Specification to niezawodny, bezpieczny i oszczędny protokół komunikacji bezprzewodowej na potrzeby urządzeń z ograniczonymi zasobami, które są powszechnie spotykane w inteligentnych domach i budynkach komercyjnych. OpenThread udostępnia pełny zakres warstwy sieci w Thread, taki jak IPv6, 6LoWPAN, IEEE 802.15.4 z zabezpieczeniami MAC, ustanowieniem połączeń typu mesh i routingiem sieci typu mesh.

Firma Telink zintegrowała wdrożenie OpenThread w standardzie RTOS firmy Zephyr, co zapewnia pełną zgodność ze sprzętem Telink. Kod źródłowy tej integracji jest łatwo dostępny na GitHub. Można go też znaleźć w pakiecie SDK.

W ramach tego ćwiczenia w Codelabs zaprogramujesz OpenThread na rzeczywistym sprzęcie, utworzysz sieć Thread i będziesz nią zarządzać, a także wymienisz wiadomości między węzłami. Ilustracja poniżej przedstawia konfigurację sprzętową z OTBR (OTB) i 1 urządzenie Thread ćwiczenia z programowania.

Czego się nauczysz

• Skonfiguruj implementację OpenThread przy użyciu środowiska programistycznego Telink Zephyr.
• Aby utworzyć przykładowe interfejsy wiersza poleceń OpenThread (ot-cli-ftd i ot-rcp) i zainstalować je na płytach deweloperskich Telink B91.
• Aby skonfigurować router graniczny OpenThread (OTBR) za pomocą Dockera na urządzeniu Raspberry Pi 3B+ lub nowszym:
• Tworzenie sieci Thread w OTBR.
• Dodawanie urządzeń do sieci Thread przy użyciu debugowania spoza zakresu.
• Do sprawdzania połączeń między węzłami w sieci Thread przy użyciu interfejsu wiersza poleceń.

Czego potrzebujesz

Sprzęt:

• Dwie płytki rozwojowe B91.
• 1 Raspberry Pi 3B lub nowszy z obrazem systemu operacyjnego Raspbian.
• Komputer z systemem Linux i co najmniej 2 portami USB.
• Przełącznik (lub router) połączony z internetem i kilka kabli Ethernet.

Oprogramowanie:

• Narzędzie Telink Burning and Debugging Tool – LinuxBDT.
• narzędzie do obsługi portów szeregowych, np. PuTTY;
• Inne narzędzia, takie jak Git czy West.

2. Wymagania wstępne

Thread Concepts i interfejs wiersza poleceń OpenThread

Przed rozpoczęciem tego ćwiczenia z programowania warto zapoznać się z ćwiczeniami z programowania symulacji OpenThread, aby zapoznać się z podstawowymi pojęciami dotyczącymi Thread i interfejsem wiersza poleceń OpenThread.

Maszyna z systemem Linux

Komputer z systemem Linux (Ubuntu 20.04 LTS lub nowszy) służy jako maszyna do kompilacji, która konfiguruje środowisko programistyczne Telink Zephyr i instaluje wszystkie płyty deweloperskie Thread. Do wykonania tych zadań komputer z systemem Linux wymaga 2 dostępnych portów USB i połączenia z internetem.

Terminale i połączenia portów szeregowych

Możesz podłączyć je bezpośrednio do portu USB komputera z systemem Linux. Aby uzyskać dostęp do urządzeń, będziesz też potrzebować narzędzia do obsługi portów szeregowych.

W ramach tego ćwiczenia w Codelabs narzędzie terminalowe PuTTY jest używane do sterowania FTD Joiner i Raspberry Pi. Opisuje ona jego zastosowanie, ale można też zastosować inne oprogramowanie terminalowe.

Zestaw deweloperski Telink B91

To ćwiczenie w Codelabs wymaga 2 zestawów zestawów deweloperskich B91. Poniższe zdjęcie przedstawia minimalną liczbę wymaganych komponentów w jednym zestawie.

Jeden z tych zestawów będzie używany jako RCP (koprocesora radiowego), a drugi jako FTD (urządzenie z pełnym wątkiem). Jeśli nie masz jeszcze tego zestawu, możesz uzyskać więcej informacji na oficjalnej stronie firmy Telink. Oto niektóre z komponentów:

Raspberry Pi 3B lub nowsza z obrazem systemu operacyjnego Raspbian

Do tego ćwiczenia w Codelabs potrzebny jest Raspberry Pi 3B lub nowszy z obrazem systemu operacyjnego Raspbian Bullseye Lite lub Raspbian Bullseye with Desktop. Jest on połączony z internetem przez Ethernet i zostanie skonfigurowany jako host routera granicznego OpenThread (OTBR).

Połączenie sieciowe

Przełącznik (lub router) podłączony do internetu i kilka kabli Ethernet. Służą do łączenia Raspberry Pi z komputerem z systemem Linux, co ułatwia konfigurowanie użytkownika Raspberry Pi przez hosta.

LinuxBDT

Telink narzędzie do tworzenia i debugowania i debugowania (BDT), które obejmuje wszystkie serie układów Telink, umożliwia wymazywanie i wdrażanie oprogramowania OpenThread na płytach deweloperskich Telink B91. Zainstaluj na komputerze z systemem X86 system Linux w wersji linuxBDT.

Inne

• Git do skonfigurowania środowiska programistycznego Telink Zephyr.
• West, do zarządzania projektem Zephyr i tworzenia plików binarnych OpenThread.

3. Skonfiguruj oprogramowanie układowe

Skonfiguruj środowisko programistyczne Telink Zephyr

Na komputerze z systemem Linux otwórz terminal interfejsu wiersza poleceń i zacznij od wykonania poniższych poleceń, aby upewnić się, że interfejs APT jest aktualny.

$ sudo apt update
$ sudo apt upgrade

Następnie wykonaj poniższe 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 minimalnej 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
   

   Przed wykonaniem kolejnych czynności sprawdź wersje zainstalowane w systemie. Jeśli wersje nie są prawidłowe, zmień wersję lustrzaną APT na stabilną i aktualną wersję powietrzną lub ręcznie zaktualizuj te zależności.
2. Zainstaluj zachodni.

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

   Sprawdź, czy ~/.local/bin znajduje się 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 zamontować 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 opcjonalny tekst, 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. Utwórz przykład aplikacji 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. Wykonaj te polecenia:

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

8. Dodaj zdalne repozytorium Telink Zephyr. Pobierz lokalnie repozytorium Telink jako gałąź programistyczną 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 artykule Zephyr Doc – wprowadzający przewodnik.

Skonfiguruj Telink LinuxBDT

Pobierz narzędzie Telink LinuxBDT i rozpakuj je do katalogu lokalnego komputera z systemem Linux, takiego jak katalog główny ~, aby móc wgrać oprogramowanie układowe na płytę programistyczną B91.

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

Podłącz płytę Burning Board do komputera z systemem Linux przez interfejs USB, a następnie wpisz następujące 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

Komunikat „Telink Web Debugger v3.6” oznacza, że programista BDT nawiązał połączenie z komputerem z systemem Linux.

Kompilacja oprogramowania układowego

W ramach tego ćwiczenia w Codelabs utworzysz 2 typy oprogramowania układowego OpenThread:

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

Metody kompilacji są następujące:

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

2. W pełni funkcjonalne urządzenie do obsługi wątków 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
   

Lampa błyskowa oprogramowania

Podłącz płytę rozwojową B91 do płytki Burning Board za pomocą kabla USB, jak pokazano na ilustracji poniżej.

W wierszu poleceń wykonaj te polecenia, aby nagrać oprogramowanie układowe (np. flashowanie 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 Flasha w przypadku ot-rcp jest zasadniczo taka sama jak w przypadku ot-cli-ftd. Występują jednak różnice w ścieżkach i nazwach oprogramowania układowego.

Po mignięciu 2 płytki rozwojowe B91 odpowiednio je oznacz. Oznacz tablicę, w przypadku której migała etykieta ot-cli-ftd, jako „FTD Joiner” a karta zamigała z ot-rcp jako „RCP”.

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

Jak pokazano na ilustracji, podłącz FTD Joiner bezpośrednio do portu USB komputera 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 ten port.

Dokumentacja wiersza poleceń OpenThread znajduje się tutaj: dokumentacja interfejsu wiersza poleceń OpenThread. Pamiętaj, aby wszystkie polecenia poprzedzały prefiks ot.

Przykłady:

> ot state
disabled
Done
> ot channel
11
Done
>

5. Konfigurowanie Raspberry Pi jako routera granic OpenThread Router

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

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

Współprocesor radiowy (RCP)

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

Malinowy Pi

1. Upewnij się, że obraz systemu operacyjnego Raspbian Bullseye Lite lub Raspbian Bullseye with Desktop jest prawidłowo zapisany na karcie SD.
2. Możesz połączyć się przez SSH z Raspberry Pi lub pracować bezpośrednio z Raspbian Desktop. Te ćwiczenia w Codelabs będą używać SSH.
3. Zanim w następnym kroku zaczniesz instalować OTBR Docker, 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 i otwórz okno terminala SSH.

1. Zainstaluj Dockera:

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

2. Umieść bieżące konto w grupie Dockera, aby przyznać to uprawnienie. Dzięki temu nie będzie trzeba dodawać interfejsu sudo przed każdym poleceniem.

   $ sudo usermod -aG docker $USER
   

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

   $ sudo dockerd
   

4. Skrypty zapory sieciowej OTBR generują reguły wewnątrz kontenera Dockera. Zanim to nastąpi, uruchom polecenie modprobe, aby wczytać moduł jądra systemu iptables.

   $ sudo modprobe ip6table_filter
   

Konfigurowanie i uruchamianie Dockera

To ćwiczenia w programie pobiera obraz Dockera OTBR bezpośrednio 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. Sprawdź nazwę portu szeregowego urządzenia RCP, zaznaczając pole /dev. ttyACM0 oznacza, że RCP jest prawidłowo 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 nadal korzystać z tego Dockera w OTBR, 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 OTBR Docker:

  $ docker stop otbr
  

• Usuń OTBR Docker:

  $ docker rm otbr
  

• Załaduj ponownie OTBR Docker:

  $ docker restart otbr
  

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

6. Tworzenie sieci Thread

Tworzenie sieci Thread na RCP

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

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

Wpisz polecenia w kolejności określonej w tabeli i upewnij się, że każdy krok przynosi oczekiwany rezultat, zanim przejdziesz do kolejnego.

Gdy ot-cli-ftd urządzeń dołączy do tej sieci Thread, będzie używany klucz sieciowy wygenerowany losowo przez OTBR podczas tworzenia sieci.

Dodaj łącznik FTD do Thread przez uruchomienie poza zakresem

Uruchamianie poza zakresem oznacza przesyłanie danych logowania do sieci do urządzeń oczekujących na połączenie z siecią, korzystając z metod bezprzewodowych (na przykład ręcznego wpisywania w interfejsie wiersza poleceń OpenThread). Wpisz w konsoli szeregowej podane niżej polecenia do FTD Joiner.

Topologia

Wpisz w terminalu SSH polecenia takie jak ipaddr, child table czy router table, aby otrzymać 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 przy OTBR to 0xb000, a RLOC16 osoby połączonej FTD na początku to 0xb001. Następnie RLOC16 łącznika FTD zmieni się na 0x8400 po uzyskaniu identyfikatora routera. Widać, że narzędzie FTD Joiner zostało przekształcone z elementu podrzędnego w router.

Bieżąca sieć Thread zawiera 2 węzły. Topologia pokazuje to na rysunku poniżej.

7. Komunikacja między urządzeniami Thread

Komunikacja ICMPv6

Polecenie ping pozwala sprawdzić, czy urządzenia Thread w tej samej sieci mogą się ze sobą komunikować. Najpierw użyj polecenia ipaddr, aby uzyskać wartość 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 poniższe polecenie w konsoli szeregowej FTD Joiner, 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 odebrała żądanie ping, a narzędzie FTD Joiner odebrało odpowiedź ping zwróconą przez OTBR. Komunikacja między urządzeniami przebiegła pomyślnie.

Komunikacja UDP

Usługi aplikacji udostępniane przez OpenThread też zawierają protokół UDP. Za pomocą interfejsu UDP API możesz przekazywać informacje między węzłami w sieci Thread lub do sieci zewnętrznych przez router Border Router. Szczegółowe wprowadzenie do interfejsu UDP API OpenThread znajdziesz w artykule OpenThread CLI – UDP Example. To ćwiczenia w programie wykorzysta niektóre znajdujące się w nim interfejsy API do przesyłania informacji między OTBR a FTD Joiner.

Najpierw pobierz lokalny identyfikator EID sieci typu mesh dla OTBR. Ten adres jest też jednym z adresów IPv6 urządzenia Thread i może służyć do uzyskiwania dostępu do urządzeń Thread w tej samej partycji sieciowej Thread.

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

Wpisz następujące 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 pakiet UDP narzędzia FTD Joiner. Powiąż port urządzenia 1022, a następnie wyślij do OTBR 5-bajtową wiadomość w formacie 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 generuje poniższe informacje. OTBR otrzymuje komunikat hello od narzędzia FTD Joiner, co oznacza, że komunikacja UDP się powiodła.

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

Wiesz już:

• Tworzenie środowiska programistycznego Telink Zephyr i korzystanie z niego.
• Dowiedz się, jak tworzyć pliki binarne ot-cli-ftd i ot-rcp oraz jak wgrać je na płytki rozwojowe Telink B91.
• Jak skonfigurować Raspberry Pi 3B lub nowszą wersję jako router granic OpenThread (OTBR) przy użyciu Dockera.
• Jak utworzyć sieć Thread w OTBR.
• Jak dodawać urządzenia do sieci Thread przy użyciu uruchomienia poza zakresem.
• Jak sprawdzić połączenia między węzłami w sieci Thread.

Dalsza lektura

Na stronach openthread.io i GitHub znajdziesz informacje o różnych zasobach OpenThread, w tym:

• Obsługiwane platformy – poznaj wszystkie platformy obsługujące OpenThread.
• Utwórz OpenThread – więcej informacji o tworzeniu i konfigurowaniu OpenThread.
• Thread Primer – obejmuje wszystkie pojęcia związane z Thread ćwiczenie z programowania;

Dokumenty referencyjne:

• Dokumentacja interfejsu wiersza poleceń OpenThread
• Dokumentacja interfejsu wiersza poleceń UDP OpenThread
• Dokumentacja interfejsu OpenThread UDP API.