Google 致力于为黑人社区推动种族平等。查看具体行动。

Diese Seite wurde von der Cloud Translation API übersetzt.

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 Geräte im Internet der Dinge (IoT) entwickelt wurde. OpenThread wurde vom Google Nest-Team entwickelt und steht der Entwickler-Community kostenlos als Open-Source-Projekt 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 Homes 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 eingebunden und ermöglicht so eine nahtlose Kompatibilität mit Telink-Hardware. Der Quellcode für diese Integration ist auf GitHub leicht zugänglich 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

Zum Einrichten der OpenThread-Implementierung mithilfe der Telink-Zephyr-Entwicklungsumgebung.
Erstellen der Beispiele für die OpenThread-Befehlszeile (ot-cli-ftd und ot-rcp) und Übertragen der Beispiele auf Telink B91-Entwicklungsboards.
So richten Sie einen OpenThread-Border-Router (OTBR) mit Docker auf einem Raspberry Pi 3B+ oder höher ein.
Zum Erstellen eines Thread-Netzwerks auf dem OTBR.
Geräte zum Thread-Netzwerk über Out-of-Band-Debugging hinzufügen
Prüfen der Konnektivität zwischen Knoten im Thread-Netzwerk mithilfe der Befehlszeile

Voraussetzungen

Hardware:

Zwei B91-Entwicklungsgremien.
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 and Debugging Tool“ — LinuxBDT.
Terminal-Tool für serielle Ports, z. B. PuTTY.
Andere Tools wie Git und West.

2. Voraussetzungen

Thread-Konzepte und OpenThread-Befehlszeile

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

Linux-Computer

Der Linux-Computer (Ubuntu v20.04 LTS oder höher) dient als Build-Maschine für die Einrichtung der Telink-Zephyr-Entwicklungsumgebung und das Flashen aller Thread-Entwicklungsboards. Dazu 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-Anschluss des Linux-Computers anschließen. Außerdem benötigen Sie ein Terminal-Tool für den seriellen Port, um auf die Geräte zuzugreifen.

In diesem Codelab wird FTD Joiner und Raspberry Pi mit dem Terminal-Tool PuTTY gesteuert. Sie bietet einen Überblick über die Verwendung, es kann aber auch andere Terminalsoftware eingesetzt werden.

Telink B91-Entwicklungskit

Für dieses Codelab sind zwei Sets 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 auf der offiziellen Website von Telink weitere Informationen. Folgende Komponenten sind zu verwenden:

Index	Name
1	Telink B91 Development Board
2	Telink-Brennplatte
3	2,4-GHz-Antenne
4	USB-Kabel (USB-A auf Mini-USB)

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

Einen mit dem Internet verbundenen 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 and Debugging Tool (BDT), das für alle Telink-Chipserien verwendet wird, können Sie OpenThread-Firmware löschen und auf den Telink B91-Entwicklungsboards installieren. Installieren Sie die X86-basierte Linux-Version linuxBDT auf Ihrem Linux-Computer.

Anderes Angebot

Git zum Einrichten der Telink Zephyr-Entwicklungsumgebung
West zum Verwalten des Zephyr-Projekts und zum Erstellen von OpenThread-Binärprogrammen.

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 anschließend mit den folgenden Schritten fort.

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
```
Zephyr benötigt derzeit Mindestversionen der Hauptabhängigkeiten wie CMake (3.20.0), Python3 (3.6) und Devicetree Compiler (1.4.6).
```
$ cmake --version
$ python3 --version
$ dtc --version
```
Prüfen Sie die auf Ihrem System installierten Versionen, bevor Sie mit den nächsten Schritten fortfahren. Wenn die Versionen nicht korrekt sind, stellen Sie den APT-Spiegel auf einen stabilen und aktuellen Spiegel um oder aktualisieren Sie diese Abhängigkeiten manuell.

„Westen installieren“.

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

~/.local/bin muss in der Umgebungsvariablen $PATH enthalten sein.

Rufen Sie den Quellcode des Zephyr-Projekts ab.

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

Zusätzliche Python-Abhängigkeiten für Zephyr installieren.

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

Zephyr-Toolchain einrichten 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 wie unten gezeigt im empfohlenen Pfad.

$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 ein beliebiger Text sein kann, z. B. -0.16.1. Das Verzeichnis kann nach der SDK-Installation 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

Erstellen Sie das Hello World-Beispiel. Überprü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 Build-Befehl „West“, um das Beispiel „hello_world“ aus dem Stammverzeichnis des Zephyr-Repositorys zu erstellen. Sie finden die Firmware mit dem Namen zephyr.bin unter der build/zephyr directory.
Fügen Sie das Skript der Zephyr-Umgebung zu ~/.bashrc hinzu. Führen Sie die folgenden Befehle aus.
```
$ echo "source ~/zephyrproject/zephyr/zephyr-env.sh" >> ~/.bashrc
$ source ~/.bashrc
```

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

Telink LinuxBDT einrichten

Laden Sie das Telink LinuxBDT-Tool herunter und extrahieren Sie es in ein lokales Verzeichnis auf Ihrem Linux-Computer, z. B. das Basisverzeichnis ~. Dadurch kann die Firmware auf dem B91 Development Board geflasht werden.

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

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

ot-cli-ftd,
und ot-rcp.

Die Kompilierungsmethoden sind wie folgt:

Funk-Koprozessor(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

Thread-Gerät mit vollem Funktionsumfang 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

Schließen Sie ein B91 Development Board über ein USB-Kabel an das Burning Board an, wie in der folgenden Abbildung dargestellt.

Führen Sie in der Befehlszeile die folgenden Befehle aus, um ein Brennen der Firmware durchzuführen. Verwenden Sie als Beispiel das Blinken 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 entspricht im Wesentlichen der für ot-cli-ftd. Es gibt jedoch Unterschiede in den Firmwarepfaden und -namen.

Nach dem Blinken können Sie die beiden B91 Development Boards voneinander unterscheiden, indem Sie sie entsprechend markieren. Beschrifte die Platine mit ot-cli-ftd als „FTD Joiner“ und auf der Tafel ot-rcp als „RCP“.

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

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

Öffnen Sie PuTTY, nachdem Sie das FTD-Joiner-Gerät mit dem Linux-Computer verbunden haben. 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 hier: OpenThread-CLI-Referenz. Achten Sie darauf, allen Befehlen das Präfix 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 Firmware, die als Border Router (BR) erforderlich sind.
RCP ist für die Thread-Kommunikation verantwortlich.

Funk-Co-Prozessor(RCP)

Führe dieselben Schritte wie beim Blinken der Firmware von ot-cli-ftd durch, um die ot-rcp-Firmware zu flashen. Schließen Sie das B91 Development Board an einen USB-Anschluss des Raspberry Pi an, wie in der folgenden Abbildung dargestellt.

Raspberry Pi

Prüfen Sie, ob das Raspbian Bullseye Lite OS-Image oder Raspbian Bullseye with Desktop korrekt auf die SD-Karte geschrieben wurde.
Sie können entweder eine SSH-Verbindung zum Raspberry Pi herstellen oder direkt mit dem Raspbian Desktop arbeiten. In diesem Codelab wird SSH verwendet.
Bevor Sie im nächsten Schritt OTBR-Docker installieren, müssen Sie zuerst 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 aktualisieren, starten Sie Raspberry Pi neu und öffnen Sie ein SSH-Terminalfenster.

Installieren Sie Docker:

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

Fügen Sie das aktuelle Konto einer Docker-Gruppe hinzu, um die Berechtigung zu gewähren. So muss nicht sudo vor jedem Befehl hinzugefügt werden.
```
$ sudo usermod -aG docker $USER
```
Sie müssen den Raspberry Pi neu starten, damit die Änderungen wirksam werden.
Wenn Docker noch nicht gestartet wurde, starten Sie es:
```
$ sudo dockerd
```
Die OTBR-Firewallskripts generieren Regeln im Docker-Container. Führen Sie vorher 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 verifiziert.

Rufen Sie das neueste Image ab:
```
$ docker pull openthread/otbr:latest
```

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

Ermitteln Sie den Namen des seriellen Ports des RCP-Geräts. Dazu prüfen Sie /dev, ttyACM0 zeigt an, dass der RCP korrekt verbunden ist.
```
$ ls /dev/tty*
...
/dev/ttyACM0
... 
```

Führen Sie zum ersten Mal OTBR-Docker aus und verweisen Sie auf den seriellen Port von 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

Ö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:

Informationen zum ausgeführten Docker-Container abrufen:
```
$ docker ps -aq
```
OTBR-Docker beenden:
```
$ docker stop otbr
```
OTBR-Docker entfernen:
```
$ docker rm otbr
```
OTBR-Docker aktualisieren:
```
$ 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 unter RCP erstellen

Wir verwenden die ot-ctl-Shell auf dem OTBR, um ein Thread-Netzwerk einzurichten. Wenn Sie die Shell im letzten Abschnitt verlassen haben, geben Sie den folgenden Befehl ein, um sie im SSH-Terminal noch einmal 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.

Index	Befehl	Einführung	Erwartete Antwort
1	`dataset init new`	Erstellen Sie ein neues zufälliges Netzwerk-Dataset.	Fertig
2	`dataset commit active`	Übertragen Sie das neue Dataset per Commit zum aktiven operativen Dataset im nichtflüchtigen Speicher.	Fertig
3	`ifconfig up`	Rufen Sie die IPv6-Schnittstelle auf.	Fertig
4	`thread start`	Aktivieren Sie den Thread-Protokollvorgang und hängen Sie ihn an ein Thread-Netzwerk an.	Fertig
			Warten Sie 10 Sekunden, bis die Thread-Schnittstelle aktiv ist.
5	`state`	Prüfen Sie den Gerätestatus.Dieser Befehl kann mehrmals aufgerufen werden, bis er zum Leader wird und mit dem nächsten Schritt fortfährt.	Leader Fertig
6	`dataset active`	Prüfen Sie das vollständige aktive operative Dataset und notieren Sie den Netzwerkschlüssel.	Aktiver Zeitstempel: 1 Kanal: 13 Kanalmaske: 0x07fff800 Externe PAN-ID: b07476e168eda4fc Lokales Präfix für Mesh-Netzwerk: fd8c:60bc:a98:c7ba::/64 Netzwerkschlüssel: c319292d28d45484

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

FTD-Verbinder ü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 über nicht-drahtlose Methoden (z. B. manuelle Eingabe in die OpenThread-Befehlszeile) beizutreten. Geben Sie die folgenden Befehle der Reihe nach in der seriellen Konsole an den FTD Joiner ein.

Index	Befehl	Einführung	Erwartete Antworten
1	`ot dataset networkkey c312485187484ceb5992d2343baaf93d`	Für die Verbindung eines Geräts mit einem Thread-Netzwerk ist nur der Netzwerkschlüssel erforderlich.	Fertig
2	`ot dataset commit active`	Übertragen Sie das neue Dataset per Commit zum aktiven operativen Dataset im nichtflüchtigen Speicher.	Fertig
3	`ot ifconfig up`	Rufen Sie die IPv6-Schnittstelle auf.	Fertig
4	`ot thread start`	Aktivieren Sie den Thread-Protokollvorgang und hängen Sie ihn an ein Thread-Netzwerk an.	Fertig
			Warten Sie 20 Sekunden, bis das Gerät verbunden wird und sich selbst konfiguriert.
5	`ot state`	Prüfen Sie den Gerätestatus.	Kind/Router Fertig

Topologie

Geben Sie Befehle wie ipaddr, child table, router table im 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

Der RLOC16 des OTBR ist 0xb000 und der RLOC16 des FTD Joiner ist anfangs 0xb001. Danach ändert sich RLOC16 des FTD-Joiners nach Erhalt der Router-ID zu 0x8400. Es ist zu sehen, dass der FTD Joiner von einem Kind auf einen Router aktualisiert wurde.

Das aktuelle Thread-Netzwerk enthält zwei Knoten. Die Topologie ist in der folgenden Abbildung 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. Verwenden Sie 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 Ausgabeantwort des seriellen Ports gibt an, dass die OTBR-Seite die Ping-Anfrage erhalten hat und der FTD Joiner die vom OTBR zurückgegebene Ping-Antwort erhalten hat. Die Kommunikation zwischen den beiden Geräten ist 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 detaillierte Einführung in die UDP API von OpenThread finden Sie unter OpenThread-Befehlszeile – UDP-Beispiel. 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 die folgenden Befehle im SSH-Terminal 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 das UDP des FTD Joiner. Binden Sie den 1022-Port des Geräts und senden Sie 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 erhält die Nachricht hello 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.

Sie wissen jetzt:

Anleitung zum Erstellen und Verwenden der Telink-Zephyr-Entwicklungsumgebung.
Hier erfahren Sie, wie Sie die ot-cli-ftd- und ot-rcp-Binärprogramme erstellen und auf Telink B91-Entwicklungsboards übertragen.
Anleitung zum Einrichten eines Raspberry Pi 3B+-Version oder höher als OpenThread Border Router (OTBR) mit Docker
Hier erfahren Sie, wie Sie ein Thread-Netzwerk auf OTBR erstellen.
Hier erfahren Sie, wie Sie dem Thread-Netzwerk Geräte über die Out-of-Band-Inbetriebnahme hinzufügen.
So prüfen Sie die Konnektivität zwischen Knoten im Thread-Netzwerk.

Weiterführende Literatur

Unter openthread.io und GitHub finden Sie Informationen zu verschiedenen OpenThread-Ressourcen, darunter:

Unterstützte Plattformen – Entdecken Sie alle Plattformen, die OpenThread unterstützen.
Build OpenThread (OpenThread erstellen) – weitere Details zum Erstellen und Konfigurieren von OpenThread
Thread-Primer – behandelt alle Thread-Konzepte aus diesem Codelab

Referenzdokumente: