1. Einführung
OpenThread von Google ist eine Open-Source-Implementierung des Thread-Netzwerkprotokolls. Google Nest hat OpenThread veröffentlicht, um die in Nest-Produkten verwendete Technologie Entwicklern zur Verfügung zu stellen und so die Entwicklung von Produkten für das vernetzte Zuhause zu beschleunigen.
Die Thread-Spezifikation definiert ein zuverlässiges, sicheres und energieeffizientes IPv6-basiertes Protokoll für die drahtlose Kommunikation zwischen Geräten für Anwendungen im Haushalt. OpenThread implementiert alle Thread-Netzwerkschichten, einschließlich IPv6, 6LoWPAN, IEEE 802.15.4 mit MAC-Sicherheit, Mesh Link Establishment und Mesh Routing.
In diesem Codelab wird beschrieben, wie Sie ein Thread-Netzwerk auf simulierten Geräten simulieren.
Lerninhalte
- OpenThread-Build-Toolchain einrichten
- Thread-Netzwerk simulieren
- Thread-Knoten authentifizieren
- Thread-Netzwerk mit OpenThread Daemon verwalten
Voraussetzungen
- git
- Grundkenntnisse zu Linux und Netzwerkrouting
2. Build-System einrichten
Git
Für dieses Codelab ist Git erforderlich. Laden Sie es herunter und installieren Sie es, bevor Sie fortfahren.
Folgen Sie nach der Installation der Anleitung für Ihr Betriebssystem, um OpenThread herunterzuladen und zu erstellen.
XCode für Mac OS X
XCode ist erforderlich, um OpenThread unter Mac OS X zu installieren und zu erstellen.
Installieren Sie nach der Installation von Xcode die Xcode-Befehlszeilentools:
$ xcode-select --install
Entwicklung unter Linux / Mac OS X
Diese Installationsanleitung wurde unter Ubuntu Server 14.04 LTS und Mac OS X Sierra 10.12.6 getestet.
OpenThread installieren Mit den bootstrap-Befehlen wird sichergestellt, dass die Toolchain installiert und die Umgebung richtig konfiguriert ist:
$ mkdir -p ~/src $ cd ~/src $ git clone --recursive https://github.com/openthread/openthread.git $ cd openthread $ ./script/bootstrap
Windows verwenden
Wenn Sie Windows bevorzugen, empfehlen wir Ihnen, die Docker-Version dieses Codelabs auszuprobieren.
3. OpenThread-Anwendungen erstellen
Nachdem die Installation abgeschlossen ist, erstellen Sie die OpenThread-Beispielanwendung. In diesem Codelab verwenden wir das Simulationsbeispiel.
$ cd ~/src/openthread $ ./script/cmake-build simulation
Erstellen Sie nun den OpenThread-Daemon:
$ ./script/cmake-build posix -DOT_DAEMON=ON
4. Thread-Netzwerk simulieren
Die Beispielanwendung, die Sie in diesem Codelab verwenden, ist eine minimale OpenThread-Anwendung, die die OpenThread-Konfigurations- und Verwaltungsschnittstellen über eine einfache Befehlszeile (Command Line Interface, CLI) verfügbar macht.
In dieser Übung werden die minimalen Schritte beschrieben, die erforderlich sind, um ein simuliertes Thread-Gerät von einem anderen simulierten Thread-Gerät aus anzupingen.
Die Abbildung unten zeigt eine grundlegende Thread-Netzwerktopologie. In dieser Übung simulieren wir die beiden Knoten im grünen Kreis: einen Thread-Leader und einen Thread-Router mit einer einzigen Verbindung zwischen ihnen.
Knoten anpingen
1. Knoten 1 starten
Wechseln Sie zum Verzeichnis openthread und starten Sie den CLI-Prozess für ein simuliertes Thread-Gerät mit dem Binärprogramm ot-cli-ftd.
$ cd ~/src/openthread $ ./build/simulation/examples/apps/cli/ot-cli-ftd 1
Hinweis:Wenn Sie die Eingabeaufforderung > nach dem Ausführen dieses Befehls nicht sehen, drücken Sie enter.
Dieses Binärprogramm implementiert ein OpenThread-Gerät, das auf POSIX simuliert wird. Der IEEE 802.15.4-Funk-Treiber wird auf UDP implementiert (IEEE 802.15.4-Frames werden in UDP-Nutzlasten übergeben).
Das Argument von 1 ist ein Dateideskriptor, der die niedrigstwertigen Bits der „werkseitig zugewiesenen“ IEEE EUI-64 für das simulierte Gerät darstellt. Dieser Wert wird auch verwendet, wenn eine Bindung an einen UDP-Port für die IEEE 802.15.4-Funkemulation erfolgt (Port = 9000 + Dateideskriptor). Jede Instanz eines simulierten Thread-Geräts in diesem Codelab verwendet einen anderen Dateideskriptor.
Hinweis:Verwenden Sie beim Erstellen des Prozesses für ein simuliertes Gerät nur Dateideskriptoren von 1 oder höher, wie in diesem Codelab beschrieben. Ein Dateideskriptor von 0 ist für andere Zwecke reserviert.
Erstellen Sie ein neues Operational Dataset und legen Sie es als aktives Dataset fest. Das operative Dataset ist die Konfiguration für das Thread-Netzwerk, das Sie erstellen.
> dataset init new Done > dataset Active Timestamp: 1 Channel: 20 Channel Mask: 07fff800 Ext PAN ID: d6263b6d857647da Mesh Local Prefix: fd61:2344:9a52:ede0/64 Network Key: e4344ca17d1dca2a33f064992f31f786 Network Name: OpenThread-c169 PAN ID: 0xc169 PSKc: ebb4f2f8a68026fc55bcf3d7be3e6fe4 Security Policy: 0, onrcb Done
Übernehmen Sie dieses Dataset als das aktive:
> dataset commit active Done
IPv6-Schnittstelle aktivieren:
> ifconfig up Done
Thread-Protokollvorgang starten:
> thread start Done
Warte einige Sekunden und prüfe, ob das Gerät zum Thread-Leader geworden ist. Das Leader-Gerät ist für die Verwaltung der Router-ID-Zuweisung verantwortlich.
> state leader Done
Rufen Sie die IPv6-Adressen auf, die der Thread-Schnittstelle von Knoten 1 zugewiesen sind (Ihre Ausgabe wird sich unterscheiden):
> ipaddr fd61:2344:9a52:ede0:0:ff:fe00:fc00 fd61:2344:9a52:ede0:0:ff:fe00:5000 fd61:2344:9a52:ede0:d041:c5ba:a7bc:5ce6 fe80:0:0:0:94da:92ea:1353:4f3b Done
Beachten Sie die spezifischen IPv6-Adresstypen:
- Beginnt mit
fd= mesh-local - Beginnt mit
fe80= Link-Local
Mesh-lokale Adresstypen werden weiter klassifiziert:
- Enthält
ff:fe00= Router Locator (RLOC) - Enthält nicht
ff:fe00= Endpunkt-ID (EID)
Suchen Sie in der Konsolenausgabe nach der EID und notieren Sie sie sich für die spätere Verwendung. In der obigen Beispielausgabe lautet die EID:
fd61:2344:9a52:ede0:d041:c5ba:a7bc:5ce6
2. Knoten 2 starten
Öffnen Sie ein neues Terminal, wechseln Sie in das Verzeichnis openthread und starten Sie den CLI-Prozess. Das ist Ihr zweites simuliertes Thread-Gerät:
$ cd ~/src/openthread $ ./build/simulation/examples/apps/cli/ot-cli-ftd 2
Hinweis:Wenn Sie die Eingabeaufforderung > nach dem Ausführen dieses Befehls nicht sehen, drücken Sie enter.
Konfigurieren Sie den Thread-Netzwerkschlüssel und die PAN-ID mit denselben Werten wie das operative Dataset von Knoten 1:
> dataset networkkey e4344ca17d1dca2a33f064992f31f786 Done > dataset panid 0xc169 Done
Übernehmen Sie dieses Dataset als das aktive:
> dataset commit active Done
IPv6-Schnittstelle aktivieren:
> ifconfig up Done
Thread-Protokollvorgang starten:
> thread start Done
Das Gerät wird als Kinderkonto initialisiert. Ein Thread-Child entspricht einem Endgerät, also einem Thread-Gerät, das Unicast-Traffic nur mit einem Parent-Gerät überträgt und empfängt.
> state child Done
Innerhalb von zwei Minuten sollte sich der Status von child zu router ändern. Ein Thread-Router kann Traffic zwischen Thread-Geräten weiterleiten. Sie wird auch als „Übergeordnete Einheit“ bezeichnet.
> state router Done
Netzwerk bestätigen
Eine einfache Möglichkeit, das Mesh-Netzwerk zu überprüfen, ist die Routertabelle.
1. Prüfe die Verbindung.
Rufen Sie auf Knoten 2 den RLOC16 ab. RLOC16 sind die letzten 16 Bit der RLOC-IPv6-Adresse des Geräts.
> rloc16 5800 Done
Prüfe auf Knoten 1 die Routertabelle nach dem RLOC16 von Knoten 2. Prüfen Sie, ob Knoten 2 zuerst in den Routerstatus gewechselt ist.
> router table | ID | RLOC16 | Next Hop | Path Cost | LQI In | LQI Out | Age | Extended MAC | +----+--------+----------+----------+-------+---------+-----+------------------+ | 20 | 0x5000 | 63 | 0 | 0 | 0 | 0 | 96da92ea13534f3b | | 22 | 0x5800 | 63 | 0 | 3 | 3 | 23 | 5a4eb647eb6bc66c |
Der RLOC von Knoten 1 mit 0xa800 ist in der Tabelle zu finden. Das bestätigt, dass er mit dem Mesh verbunden ist.
2. Knoten 1 von Knoten 2 aus anpingen
Prüfen Sie die Verbindung zwischen den beiden simulierten Thread-Geräten. In Knoten 2, ping die EID, die Knoten 1 zugewiesen ist:
> ping fd61:2344:9a52:ede0:d041:c5ba:a7bc:5ce6 > 16 bytes from fd61:2344:9a52:ede0:d041:c5ba:a7bc:5ce6: icmp_seq=1 hlim=64 time=12ms
Drücken Sie enter, um zur >-CLI-Eingabeaufforderung zurückzukehren.
Netzwerk testen
Nachdem Sie jetzt erfolgreich zwischen zwei simulierten Thread-Geräten pingen können, testen Sie das Mesh-Netzwerk, indem Sie einen Knoten offline nehmen.
Kehren Sie zu Knoten 1 zurück und beenden Sie Thread:
> thread stop Done
Wechsle zu Knoten 2 und prüfe den Status. Innerhalb von zwei Minuten erkennt Knoten 2, dass der Leader (Knoten 1) offline ist. Knoten 2 sollte nun als leader des Netzwerks angezeigt werden:
> state router Done ... > state leader Done
Wenn die Bestätigung erfolgt ist, beenden Sie Thread und setzen Sie Knoten 2 auf die Werkseinstellungen zurück, bevor Sie die App schließen. Durch das Zurücksetzen auf die Werkseinstellungen wird sichergestellt, dass die in dieser Übung verwendeten Thread-Netzwerk-Anmeldedaten nicht in die nächste Übung übernommen werden.
> thread stop Done > factoryreset > > exit
Setzen Sie auch Node 1 auf die Werkseinstellungen zurück und beenden Sie den Knoten:
> factoryreset > > exit
Eine Liste aller verfügbaren CLI-Befehle finden Sie in der OpenThread-CLI-Referenz.
5. Knoten mit Commissioning authentifizieren
In der vorherigen Übung haben Sie ein Thread-Netzwerk mit zwei simulierten Geräten eingerichtet und die Konnektivität überprüft. Dadurch kann jedoch nur nicht authentifizierter IPv6-Link-Local-Traffic zwischen Geräten übertragen werden. Damit globaler IPv6-Traffic zwischen ihnen (und dem Internet über einen Thread-Border-Router) weitergeleitet werden kann, müssen Knoten authentifiziert werden.
Zur Authentifizierung muss ein Gerät als Commissioner fungieren. Der Commissioner ist der derzeit ausgewählte Authentifizierungsserver für neue Thread-Geräte und der Autorisierer für die Bereitstellung der Anmeldedaten für das Netzwerk, die für den Beitritt der Geräte zum Netzwerk erforderlich sind.
In dieser Übung verwenden wir dieselbe Topologie mit zwei Knoten wie zuvor. Bei der Authentifizierung fungiert der Thread-Leader als Commissioner und der Thread-Router als Joiner.
1. Netzwerk erstellen
Wenn Sie mit der vorherigen Übung fortfahren, sollten bereits zwei Terminalfenster geöffnet sein. Wenn nicht, müssen Sie dafür sorgen, dass zwei geöffnet und einsatzbereit sind. Eine dient als Knoten 1, die andere als Knoten 2.
Starten Sie in Node 1 den CLI-Prozess:
$ cd ~/src/openthread $ ./build/simulation/examples/apps/cli/ot-cli-ftd 1
Hinweis:Wenn Sie die Eingabeaufforderung > nach dem Ausführen dieses Befehls nicht sehen, drücken Sie enter.
Erstellen Sie ein neues Operational Dataset, legen Sie es als aktives Dataset fest und starten Sie Thread:
> dataset init new Done > dataset Active Timestamp: 1 Channel: 12 Channel Mask: 07fff800 Ext PAN ID: e68d05794bf13052 Mesh Local Prefix: fd7d:ddf7:877b:8756/64 Network Key: a77fe1d03b0e8028a4e13213de38080e Network Name: OpenThread-8f37 PAN ID: 0x8f37 PSKc: f9debbc1532487984b17f92cd55b21fc Security Policy: 0, onrcb Done
Übernehmen Sie dieses Dataset als das aktive:
> dataset commit active Done
IPv6-Schnittstelle aktivieren:
> ifconfig up Done
Thread-Protokollvorgang starten:
> thread start Done
Warte einige Sekunden und prüfe, ob das Gerät ein Thread-Leader geworden ist:
> state leader Done
2. Rolle „Commissioner“ starten
Starten Sie die Rolle „Commissioner“ auf Knoten 1:
> commissioner start Done
Erlaube allen Joinern (mit dem Platzhalter *) mit den J01NME-Anmeldedaten für Joiner die Inbetriebnahme im Netzwerk. Ein Joiner ist ein Gerät, das von einem Administrator zu einem in Betrieb genommenen Thread-Netzwerk hinzugefügt wird.
> commissioner joiner add * J01NME Done
3. Rolle „Mitglied“ starten
Starten Sie in einem zweiten Terminalfenster einen neuen CLI-Prozess. Das ist Knoten 2.
$ cd ~/src/openthread $ ./build/simulation/examples/apps/cli/ot-cli-ftd 2
Aktivieren Sie auf Knoten 2 die Joiner-Rolle mit den J01NME-Anmeldedaten.
> ifconfig up Done > joiner start J01NME Done
… warte einige Sekunden auf die Bestätigung …
Join success
Als Joiner hat sich das Gerät (Knoten 2) erfolgreich beim Commissioner (Knoten 1) authentifiziert und die Anmeldedaten für das Thread-Netzwerk erhalten.
Nachdem Node 2 authentifiziert wurde, starten Sie Thread:
> thread start Done
4. Netzwerkauthentifizierung validieren
Prüfen Sie das state auf Knoten 2, um zu bestätigen, dass er jetzt mit dem Netzwerk verbunden ist. Innerhalb von zwei Minuten wechselt Knoten 2 von child zu router:
> state child Done ... > state router Done
5. Konfiguration zurücksetzen
Setzen Sie die Konfiguration zurück, um sich auf die nächste Übung vorzubereiten. Beende auf jedem Knoten Thread, setze das Gerät auf die Werkseinstellungen zurück und beende das simulierte Thread-Gerät:
> thread stop Done > factoryreset > > exit
Möglicherweise müssen Sie enter einige Male drücken, um die Eingabeaufforderung > nach einem factoryreset-Befehl wieder aufzurufen.
6. Netzwerk mit OpenThread Daemon verwalten
In dieser Übung simulieren wir eine CLI-Instanz (ein einzelnes eingebettetes SoC-Thread-Gerät) und eine RCP-Instanz (Radio Co-Processor).
ot-daemon ist ein Modus der OpenThread-POSIX-App, der einen UNIX-Socket als Ein- und Ausgabe verwendet, sodass der OpenThread-Kern als Dienst ausgeführt werden kann. Ein Client kann mit diesem Dienst kommunizieren, indem er über die OpenThread-Befehlszeile als Protokoll eine Verbindung zum Socket herstellt.
ot-ctl ist eine CLI, die von ot-daemon bereitgestellt wird, um den RCP zu verwalten und zu konfigurieren. Damit verbinden wir den RCP mit dem vom Thread-Gerät erstellten Netzwerk.
„ot-daemon“ verwenden
In dieser Übung werden drei Terminalfenster verwendet, die den folgenden entsprechen:
- CLI-Instanz des simulierten Thread-Geräts (Knoten 1)
ot-daemon-Prozessot-ctl-CLI-Instanz
Wenn Sie mit der vorherigen Übung fortfahren, sollten bereits zwei Terminalfenster geöffnet sein. Öffnen Sie ein drittes Terminalfenster, damit Sie für diese Übung drei Terminalfenster zur Verfügung haben.
1. Knoten 1 starten
Starten Sie im ersten Terminalfenster den CLI-Prozess für Ihr simuliertes Thread-Gerät:
$ cd ~/src/openthread $ ./build/simulation/examples/apps/cli/ot-cli-ftd 1
Hinweis:Wenn Sie die Eingabeaufforderung > nach dem Ausführen dieses Befehls nicht sehen, drücken Sie enter.
Erstellen Sie ein neues Operational Dataset, legen Sie es als aktives Dataset fest und starten Sie Thread:
> dataset init new Done > dataset Active Timestamp: 1 Channel: 13 Channel Mask: 07fff800 Ext PAN ID: 97d584bcd493b824 Mesh Local Prefix: fd55:cf34:dea5:7994/64 Network Key: ba6e886c7af50598df1115fa07658a83 Network Name: OpenThread-34e4 PAN ID: 0x34e4 PSKc: 38d6fd32c866927a4dfcc06d79ae1192 Security Policy: 0, onrcb Done
Übernehmen Sie dieses Dataset als das aktive:
> dataset commit active Done
IPv6-Schnittstelle aktivieren:
> ifconfig up Done
Thread-Protokollvorgang starten:
> thread start Done
Rufen Sie die IPv6-Adressen auf, die der Thread-Schnittstelle von Knoten 1 zugewiesen sind:
> ipaddr fd55:cf34:dea5:7994:0:ff:fe00:fc00 fd55:cf34:dea5:7994:0:ff:fe00:d000 fd55:cf34:dea5:7994:460:872c:e807:c4ab fe80:0:0:0:9cd8:aab6:482f:4cdc Done >
Wie im Schritt Thread-Netzwerk simulieren beschrieben, ist eine Adresse link-lokal (fe80) und drei sind mesh-lokal (fd). Die EID ist die mesh-lokale Adresse, die nicht ff:fe00 in der Adresse enthält. In dieser Beispielausgabe lautet die EID fd55:cf34:dea5:7994:460:872c:e807:c4ab.
Suchen Sie in der ipaddr-Ausgabe nach der spezifischen EID, die für die Kommunikation mit dem Knoten verwendet wird.
2. ot-daemon starten
Wechseln Sie im zweiten Terminalfenster zum Verzeichnis openthread und starten Sie ot-daemon für einen RCP-Knoten, den wir als „Knoten 2“ bezeichnen. Verwenden Sie das Flag -v, damit Sie die Log-Ausgabe sehen und bestätigen können, dass der Prozess ausgeführt wird. Achten Sie darauf, sudo zu verwenden:
$ cd ~/src/openthread
$ sudo ./build/posix/src/posix/ot-daemon -v \
'spinel+hdlc+forkpty://build/simulation/examples/apps/ncp/ot-rcp?forkpty-arg=2'
Bei erfolgreicher Ausführung wird im ausführlichen Modus eine Ausgabe ähnlich der folgenden generiert:ot-daemon
ot-daemon[12463]: Running OPENTHREAD/thread-reference-20200818-1938-g0f10480ed; POSIX; Aug 30 2022 10:55:05 ot-daemon[12463]: Thread version: 4 ot-daemon[12463]: Thread interface: wpan0 ot-daemon[12463]: RCP version: OPENTHREAD/thread-reference-20200818-1938-g0f10480ed; SIMULATION; Aug 30 2022 10:54:10
Lassen Sie dieses Terminal geöffnet und im Hintergrund laufen. Sie geben keine weiteren Befehle ein.
3. Mit ot-ctl dem Netzwerk beitreten
Wir haben Knoten 2 (das ot-daemon-RCP) noch nicht in einem Thread-Netzwerk in Betrieb genommen. Hier kommt ot-ctl ins Spiel. ot-ctl verwendet dieselbe CLI wie die OpenThread-CLI-App. Daher können Sie ot-daemon-Knoten auf dieselbe Weise wie die anderen simulierten Thread-Geräte steuern.
Starten Sie ot-ctl in einem dritten Terminalfenster:
$ sudo ./build/posix/src/posix/ot-ctl >
Hinweis:Wenn Sie die Eingabeaufforderung > nach dem Ausführen dieses Befehls nicht sehen, drücken Sie enter.
Sie verwenden ot-ctl in diesem dritten Terminalfenster, um Node 2 (den RCP-Knoten) zu verwalten, den Sie im zweiten Terminalfenster mit ot-daemon gestartet haben. Prüfen Sie die state von Knoten 2:
> state disabled Done
Rufen Sie die eui64 von Knoten 2 ab, um das Verbinden auf den jeweiligen Joiner zu beschränken:
> eui64 18b4300000000001 Done
Starten Sie auf Knoten 1 (erstes Terminalfenster) den Commissioner und beschränken Sie das Beitreten auf diese eui64:
> commissioner start Done > commissioner joiner add 18b4300000000001 J01NME Done
Rufen Sie auf Knoten 2 (drittes Terminalfenster) die Netzwerkschnittstelle auf und treten Sie dem Netzwerk bei:
> ifconfig up Done > joiner start J01NME Done
… warte einige Sekunden auf die Bestätigung …
Join success
Als Joiner hat sich der RCP (Knoten 2) erfolgreich beim Commissioner (Knoten 1) authentifiziert und die Thread-Netzwerk-Anmeldedaten erhalten.
Verbinden Sie nun Knoten 2 mit dem Thread-Netzwerk:
> thread start Done
4. Netzwerkauthentifizierung validieren
Prüfen Sie das state auf Knoten 2, um zu bestätigen, dass er jetzt mit dem Netzwerk verbunden ist. Innerhalb von zwei Minuten wechselt Knoten 2 von child zu router:
> state child Done ... > state router Done
5. Verbindung validieren
Beenden Sie ot-ctl mit Strg+D oder dem Befehl exit und pingen Sie dann in der Befehlszeile Ihres Hostcomputers Knoten 1 mit seiner EID und dem Befehl ping6 an. Wenn die ot-daemon-RCP-Instanz erfolgreich dem Thread-Netzwerk beigetreten ist und mit diesem kommuniziert, ist der Ping erfolgreich:
$ ping6 -c 4 fd55:cf34:dea5:7994:460:872c:e807:c4ab PING fd55:cf34:dea5:7994:460:872c:e807:c4ab (fd55:cf34:dea5:7994:460:872c:e807:c4ab): 56 data bytes 64 bytes from fd55:cf34:dea5:7994:460:872c:e807:c4ab: icmp_seq=0 ttl=64 time=4.568 ms 64 bytes from fd55:cf34:dea5:7994:460:872c:e807:c4ab: icmp_seq=1 ttl=64 time=6.396 ms 64 bytes from fd55:cf34:dea5:7994:460:872c:e807:c4ab: icmp_seq=2 ttl=64 time=7.594 ms 64 bytes from fd55:cf34:dea5:7994:460:872c:e807:c4ab: icmp_seq=3 ttl=64 time=5.461 ms --- fd55:cf34:dea5:7994:460:872c:e807:c4ab ping statistics --- 4 packets transmitted, 4 packets received, 0% packet loss round-trip min/avg/max/stddev = 4.568/6.005/7.594/1.122 ms
7. Glückwunsch!
Sie haben Ihr erstes Thread-Netzwerk mit OpenThread erfolgreich simuliert. Sehr gut!
In diesem Codelab haben Sie Folgendes gelernt:
- OpenThread-Build-Toolchain einrichten
- Thread-Netzwerk simulieren
- Thread-Knoten authentifizieren
- Thread-Netzwerk mit OpenThread Daemon verwalten
Weitere Informationen finden Sie in den folgenden Referenzen: