1. Einführung
OpenThread ist eine Open-Source-Implementierung des Thread®-Netzwerkprotokolls. Google Nest hat OpenThread veröffentlicht, um Entwicklern die Technologie, die in Nest-Produkten verwendet wird, allgemein zur Verfügung zu stellen und so die Entwicklung von Produkten für das Smart Home zu beschleunigen.
In der Thread-Spezifikation wird ein IPv6-basiertes zuverlässiges, sicheres und energiesparendes Kommunikationsprotokoll für Geräte zwischen Geräten für Home-Anwendungen definiert. OpenThread implementiert alle Thread-Netzwerkebenen, einschließlich IPv6, 6LoWPAN, IEEE 802.15.4 mit MAC-Sicherheit, Mesh-Link-Etablierung und Mesh-Routing.
In diesem Codelab programmieren Sie OpenThread auf echter Hardware, erstellen und verwalten ein Thread-Netzwerk und übergeben Nachrichten zwischen Knoten.
Lerninhalte
- OpenThread-Befehlszeilen-Binärdateien auf Entwicklungsboards erstellen und blinken lassen
- RCP erstellen, die aus einer Linux-Maschine und einem Entwicklungsboard besteht
- Kommunikation mit einem RCP mit OpenThread Daemon und
ot-ctl - Thread-Knoten mit dem GNU-Bildschirm und der OpenThread-Befehlszeile manuell verwalten
- Sichere Inbetriebnahme von Geräten in einem Thread-Netzwerk
- So funktioniert IPv6-Multicast
- Nachrichten zwischen Thread-Knoten mit UDP übergeben
Voraussetzungen
Hardware:
- 3 Nord-Halbleiter-nRF52840-Entwicklerplatinen
- 3 USB-zu-Micro-USB-Kabel zum Verbinden der Karten
- Eine Linux-Maschine mit mindestens drei USB-Anschlüssen
Software:
- GNU-Toolchain
- Nordische Befehlszeilentools nRF5x
- Segger J-Link-Software
- OpenThread
- Git
2. Erste Schritte
OpenThread-Simulation
Bevor Sie beginnen, können Sie das OpenThread Simulation Codelab ausführen, um sich mit den grundlegenden Thread-Konzepten und der OpenThread-Befehlszeile vertraut zu machen.
Terminals für serielle Ports
Sie sollten wissen, wie Sie eine Verbindung zu einem seriellen Port über ein Terminal herstellen. Dieses Codelab verwendet GNU Screen und bietet eine Nutzungsübersicht, es kann aber auch jede andere Terminalsoftware verwendet werden.
Linux-Maschine
Dieses Codelab wurde entwickelt, um eine i386- oder x86-basierte Linux-Maschine zu verwenden, die als Host für ein RCP-Thread-Gerät (Radio Co-Processor) verwendet wird, sowie zum Flashieren aller Thread-Entwicklungsboards. Alle Schritte wurden unter Ubuntu 14.04.5 LTS (Trusty Tahr) getestet.
Nordische Halbleiterplatinen nRF52840
Dieses Codelab verwendet drei nRF52840 PDK-Karten.
SEGGER J-Link installieren
Wir verwenden SEGGER J-Link, um die nRF52840-Boards zu programmieren, die JTAG-Module enthalten. Installieren Sie das Programm auf Ihrem Linux-Computer.
Laden Sie das entsprechende Paket für Ihren Computer herunter und installieren Sie es am richtigen Speicherort. Unter Linux ist dies /opt/SEGGER/JLink.
nRF5x-Befehlszeilentools installieren
Mit den nRF5x-Befehlszeilentools können Sie die OpenThread-Binärdateien auf die nRF52840-Boards blinken lassen. Installieren Sie den entsprechenden Build nRF5x-Command-Line-Tools-<OS> auf Ihrem Linux-Rechner.
Platzieren Sie das extrahierte Paket im Stammverzeichnis ~/.
ARM GNU Toolchain installieren
Die ARM GNU Toolchain wird für das Erstellen verwendet.
Wir empfehlen, das extrahierte Archiv in /opt/gnu-mcu-eclipse/arm-none-eabi-gcc/ auf Ihrem Linux-Computer zu speichern. Die Installationsanleitung finden Sie in der Datei readme.txt des Archivs.
Installationsbildschirm (optional)
Der Bildschirm ist ein einfaches Tool für den Zugriff auf Geräte, die über einen seriellen Port verbunden sind. In diesem Codelab wird "Screen" verwendet. Sie können jedoch eine beliebige Anwendung des seriellen Ports mit Terminal verwenden.
$ sudo apt-get install screen
3. Repositories klonen
OpenThread
OpenThread klonen und installieren Die script/bootstrap-Befehle sorgen dafür, dass die Toolchain installiert und die Umgebung ordnungsgemäß konfiguriert ist:
$ mkdir -p ~/src $ cd ~/src $ git clone --recursive https://github.com/openthread/openthread.git $ cd openthread $ ./script/bootstrap
Erstellen Sie den OpenThread Daemon:
$ script/cmake-build posix -DOT_DAEMON=ON
Jetzt können Sie OpenThread erstellen und auf die nRF52840-Boards blinken.
4. RCP-Join einrichten
Build und Flash
Erstellen Sie das OpenThread nRF52840-Beispiel mit Joiner und nativer USB-Funktionalität. Ein Gerät verwendet die Rolle "Joiner", um sich sicher zu authentifizieren und in einem Thread-Netzwerk in Betrieb zu nehmen. Natives USB ermöglicht die Verwendung von USB CDC ACM als seriellen Transport zwischen dem nRF52840 und dem Host.
Führen Sie zuerst rm -rf build aus, um das Repository vorheriger Builds immer zu bereinigen.
$ cd ~/src $ git clone --recursive https://github.com/openthread/ot-nrf528xx.git $ cd ot-nrf528xx $ script/build nrf52840 USB_trans
Wechseln Sie in das Verzeichnis mit der OpenThread RCP-Binärdatei und konvertieren Sie es in das Hexadezimalformat:
$ cd ~/src/ot-nrf528xx/build/bin $ arm-none-eabi-objcopy -O ihex ot-rcp ot-rcp.hex
Verbinden Sie das USB-Kabel mit dem Micro-USB-Debug-Port neben dem externen Stromanschluss der nRF52840-Karte und verbinden Sie es mit dem Linux-Computer. Setzen Sie den Schieberegler für die nRF-Stromquelle auf der nRF52840-Karte auf VDD. Wenn die Verbindung richtig hergestellt ist, ist LED5 eingeschaltet.
Wenn dies das erste Board ist, das an den Linux-Computer angeschlossen ist, wird es als serieller Port /dev/ttyACM0 angezeigt. Alle nRF52840-Boards verwenden ttyACM für die ID des seriellen Ports.
$ ls /dev/ttyACM* /dev/ttyACM0
Notieren Sie sich die Seriennummer des nRF52840-Boards, das für den RCP verwendet wird:
Gehen Sie zum Speicherort der nRFx-Befehlszeilentools und blinken Sie die OpenThread RCP-Hex-Datei mithilfe der Seriennummer des Boards in das nRF52840-Board. Wenn Sie das Flag --verify weglassen, erscheint eine Warnmeldung, dass der Flash-Prozess ohne Fehler fehlschlagen kann.
$ cd ~/nrfjprog/
$ ./nrfjprog -f nrf52 -s 683704924 --verify --chiperase --program \
~/src/ot-nrf528xx/build/bin/ot-rcp.hex --reset
Bei Erfolg wird die folgende Ausgabe generiert:
Parsing hex file. Erasing user available code and UICR flash areas. Applying system reset. Checking that the area to write is not protected. Programing device. Applying system reset. Run.
Kennzeichnen Sie das Board mit "RCP", damit Sie später die Board-Rollen nicht verwechseln.
Mit nativem USB-Anschluss verbinden
Da der OpenThread RCP-Build das native USB CDC ACM als seriellen Transport ermöglicht, müssen Sie den nRF-USB-Port auf der nRF52840-Karte verwenden, um mit dem RCP-Host (Linux-Computer) zu kommunizieren.
Trennen Sie das Micro-USB-Kabel des USB-Kabels vom Debug-Port der blinkenden nRF52840-Karte und schließen Sie es wieder an den Micro-USB-Port an.nRF-USB Port neben demZURÜCKSETZEN Schaltfläche Setzen Sie den nRF-Stromquelle auf USB.
OpenThread Daemon starten
Verwenden Sie im RCP-Design OpenThread Daemon, um mit dem Thread-Gerät zu kommunizieren und es zu verwalten. Starten Sie ot-daemon mit dem ausführlichen Flag -v, damit Sie die Logausgabe sehen und prüfen können, ob sie ausgeführt wird:
$ cd ~/src/openthread
$ ./build/posix/src/posix/ot-daemon -v \
'spinel+hdlc+uart:///dev/ttyACM0?uart-baudrate=115200'
Bei Erfolg generiert ot-daemon im ausführlichen Modus eine Ausgabe, die in etwa so aussieht:
ot-daemon[228024]: Running OPENTHREAD/20191113-00831-gfb399104; POSIX; Jun 7 2020 18:05:15 ot-daemon[228024]: Thread version: 2 ot-daemon[228024]: RCP version: OPENTHREAD/20191113-00831-gfb399104; SIMULATION; Jun 7 2020 18:06:08
Lassen Sie dieses Terminalfenster geöffnet, damit Logs von ot-daemon angezeigt werden können.
Verwenden Sie ot-ctl, um mit dem RCP-Knoten zu kommunizieren. ot-ctl verwendet dieselbe Befehlszeile wie die OpenThread-Befehlszeilenanwendung. Daher können Sie ot-daemon-Knoten genauso wie die anderen simulierten Thread-Geräte steuern.
Starten Sie ot-ctl in einem zweiten Terminalfenster:
$ ./build/posix/bin/ot-ctl >
Prüfen Sie den state von Knoten 2 (den RCP-Knoten), den Sie mit ot-daemon gestartet haben:
> state disabled Done
5 FTDs einrichten
Die beiden anderen in diesem Codelab verwendeten Threadknoten sind Full-Thread-Geräte (FTDs) im Standard-System-on-Chip-Design (SoC). In einer Produktionseinstellung könnten Sie wpantund verwenden, einen produktionstauglichen Netzwerkschnittstellen-Treiber, um OpenThread NCP-Instanzen zu steuern, aber in diesem Codelab verwenden wir ot-ctl, den OpenThread Befehlszeile
Ein Gerät dient als Provisionsstelle, um Geräte sicher in diesem Netzwerk zu authentifizieren und in Betrieb zu nehmen. Das andere Gerät fungiert als Joiner, sodass der Commissioner sich beim Thread-Netzwerk authentifizieren kann.
Build und Flash
Erstellen Sie das OpenThread FTD-Beispiel für die nRF52840-Plattform mit den Rollen CommissionProvision“ und JoinJoiner“:
$ cd ~/src/ot-nrf528xx $ rm -rf build $ script/build nrf52840 USB_trans -DOT_JOINER=ON -DOT_COMMISSIONER=ON
Wechseln Sie in das Verzeichnis mit der Binärdatei des OpenThread Full Thread Device (FTD) und konvertieren Sie es in das Hex-Format:
$ cd ~/src/ot-nrf528xx/build/bin $ arm-none-eabi-objcopy -O ihex ot-cli-ftd ot-cli-ftd.hex
Verbinden Sie das USB-Kabel mit dem Micro-USB-Port neben dem externen Stromanschluss der nRF52840-Karte und verbinden Sie es mit dem Linux-Computer. Wenn der RCP noch an den Linux-Computer angeschlossen ist, sollte dieses neue Board als serieller Port /dev/ttyACM1 angezeigt werden (alle nRF52840-Boards verwenden ttyACM für die ID des seriellen Ports).
$ ls /dev/ttyACM* /dev/ttyACM0 /dev/ttyACM1
Notieren Sie wie zuvor die Seriennummer der nRF52840-Karte, die für die FTD verwendet wird:
Gehen Sie zum Speicherort der nRFx-Befehlszeilentools und blinken Sie die FTD-HDE-Datei der OpenThread-Befehlszeile auf das nRF52840-Board. Verwenden Sie dazu die Seriennummer des Boards:
$ cd ~/nrfjprog/
$ ./nrfjprog -f nrf52 -s 683704924 --verify --chiperase --program \
~/src/ot-nrf528xx/build/bin/ot-cli-ftd.hex --reset
Kennzeichnen Sie das Board mit "Provision".
Mit nativem USB-Anschluss verbinden
Da der OpenThread FTD-Build das native USB CDC ACM als seriellen Transport ermöglicht, müssen Sie den nRF-USB-Port auf dem nRF52840-Board verwenden, um mit dem RCP-Host (Linux-Computer) zu kommunizieren.
Trennen Sie das Micro-USB-Kabel des USB-Kabels vom Debug-Port der blinkenden nRF52840-Karte und schließen Sie es wieder an den Micro-USB-Port an.nRF-USB Port neben demZURÜCKSETZEN Schaltfläche Setzen Sie den nRF-Stromquelle auf USB.
Build prüfen
Prüfen Sie, ob ein Build erfolgreich war. Rufen Sie dazu die OpenThread-Befehlszeile über einen GNU-Bildschirm in einem Terminalfenster auf. Die nRF52840-Boards verwenden eine Baudrate von 115200.
$ screen /dev/ttyACM1 115200
Drücken Sie im neuen Fenster mehrmals die Eingabetaste auf der Tastatur, um die Eingabeaufforderung > für OpenThread aufzurufen. Rufen Sie die IPv6-Schnittstelle auf und suchen Sie nach Adressen:
> ifconfig up Done > ipaddr fe80:0:0:0:1cd6:87a9:cb9d:4b1d Done
Strg + A → verwenden
d Trennen Sie sie vom Bildschirm "FTD Commissioner CLI" und kehren Sie zum Linux-Terminal zurück, damit das nächste Board blinkt. Sie können die Befehlszeile jederzeit wieder eingeben, indem Siescreen -r über die Befehlszeile. Verwenden Sie screen -ls, um eine Liste der verfügbaren Bildschirme aufzurufen:
$ screen -ls
There is a screen on:
74182.ttys000.mylinuxmachine (Detached)
1 Socket in /tmp/uscreens/S-username.
FTD Joiner einrichten
Wiederholen Sie den obigen Vorgang, um das dritte nRF52840-Board mit dem vorhandenen ot-cli-ftd.hex-Build zu blinken. Verbinden Sie das Board anschließend wieder mit dem PC über den nRF-USB-Port und stellen Sie den nRF-Stromquelle auf VDD ein.
Wenn die beiden anderen Knoten mit dem Linux-Computer verbunden sind, wenn dieses dritte Board angeschlossen wird, sollte es als serieller Port /dev/ttyACM2 angezeigt werden:
$ ls /dev/ttyACM* /dev/ttyACM0 /dev/ttyACM1 /dev/ttyACM2
Kennzeichnen Sie das Board mit "Joiner".
Wenn Sie den Bildschirm prüfen, statt eine neue Instanz des Bildschirms über die Befehlszeile zu erstellen, verknüpfen Sie ihn wieder mit dem vorhandenen Bildschirm und erstellen Sie darin ein neues Fenster, das Sie für den FTD Commissioner verwendet haben:
$ screen -r
Neues Fenster im Bildschirm mit Strg + A erstellen. c aus.
Eine neue Eingabeaufforderung wird angezeigt. Rufen Sie die OpenThread-Befehlszeile für den FTD Joiner auf:
$ screen /dev/ttyACM2 115200
Drücken Sie in diesem neuen Fenster einige Mal die Eingabetaste, um die Eingabeaufforderung > der OpenThread-Befehlszeile aufzurufen. Rufen Sie die IPv6-Schnittstelle auf und suchen Sie nach Adressen:
> ifconfig up Done > ipaddr fe80:0:0:0:6c1e:87a2:df05:c240 Done
Da sich die FTD Joiner-Befehlszeile jetzt in derselben Instanz des Bildschirms befindet wie der FTD Commissioner, können Sie mithilfe von Strg + A → n zwischen ihnen wechseln.
Strg + A → verwenden
d , um den Bildschirm zu verlassen.
6. Terminalfenstereinrichtung
Künftig wechseln Sie häufig zwischen Thread-Geräten. Achten Sie also darauf, dass alle Geräte live sind und leicht zugänglich sind. Bisher verwenden wir den Bildschirm, um auf die beiden FTDs zuzugreifen. Außerdem ermöglicht dieses Tool das Teilen des Bildschirms im selben Terminalfenster. So sehen Sie, wie ein Knoten auf Befehle reagiert, die für einen anderen Knoten ausgeführt werden.
Idealerweise sollten Ihnen vier Fenster zur Verfügung stehen:
ot-daemon-Dienst/-Logs- RCP Joiner über
ot-ctl - FTD Commissioner über OpenThread CLI
- FTD Joiner über die OpenThread-Befehlszeile
Wenn Sie Ihre eigene Terminal- oder serielle Portkonfiguration oder ein eigenes Tool verwenden möchten, können Sie mit dem nächsten Schritt fortfahren. Sie können die Terminalfenster für alle Geräte so konfigurieren, wie es für Sie am besten ist.
Bildschirm wird verwendet
Der Einfachheit halber sollten Sie nur eine Bildschirmsitzung starten. Wenn Sie beide FTDs einrichten, sollten Sie bereits einen haben.
Alle Befehle auf dem Bildschirm beginnen mit Strg + a.
Grundlegende Bildschirmbefehle:
Verbinden Sie sich noch einmal über die Befehlszeile mit der Bildschirmsitzung. |
|
Bildschirmsitzung verlassen | Strg + A → |
Neues Fenster in der Bildschirmsitzung erstellen | Strg + A → |
Zwischen Fenstern in derselben Bildschirmsitzung wechseln | Strg + a → |
Das aktuelle Fenster in der Bildschirmsitzung beenden | Strg + A → |
Bildschirm teilen
Mit Screen können Sie das Terminal in mehrere Fenster aufteilen:
Die Befehle in screen werden über Strg + A aufgerufen. Jeder Befehl sollte mit dieser Zugriffsschlüsselkombination beginnen.
Wenn Sie das Codelab genau befolgt haben, sollten Sie zwei Fenster (FTD Commissioner, FTD Joiner) auf derselben Bildschirminstanz haben. Wenn Sie den Bildschirm aufteilen möchten, müssen Sie zuerst Ihre vorhandene Bildschirmsitzung starten:
$ screen -r
Sie sollten eines der FTD-Geräte verwenden. Gehen Sie so vor:
- Strg + A →
S, um das Fenster horizontal zu teilen - Strg + A →
Tab, um den Cursor in das neue leere Fenster zu bewegen - Strg + A →
n, um zum nächsten Fenster zu wechseln - Wenn es mit dem oberen Fenster identisch ist, drücken Sie noch einmal Strg + A →
n, um das andere FTD-Gerät aufzurufen
Beide sind jetzt sichtbar. Verwenden Sie die Tastenkombination Strg + A → Tab. Es wird empfohlen, die Fenster mit Strg + A → A umzubenennen, um Verwechslungen zu vermeiden.
Erweiterte Nutzung
Damit der Bildschirm weiter in Quadranten aufgeteilt wird und die ot-daemon-Logs und der RCP-Joiner ot-ctl angezeigt werden, müssen diese Dienste innerhalb derselben Screen-Instanz gestartet werden. Beenden Sie dazu ot-daemon, beenden Sie ot-ctl und starten Sie sie in einem neuen Bildschirmfenster neu (Strg + A → c).
Diese Einrichtung ist nicht erforderlich und bleibt als Übung für den Nutzer übrig.
Mit den folgenden Befehlen können Sie Fenster aufteilen und zwischen ihnen wechseln:
Neues Fenster erstellen | Strg + A → |
Fenster vertikal aufteilen | Strg + A → |
Fenster horizontal aufteilen | Strg + A → |
Zum nächsten angezeigten Fenster wechseln | Strg + A → |
Angezeigtes Fenster vor- oder zurückspulen | Strg + A → |
Aktuelles Fenster umbenennen | Strg + A → |
Sie können den Bildschirm jederzeit mit +Strg + → → d“ verlassen und mit screen -r über die Befehlszeile wieder verbinden.
Weitere Informationen zum Bildschirm finden Sie in der Kurzübersicht des GNU-Bildschirms.
7. Thread-Netzwerk erstellen
Nachdem Sie alle Terminalfenster und Bildschirme konfiguriert haben, erstellen Sie das Thread-Netzwerk. Erstellen Sie auf dem FTD Commissioner ein neues operatives Dataset und führen Sie ein Commit als aktives Dataset aus. Das operative Dataset ist die Konfiguration für das Thread-Netzwerk, das Sie erstellen.
## FTD Commissioner ## ---------------------- > dataset init new Done > dataset Active Timestamp: 1 Channel: 11 Channel Mask: 07fff800 Ext PAN ID: c0de7ab5c0de7ab5 Mesh Local Prefix: fdc0:de7a:b5c0/64 Network Key: 1234c0de7ab51234c0de7ab51234c0de Network Name: OpenThread-c0de PAN ID: 0xc0de PSKc: ebb4f2f8a68026fc55bcf3d7be3e6fe4 Security Policy: 0, onrcb Done
Notieren Sie sich den Netzwerkschlüssel 1234c0de7ab51234c0de7ab51234c0de. Er wird später verwendet.
Speichern Sie dieses Dataset als aktiv:
> dataset commit active Done
IPv6-Schnittstelle aufrufen:
> ifconfig up Done
Starten Sie den Thread-Protokollvorgang:
> thread start Done
Prüfen Sie nach kurzer Zeit den Gerätestatus. Er sollte die beste Variante sein. Sie können den RLOC16 auch zur späteren Verwendung abrufen.
## FTD Commissioner ## ---------------------- > state leader Done > rloc16 0c00 Done
Prüfen Sie die IPv6-Adressen des Geräts:
## FTD Commissioner ## ---------------------- > ipaddr fdc0:de7a:b5c0:0:0:ff:fe00:fc00 # Leader Anycast Locator (ALOC) fdc0:de7a:b5c0:0:0:ff:fe00:c00 # Routing Locator (RLOC) fdc0:de7a:b5c0:0:6394:5a75:a1ad:e5a # Mesh-Local EID (ML-EID) fe80:0:0:0:1cd6:87a9:cb9d:4b1d # Link-Local Address (LLA)
Das Netzwerk "Codelab" ist jetzt sichtbar, wenn es von anderen Thread-Geräten gescannt wird.
Über ot-ctl in der RCP-Join-Ressource:
## RCP Joiner ## ---------------- > scan | J | Network Name | Extended PAN | PAN | MAC Address | Ch | dBm | LQI | +---+------------------+------------------+------+------------------+----+-----+-----+ | 0 | OpenThread-c0de | c0de7ab5c0de7ab5 | c0de | 1ed687a9cb9d4b1d | 11 | -36 | 232 |
Über die OpenThread-Befehlszeile im FTD Joiner:
## FTD Joiner ## ---------------- > scan | J | Network Name | Extended PAN | PAN | MAC Address | Ch | dBm | LQI | +---+------------------+------------------+------+------------------+----+-----+-----+ | 0 | OpenThread-c0de | c0de7ab5c0de7ab5 | c0de | 1ed687a9cb9d4b1d | 11 | -38 | 229 |
Wenn das Netzwerk codeCodelab“ nicht in der Liste angezeigt wird, wiederholen Sie den Scanvorgang.
Beachten Sie, dass das Netzwerk bei beiden Scans nicht teilbar ist (Spalte J im RCP-Join und FTD-Join). Dies bedeutet nur, dass Thread Commissioning im Netzwerk nicht aktiv ist. Sie können weiterhin Out-of-Band verknüpfen, indem Sie den Netzwerkschlüssel manuell im Joiner-Gerät eingeben.
8. RCP-Join hinzufügen
Fügen Sie den RCP-Join dem soeben erstellten Thread-Netzwerk mit einem Out-of-Band-Prozess hinzu. Suchen Sie im RCP Joiner nach Netzwerken:
## RCP Joiner ## ---------------- > scan | J | Network Name | Extended PAN | PAN | MAC Address | Ch | dBm | LQI | +---+------------------+------------------+------+------------------+----+-----+-----+ | 0 | OpenThread-c0de | c0de7ab5c0de7ab5 | c0de | 1ed687a9cb9d4b1d | 11 | -38 | 229 |
Fügen Sie den Netzwerkschlüssel, den wir gerade vom FTD Commissioner erhalten haben, für den RCP Joiner im aktiven Dataset ein.
## RCP Joiner ## ---------------- > dataset networkkey 1234c0de7ab51234c0de7ab51234c0de Done > dataset commit active Done
Prüfen Sie, ob das Dataset richtig festgelegt ist.
## RCP Joiner ## ---------------- > dataset Network Key: 1234c0de7ab51234c0de7ab51234c0de
Rufen Sie den Thread auf, damit der RCP-Join dem "Codelab"-Netzwerk beigetreten ist. Warten Sie einige Sekunden und prüfen Sie dann den Status, RLOC16 und seine IPv6-Adressen:
## RCP Joiner ## ---------------- > thread start Done > state child Done > rloc16 0c01 Done > ipaddr fdc0:de7a:b5c0:0:0:ff:fe00:0c01 # Routing Locator (RLOC) fdc0:de7a:b5c0:0:66bf:99b9:24c0:d55f # Mesh-Local EID (ML-EID) fe80:0:0:0:18e5:29b3:a638:943b # Link-Local Address (LLA) Done
Notieren Sie sich die Mesh-Local-IPv6-Adresse (hier fdc0:de7a:b5c0:0:66bf:99b9:24c0:d55f), da Sie sie später benötigen.
Rufen Sie den FTD Commissioner wieder auf und prüfen Sie anhand der Router- und untergeordneten Tabellen, dass beide Geräte zum selben Netzwerk gehören. Ermitteln Sie mit dem RLOC16 den RCP-Join.
## FTD Commissioner ## ---------------------- > router table | ID | RLOC16 | Next Hop | Path Cost | LQ In | LQ Out | Age | Extended MAC | +----+--------+----------+-----------+-------+--------+-----+------------------+ | 3 | 0x0c00 | 3 | 0 | 0 | 0 | 35 | 1ed687a9cb9d4b1d | Done > child table | ID | RLOC16 | Timeout | Age | LQ In | C_VN |R|S|D|VER| Extended MAC | +-----+--------+------------+------------+-------+------+-+-+-+---+------------------+ | 1 | 0x0c01 | 240 | 25 | 3 | 89 |1|1|1| 2| 1ae529b3a638943b | Done
Pingen Sie die Mesh-lokale Adresse des RCP-Joins an (die aus der ipaddr-Ausgabe des RCP-Joiner-Client erhaltene Mesh-Local-Adresse), um die Verbindung zu prüfen:
## FTD Commissioner ## ---------------------- > ping fdc0:de7a:b5c0:0:66bf:99b9:24c0:d55f > 8 bytes from fdc0:de7a:b5c0:0:66bf:99b9:24c0:d55f: icmp_seq=1 hlim=64 time=40ms
Wir haben jetzt ein Thread-Netzwerk mit zwei Knoten, wie in diesem Topologiediagramm veranschaulicht:
Topologiediagramme
Während Sie den Rest des Codelab durchgehen, wird immer ein neues Diagramm zur Threadtopologie angezeigt, sobald sich der Status des Netzwerks ändert. Knotenrollen werden so angegeben:
Router sind immer Fünfeckschilder und Endgeräte sind immer Kreise. Die Zahlen auf den einzelnen Knoten stellen die Router-ID oder die untergeordnete ID dar, die in der Befehlszeilenausgabe angezeigt werden, je nachdem, welche Rolle der Knoten aktuell hat.
9. FTD Joiner in Betrieb nehmen
Jetzt fügen wir das dritte Thread-Gerät dem Codelab-Netzwerk hinzu. Diesmal verwenden wir die sicherere In-Band-Inbetriebnahme. Suchen Sie im FTD Joiner nach dem Netzwerk:
## FTD Joiner ## ---------------- > scan | J | Network Name | Extended PAN | PAN | MAC Address | Ch | dBm | LQI | +---+------------------+------------------+------+------------------+----+-----+-----+ | 0 | OpenThread-c0de | c0de7ab5c0de7ab5 | c0de | f65ae2853ff0c4e4 | 11 | -36 | 57 |
Ein 0 in der Spalte J gibt an, dass Thread Commissioning auf dem Gerät nicht aktiv ist.
Gehen wir bei der Inbetriebnahme dieses nächsten Geräts konkret aus und lassen Sie nur den FTD Joiner zu. Rufen Sie noch den FTD Joiner ab, um den eui64 abzurufen, damit der FTD Commissioner es identifizieren kann:
## FTD Joiner ## ---------------- > eui64 2f57d222545271f1 Done
Geben Sie in der Hilfe des FTD Commissioner den Commissioner ein und geben Sie die eui64 des Geräts, das beitreten darf, sowie die Joiner-Anmeldedaten an, z. B. J01NME. Die Joiner-Anmeldedaten sind ein gerätespezifischer String aus allen alphanumerischen Großbuchstaben in Großbuchstaben (0–9 und AY, ohne I, O, Q und Z für Lesbarkeit), die zwischen 6 und 32 Zeichen lang ist.
## FTD Commissioner ## ---------------------- > commissioner start Done > commissioner joiner add 2f57d222545271f1 J01NME Done
Wechseln Sie zum FTD Joiner und scannen Sie noch einmal:
## FTD Joiner ## ---------------- > scan | J | Network Name | Extended PAN | PAN | MAC Address | Ch | dBm | LQI | +---+------------------+------------------+------+------------------+----+-----+-----+ | 1 | OpenThread-c0de | c0de7ab5c0de7ab5 | c0de | 1ed687a9cb9d4b1d | 11 | -45 | 196 |
Wie durch die 1 in der Spalte J angegeben, ist Thread Commissioning jetzt im Netzwerk aktiv. Starten Sie die Joiner-Rolle mit den Anmeldedaten, die Sie gerade auf dem FTD Commissioner eingerichtet haben:
## FTD Joiner ## ---------------- > ifconfig up Done > joiner start J01NME Done
Sie erhalten innerhalb von etwa einer Minute eine Bestätigung über eine erfolgreiche Authentifizierung:
## FTD Joiner ## ---------------- > Join success
Starten Sie den Thread, damit der FTD Joiner dem "Codelab"-Netzwerk beitritt, und prüfen Sie sofort den Status und das RLOC16:
## FTD Joiner ## ---------------- > thread start Done > state child Done > rloc16 0c02 Done
Prüfen Sie die IPv6-Adressen des Geräts. Beachten Sie, dass kein ALOC vorhanden ist. Das liegt daran, dass dieses Gerät nicht der Leader ist und es auch keine Anycast-spezifische Rolle hat, die ein ALOC erfordert.
## FTD Joiner ## ---------------- > ipaddr fdc0:de7a:b5c0:0:0:ff:fe00:c02 # Routing Locator (RLOC) fdc0:de7a:b5c0:0:3e2e:66e:9d41:ebcd # Mesh-Local EID (ML-EID) fe80:0:0:0:e4cd:d2d9:3249:a243 # Link-Local Address (LLA)
Wechseln Sie sofort zum FTD Commissioner und prüfen Sie anhand der Router- und untergeordneten Tabellen, ob im Codelab-Netzwerk drei Geräte vorhanden sind:
## FTD Commissioner ## ---------------------- > router table | ID | RLOC16 | Next Hop | Path Cost | LQ In | LQ Out | Age | Extended MAC | +----+--------+----------+-----------+-------+--------+-----+------------------+ | 3 | 0x0c00 | 3 | 0 | 0 | 0 | 50 | 1ed687a9cb9d4b1d | > child table | ID | RLOC16 | Timeout | Age | LQ In | C_VN |R|S|D|N| Extended MAC | +-----+--------+------------+------------+-------+------+-+-+-+-+------------------+ | 1 | 0x0c01 | 240 | 25 | 3 | 89 |1|1|1|1| 1ae529b3a638943b | | 2 | 0x0c02 | 240 | 15 | 3 | 44 |1|1|1|1| e6cdd2d93249a243 | Done
Basierend auf dem RLOC16 wurde der FTD Joiner als Endgerät (untergeordnet) an das Netzwerk angehängt. Hier unsere aktualisierte Topologie:
10. Unterhaltung in Aktion
Die Thread-Geräte in diesem Codelab sind eine bestimmte Art von Full Thread Device (FTD), einem sogenannten Router-fähigen Endgerät. Das heißt, sie können entweder als Router oder als Endgerät fungieren und sich selbst von einem Endgerät zu einem Router hochstufen.
Der Thread kann bis zu 32 Router unterstützen, aber es wird versucht, die Anzahl der Router zwischen 16 und 23 zu halten. Wenn ein REED als Endgerät (untergeordnet) angehängt wird und die Anzahl der Router unter 16 liegt, wird es nach einem zufälligen Zeitraum innerhalb von 2 Minuten automatisch zu einem Router hochgestuft.
Wenn Sie nach dem Hinzufügen des FTD Joiner zwei untergeordnete Elemente in Ihrem Thread-Netzwerk hatten, warten Sie mindestens zwei Minuten und prüfen Sie dann die Router- und untergeordneten Tabellen im FTD Commissioner noch einmal:
## FTD Commissioner ## ---------------------- > router table | ID | RLOC16 | Next Hop | Path Cost | LQ In | LQ Out | Age | Extended MAC | +----+--------+----------+-----------+-------+--------+-----+------------------+ | 3 | 0x0c00 | 3 | 0 | 0 | 0 | 50 | 1ed687a9cb9d4b1d | | 46 | 0xb800 | 63 | 0 | 3 | 3 | 1 | e6cdd2d93249a243 | > child table | ID | RLOC16 | Timeout | Age | LQ In | C_VN |R|S|D|N| Extended MAC | +-----+--------+------------+------------+-------+------+-+-+-+-+------------------+ | 1 | 0x0c01 | 240 | 61 | 3 | 89 |1|1|1|1| 1ae529b3a638943b | Done
Der FTD Joiner (Extended MAC = e6cdd2d93249a243) hat sich selbst zu einem Router hochgestuft. Der RLOC16 ist anders (b800 statt 0c02). Das liegt daran, dass der RLOC16 auf der Router-ID und der untergeordneten ID eines Geräts basiert. Bei der Umstellung von einem Endgerät auf einen Router ändern sich die Werte für die Router-ID und die untergeordnete ID, ebenso wie der RLOC16.
Bestätigen Sie den neuen Status und RLOC16 im FTD Joiner:
## FTD Joiner ## ---------------- > state router Done > rloc16 b800 Done
FTD Joiner herunterstufen
Sie können dieses Verhalten testen, indem Sie für den FTD Joiner ein manuelles Downgrade von einem Router auf ein Endgerät ausführen. Ändern Sie den Status in "child" und prüfen Sie den RLOC16:
## FTD Joiner ## ---------------- > state child Done > rloc16 0c03 Done
Auf dem FTD Commissioner sollte der FTD Joiner nun in der untergeordneten Tabelle angezeigt werden (ID = 3). Es kann sogar während des Übergangs in beiden vorkommen:
## FTD Commissioner ## ---------------------- > router table | ID | RLOC16 | Next Hop | Path Cost | LQ In | LQ Out | Age | Extended MAC | +----+--------+----------+-----------+-------+--------+-----+------------------+ | 3 | 0x0c00 | 3 | 0 | 0 | 0 | 50 | 1ed687a9cb9d4b1d | | 46 | 0xb800 | 63 | 0 | 3 | 3 | 1 | e6cdd2d93249a243 | > child table | ID | RLOC16 | Timeout | Age | LQ In | C_VN |R|S|D|N| Extended MAC | +-----+--------+------------+------------+-------+------+-+-+-+-+------------------+ | 1 | 0x0c01 | 240 | 61 | 3 | 89 |1|1|1|1| 1ae529b3a638943b | | 3 | 0x0c03 | 240 | 16 | 3 | 94 |1|1|1|1| e6cdd2d93249a243 | Done
Nach einiger Zeit wechselt es wieder zu einem Router mit dem RLOC b800.
Führungsperson entfernen
Der Leader wird von allen Thread-Routern selbst ausgewählt. Wenn also der aktuelle Leader aus dem Thread-Netzwerk entfernt wird, wird einer der anderen Router zum neuen Leader.
Fahren Sie im FTD Commissioner den Thread herunter, um ihn aus dem Thread-Netzwerk zu entfernen:
## FTD Commissioner ## ---------------------- > thread stop Done > ifconfig down Done
Innerhalb von zwei Minuten wird der FTD Joiner zum neuen Thread-Leader. Prüfen Sie den Status und die IPv6-Adressen des FTD Joiner, um Folgendes zu verifizieren:
## FTD Joiner ## ---------------- > state leader Done > ipaddr fdc0:de7a:b5c0:0:0:ff:fe00:fc00 # Now it has the Leader ALOC! fdc0:de7a:b5c0:0:0:ff:fe00:b800 fdc0:de7a:b5c0:0:3e2e:66e:9d41:ebcd fe80:0:0:0:e4cd:d2d9:3249:a243 Done
Prüfen Sie die untergeordnete Tabelle. Beachten Sie, dass es ein neues RLOC16 gibt. Das ist der RCP-Join, wie durch seine ID und erweiterte MAC angegeben. Damit das Thread-Netzwerk zusammen erhalten bleibt, hat es übergeordnete Router vom FTD Commissioner zum FTD Joiner gewechselt. Dies führt zu einem neuen RLOC16 für den RCP-Join (weil sich seine Router-ID von 3 auf 46 geändert hat).
## FTD Joiner ## ---------------- > child table | ID | RLOC16 | Timeout | Age | LQ In | C_VN |R|S|D|N| Extended MAC | +-----+--------+------------+------------+-------+------+-+-+-+-+------------------+ | 1 | 0xb801 | 240 | 27 | 3 | 145 |1|1|1|1| 1ae529b3a638943b | Done
Möglicherweise müssen Sie einige Minuten warten, bis der RCP Joiner als FTD Joiner als untergeordnetes Element angehängt wurde. Prüfen Sie den Status und den RLOC16, um Folgendes zu bestätigen:
## RCP Joiner ## -------------- > state child > rloc16 b801
Hängen Sie den FTD Commissioner wieder an
Ein Thread-Netzwerk mit zwei Knoten macht keinen großen Spaß. Stellen Sie den FTD Commissioner wieder online.
Starten Sie den Thread auf dem FTD Commissioner neu:
## FTD Commissioner ## ---------------------- > ifconfig up Done > thread start Done
Innerhalb von zwei Minuten wird er automatisch wieder dem Codelab-Netzwerk als Endgerät hinzugefügt und dann automatisch zum Router hochgestuft.
## FTD Commissioner ## ---------------------- > state router Done
Prüfen Sie die Router- und untergeordneten Tabellen im FTD Joiner, um Folgendes zu überprüfen:
## FTD Joiner ## ---------------- > router table | ID | RLOC16 | Next Hop | Path Cost | LQ In | LQ Out | Age | Extended MAC | +----+--------+----------+-----------+-------+--------+-----+------------------+ | 3 | 0x0c00 | 63 | 0 | 3 | 3 | 0 | 1ed687a9cb9d4b1d | | 46 | 0xb800 | 46 | 0 | 0 | 0 | 15 | e6cdd2d93249a243 | > child table | ID | RLOC16 | Timeout | Age | LQ In | C_VN |R|S|D|N| Extended MAC | +-----+--------+------------+------------+-------+------+-+-+-+-+------------------+ | 1 | 0xb801 | 240 | 184 | 3 | 145 |1|1|1|1| 1ae529b3a638943b | Done
Unser Thread-Netzwerk besteht wieder aus drei Knoten.
11. Fehlerbehebung
Die Verwaltung eines Thread-Netzwerks mit mehreren Geräten auf verschiedenen Terminal- oder Bildschirmfenstern kann kompliziert sein. Mit diesen Tipps können Sie den Status des Netzwerks oder Ihres Arbeitsbereichs zurücksetzen, falls Probleme auftreten.
Display
Sollten Sie Ihre Konfiguration verlieren (zu viele Bildschirmfenster oder Bildschirme im Bildschirm), beenden Sie das Fenster mit der Tastenkombination +Strg + A → k“, bis kein Fenster mehr angezeigt wird.screen -ls und in der Befehlszeile wird No Sockets found ausgegeben. Erstellen Sie dann die Bildschirmfenster für jedes Gerät neu. Gerätestatus bleiben auch dann erhalten, wenn der Bildschirm beendet wird.
Threadknoten
Wenn die Thread-Netzwerktopologie nicht wie in diesem Codelab beschrieben wird oder Knoten aus irgendeinem Grund getrennt werden (z. B. weil die Linux-Maschine, die sie verwendet), in den Ruhemodus versetzt wurde, sollten Sie den Thread herunterfahren, die Anmeldedaten für das Netzwerk löschen und noch einmal von vorn beginnenThread-Netzwerk erstellen an.
So setzen Sie die FTDs zurück:
## FTD Commissioner or FTD Joiner ## ------------------------------------ > thread stop Done > ifconfig down Done > factoryreset Done
Der RCP kann auf dieselbe Weise über ot-ctl zurückgesetzt werden:
## RCP Joiner ## ---------------- > thread stop Done > ifconfig down Done > factoryreset Done
12. Multicast verwenden
Multicast wird verwendet, um Informationen an eine Gruppe von Geräten gleichzeitig zu übertragen. In einem Thread-Netzwerk sind bestimmte Adressen, je nach Umfang, für die Multicast-Nutzung bei verschiedenen Gerätegruppen reserviert.
IPv6-Adresse | Umfang | Zugestellt |
| Link-Local | Alle FTDs und MEDs |
| Link-Local | Alle FTDs und Border Router |
| Mesh-Netzwerk-Lokal | Alle FTDs und MEDs |
| Mesh-Netzwerk-Lokal | Alle FTDs und Border Router |
Da wir in diesem Codelab keinen Border Router verwenden, konzentrieren wir uns auf die beiden FTD- und MED-Multicast-Adressen.
Link-Local
Der Link-Local-Bereich umfasst alle Thread-Schnittstellen, auf die über eine einzelne Funkübertragung oder ein einzelner "Hop" zugegriffen werden kann. Die Netzwerktopologie gibt vor, welche Geräte auf einen Ping an die ff02::1-Multicast-Adresse reagieren.
Pingen Sie ff02::1 vom FTD Commissioner:
## FTD Commissioner ## ---------------------- > ping ff02::1 > 8 bytes from fe80:0:0:0:e4cd:d2d9:3249:a243: icmp_seq=2 hlim=64 time=9ms
Im Netzwerk gibt es zwei weitere Geräte (FTD Joiner und RCP Joiner), aber der FTD Commissioner hat nur eine Antwort von der Link-Local Address (LLA) des FTD Joiner erhalten. Das bedeutet, dass der FTD Joiner das einzige Gerät ist, das der FTD Commissioner mit einem einzigen Hop erreichen kann.
Pingen Sie ff02::1 über den FTD Joiner:
## FTD Joiner ## ---------------- > ping ff02::1 > 8 bytes from fe80:0:0:0:1cd6:87a9:cb9d:4b1d: icmp_seq=1 hlim=64 time=11ms 8 bytes from fe80:0:0:0:18e5:29b3:a638:943b: icmp_seq=1 hlim=64 time=24ms
Zwei Antworten! Wenn wir die IPv6-Adressen der anderen Geräte prüfen, sehen wir, dass die erste (endet auf 4b1d) die LAD des FTD-Verantwortlichen und die zweite (endet auf 943b) die LAA des RCP-Joiner.
Dies bedeutet, dass der FTD Joiner direkt mit dem FTD Commissioner und dem RCP Joiner verbunden ist, der unsere Topologie bestätigt.
Mesh-Netzwerk-Lokal
Der Bereich "Mesh-Local" umfasst alle Thread-Schnittstellen, die im selben Thread-Netzwerk erreichbar sind. Sehen Sie sich die Antworten auf einen Ping an die Multicast-Adresse ff03::1 an.
Pingen Sie ff03::1 vom FTD Commissioner:
## FTD Commissioner ## ---------------------- > ping ff03::1 > 8 bytes from fdc0:de7a:b5c0:0:0:ff:fe00:b800: icmp_seq=3 hlim=64 time=9ms 8 bytes from fdc0:de7a:b5c0:0:66bf:99b9:24c0:d55f: icmp_seq=3 hlim=64 time=68ms
Diesmal hat der FTD Commissioner zwei Antworten erhalten: eine vom FTD Joiner's Routing Locator (RLOC, mit der Endung b800) und eine vom RCP Joiner (Mesh-Local EID, enden mit d55f). Der Grund dafür ist, dass der lokale Mesh-Netzwerkbereich das gesamte Thread-Netzwerk umfasst. Unabhängig davon, wo sich das Gerät im Netzwerk befindet, wird es die ff03::1-Adresse abonnieren.
Pingen Sie ff03::1 vom FTD Joiner aus, um dasselbe Verhalten zu bestätigen:
## FTD Joiner ## ---------------- > ping ff03::1 > 8 bytes from fdc0:de7a:b5c0:0:0:ff:fe00:c00: icmp_seq=2 hlim=64 time=11ms 8 bytes from fdc0:de7a:b5c0:0:66bf:99b9:24c0:d55f: icmp_seq=2 hlim=64 time=23ms
Notieren Sie die Antwortzeit für den RCP-Join in beiden Ping-Ausgaben. Der RCP-Joiner brauchte viel länger, um den FTD Joiner (68 ms) zu erreichen als den FTD Joiner (23 ms). Der Grund dafür ist, dass der FTD Commissioner mit zwei Hops verbunden ist – im Vergleich zum FTD Joiner.
Möglicherweise haben Sie auch bemerkt, dass der mit dem Mesh-Netzwerk verbundene Multicast-Ping nur bei den beiden FTDs mit dem RLOC antwortet, nicht mit dem RCP-Join. Das liegt daran, dass die FTDs Router im Netzwerk sind, während der RCP ein Endgerät ist.
Prüfen Sie den Status des RCP Joiner, um Folgendes zu bestätigen:
## RCP Joiner ## ---------------- > state child
13. Nachrichten mit UDP senden
Einer der Anwendungsdienste von OpenThread ist das User Datagram Protocol (UDP), ein Transport Layer-Protokoll. Eine Anwendung, die auf OpenThread basiert, könnte die UDP API für die Übertragung von Nachrichten zwischen Knoten in einem Thread-Netzwerk oder an andere Geräte in einem externen Netzwerk verwenden, z. B. wenn das Thread-Netzwerk einen Border-Router hat.
UDP-Sockets werden über die OpenThread-Befehlszeile bereitgestellt. Wir leiten damit Nachrichten zwischen den beiden FTDs weiter.
Rufen Sie die Mesh-Local-EID-Adresse für den FTD Joiner ab. Wir verwenden diese Adresse, da sie von überall aus im Thread-Netzwerk erreichbar ist.
## FTD Joiner ## ---------------- > ipaddr fdc0:de7a:b5c0:0:0:ff:fe00:fc00 # Leader Anycast Locator (ALOC) fdc0:de7a:b5c0:0:0:ff:fe00:b800 # Routing Locator (RLOC) fe80:0:0:0:e4cd:d2d9:3249:a243 # Link-Local Address (LLA) fdc0:de7a:b5c0:0:3e2e:66e:9d41:ebcd # Mesh-Local EID (ML-EID) Done
Starten Sie UDP und binden Sie es für jede IPv6-Adresse an einen Socket:
## FTD Joiner ## ---------------- > udp open Done > udp bind :: 1212
Wechseln Sie zum FTD Commissioner, starten Sie UDP und stellen Sie mit der ML-EID eine Verbindung zum Socket her, den Sie im FTD Joiner eingerichtet haben:
## FTD Commissioner ## ---------------------- > udp open Done > udp connect fdc0:de7a:b5c0:0:3e2e:66e:9d41:ebcd 1212 Done
Die UDP-Verbindung sollte zwischen den beiden Knoten aktiv sein. Senden Sie eine Nachricht vom FTD Commissioner:
## FTD Commissioner ## ---------------------- > udp send hellothere Done
In der FTD Joiner-Instanz wurde die UDP-Nachricht empfangen.
## FTD Joiner ## ---------------- > 10 bytes from fdc0:de7a:b5c0:0:0:ff:fe00:c00 49153 hellothere
14. Glückwunsch!
Sie haben ein physisches Thread-Netzwerk erstellt.
Jetzt weißt du:
- den Unterschied zwischen Gerätetypen, Rollen und Bereichen von Threads
- Wie Thread-Geräte ihren Status innerhalb des Netzwerks verwalten
- Einfache Nachrichten zwischen Knoten mit UDP übergeben
Weiteres Vorgehen
Erstellen Sie auf Grundlage dieses Codelabs die folgenden Übungen:
- Blenden Sie das FTD Joiner Board mithilfe der Binärdatei
ot-cli-mtdals MTD neu ein und achten Sie darauf, dass es sich nie auf einen Router aktualisiert oder versucht, zum Leader zu werden. - Fügen Sie dem Netzwerk weitere Geräte hinzu (versuchen Sie es mit einer anderen Plattform!) und skizzieren Sie die Topologie mithilfe von Router- und untergeordneten Tabellen sowie Pings an die Multicast-Adressen.
- NCP mit pyspinel steuern
- Konvertieren Sie den NCP mithilfe des OpenThread Border Routers in einen Border-Router und verbinden Sie das Thread-Netzwerk mit dem Internet.
Weitere Informationen
Sehen Sie sich openthread.io und GitHub für eine Vielzahl von OpenThread-Ressourcen an, einschließlich:
- Unterstützte Plattformen: Ermitteln Sie alle Plattformen, die OpenThread unterstützen.
- OpenThread erstellen – weitere Informationen zum Erstellen und Konfigurieren von OpenThread
- Thread Primer: Alle Thread-Konzepte aus diesem Codelab
Referenz: