Thread-Netzwerk mit dem B91 Development Board und OpenThread erstellen

1. Einführung

OpenThread ist eine Open-Source-Implementierung des Thread®-Netzwerkprotokolls. Dabei handelt es sich um ein robustes und sicheres drahtloses Mesh-Netzwerkprotokoll, das für das Internet der Dinge (IoT) entwickelt wurde. OpenThread wurde vom Google Nest-Team entwickelt und steht der Entwickler-Community als Open-Source-Projekt kostenlos zur Verfügung.

Die Thread-Spezifikation bietet ein zuverlässiges, sicheres und energieeffizientes drahtloses Kommunikationsprotokoll für ressourcenbeschränkte Geräte, die häufig in Smart-Home-Geräten und Geschäftsgebäuden zu finden sind. OpenThread umfasst den gesamten Bereich der Netzwerkschicht innerhalb von Thread, z. B. IPv6, 6LoWPAN, IEEE 802.15.4 mit MAC-Sicherheit, Mesh-Link-Einrichtung und Mesh-Routing.

Telink hat die OpenThread-Implementierung in Zephyr RTOS integriert, was eine nahtlose Kompatibilität mit Telink-Hardware ermöglicht. Der Quellcode für diese Integration ist auf GitHub leicht zugänglich und er wird auch als Software Development Kit (SDK) bereitgestellt.

In diesem Codelab programmieren Sie OpenThread auf Hardware, erstellen und verwalten ein Thread-Netzwerk und tauschen Nachrichten zwischen Knoten aus. Das Bild unten zeigt die Hardwareeinrichtung mit einem OT Border Router (OTBR) und einem Thread-Gerät im Codelab.

Lerninhalte

• Einrichtung der OpenThread-Implementierung mithilfe der Telink Zephyr-Entwicklungsumgebung
• Zum Erstellen der OpenThread-CLI-Beispiele (ot-cli-ftd und ot-rcp) und zum Flashen auf Telink B91 Development Boards
• Einrichten eines OpenThread-Border-Routers (OTBR) mit Docker auf einem Raspberry Pi 3B+ oder höher
• Thread-Netzwerk im OTBR erstellen
• Durch Out-of-Band-Debugging Geräte zum Thread-Netzwerk hinzufügen
• Validieren der Konnektivität zwischen Knoten im Thread-Netzwerk mithilfe der Befehlszeile.

Voraussetzungen

Hardware:

• Zwei B91 Development Boards.
• Ein Raspberry Pi 3B oder höher mit Raspbian OS-Image.
• Ein Linux-Computer mit mindestens zwei USB-Ports.
• Ein mit dem Internet verbundener Switch (oder Router) und mehrere Ethernetkabel.

Software:

• Telink Burning- und Debugging-Tool – LinuxBDT.
• Terminaltool für serielle Ports, z. B. PuTTY
• Andere Tools wie Git und West.

2. Vorbereitung

Thread-Konzepte und OpenThread-CLI

Es kann hilfreich sein, sich vor diesem Codelab mit den grundlegenden Thread-Konzepten und der OpenThread-Befehlszeile vertraut zu machen, indem Sie das Codelab für die OpenThread-Simulation durchgehen.

Linux-Computer

Der Linux-Computer (Ubuntu v20.04 LTS oder höher) fungiert als Build-Computer zum Einrichten der Telink Zephyr-Entwicklungsumgebung und zum Flashen aller Thread-Entwicklungsboards. Dafür benötigt der Linux-Computer zwei verfügbare USB-Ports und eine Internetverbindung.

Verbindung des seriellen Ports und Terminals

Sie können das Gerät direkt an den USB-Port des Linux-Computers anschließen. Außerdem benötigen Sie für den Zugriff auf die Geräte ein Terminal-Tool für die serielle Schnittstelle.

In diesem Codelab wird das Terminal-Tool PuTTY zur Steuerung von FTD Joiner und Raspberry Pi verwendet. Sie bietet einen Überblick über die Nutzung, es kann jedoch auch andere Terminalsoftware eingesetzt werden.

Telink B91-Entwicklungskit

Für dieses Codelab sind zwei B91-Entwicklungskits erforderlich. Das Foto unten zeigt die mindestens erforderlichen Komponenten in einem Satz.

Eines dieser Kits wird als RCP (Radio Co-Processor) verwendet, das andere als FTD (Full Thread Device). Wenn Sie das Kit noch nicht haben, finden Sie weitere Informationen auf der offiziellen Website von Telink. Folgende Komponenten sind zu verwenden:

Raspberry Pi 3B oder höher mit Raspbian OS Image

In diesem Codelab wird ein Raspberry Pi 3B oder höher mit Raspbian Bullseye Lite OS-Image oder Raspbian Bullseye mit Desktop benötigt. Es ist über Ethernet mit dem Internet verbunden und wird als Host für den OpenThread-Border-Router (OTBR) konfiguriert.

Netzwerkverbindung

Ein mit dem Internet verbundener Switch (oder Router) und mehrere Ethernetkabel. Sie werden verwendet, um den Raspberry Pi mit dem Linux-Computer zu verbinden und die Nutzerkonfiguration des Raspberry Pi über den Host zu erleichtern.

LinuxBDT

Mit dem Burning- und Debugging-Tool (BDT) von Telink, das für alle Telink-Chipserien gilt, können Sie OpenThread-Firmware löschen und auf den Telink B91-Entwicklungsboards löschen und flashen. Installieren Sie die X86-basierte Linux-Version linuxBDT auf Ihrem Linux-Computer.

Sonstiges

• Git zum Einrichten der Telink Zephyr-Entwicklungsumgebung
• West zur Verwaltung des Zephyr-Projekts und zum Erstellen von OpenThread-Binärdateien.

3. Firmware einrichten

Telink Zephyr-Entwicklungsumgebung einrichten

Öffnen Sie auf dem Linux-Computer ein CLI-Terminal und führen Sie die folgenden Befehle aus, um sicherzustellen, dass Ihr APT auf dem neuesten Stand ist.

$ sudo apt update
$ sudo apt upgrade

Fahren Sie danach mit den folgenden Schritten fort.

1. Installieren Sie die Abhängigkeiten.

   $ 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
   

   Für Zephyr sind derzeit mindestens Versionen der Hauptabhängigkeiten wie CMake (3.20.0), Python3 (3.6) und Devicetree Compiler (1.4.6) erforderlich.

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

   Überprüfen Sie die installierten Versionen auf Ihrem System, bevor Sie mit den nächsten Schritten fortfahren. Wenn die Versionen nicht korrekt sind, stellen Sie den APT-Mirror auf eine stabile und aktuelle Spiegelung um oder aktualisieren Sie diese Abhängigkeiten manuell.
2. Installieren Sie „Westen“.

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

   Achten Sie darauf, dass ~/.local/bin in Ihrer Umgebungsvariable $PATH enthalten ist.
3. Rufen Sie den Quellcode des Zephyr-Projekts ab.

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

4. Installieren Sie zusätzliche Python-Abhängigkeiten für Zephyr.

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

5. Richten Sie die Zephyr-Toolchain ein. Laden Sie die Zephyr-Toolchain (ca. 1–2 GB) in ein lokales Verzeichnis herunter, damit Sie die meisten Boards flashen können.

   $ 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
   

   Laden Sie das Zephyr SDK herunter und platzieren Sie es in dem empfohlenen Pfad, wie unten gezeigt.

   $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]
   

   Dabei ist [-x.y.z] optionaler Text, der aus einem beliebigen Text bestehen kann, z. B. -0.16.1. Das Verzeichnis kann nach der Installation des SDK nicht mehr verschoben werden. Installieren Sie dann die Zephyr-Toolchain.

   $ 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. Erstellen Sie das Hello World-Beispiel. Prüfen Sie zuerst anhand des Hello World-Beispiels, ob die offizielle Zephyr-Projektkonfiguration korrekt ist, und fahren Sie dann mit der Einrichtung Ihres benutzerdefinierten Projekts fort.

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

   Verwenden Sie den Build-Befehl West, um das Beispiel „hello_world“ aus dem Stammverzeichnis des Zephyr-Repositorys zu erstellen. Die Firmware mit dem Namen zephyr.bin findest du unter der build/zephyr directory.
7. Fügen Sie das Zephyr-Umgebungsskript ~/.bashrc hinzu. Führen Sie die folgenden Befehle aus.

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

8. Fügen Sie das Telink Zephyr-Remote-Repository hinzu. Laden Sie das Telink-Repository lokal als Entwicklungszweig herunter und aktualisieren Sie es.

   $ 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
   

Weitere Informationen findest du im Startleitfaden für Zephyr.

Telink LinuxBDT einrichten

Lade das Telink LinuxBDT-Tool herunter und entpacke es in ein lokales Verzeichnis auf deinem Linux-Computer, z. B. das Basisverzeichnis ~. Dadurch kannst du die Firmware auf das B91 Development Board flashen.

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

Verbinden Sie das Burning Board über die USB-Schnittstelle mit dem Linux-Computer und geben Sie dann die folgenden Befehle ein.

$ 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

Wenn die Meldung „Telink Web Debugger v3.6“ angezeigt wird, bedeutet dies, dass der BDT-Programmierer erfolgreich eine Verbindung zum Linux-Computer hergestellt hat.

Firmware-Compilation

In diesem Codelab werden zwei Arten von OpenThread-Firmware erstellt:

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

Die Kompilierungsmethoden sind:

1. Funk-Co-Prozessor](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. Thread-Gerät mit vollem Funktionsumfang und interaktiver Befehlszeile (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
   

Firmware-Flash

Schließen Sie ein B91 Development Board über ein USB-Kabel an das Burning Board an (siehe Abbildung unten).

Führen Sie in der Befehlszeile die folgenden Befehle aus, um das Firmware-Buring durchzuführen. Verwenden Sie dabei als Beispiel das Flashen der ot-cli-ftd-Firmware.

$ 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

Die Flash-Methode für ot-rcp ist im Grunde dieselbe wie für ot-cli-ftd. Es gibt jedoch Unterschiede bei den Pfaden und Namen der Firmware.

Trennen Sie die beiden B91 Development Boards nach dem Blinken entsprechend, indem Sie sie entsprechend markieren. Beschriften Sie das Board mit dem Flash-Element ot-cli-ftd als „FTD Joiner“. und das Board hat ot-rcp als „RCP“ angezeigt.

4. Serielle Konsole für das FTD-Joiner-Gerät konfigurieren

Stecken Sie den FTD-Joiner direkt in den USB-Anschluss des Linux-Computers, wie in der Abbildung dargestellt.

Nachdem Sie das FTD-Joiner-Gerät mit dem Linux-Computer verbunden haben, öffnen Sie PuTTY. Erstellen Sie dann ein neues Terminal, legen Sie die Informationen zum seriellen Port fest und öffnen Sie den seriellen Port.

Die Befehlszeilenreferenz zu OpenThread finden Sie hier: Referenz zur OpenThread-Befehlszeile. Achten Sie darauf, allen Befehlen ot voranzustellen.

Beispiele:

> ot state
disabled
Done
> ot channel
11
Done
>

5. Raspberry Pi als OpenThread-Border-Router einrichten

Ein OpenThread-Border-Router ist ein Gerät, das aus zwei Hauptteilen besteht:

• Raspberry Pi enthält alle Dienste und die Firmware, die für die Funktion eines Border Router (BR) erforderlich sind.
• RCP ist für die Thread-Kommunikation verantwortlich.

Co-Prozessor (Funkprozessor) (RCP)

Wenn du die ot-rcp-Firmware flashen möchtest, folge denselben Schritten wie der ot-cli-ftd-Firmware-Flash-Prozess. Schließen Sie das B91 Development Board an einen USB-Anschluss des Raspberry Pi an (siehe Abbildung unten).

Himbeer-Pi

1. Prüfen Sie, ob das Raspbian Bullseye Lite OS-Image oder Raspbian Bullseye mit Desktop korrekt auf die SD-Karte geschrieben ist.
2. Sie haben die Möglichkeit, entweder eine SSH-Verbindung zum Raspberry Pi herzustellen oder direkt mit Raspbian Desktop zu arbeiten. In diesem Codelab wird SSH verwendet.
3. Bevor Sie im nächsten Schritt mit der Installation von OTBR-Docker beginnen, müssen Sie zuerst das lokale Repository und den Paketmanager aktualisieren.

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

Docker installieren

Wenn Sie nur das lokale Repository und die APT-Datei des Paketmanagers im vorherigen Schritt aktualisiert haben, starten Sie Raspberry Pi neu und öffnen Sie dann ein SSH-Terminalfenster.

1. Installieren Sie Docker:

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

2. Fügen Sie das aktuelle Konto in eine Docker-Gruppe ein, um die Berechtigung zu erteilen, damit sudo nicht vor jedem Befehl hinzugefügt werden muss.

   $ sudo usermod -aG docker $USER
   

   Sie müssen den Raspberry Pi neu starten, damit die Änderungen wirksam werden.
3. Wenn Docker noch nicht gestartet wurde, starten Sie es:

   $ sudo dockerd
   

4. Die OTBR-Firewall-Skripts generieren Regeln im Docker-Container. Führen Sie davor modprobe aus, um das Kernelmodul von iptables zu laden.

   $ sudo modprobe ip6table_filter
   

Docker konfigurieren und ausführen

Mit diesem Codelab wird das OTBR-Docker-Image direkt aus dem OpenThread Docker Hub abgerufen. Dieses Image wurde vom OpenThread-Team getestet und verifiziert.

1. Rufen Sie das neueste Image ab:

   $ docker pull openthread/otbr:latest
   

2. Prüfen Sie die Image-Liste im Docker-Container:

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

3. Ermitteln Sie den Namen des seriellen Ports des RCP-Geräts, indem Sie /dev prüfen. ttyACM0 zeigt an, dass das RCP richtig verbunden ist.

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

4. Führen Sie OTBR-Docker zum ersten Mal aus und verweisen Sie auf den seriellen Port von RCP (ttyACM0). Wenn Sie diesen OTBR-Docker weiter verwenden möchten, verwenden Sie den Befehl 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. Öffnen Sie ein neues SSH-Terminalfenster, um die Verbindung zwischen Raspberry Pi und RCP zu testen.

   $ docker exec -ti otbr sh -c "sudo ot-ctl"
   > state 
   disabled
   Done
   

Optionale Docker-Befehle:

• Rufen Sie Informationen zum ausgeführten Docker-Container ab:

  $ docker ps -aq
  

• Beenden Sie den OTBR-Docker:

  $ docker stop otbr
  

• Entfernen Sie den OTBR-Docker:

  $ docker rm otbr
  

• Aktualisieren Sie den OTBR-Docker:

  $ docker restart otbr
  

Jetzt sind ein FTD Joiner-Gerät und ein OTBR bereit und Sie können mit dem nächsten Schritt fortfahren, um das Thread-Netzwerk zu erstellen.

6. Thread-Netzwerk erstellen

Thread-Netzwerk auf RCP erstellen

Wir verwenden die ot-ctl-Shell im OTBR, um ein Thread-Netzwerk einzurichten. Wenn Sie die Shell im letzten Abschnitt beendet haben, geben Sie den folgenden Befehl ein, um sie im SSH-Terminal neu zu starten:

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

Geben Sie als Nächstes die Befehle in der in der Tabelle angegebenen Reihenfolge ein und achten Sie darauf, dass jeder Schritt das erwartete Ergebnis erzielt, bevor Sie mit dem nächsten fortfahren.

Der vom OTBR bei der Netzwerkerstellung zufällig generierte Netzwerkschlüssel wird verwendet, wenn ot-cli-ftd-Geräte diesem Thread-Netzwerk beitreten.

FTD-Verbindungskabel über Out-of-Band-Inbetriebnahme zu Thread hinzufügen

Die Out-of-Band-Inbetriebnahme bezieht sich auf die Übertragung von Netzwerkanmeldedaten an Geräte, die auf den Beitritt zum Netzwerk warten, und zwar über nicht drahtlose Methoden (z. B. manuelle Eingabe über die OpenThread-CLI). Geben Sie die folgenden Befehle in der seriellen Konsole in der richtigen Reihenfolge zum FTD-Joiner ein.

Topologie

Geben Sie Befehle wie ipaddr, child table, router table in das SSH-Terminal ein, um Antworten wie die folgenden Code-Snippets zu erhalten.

> 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

Die RLOC16 des OTBR ist 0xb000 und die RLOC16 des FTD-Joiner ist anfänglich 0xb001. Dann wird der RLOC16 des FTD-Joiner zu 0x8400, nachdem die Router-ID abgerufen wurde. Wie Sie sehen können, wurde der FTD Joiner von einem untergeordneten Element zu einem Router aktualisiert.

Das aktuelle Thread-Netzwerk enthält zwei Knoten und die Topologie ist in der folgenden Abbildung dargestellt.

7. Kommunikation zwischen Thread-Geräten

ICMPv6-Kommunikation

Wir verwenden den Befehl ping, um zu prüfen, ob Thread-Geräte im selben Netzwerk miteinander kommunizieren können. Rufen Sie zuerst mit dem Befehl ipaddr das RLOC des Geräts ab.

> 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

Geben Sie in der seriellen Konsole des FTD-Joiner den folgenden Befehl ein, um den Ping-Vorgang auszuführen.

> 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

Die Ausgabeantwort des seriellen Ports zeigt an, dass die OTBR-Seite die Ping-Anfrage erhalten hat und der FTD-Joiner die von OTBR zurückgegebene Ping-Antwort erhalten hat. Die Kommunikation zwischen den beiden Geräten war erfolgreich.

UDP-Kommunikation

Zu den von OpenThread bereitgestellten Anwendungsdiensten gehört auch UDP. Mit der UDP API können Sie Informationen zwischen Knoten im Thread-Netzwerk oder über den Border Router an externe Netzwerke weitergeben. Die ausführliche Einführung in die UDP-API von OpenThread finden Sie unter OpenThread CLI – UDP Example. In diesem Codelab werden einige der darin enthaltenen APIs verwendet, um Informationen zwischen OTBR und FTD Joiner zu übertragen.

Rufen Sie zuerst die Mesh-Local-EID des OTBR ab. Diese Adresse ist auch eine der IPv6-Adressen des Thread-Geräts und kann für den Zugriff auf Thread-Geräte in derselben Thread-Netzwerkpartition verwendet werden.

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

Geben Sie im SSH-Terminal die folgenden Befehle ein, um OTBR UDP zu aktivieren und den 1022-Port des Geräts zu binden.

> udp open
Done
> udp bind :: 1022
Done

Geben Sie die folgenden Befehle in die serielle Konsole ein und aktivieren Sie UDP des FTD-Joiner. Binden Sie den 1022-Port des Geräts ein und senden Sie dann eine 5-Byte-hello-Nachricht an das OTBR.

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

Das SSH-Terminal gibt die folgenden Informationen aus. OTBR empfängt die hello-Nachricht vom FTD-Joiner, was bedeutet, dass die UDP-Kommunikation erfolgreich ist.

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

8. Glückwunsch

Sie haben ein einfaches Thread-Netzwerk erstellt und die Kommunikation innerhalb dieses Netzwerks überprüft.

Jetzt wissen Sie:

• Entwicklung und Verwendung der Telink Zephyr-Entwicklungsumgebung
• Hier erfahren Sie, wie Sie die Binärdateien ot-cli-ftd und ot-rcp erstellen und auf Telink B91 Development Boards flashen.
• Hier erfahren Sie, wie Sie mit Docker eine Version von Raspberry Pi 3B oder höher als OpenThread Border Router (OTBR) einrichten.
• Thread-Netzwerk auf OTBR erstellen
• So fügst du dem Thread-Netzwerk über Out-of-Band-Inbetriebnahme Geräte hinzu.
• Verbindung zwischen Knoten im Thread-Netzwerk prüfen

Weiterführende Literatur

Auf openthread.io und GitHub erfahren Sie mehr über verschiedene OpenThread-Ressourcen, darunter:

• Unterstützte Plattformen – Finden Sie alle Plattformen, die OpenThread unterstützen.
• OpenThread erstellen – weitere Details zum Erstellen und Konfigurieren von OpenThread
• Thread Primer – behandelt alle Thread-Konzepte in diesem Codelab

Referenzdokumente:

• Referenz zur OpenThread-Befehlszeile
• Referenz zur OpenThread-UDP-Befehlszeile
• Referenz zur OpenThread UDP API