Thread-Netzwerk mit dem B91 Development Board und OpenThread erstellen

1. Einführung

OpenThread ist eine Open-Source-Implementierung des Thread®-Netzwerkprotokolls, einem robusten und sicheren drahtlosen Mesh-Netzwerkprotokoll, das für IoT-Geräte (Internet of Things) entwickelt wurde. OpenThread wurde vom Nest-Team von Google entwickelt und ist der Entwickler-Community als Open-Source-Projekt frei verfügbar.

Die Thread-Spezifikation legt ein zuverlässiges, sicheres und energieeffizientes drahtloses Kommunikationsprotokoll für ressourcenbeschränkte Geräte fest, die häufig in Smart Homes und gewerblichen Gebäuden zu finden sind. OpenThread umfasst den gesamten Umfang 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 verfügbar und wird auch als Software Development Kit (SDK) bereitgestellt.

In diesem Codelab programmieren Sie OpenThread auf echter 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

• So richten Sie die OpenThread-Implementierung mit der Telink Zephyr-Entwicklungsumgebung ein.
• So erstellen Sie die OpenThread-CLI-Beispiele (ot-cli-ftd und ot-rcp) und flashen sie auf Telink B91-Entwicklungsboards.
• So richten Sie einen OpenThread Border Router (OTBR) mit Docker auf einem Raspberry Pi 3B+ oder höher ein.
• So erstellen Sie ein Thread-Netzwerk auf dem OTBR:
• Geräte über Out-of-Band-Debugging zum Thread-Netzwerk hinzufügen.
• So prüfen Sie die Verbindung zwischen Knoten im Thread-Netzwerk über die Befehlszeile.

Voraussetzungen

Hardware:

• Zwei B91-Entwicklungsboards.
• Ein Raspberry Pi 3B+ oder höher mit Raspbian-Betriebssystem-Image.
• Ein Linux-Computer mit mindestens zwei USB-Anschlüssen.
• Ein mit dem Internet verbundener Switch (oder Router) und mehrere Ethernetkabel.

Software:

• Telink Burning and Debugging Tool – LinuxBDT.
• Terminaltool für den seriellen Port, z. B. PuTTY.
• Andere Tools wie Git und West.

2. Vorbereitung

Thread-Konzepte und OpenThread-CLI

Es kann hilfreich sein, vor diesem Codelab das OpenThread-Simulations-Codelab durchzuarbeiten, um sich mit den grundlegenden Thread-Konzepten und der OpenThread-Befehlszeile vertraut zu machen.

Linux-Computer

Die Linux-Maschine (Ubuntu v20.04 LTS oder höher) dient als Build-Maschine zum Einrichten der Telink Zephyr-Entwicklungsumgebung und zum Flashen aller Thread-Entwicklungsboards. Für diese Aufgaben sind zwei freie USB-Anschlüsse und eine Internetverbindung auf dem Linux-Computer erforderlich.

Verbindung und Terminals für serielle Ports

Sie können das Gerät direkt an den USB-Anschluss des Linux-Computers anschließen. Außerdem benötigen Sie ein serielles Port-Terminal-Tool, um auf die Geräte zuzugreifen.

In diesem Codelab wird das Terminaltool PuTTY zum Steuern des FTD-Joiners und des Raspberry Pi verwendet. Es bietet einen Überblick über die Verwendung, aber auch andere Terminalsoftware kann verwendet werden.

Telink B91 Development Kit

Für dieses Codelab sind zwei B91-Entwicklungskits erforderlich. Auf dem Foto unten sind die erforderlichen Mindestkomponenten in einem Set zu sehen.

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 Telink-Website. Hier einige Komponenten, die verwendet werden können:

Raspberry Pi 3B+ oder höher mit Raspbian-Betriebssystem-Image

Für dieses Codelab ist ein Raspberry Pi 3B+ oder höher mit dem Raspbian Bullseye Lite-Betriebssystem-Image oder Raspbian Bullseye mit Desktop erforderlich. Er 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 Konfiguration des Raspberry Pi über den Host zu ermöglichen.

LinuxBDT

Mit dem Burning and Debugging Tool (BDT) von Telink, das für alle Telink-Chipserien gilt, können Sie die OpenThread-Firmware 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 zum Verwalten von Zephyr-Projekten 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 zuerst die folgenden Befehle aus, um sicherzustellen, dass Ihr APT auf dem neuesten Stand ist.

$ sudo apt update
$ sudo apt upgrade

Fahren Sie dann 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 Mindestversionen der wichtigsten Abhängigkeiten erforderlich, z. B. CMake (3.20.0), Python3 (3.6) und Devicetree Compiler (1.4.6).

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

   Prüfen Sie die installierten Versionen auf Ihrem System, bevor Sie mit den nächsten Schritten fortfahren. Wenn die Versionen nicht korrekt sind, wechseln Sie den APT-Mirror zu einem stabilen und aktuellen Mirror oder aktualisieren Sie diese Abhängigkeiten manuell.
2. Installieren Sie „west“.

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

   Prüfen Sie, ob ~/.local/bin in der Umgebungsvariable $PATH enthalten ist.
3. Zephyr Project-Quellcode abrufen

   $ 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 legen Sie es wie unten gezeigt im empfohlenen Pfad ab.

   $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 beliebigen Text enthalten 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. 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 West-Build-Befehl, um das hello_world-Beispiel aus dem Stammverzeichnis des Zephyr-Repositorys zu erstellen. Die Firmware mit dem Namen zephyr.bin finden Sie unter build/zephyr directory.
7. Fügen Sie das Zephyr-Umgebungsskript zu ~/.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 finden Sie im Zephyr-Dokument – Erste Schritte.

Telink LinuxBDT einrichten

Laden Sie das Telink LinuxBDT-Tool herunter und extrahieren Sie es in ein lokales Verzeichnis auf Ihrem Linux-Computer, z. B. in das Basisverzeichnis ~, damit Sie die Firmware auf das B91-Entwicklungsboard flashen können.

$ 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, hat der BDT-Programmierer erfolgreich eine Verbindung zum Linux-Computer hergestellt.

Firmware-Compilation

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

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

Die Kompilierungsmethoden sind:

1. Funk-Coprozessor (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. Vollwertiges Thread-Gerät mit 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

Verbinden Sie ein B91-Entwicklungsboard mit dem Burning Board über ein USB-Kabel, wie in der Abbildung unten dargestellt.

Führen Sie in der Befehlszeile die folgenden Befehle aus, um die Firmware zu flashen (am Beispiel des Flashings 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 Firmware-Pfaden und ‑Namen.

Markieren Sie die beiden B91-Entwicklungsboards nach dem Flashen entsprechend, um sie unterscheiden zu können. Kennzeichne das mit ot-cli-ftd geflashte Board als „FTD Joiner“ und das mit ot-rcp geflashte Board als „RCP“.

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

Wie auf dem Bild zu sehen, stecken Sie den FTD-Joiner direkt in den USB-Anschluss des Linux-Computers.

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 OpenThread-Befehlszeilenreferenz finden Sie unter OpenThread CLI Reference. Stellen Sie allen Befehlen ot voran.

Beispiele:

> ot state
disabled
Done
> ot channel
11
Done
>

5. Raspberry Pi als OpenThread Border Router einrichten

Ein OpenThread Border Router besteht aus zwei Hauptteilen:

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

Radio Co-Processor (RCP)

Wenn du die ot-rcp-Firmware flashen möchtest, gehe genauso vor wie beim Flashen der ot-cli-ftd-Firmware. Verbinden Sie das B91-Entwicklungsboard mit einem USB-Anschluss des Raspberry Pi, wie in der Abbildung unten dargestellt.

Raspberry Pi

1. Achten Sie darauf, dass das Raspbian Bullseye Lite-Betriebssystem-Image oder Raspbian Bullseye mit Desktop richtig auf die SD-Karte geschrieben wurde.
2. Sie haben die Möglichkeit, eine SSH-Verbindung zum Raspberry Pi herzustellen oder direkt mit dem Raspbian-Desktop zu arbeiten. In diesem Codelab wird SSH verwendet.
3. Bevor Sie mit der Installation von OTBR Docker im nächsten Schritt fortfahren, müssen Sie das lokale Repository und den Paketmanager aktualisieren.

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

Docker installieren

Wenn Sie im vorherigen Schritt nur das lokale Repository und den Paketmanager APT 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 einer Docker-Gruppe hinzu, um die Berechtigung zu erteilen, damit sudo nicht vor jedem Befehl hinzugefügt werden muss.

   $ sudo usermod -aG docker $USER
   

   Du musst den Raspberry Pi neu starten, damit die Änderungen wirksam werden.
3. Wenn Docker nicht gestartet wurde, starten Sie es:

   $ sudo dockerd
   

4. Die OTBR-Firewallskripts 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

In diesem Codelab wird das OTBR-Docker-Image direkt aus dem OpenThread Docker Hub abgerufen. Dieses Image wurde vom OpenThread-Team getestet und bestätigt.

1. Rufen Sie das aktuelle Image ab:

   $ docker pull openthread/otbr:latest
   

2. Prüfen Sie die Imageliste 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 gibt an, dass das RCP-Gerät richtig angeschlossen ist.

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

4. Führen Sie OTBR Docker zum ersten Mal aus und verweisen Sie auf den seriellen Port des RCP (ttyACM0). Wenn Sie diesen OTBR Docker weiterhin 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 dem Raspberry Pi und dem RCP zu testen.

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

Optionale Docker-Befehle:

• Informationen zum laufenden Docker-Container abrufen:

  $ docker ps -aq
  

• OTBR-Docker beenden:

  $ docker stop otbr
  

• OTBR-Docker entfernen:

  $ docker rm otbr
  

• OTBR-Docker neu laden:

  $ docker restart otbr
  

An diesem Punkt 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 auf dem 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 die Befehle als Nächstes in der in der Tabelle angegebenen Reihenfolge ein und prüfen Sie, ob jeder Schritt das erwartete Ergebnis liefert, bevor Sie mit dem nächsten Schritt fortfahren.

Der Netzwerkschlüssel, der von OTBR während der Netzwerkerstellung zufällig generiert wird, wird verwendet, wenn ot-cli-ftd-Geräte diesem Thread-Netzwerk beitreten.

FTD-Joiner ü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 darauf warten, dem Netzwerk beizutreten, über nicht drahtlose Methoden (z. B. manuelle Eingabe in der OpenThread-Befehlszeile). Geben Sie die folgenden Befehle in der seriellen Konsole in der angegebenen Reihenfolge ein, um den FTD-Joiner zu konfigurieren.

Topologie

Geben Sie im SSH-Terminal Befehle wie ipaddr, child table und router table 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-Joiners ist anfangs 0xb001. Die RLOC16 des FTD-Joiners wird dann nach Erhalt der Router-ID zu 0x8400. Der FTD-Joiner wurde von einem untergeordneten Gerät zu einem Router hochgestuft.

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

7. Kommunikation zwischen Thread-Geräten

ICMPv6-Kommunikation

Mit dem Befehl ping prüfen wir, ob Thread-Geräte im selben Netzwerk miteinander kommunizieren können. Verwende zuerst den Befehl ipaddr, um den RLOC des Geräts abzurufen.

> 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 den folgenden Befehl in die serielle Konsole des FTD-Joiner 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 Ausgabereaktion des seriellen Ports gibt an, dass die OTBR-Seite die Ping-Anfrage empfangen hat und der FTD-Joiner die von OTBR zurückgegebene Ping-Antwort empfangen hat. Die Kommunikation zwischen den beiden Geräten ist erfolgreich.

UDP-Kommunikation

Die von OpenThread bereitgestellten Anwendungsdienste umfassen auch UDP. Mit der UDP API können Sie Informationen zwischen Knoten im Thread-Netzwerk oder über den Border Router an externe Netzwerke übertragen. Eine detaillierte Einführung in die UDP API von OpenThread finden Sie unter OpenThread CLI – UDP-Beispiel. In diesem Codelab werden einige der APIs verwendet, um Informationen zwischen OTBR und FTD-Joiner zu übertragen.

Rufen Sie zuerst die Mesh-Local-EID von OTBR ab. Diese Adresse ist auch eine der IPv6-Adressen des Thread-Geräts und kann verwendet werden, um auf Thread-Geräte in derselben Thread-Netzwerkpartition zuzugreifen.

> 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 Port 1022 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 das UDP des FTD Joiner. Binde den Port 1022 des Geräts und sende dann eine 5‑Byte-hello-Nachricht an 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. Das 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 in diesem Netzwerk überprüft.

Sie wissen jetzt:

• So erstellen und verwenden Sie die Telink Zephyr-Entwicklungsumgebung.
• So erstellen Sie die Binärdateien ot-cli-ftd und ot-rcp und flashen sie auf Telink B91-Entwicklungsboards.
• So richten Sie einen Raspberry Pi 3B+ oder höher als OpenThread Border Router (OTBR) mit Docker ein.
• Thread-Netzwerk auf OTBR erstellen
• Geräte über die Out-of-Band-Inbetriebnahme dem Thread-Netzwerk hinzufügen
• So prüfen Sie die Verbindung zwischen Knoten im Thread-Netzwerk.

Weiterführende Literatur

Auf openthread.io und GitHub findest du verschiedene OpenThread-Ressourcen, darunter:

• Unterstützte Plattformen: Hier finden Sie alle Plattformen, die OpenThread unterstützen.
• OpenThread erstellen – Weitere Informationen zum Erstellen und Konfigurieren von OpenThread
• Thread Primer: Hier werden alle Thread-Konzepte behandelt, die in diesem Codelab vorgestellt werden.

Referenzdokumente:

• OpenThread-Befehlszeilenreferenz
• OpenThread UDP-Befehlszeilenreferenz
• OpenThread UDP API-Referenz