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 typu mesh i routing w sieci typu 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.
W tym ćwiczeniu zaprogramujesz OpenThread na rzeczywistym sprzęcie, utworzysz sieć Thread i będziesz nią zarządzać oraz wymieniać wiadomości między węzłami. Ilustracja poniżej przedstawia konfigurację sprzętową, w tym router graniczny OTBR i 1 urządzenie Thread w samouczku.
Czego się nauczysz
- Aby skonfigurować implementację OpenThread za pomocą środowiska programistycznego Telink Zephyr.
- Aby skompilować przykłady interfejsu wiersza poleceń OpenThread (
ot-cli-ftdiot-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 systemem Linux z co najmniej 2 portami USB.
- Przełącznik (lub router) z dostępem do internetu i kilka kabli Ethernet.
Oprogramowanie:
- Narzędzie do programowania 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 z programowania, warto zapoznać się z podstawowymi pojęciami dotyczącymi Thread i interfejsem wiersza poleceń OpenThread, wykonując ćwiczenie z programowania dotyczące symulacji OpenThread.
Urządzenie 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 zaprogramować wszystkie płytki deweloperskie Thread. Aby wykonać te zadania, komputer z systemem Linux musi mieć 2 wolne porty USB i połączenie z internetem.
Połączenie z portem szeregowym i terminale
Możesz podłączyć urządzenie bezpośrednio do portu USB komputera z Linuksem. Do uzyskania dostępu do urządzeń potrzebne będzie też narzędzie terminala portu szeregowego.
W tym laboratorium kodowym do sterowania urządzeniem FTD Joiner i Raspberry Pi używane jest narzędzie terminalowe PuTTY. Zawiera ona omówienie jej użycia, ale można też używać innego oprogramowania terminala.
Telink B91 Development Kit
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 samouczku 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.
- Zachód, aby zarządzać projektem Zephyr i kompilować pliki binarne 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
$ cmake --version $ python3 --version $ dtc --version
- Zainstaluj zachód.
$ pip3 install --user -U west $ echo 'export PATH=~/.local/bin:"$PATH"' >> ~/.bashrc $ source ~/.bashrc
~/.local/binznajduje 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
$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]
$ 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 własny projekt.
$ cd ~/zephyrproject/zephyr $ west build -p auto -b tlsr9518adk80d samples/hello_world
zephyr.binznajdziesz w sekcjibuild/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 Zephyr Doc – Getting Started Guide (Zephyr Doc – przewodnik dla początkujących).
Konfigurowanie Telink LinuxBDT
Pobierz narzędzie Telink LinuxBDT i wypakuj 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:
- Koprocesor 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
- 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 Burning Board 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 flash dla ot-rcp jest w zasadzie taka sama jak dla 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 układowe 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 interfejsem graficznym 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 samouczku będziemy używać 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ć
sudo.$ sudo usermod -aG docker $USER
- 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 załadować moduł jądra systemu iptables.$ sudo modprobe ip6table_filter
Konfigurowanie i uruchamianie Dockera
W tym samouczku obraz Dockera OTBR 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.ttyACM0oznacza, ż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ć 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ń Dockera OTBR:
$ docker rm otbr
- Ponowne załadowanie 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
Do utworzenia sieci Thread używamy powłoki ot-ctl na urządzeniu 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 |
| Utwórz nowy losowy zbiór danych sieci. | Gotowe | ||
2 |
| Zatwierdź nowy zbiór danych w aktywnym operacyjnym zbiorze danych w pamięci trwałej. | Gotowe | ||
3 |
| Otwórz interfejs IPv6. | Gotowe | ||
4 |
| włączyć protokół Thread i połączyć się z siecią Thread, | Gotowe | ||
Poczekaj 10 sekund, aż interfejs Thread będzie gotowy. | |||||
5 |
| 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 | ||
6 |
| Sprawdź pełny aktywny zbiór danych operacyjnych i zarejestruj klucz sieciowy. | Active Timestamp: 1 | ||
Klucz sieciowy wygenerowany losowo przez OTBR podczas tworzenia sieci będzie używany, gdy urządzenia ot-cli-ftd będą dołączać do tej sieci Thread.
Dodawanie urządzenia FTD Joiner do sieci Thread za pomocą prowizjonowania 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ęcznego wpisywania w interfejsie wiersza poleceń OpenThread). Wpisz w konsoli szeregowej te polecenia w kolejności, w jakiej są podane, aby połączyć urządzenie FTD.
Indeks | Polecenie | Wprowadzenie | Oczekiwane odpowiedzi | ||
1 |
| Aby urządzenie mogło połączyć się z siecią Thread, potrzebny jest tylko klucz sieciowy. | Gotowe | ||
2 |
| Zatwierdź nowy zbiór danych w aktywnym operacyjnym zbiorze danych w pamięci trwałej. | Gotowe | ||
3 |
| Otwórz interfejs IPv6. | Gotowe | ||
4 |
| włączyć protokół Thread i połączyć się z siecią Thread, | Gotowe | ||
Poczekaj 20 sekund, aż urządzenie dołączy do sieci i się skonfiguruje. | |||||
5 |
| Sprawdź stan urządzenia. | węzeł podrzędny/router | ||
Topologia
Wpisz w terminalu SSH polecenia takie jak ipaddr, child table czy router table, aby uzyskać odpowiedzi podobne do tych fragmentów 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 to 0xb000, a wartość RLOC16 FTD Joiner to 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 router.
Obecna sieć Thread zawiera 2 węzły, a jej topologia jest taka jak 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ź wyjściowa portu szeregowego wskazuje, że strona OTBR otrzymała żądanie ping, a FTD Joiner otrzymał odpowiedź ping 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 laboratorium wykorzystamy niektóre interfejsy 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
Utworzysz prostą sieć Thread i sprawdzisz komunikację w jej obrębie.
Wiesz już:
- Jak utworzyć i używać środowiska programistycznego Telink Zephyr.
- Jak utworzyć pliki binarne
ot-cli-ftdiot-rcporaz 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
Odwiedź openthread.io i GitHub, aby dowiedzieć się więcej o różnych zasobach OpenThread, w tym:
- Obsługiwane platformy – poznaj wszystkie platformy, które obsługują OpenThread.
- Kompilowanie OpenThread – więcej informacji o kompilowaniu i konfigurowaniu OpenThread.
- Wprowadzenie do Thread – omówienie wszystkich koncepcji związanych z Threadem, które są przedstawione w tych ćwiczeniach z programowania.
Dokumenty referencyjne: