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

1. Wstęp

26b7f4f6b3ea0700.png

OpenThread to implementacja protokołu sieciowego Thread®, czyli solidnego i bezpiecznego protokołu sieci typu mesh przeznaczonego dla urządzeń Internet of Things (IoT). Platforma OpenThread została opracowana przez zespół Google Nest i jest dostępna bezpłatnie dla społeczności programistów jako projekt open source.

Thread Specification to niezawodny, bezpieczny i energooszczędny protokół komunikacji bezprzewodowej na potrzeby urządzeń z ograniczonym dostępem często używanych w inteligentnych domach i budynkach komercyjnych. OpenThread obejmuje pełny zakres warstwy sieciowej w Thread, np. IPv6, 6LoWPAN, IEEE 802.15.4 z zabezpieczeniami MAC, nawiązywaniem połączeń typu mesh i routingiem sieci typu mesh.

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

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

codelab_overview.png

Czego się nauczysz

  • Konfigurowanie implementacji OpenThread w środowisku programistycznym Telink Zephyr.
  • Aby utworzyć przykładowe interfejsy wiersza poleceń OpenThread (ot-cli-ftd i ot-rcp) i wgrać je na tablice deweloperskie Telink B91.
  • Konfigurowanie routera granicznego OpenThread (OTBR) za pomocą Dockera na urządzeniu Raspberry Pi 3B lub nowszym
  • Tworzenie sieci typu Thread w OTBR:
  • Aby dodać urządzenia do sieci Thread przy użyciu debugowania poza pasmem.
  • Sprawdzanie połączeń między węzłami w sieci Thread za pomocą interfejsu wiersza poleceń.

Czego potrzebujesz

Sprzęt:

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

Oprogramowanie:

  • Telink Burning and Debugging Tool — LinuxBDT.
  • Narzędzie do podłączania portów szeregowych, takie jak PuTTY.
  • Inne narzędzia, takie jak Git i West.

2. Wymagania wstępne

Thread Concepts i interfejs wiersza poleceń OpenThread

Przed tym ćwiczeniem w programowaniu warto zapoznać się z ćwiczeniami z programowania OpenThread Simulation, które pozwolą im zapoznać się z podstawowymi pojęciami dotyczącymi Thread i interfejsem wiersza poleceń OpenThread.

Maszyna z systemem Linux

Komputer z systemem Linux (Ubuntu w wersji 20.04 LTS lub nowszej) pełni rolę maszyny do kompilacji, która umożliwia skonfigurowanie środowiska programistycznego Telink Zephyr i flashowanie wszystkich tablic programistycznych Thread. Do wykonania tych zadań komputer z systemem Linux wymaga dwóch dostępnych portów USB i połączenia z internetem.

Terminale i połączenie portu szeregowego

Możesz je podłączyć 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 portu szeregowego.

W tym ćwiczeniu z programowania narzędzie terminala PuTTY służy do sterowania FTD Joiner i Raspberry Pi. Wyjaśniono w nim jego użycie, ale można też użyć innego oprogramowania terminala.

To ćwiczenie z programowania wymaga 2 zestawów pakietów dla programistów B91. Na zdjęciu poniżej widać minimalną wymaganą liczbę komponentów w jednym zestawie.

overview.png

Jeden z nich będzie używany jako urządzenie RCP (Radio Co-Processor), a drugi jako FTD (Full Thread Device). Jeśli nie masz jeszcze zestawu, więcej szczegółów możesz znaleźć na oficjalnej stronie Telink. Możesz w tym celu korzystać z następujących komponentów:

Indeks

Nazwa

1

Rada rozwoju Telink B91

2

Tablica do spalania Telink

3

Antena 2,4 GHz

4

Przewód USB (z USB A na mini USB)

Raspberry Pi 3B lub nowsza z obrazem systemu operacyjnego Raspberry

W tym ćwiczeniu z programowania potrzebny jest program Raspberry Pi 3B lub nowszy z obrazem systemu operacyjnego Raspbian Bullseye Lite lub Raspbian Bullseye z komputerem. Jest połączone z internetem przez Ethernet i zostanie skonfigurowane jako host routera OTBR OpenThread Border Router.

Połączenie z siecią

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

LinuxBDT

Narzędzie Burning and Debugging Tool (BDT) Telink, które jest przeznaczone dla wszystkich serii układów Telink, umożliwia wymazanie i załadowanie oprogramowania OpenThread na płytach deweloperskich Telink B91. Zainstaluj na komputerze z systemem Linux wersję linuxBDT opartą na platformie X86.

Inne

  • Gita do konfigurowania środowiska programistycznego Telink Zephyr.
  • do zarządzania projektem Zephyr i tworzeniem plików binarnych OpenThread.

3. Skonfiguruj oprogramowanie układowe

Na komputerze z systemem Linux otwórz terminal interfejsu wiersza poleceń i zacznij od wykonania tych poleceń, aby sprawdzić, czy APT jest aktualny.

$ sudo apt update
$ sudo apt upgrade

Gdy to zrobisz, 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 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 wykonasz kolejne kroki, sprawdź wersje zainstalowane w systemie. Jeśli wersje nie są poprawne, przełącz kopię lustrzaną APT na stabilne i aktualne oprogramowanie lustrzane lub ręcznie zaktualizuj te zależności.
  2. Zainstaluj zachód.
    $ 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 umożliwić flashowanie większości tablic.
    $ 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 strony Hello World. Najpierw sprawdź, czy oficjalna konfiguracja projektu Zephyr jest prawidłowa, korzystając z przykładu Hello World, a następnie skonfiguruj swój 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 build/zephyr directory.
  7. Dodaj skrypt środowiska Zephyr do pliku ~/.bashrc. Wykonaj te polecenia.
    $ echo "source ~/zephyrproject/zephyr/zephyr-env.sh" >> ~/.bashrc
$ source ~/.bashrc
  8. Dodaj zdalne repozytorium Telink Zephyr. Pobierz repozytorium Telink lokalnie 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 przewodniku Zephyr Doc – przewodnik dla początkujących.

Pobierz narzędzie Telink LinuxBDT i rozpakuj je do lokalnego katalogu na komputerze z systemem Linux, takiego jak katalog domowy ~. Umożliwi to załadowanie oprogramowania układowego na kartę deweloperską 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 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 w wersji 3.6” oznacza, że programator BDT nawiązał połączenie z komputerem z systemem Linux.

Kompilacja oprogramowania

Dzięki tym ćwiczeniom z programowania stworzysz 2 typy oprogramowania typu 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 polecane urządzenie z wątkami 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łytę deweloperską B91 do płytki Burning Board za pomocą kabla USB, jak pokazano na ilustracji poniżej.

connection_overview.png

Wykonaj te polecenia w wierszu poleceń, aby nagrać oprogramowanie układowe (na przykład wykorzystując 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 Flash dla elementu ot-rcp jest zasadniczo taka sama jak dla ot-cli-ftd. Występują jednak pewne różnice w nazwach i ścieżkach oprogramowania układowego.

Po zakończeniu mignięcia zwróć uwagę na dwie płyty deweloperskie B91, oznaczając je odpowiednio. Oznacz płytę migającą etykietą ot-cli-ftd jako „FTD Joiner”, a oznaczoną etykietą ot-rcp jako „RCP”.

4. Konfiguracja konsoli szeregowej dla urządzenia do łączenia FTD

Jak widać na ilustracji, podłącz narzędzie FTD Joiner bezpośrednio do portu USB komputera z systemem Linux.

usb_connection.png

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

uart_console.png

Dokumentacja wiersza poleceń OpenThread: Dokumentacja interfejsu wiersza poleceń OpenThread. Pamiętaj, aby poprzedzić wszystkie polecenia znakiem ot.

Przykłady:

> ot state
disabled
Done
> ot channel
11
Done
>

5. Skonfiguruj Raspberry Pi jako router graniczny OpenThread

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

  • Urządzenie 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 przeprowadzić aktualizację oprogramowania układowego urządzenia ot-rcp, wykonaj te same czynności co w przypadku oprogramowania urządzenia ot-cli-ftd. Podłącz płytę deweloperską B91 do portu USB w Raspberry Pi, jak pokazano na ilustracji poniżej.

OTBR_overview.png

Raspberry Pi

  1. Upewnij się, że obraz systemu operacyjnego Raspbian Bullseye Lite lub Raspbian Bullseye z pulpitem został prawidłowo zapisany na karcie SD.
  2. Możesz połączyć się z serwerem Raspberry Pi przez SSH lub pracować bezpośrednio z komputerem Raspbian. To ćwiczenie z programowania będzie używało SSH.
  3. Zanim w następnym kroku zainstalujesz Dockera OTBR, zaktualizuj repozytorium lokalne i menedżera pakietów.
    $ sudo apt-get update
$ sudp apt-get upgrade

Zainstaluj Dockera

Jeśli w poprzednim kroku zaktualizujesz repozytorium lokalne i plik APT menedżera pakietów, 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, tak aby nie trzeba było dodawać sudo przed każdym poleceniem.
    $ sudo usermod -aG docker $USER
    Aby zastosować zmiany, musisz ponownie uruchomić Raspberry Pi.
  3. Jeśli Docker się nie uruchomił, uruchom go:
    $ sudo dockerd
  4. Skrypty zapory sieciowej OTBR generują reguły wewnątrz kontenera Dockera. Zanim to nastąpi, wykonaj polecenie modprobe, aby wczytać moduł jądra systemu iptables.
    $ sudo modprobe ip6table_filter

Konfigurowanie i uruchamianie Dockera

To ćwiczenie z programowania pobiera obraz Dockera OTBR 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. Określ nazwę portu szeregowego urządzenia RCP, zaznaczając pole /dev. ttyACM0 oznacza prawidłowe połączenie RCP.
    $ ls /dev/tty*
...
/dev/ttyACM0
...
  4. Uruchom Dockera OTBR po raz pierwszy, odnosząc się do portu szeregowego RCP (ttyACM0). Jeśli chcesz nadal używać tego Dockera 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 sprawdzić połączenie 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
  • Zatrzymanie Dockera OTBR:
    $ docker stop otbr
  • Usuń Dockera OTBR:
    $ docker rm otbr
  • Załaduj ponownie Dockera OTBR:
    $ docker restart otbr

Na tym etapie gotowe są urządzenia FTD Joiner i OTBR. Możesz przejść do kolejnego kroku, który pozwoli Ci utworzyć sieć Thread.

6. Tworzenie sieci typu Thread

Tworzenie sieci typu Thread w RCP

Do ustanowienia sieci typu Thread używamy powłoki ot-ctl w OTBR. Jeśli powłoka została zamknięta w ostatniej sekcji, wpisz następujące polecenie, aby uruchomić ją ponownie 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 kolejnego kroku upewnij się, że każdy krok przynosi oczekiwany wynik.

Indeks

Polecenie

Wstęp

Oczekiwana odpowiedź

1

dataset init new

Utwórz nowy losowy zbiór danych sieciowych.

OK

2

dataset commit active

Zatwierdź nowy zbiór danych do aktywnego zbioru danych operacyjnych w pamięci nieulotnej.

OK

3

ifconfig up

Wyświetl interfejs IPv6.

OK

4

thread start

Włącz obsługę protokołu Thread i podłącz do sieci Thread.

OK

Odczekaj 10 sekund, aż interfejs wątku się uruchomi.

5

state

Sprawdź stan urządzenia.To polecenie możesz wywołać wiele razy, aż stanie się liderem i przejdzie do następnego kroku.

lider
Gotowe

6

dataset active

Sprawdź kompletny aktywny zbiór danych operacyjnych i zapisz klucz sieciowy.

Aktywna sygnatura czasowa: 1
Nazwa kanału: 13
Maska kanału: 0x07ffff800
Ext PAN ID: b07476e168eda4fc
Lokalny przedrostek sieci: fd8c:60bc:a98:c7ba::/64
Klucz sieciowy: c31248518748




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

Dodaj łącznika FTD do Thread za pomocą zewnętrznego zlecenia

Przekazywanie danych poza zakresem odnosi się do przesyłania danych logowania do sieci do urządzeń czekających na dołączenie do sieci za pomocą metod niezwiązanych z bezprzewodową metodą (na przykład przez ręczne wpisanie danych w interfejsie wiersza poleceń OpenThread). W konsoli szeregowej wpisz po kolei poniższe polecenia do narzędzia FTD Joiner.

Indeks

Polecenie

Wstęp

Oczekiwane odpowiedzi

1

ot dataset networkkey c312485187484ceb5992d2343baaf93d

Aby urządzenie mogło połączyć się z siecią typu Thread, wymagane jest tylko podanie klucza sieciowego.

OK

2

ot dataset commit active

Zatwierdź nowy zbiór danych do aktywnego zbioru danych operacyjnych w pamięci nieulotnej.

OK

3

ot ifconfig up

Wyświetl interfejs IPv6.

OK

4

ot thread start

Włącz obsługę protokołu Thread i podłącz do sieci Thread.

OK

Poczekaj 20 sekund, aż urządzenie połączy się i skonfiguruje.

5

ot state

Sprawdź stan urządzenia.

dziecko/router
Gotowe

Topologia

W terminalu SSH wpisz polecenia takie jak ipaddr, child table czy router table, aby otrzymać odpowiedzi takie jak te podane poniżej.

> 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 dla OTBR to 0xb000, a RLOC16 dla FTD Joiner początkowo to 0xb001. Następnie w polu RLOC16 usługi FTD Joiner otrzyma wartość 0x8400 po uzyskaniu identyfikatora routera. Widać, że narzędzie do łączenia FTD zostało przekształcone z podrzędnego w router.

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

topology.png

7. Komunikacja między urządzeniami Thread

Komunikacja ICMPv6

Używamy polecenia ping do sprawdzania, 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 następujące polecenie w konsoli szeregowej narzędzia 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 dwoma urządzeniami się powiodła.

Połączenia UDP

Usługi aplikacji dostarczane przez OpenThread też zawierają protokół UDP. Za pomocą interfejsu UDP API możesz przekazywać informacje między węzłami w sieci Thread oraz przekazywać informacje do sieci zewnętrznych za pomocą routera Border Router. Szczegółowe informacje o interfejsie UDP API OpenThread znajdziesz w interfejsie wiersza poleceń OpenThread – przykład UDP. W tym ćwiczeniu z programowania użyjemy niektórych zawartych w nim interfejsów API do przesyłania informacji między OTBR a FTD Joiner.

Najpierw pobierz EID OTBR sieci typu mesh. Ten adres jest też jednym z adresów IPv6 urządzenia Thread i można go używać, aby uzyskiwać dostęp do urządzeń Thread w tej samej partycji sieciowej Thread.

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

Wpisz poniższe polecenia w terminalu SSH, aby włączyć protokół OTBR UDP i powiązać port 1022 urządzenia.

> udp open
Done
> udp bind :: 1022
Done

Wpisz poniższe polecenia w konsoli szeregowej i włącz protokół UDP funkcji FTD Joiner. Powiąż port 1022 urządzenia i wyślij 5-bajtową wiadomość 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 otrzymuje wiadomość hello od narzędzia FTD Joiner, co oznacza, że komunikacja UDP jest udana.

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

8. Gratulacje

Tworzysz prostą sieć typu Thread i zweryfikowałeś komunikację w tej sieci.

Wiesz już:

  • Jak utworzyć środowisko programistyczne Telink Zephyr i jak go używać.
  • Jak utworzyć pliki binarne ot-cli-ftd i ot-rcp, a także umieścić je na płytkach deweloperskich Telink B91.
  • Dowiedz się, jak skonfigurować Raspberry Pi 3B lub nowszą wersję jako router OpenThread Border Router (OTBR) za pomocą Dockera.
  • Jak utworzyć sieć typu Thread w OTBR.
  • Dodawanie urządzeń do sieci Thread przy użyciu pozapasmowego uruchamiania.
  • Jak sprawdzić połączenia między węzłami w sieci Thread.

Dalsza lektura

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

  • Obsługiwane platformy – poznaj wszystkie platformy obsługujące OpenThread.
  • Tworzenie OpenThread – więcej informacji o kompilowaniu i konfigurowaniu OpenThread.
  • Thread Primer – obejmuje wszystkie koncepcje związane z Thread opisane w tym ćwiczeniu z programowania;

Dokumenty referencyjne: