1) Einführung
OpenThread ist ein von Google veröffentlichtes Open-Source-Protokoll des Thread®-Netzwerkprotokolls. Google Nest hat OpenThread veröffentlicht, um die Technologie, die in Nest-Produkten zum Einsatz kommt, allgemein für Entwickler verfügbar gemacht. So lässt sich die Entwicklung von Produkten für das Smart Home beschleunigen.
Die Thread-Spezifikation definiert ein IPv6-basiertes zuverlässiges, sicheres und energiesparendes Kommunikationsprotokoll für kabellose Geräte zwischen Geräten. OpenThread implementiert alle Thread-Netzwerkebenen, einschließlich IPv6, 6LoWPAN, IEEE 802.15.4 mit MAC-Sicherheit, Mesh-Link-Einrichtung 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-CLI-Binärdateien erstellen und in Entwicklungsboards speichern
- RCP besteht aus einem Linux-Computer und einem Entwicklungsboard
- Mit einem RCP über OpenThread Daemon kommunizieren und
ot-ctl - Thread-Knoten mit GNU Screen und der OpenThread CLI 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 Nordic Semiconductor nRF52840 Entwicklungsplatten
- 3 USB-auf-Micro-USB-Kabel zum Verbinden der Boards
- Ein Linux-Computer mit mindestens 3 USB-Ports
Software:
- GNU-Toolchain
- Nordic nRF5x-Befehlszeilentools
- Segger J-Link-Software
- OpenThread
- Git
2. Erste Schritte
OpenThread-Simulation
Bevor Sie beginnen, sollten Sie sich das OpenThread-Simulations-Codelab ansehen, um sich mit den grundlegenden Thread-Konzepten und der OpenThread-Befehlszeile vertraut zu machen.
Ports für serielle Ports
Sie sollten mit dem Herstellen einer Verbindung zu einem seriellen Port über ein Terminal vertraut sein. Dieses Codelab nutzt GNU Screen und bietet eine Nutzungsübersicht. Es kann aber jede andere Terminalsoftware verwendet werden.
Linux-Computer
Dieses Codelab wurde entwickelt, um einen i386- oder x86-basierten Linux-Computer als Host für ein RCP-Thread-Gerät (Radio Co-Processor) zu verwenden und alle Thread-Entwicklungsplatinen zu blinken. Alle Schritte wurden auf Ubuntu 14.04.5 LTS (Trusty Tahr) getestet.
Nordic Semiconductor nRF52840 Platinen
Dieses Codelab verwendet drei nRF52840 PDK-Boards.
SEGGER J-Link installieren
Wir verwenden SEGGER J-Link zum Programmieren der nRF52840-Boards mit integrierten JTAG-Modulen. Installieren Sie die Datei auf Ihrem Linux-Computer.
Laden Sie das entsprechende Paket für Ihren Computer herunter und installieren Sie es an der richtigen Stelle. Unter Linux ist das /opt/SEGGER/JLink.
nRF5x-Befehlszeilentools installieren
Mit den nRF5x-Befehlszeilentools können Sie die OpenThread-Binärdateien auf die nRF52840-Boards blinken. Installieren Sie den entsprechenden nRF5x-Command-Line-Tools-<OS>-Build auf Ihrem Linux-Computer.
Legen Sie das extrahierte Paket im Stammordner „~/“ ab
ARM GNU Toolchain installieren
Die ARM GNU Toolchain wird für den Bau verwendet.
Wir empfehlen, das extrahierte Archiv in /opt/gnu-mcu-eclipse/arm-none-eabi-gcc/ auf deinem Linux-Computer zu speichern. Eine 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. Dieses Codelab verwendet Display, Sie können aber jede beliebige serielle Portterminal-Anwendung verwenden.
$ sudo apt-get install screen
3. Repositories klonen
OpenThread
Klonen und installieren Sie OpenThread. Mit den Befehlen script/bootstrap 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
OpenThread-Daemon erstellen:
$ script/cmake-build posix -DOT_DAEMON=ON
Jetzt können Sie OpenThread erstellen und auf den nRF52840-Boards blinken.
4. RCP-Joiner einrichten
Build und Flash
Erstellen Sie das Beispiel für OpenThread nRF52840 mit Joiner und nativem USB. Ein Gerät verwendet die Joiner-Rolle, 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 nRF52840 und dem Host.
Bereinigen Sie zuerst das Repository früherer Builds, indem Sie rm -rf build ausführen.
$ 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 dem OpenThread-RCP-Binärprogramm 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 auf der nRF52840-Platine und schließen Sie es an den Linux-Computer an. Stellen Sie den Schalter nRF-Stromquelle auf der nRF52840-Platte auf VDD ein. Wenn die Verbindung richtig funktioniert, ist LED5 eingeschaltet.
Wenn dies das erste Board ist, das an den Linux-Computer angeschlossen ist, wird es als serieller Port /dev/ttyACM0 angezeigt. Für alle nRF52840-Boards wird ttyACM als ID des seriellen Ports verwendet.
$ ls /dev/ttyACM* /dev/ttyACM0
Notieren Sie die Seriennummer der für den RCP verwendeten nRF52840-Platte:
Gehen Sie zum Speicherort der nRFx-Befehlszeilentools und Flashen Sie die OpenCP RCP-Hexadezimaldatei auf die nRF52840-Platine mithilfe der Seriennummer des Boards. Wenn Sie das Flag --verify weglassen, wird eine Warnmeldung angezeigt, dass der Flash-Vorgang ohne Fehler fehlschlägt.
$ 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 dem Label „RCP“, damit Sie die Boardrollen nicht verwechseln.
Mit nativem USB-Anschluss verbinden
Da der OpenThread RCP-Build die Verwendung des nativen 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.
Entfernen Sie das Micro-USB-Ende des USB-Kabels vom Debug-Port des Flash-nRF52840-Boards und stecken Sie es dann wieder neben dem RESET-Tasten in den Micro-USB-nRF-USB-Port ein. Stellen Sie den Schalter für nRF-Stromquelle auf USB ein.
OpenThread-Daemon starten
Verwenden Sie im RCP-Design OpenOpen 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
$ sudo ./build/posix/src/posix/ot-daemon -v \
'spinel+hdlc+uart:///dev/ttyACM0?uart-baudrate=115200'
Wenn der Vorgang erfolgreich war, generiert ot-daemon im ausführlichen Modus eine Ausgabe, die in etwa so aussieht:
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 Terminalfenster geöffnet, damit Logs von ot-daemon aufgerufen werden können.
Verwenden Sie ot-ctl, um mit dem RCP-Knoten zu kommunizieren. ot-ctl verwendet dieselbe Befehlszeile wie die OpenThread CLI App. Sie können daher ot-daemon-Knoten genauso steuern wie die anderen simulierten Thread-Geräte.
Starten Sie in einem zweiten Terminalfenster ot-ctl:
$ sudo ./build/posix/src/posix/ot-ctl >
Prüfen Sie die state von Knoten 2 (dem RCP-Knoten), den Sie mit ot-daemon gestartet haben:
> state disabled Done
5. FTDs einrichten
Die anderen beiden Thread-Knoten in diesem Codelab sind Full-Thread-Geräte (FTDs) auf dem standardmäßigen SoC-Design (System-on-Chip). In einer Produktionseinstellung kann eine wpantund-Netzwerkschnittstelle als Treiber für die Steuerung von OpenThread-NCP-Instanzen verwendet werden. In diesem Codelab nutzen wir jedoch ot-ctl, die OpenThread-Befehlszeile.
Ein Gerät fungiert als Verantwortlicher für die sichere Authentifizierung und Inbetriebnahme von Geräten in diesem Netzwerk. Das andere Gerät fungiert als Joiner, den der Kommissator beim Thread-Netzwerk authentifizieren kann.
Build und Flash
Erstellen Sie das Beispiel „OpenThread FTD“ für die Plattform nRF52840 mit aktivierten Provisions- und Joiner-Rollen:
$ cd ~/src/ot-nrf528xx $ rm -rf build $ script/build nrf52840 USB_trans -DOT_JOINER=ON -DOT_COMMISSIONER=ON
Wechseln Sie in das Verzeichnis mit dem Binärprogramm der OpenThread-Thread-Befehlszeile (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-Anschluss neben der externen Steckdose auf der nRF52840-Platine und schließen Sie es an den Linux-Computer an. Wenn das RCP noch an den Linux-Computer angehängt ist, sollte dieses neue Board als serieller Port /dev/ttyACM1 angezeigt werden (alle nRF52840-Boards verwenden ttyACM als Kennung des seriellen Ports).
$ ls /dev/ttyACM* /dev/ttyACM0 /dev/ttyACM1
Wie zuvor notieren Sie die Seriennummer des nRF52840-Boards, das für das FTD verwendet wird:
Wechseln Sie zum Speicherort der nRFx-Befehlszeilentools und blinken Sie die Hexadezimaldatei „OpenThread CLI FTD“ auf der nRF52840-Karte mit der Seriennummer des Boards:
$ cd ~/nrfjprog/
$ ./nrfjprog -f nrf52 -s 683704924 --verify --chiperase --program \
~/src/ot-nrf528xx/build/bin/ot-cli-ftd.hex --reset
Versehen Sie die Tafel mit „Kommissionsmitglied“.
Mit nativem USB-Anschluss verbinden
Da der OpenThread FTD-Build die Verwendung des nativen 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.
Entfernen Sie das Micro-USB-Ende des USB-Kabels vom Debug-Port des Flash-nRF52840-Boards und stecken Sie es dann wieder neben dem RESET-Tasten in den Micro-USB-nRF-USB-Port ein. Stellen Sie den Schalter für nRF-Stromquelle auf USB ein.
Build überprüfen
Überprüfen Sie einen erfolgreichen Build. Rufen Sie dazu in einem Terminalfenster über die GNU-Bildschirmseite die OpenThread CLI auf. Die nRF52840-Platinen verwenden eine Baudrate von 115200.
$ screen /dev/ttyACM1 115200
Drücken Sie mehrmals die Eingabetaste auf der Tastatur, um die Eingabeaufforderung > der OpenThread CLI 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 →
d Trennen Sie das Fenster von der FTD Commissioner CLI und kehren Sie zum Linux-Terminal zurück, damit das nächste Board blinkt. Sie können screen -r jederzeit über die Befehlszeile noch einmal eingeben. Mit screen -ls können Sie eine Liste der verfügbaren Bildschirme aufrufen:
$ screen -ls
There is a screen on:
74182.ttys000.mylinuxmachine (Detached)
1 Socket in /tmp/uscreens/S-username.
FTD-Join einrichten
Wiederholen Sie den obigen Vorgang, um das dritte nRF52840-Board mit dem vorhandenen ot-cli-ftd.hex-Build zu blinken. Wenn Sie fertig sind, verbinden Sie die Platine mithilfe des nRF-USB-Anschlusses wieder mit dem PC und stellen Sie den Schalter für nRF-Stromquelle auf VDD.
Wenn die anderen beiden Knoten an den Linux-Computer angehängt sind, wenn dieses dritte Board verbunden ist, sollte es als serieller Port /dev/ttyACM2 angezeigt werden:
$ ls /dev/ttyACM* /dev/ttyACM0 /dev/ttyACM1 /dev/ttyACM2
Kennzeichnen Sie das Board mit dem Label „Joiner“.
Wenn Sie die Überprüfung mit dem Bildschirm durchführen, stellen Sie anstelle der neuen Instanz in der Befehlszeile die aktuelle Instanz her. Erstellen Sie darin ein neues Fenster (das Sie für den FTD Commissioner verwendet haben):
$ screen -r
Erstellen Sie das neue Fenster in „Bildschirm“ mit „Strg + A“ → c.
Eine neue Befehlszeile wird angezeigt. Öffnen Sie die OpenThread-CLI für den FTD-Jointer:
$ screen /dev/ttyACM2 115200
Drücken Sie in diesem neuen Fenster einige Male die Eingabetaste, um die Eingabeaufforderung > der OpenThread CLI 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
Nachdem sich die FTD Joiner CLI nun auf demselben Bildschirm wie der FTD Commissioner befindet, können Sie mit Strg + A → n zwischen ihnen wechseln.
Strg + A →
d Sie können den Bildschirm jederzeit schließen.
6. Terminalfenster einrichten
Sie werden künftig regelmäßig zwischen Thread-Geräten wechseln. Prüfen Sie daher, ob alle aktiv und leicht zugänglich sind. Bisher haben wir „Bildschirm“ verwendet, um auf die beiden FTDs zuzugreifen. Dieses Tool lässt auch den geteilten Bildschirm im selben Terminalfenster zu. So sehen Sie, wie ein Knoten auf Befehle auf einem anderen reagiert.
Idealerweise sollten vier Fenster verfügbar sein:
ot-daemon-Dienst / Logs- RCP-Joiner über
ot-ctl - FTD Commissioner über die OpenThread CLI
- FTD Joiner über OpenThread CLI
Wenn Sie Ihre eigene Terminal-/serielle Portkonfiguration oder ein Tool verwenden möchten, fahren Sie mit dem nächsten Schritt fort. Konfigurieren Sie die Terminalfenster für alle Geräte so, wie es für Sie am besten funktioniert.
Bildschirm verwenden
Der Einfachheit halber sollten Sie nur eine Bildschirmsitzung starten. Sie sollten bereits eine haben, als Sie beide FTDs eingerichtet haben.
Alle Befehle auf dem Bildschirm beginnen mit Strg + A.
Einfache Bildschirmbefehle:
Noch einmal an die Bildschirmsitzung anhängen (über die Befehlszeile) |
|
Bildschirmsitzung verlassen | Strg + A → |
Neues Fenster in der Bildschirmsitzung erstellen | Strg + A → |
In derselben Bildschirmsitzung zwischen Fenstern wechseln | Strg + A → |
Aktuelles Fenster in der Bildschirmsitzung beenden | Strg + A → |
Splitscreen
Mit dem Bildschirm können Sie das Terminal in mehrere Fenster aufteilen:
Auf Befehle in screen kannst du mit Strg + A zugreifen. Jeder Befehl sollte mit dieser Zugriffsschlüsselkombination beginnen.
Wenn Sie dem Codelab genau folgen, sollten sich auf der gleichen Bildschirminstanz zwei Fenster befinden (FTD Commissioner, FTD Joiner). So teilen Sie den Bildschirm auf zwei Bildschirme ein:
$ screen -r
Sie sollten sich auf einem der FTD-Geräte befinden. Gehen Sie auf dem Bildschirm so vor:
- Strg + A →
S, um das Fenster horizontal aufzuteilen - Strg + A →
Tab, um den Cursor in das neue leere Fenster zu verschieben - Strg+A →
n, um zum neuen Fenster zu wechseln - Wenn sie 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. Dann können Sie mit der Tastenkombination Strg + A → Tab zwischen den beiden Modi wechseln. Es empfiehlt sich, jedem Fenster mit „Strg + A“ → „A“ einen neuen Titel zu geben, um Verwechslungen zu vermeiden.
Erweiterte Nutzung
Um den Bildschirm weiter in Quadranten zu unterteilen und die ot-daemon-Logs sowie den RCP-Joint ot-ctl anzusehen, müssen diese Dienste auf derselben Bildschirminstanz gestartet werden. Beenden Sie dazu ot-daemon und beenden Sie ot-ctl und starten Sie sie in den neuen Bildschirmfenstern („Strg + A“ → „c“).
Diese Konfiguration ist nicht erforderlich und wird dem Nutzer als Training dient.
Mit den folgenden Befehlen können Sie zwischen Fenstern aufteilen und zwischen ihnen wechseln:
Neues Fenster erstellen | Strg + A → |
Fenster vertikal teilen | Strg + A → |
Fenster horizontal teilen | Strg + A → |
Zum nächsten angezeigten Fenster wechseln | Strg + A → |
Angezeigtes Fenster nach vorn oder zurück bewegen | Strg + A → |
Aktuelles Fenster umbenennen | Strg + A → |
Sie können den Bildschirm jederzeit mit Strg + A → d verlassen und über die Befehlszeile mit screen -r anhängen.
Weitere Informationen zu Screen finden Sie in der Kurzanleitung für GNU Screen.
7. Thread-Netzwerk erstellen
Nachdem Sie alle Terminalfenster und ‐bildschirme konfiguriert haben, können Sie das Thread-Netzwerk erstellen. Erstellen Sie im FTD Commissioner ein neues operatives Dataset und übernehmen Sie es als aktives Dataset. 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, der später benötigt wird.
Legen Sie für dieses Dataset ein aktives Dataset fest:
> dataset commit active Done
Rufen Sie die IPv6-Schnittstelle auf:
> ifconfig up Done
Thread-Protokollvorgang starten:
> thread start Done
Warten Sie kurz den Gerätestatus. Es sollte die beste Variante sein. Holen Sie sich den RLOC16 auch zur späteren Verwendung.
## 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 „Codelab“-Netzwerk ist jetzt sichtbar, wenn es von anderen Thread-Geräten gescannt wird.
Von ot-ctl aus dem RCP-Joiner:
## RCP Joiner ## ---------------- > scan | PAN | MAC Address | Ch | dBm | LQI | +------+------------------+----+-----+-----+ | c0de | 1ed687a9cb9d4b1d | 11 | -36 | 232 |
Führen Sie in der OpenThread CLI auf dem FTD Joiner folgende Schritte aus:
## FTD Joiner ## ---------------- > scan | PAN | MAC Address | Ch | dBm | LQI | +------+------------------+----+-----+-----+ | c0de | 1ed687a9cb9d4b1d | 11 | -38 | 229 |
Wenn das „Codelab“-Netzwerk nicht in der Liste angezeigt wird, versuchen Sie es noch einmal.
8. RCP-Verbindung hinzufügen
Die Thread-Inbetriebnahme ist im Netzwerk nicht aktiv. Das bedeutet, dass wir den RCP-Joiner dem Thread-Netzwerk hinzufügen müssen, das wir gerade mithilfe eines Out-of-Band-Inbetriebnahmevorgangs erstellt haben.
Der FTD Commissioner hat uns den Netzwerkschlüssel notiert, zum Beispiel 1234c0de7ab51234c0de7ab51234c0de. Wenn Sie den Netzwerkschlüssel noch einmal suchen möchten, führen Sie im FTD Commissioner den folgenden Befehl aus:
## FTD Commissioner ## > dataset networkkey 1234c0de7ab51234c0de7ab51234c0de Done
Legen Sie dann im RCP Joiner den aktiven Dataset-Netzwerkschlüssel auf den FTD Commissioner Network Key fest:
## RCP Joiner ## ---------------- > dataset networkkey 1234c0de7ab51234c0de7ab51234c0de Done > dataset commit active Done
Prüfen Sie, ob das Dataset korrekt festgelegt ist.
## RCP Joiner ## ---------------- > dataset Network Key: 1234c0de7ab51234c0de7ab51234c0de
Thread aufrufen, damit der RCP-Joiner dem „Codelab“ beitreten kann. Warten Sie einige Sekunden und prüfen Sie den Status, RLOC16 und seine IPv6-Adressen:
## RCP Joiner ## ---------------- > ifconfig up Done > 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 (fdc0:de7a:b5c0:0:66bf:99b9:24c0:d55f hier). Sie werden sie später verwenden.
Prüfen Sie noch einmal im FTD Commissioner, ob sich die Router und die untergeordneten Tabellen im selben Netzwerk befinden. Verwenden Sie den RLOC16, um den RCP-Joint zu identifizieren.
## 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 lokale Mesh-Adresse des RCP-Joints (die Mesh-Local-Adresse, die aus der ipaddr-Ausgabe des RCP-Jointers stammt), 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, das aus zwei Knoten besteht – illustriert durch dieses Topologiediagramm:
Topologiediagramme
Während Sie den Rest des Codelabs durcharbeiten, wird immer dann ein neues Thread-Topologiediagramm angezeigt, wenn sich der Status des Netzwerks ändert. Knotenrollen werden so bezeichnet:
Router sind immer Fünfeck und Endnutzer sind immer Kreise. Die Nummern auf jedem Knoten stellen die Router- oder untergeordnete ID dar, die in der CLI-Ausgabe angezeigt wird. Dies hängt von der aktuellen Rolle und dem Status des jeweiligen Knotens ab.
9. FTD-Joiner in Auftrag geben
Jetzt fügen wir das dritte Thread-Gerät dem Codelab-Netzwerk hinzu. Wir werden die sicherere In-Band-Inbetriebnahme verwenden und nur den FTD-Join zulassen.
Rufen Sie auf dem FTD Joiner den eui64 auf, damit der FTD Commissioner es identifizieren kann:
## FTD Joiner ## ---------------- > eui64 2f57d222545271f1 Done
Starten Sie auf der FTD Commissioner den Commissioner und geben Sie die eui64 des Geräts, das zusammen mit den Joiner-Anmeldedaten verwendet werden kann, an, zum Beispiel J01NME. Die Joiner-Anmeldedaten sind gerätespezifische Strings aus allen alphanumerischen Großbuchstaben (0–9 und A–Y ohne I, O, Q und Z zur Lesbarkeit) mit 6 bis 32 Zeichen.
## FTD Commissioner ## ---------------------- > commissioner start Done > commissioner joiner add 2f57d222545271f1 J01NME Done
Wechseln Sie zum FTD-Joiner. Beginnen Sie die Joiner-Rolle mit den Joiner-Anmeldedaten, die Sie gerade für den FTD Commissioner eingerichtet haben:
## FTD Joiner ## ---------------- > ifconfig up Done > joiner start J01NME Done
Innerhalb weniger Minuten erhalten Sie eine Bestätigung, dass die Authentifizierung erfolgreich war:
## FTD Joiner ## ---------------- > Join success
Rufen Sie Thread auf, damit der FTD-Joiner dem Codelab beitritt und sofort den Status und RLOC16 prüft:
## FTD Joiner ## ---------------- > thread start Done > state child Done > rloc16 0c02 Done
Prüfen Sie die IPv6-Adressen des Geräts. Es gibt kein ALOC. Das liegt daran, dass dieses Gerät nicht der Leader ist und 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 in den Router- und untergeordneten Tabellen, ob drei Geräte im „Codelab“-Netzwerk 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
Gemäß RLOC16 ist der FTD-Joinr mit dem Netzwerk als Endgerät (untergeordnet) verbunden. Dies ist unsere aktualisierte Topologie:
10. Unterhaltung in Aktion
Die Thread-Geräte in diesem Codelab sind eine bestimmte Art von Full-Thread-Gerät (FTD), das als Router berechtigtes Endgerät (REED) bezeichnet wird. Das bedeutet, dass sie entweder als Router oder Endgerät fungieren und sich selbst von einem Endgerät zu einem Router hochstufen lassen.
Thread unterstützt bis zu 32 Router, versucht aber, 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, erklingt es nach einem zufälligen Zeitraum innerhalb von zwei Minuten automatisch zu einem Router.
Wenn sich in Ihrem Thread-Netzwerk zwei untergeordnete Geräte befinden, nachdem der FTD-Joiner hinzugefügt wurde, warten Sie mindestens zwei Minuten und prüfen Sie die Router- und untergeordneten Tabellen noch einmal im FTD Commissioner:
## 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-Joinr (Erweiterte MAC = e6cdd2d93249a243) hat sich auf einen Router hochgestuft. Beachten Sie, dass der RLOC16 anders ist (b800 anstelle von 0c02), da er auf dem Router und der untergeordneten ID eines Geräts basiert. Bei der Umstellung von „Endgerät“ auf „Router“ ändern sich die Werte der Router-ID und der untergeordneten ID ebenso wie der RLOC16.
Prüfen Sie den neuen Status und RLOC16 des FTD-Joints:
## FTD Joiner ## ---------------- > state router Done > rloc16 b800 Done
Downgrade des FTD-Jointers ausführen
Sie können dieses Verhalten testen, indem Sie für den FTD-Joiner ein manuelles Downgrade von einem Router auf ein Endgerät durchfü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 nun der FTD Joiner in der untergeordneten Tabelle erscheinen (ID = 3). Auch während der Umstellung kann es vorkommen, dass sowohl
## 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 er wieder zu einem Router mit dem RLOC b800.
Leader entfernen
Der Leader ist ein selbstgewählter Thread-Router. Wenn also der aktuelle Leader aus dem Thread-Netzwerk entfernt wird, wird einer der anderen Router zum neuen Leader.
Fahren Sie in der FTD Commissioner Thread herunter, um es 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-Joinrs:
## 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 einen neuen RLOC16 gibt. Dies ist der RCP-Jointer, wie durch seine ID und seinen erweiterten MAC angegeben. Um das Thread-Netzwerk zusammenzuhalten, hat das Netzwerk den übergeordneten Router vom FTD Commissioner zum FTD Joiner gewechselt. Das führt zu einem neuen RLOC16 für den RCP-Joint, da 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 untergeordneter FTD-Join verbunden wird. Prüfen Sie den Status und den RLOC16, um Folgendes zu überprüfen:
## RCP Joiner ## -------------- > state child > rloc16 b801
FTD Commissioner wieder anhängen
Ein Thread-Netzwerk mit zwei Knoten macht keinen großen Unterschied. Wir möchten, dass die FTD Commissioner wieder online sind.
Starten Sie den Thread auf der FTD Commissioner neu:
## FTD Commissioner ## ---------------------- > ifconfig up Done > thread start Done
Innerhalb von zwei Minuten wird es automatisch als „Endgerät“ an das Codelab-Netzwerk angehängt und anschließend auf einen Router hochgestuft.
## FTD Commissioner ## ---------------------- > state router Done
Prüfen Sie die Router- und untergeordneten Tabellen des FTD-Joints, 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 unterschiedlichen Terminals oder Bildschirmfenstern kann kompliziert sein. Beachten Sie die folgenden Tipps, um den Status des Netzwerks oder Ihres Arbeitsbereichs zurückzusetzen, wenn Probleme auftreten.
Display
Falls Sie den Überblick über Ihre Konfiguration verlieren (zu viele Bildschirmfenster oder Bildschirme innerhalb des Bildschirms), beenden Sie alle Fenster mit Strg + A → K, bis keine vorhanden sind, und screen -ls auf der Befehlszeile, um No Sockets found auszugeben. Erstellen Sie dann „Bildschirmfenster“ für jedes Gerät neu. Der Gerätestatus bleibt auch dann erhalten, wenn der Bildschirm beendet wird.
Thread-Knoten
Wenn die Thread-Netzwerktopologie in diesem Codelab nicht beschrieben ist oder die Verbindung der Knoten aus einem bestimmten Grund getrennt wird (z. B. weil der Linux-Computer in den Ruhemodus gewechselt wurde), sollten Sie den Thread deaktivieren, die Anmeldedaten für das Netzwerk löschen und mit dem Schritt Thread-Netzwerk erstellen beginnen.
So setzen Sie die FTDs zurück:
## FTD Commissioner or FTD Joiner ## ------------------------------------ > thread stop Done > ifconfig down Done > factoryreset Done
Das RCP kann auf dieselbe Weise über ot-ctl zurückgesetzt werden:
## RCP Joiner ## ---------------- > thread stop Done > ifconfig down Done > factoryreset Done
12. Multicast verwenden
Mit Multicast können Sie Informationen an eine Gruppe von Geräten gleichzeitig übertragen. In einem Thread-Netzwerk sind bestimmte Adressen für die Multicast-Nutzung mit verschiedenen Gerätegruppen reserviert, je nach Umfang.
IPv6-Adresse | Scope (Bereich) | Zugestellt nach |
| Link-Local | Alle FTDs und MEDs |
| Link-Local | Alle FTDs und Border-Router |
| Mesh-Lokal | Alle FTDs und MEDs |
| Mesh-Lokal | Alle FTDs und Border-Router |
Da wir in diesem Codelab keinen Border-Router verwenden, konzentrieren wir uns auf die beiden Multicast-Adressen FTD und MED.
Link-Local
Der Link-Local-Bereich umfasst alle Thread-Schnittstellen, die über eine einzelne Funkübertragung oder einen einzigen „Hop“ erreichbar sind. Die Netzwerktopologie bestimmt, welche Geräte auf einen Ping an die ff02::1-Multicast-Adresse reagieren.
Ping 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
Das Netzwerk verfügt über zwei weitere Geräte (FTD Joiner und RCP Joiner), aber der FTD Commissioner hat nur eine Antwort von der Link-Local-Adresse des FTD Joiner erhalten. Das bedeutet, dass der FTD-Jointer das einzige Gerät ist, das die FTD-Kommission mit einem einzigen Hop erreichen kann.
Senden Sie nun einen Ping an 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! Bei der Überprüfung der IPv6-Adressen für die anderen Geräte sehen wir, dass es sich bei der ersten Adresse, die auf 4b1d endet, um die FLA-Datei des FTD Commissioners und der zweiten Adresse (mit der Endung 943b) handelt.
Das bedeutet, dass der FTD-Jointer direkt mit dem FTD Commissioner und dem RCP Joiner verbunden ist, was unsere Topologie bestätigt.
Mesh-Lokal
Der Bereich „Mesh-Local“ umfasst alle Thread-Schnittstellen, die innerhalb desselben Thread-Netzwerks erreichbar sind. Sehen wir uns die Antworten an einen Ping an die Multicast-Adresse ff03::1 an.
Ping 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
Dieses Mal hat der FTD Commissioner zwei Antworten erhalten: eine vom Routing Locator des FTD Joiner (RLOC, die auf b800 endet) und eine vom Mesh-Local-EID des RCP-Joinrs (ML-EID, die auf d55f endet). Der Grund dafür ist, dass das gesamte Thread-Netzwerk aus dem Mesh-Netzwerk-Bereich besteht. Unabhängig davon, wo im Netzwerk sich ein Gerät befindet, wird die Adresse ff03::1 abonniert.
Senden Sie über den FTD-Joiner einen Ping an ff03::1, 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
Beachten Sie die Antwortzeit für den RCP-Joint der beiden Ping-Ausgaben. Der RCP-Jointer dauerte viel länger, um den FTD Commissioner zu erreichen (68ms) als der FTD Joiner (23ms). Der Grund dafür ist, dass sie zwei Hops erreichen muss, um den FTD Commissioner zu erreichen, und nur einen Hop für den FTD Joiner.
Möglicherweise haben Sie auch bemerkt, dass der Mesh-Lokal-Multicast-Ping nur für die beiden FTDs mit dem RLOC geantwortet hat, nicht mit dem RCP-Joint. Dies liegt daran, dass die FTDs Router im Netzwerk sind, während der RCP ein Endgerät ist.
Prüfen Sie den Status des RCP-Joinrs, um Folgendes zu überprüfen:
## RCP Joiner ## ---------------- > state child
13. Nachrichten mit UDP senden
Einer der von OpenThread zur Verfügung gestellten Anwendungsdienste ist User Datagram Protocol (UDP), ein Transport Layer-Protokoll. Eine Anwendung, die auf OpenThread basiert, kann die UDP API verwenden, um Nachrichten zwischen Knoten in einem Thread-Netzwerk oder an andere Geräte in einem externen Netzwerk (wie das Internet, wenn das Thread-Netzwerk einen Border-Router verfügt) zu übertragen.
UDP-Sockets werden über die OpenThread-Befehlszeile bereitgestellt. Wir verwenden sie, um Nachrichten zwischen den beiden FTDs zu übergeben.
Rufen Sie die Mesh-Local-EID-Adresse für den FTD Joiner ab. Wir verwenden diese Adresse, da Sie von überall im Thread-Netzwerk aus erreichbar sind.
## 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 an einen Socket für eine IPv6-Adresse:
## FTD Joiner ## ---------------- > udp open Done > udp bind :: 1212
Wechseln Sie zum FTD Commissioner, starten Sie UDP und stellen Sie mit seiner ML-EID eine Verbindung zum Socket her, den Sie auf dem 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 bestehen. Senden Sie eine Nachricht vom FTD Commissioner:
## FTD Commissioner ## ---------------------- > udp send hellothere Done
Beim FTD-Joiner wurde die UDP-Nachricht empfangen.
## FTD Joiner ## ---------------- > 10 bytes from fdc0:de7a:b5c0:0:0:ff:fe00:c00 49153 hellothere
14. Glückwunsch!
Du hast ein physisches Thread-Netzwerk erstellt.
Sie wissen jetzt:
- den Unterschied zwischen Thread-Gerätetypen, -Rollen und -Bereichen
- So verwalten Thread-Geräte ihre Status im Netzwerk
- Einfache Nachrichten zwischen Knoten mit UDP übertragen
Nächste Schritte
Aufbauend auf diesem Codelab können Sie folgende Übungen ausführen:
- Flashen Sie das FTD-Joiner-Board als MTD mit dem Binärprogramm
ot-cli-mtdneu und achten Sie darauf, dass es nie auf einen Router aktualisiert wird oder versucht, der Leader zu werden. - Fügen Sie dem Netzwerk weitere Geräte hinzu oder versuchen Sie es mit einer anderen Plattform. Skizzieren Sie außerdem die Topologie mithilfe von Router- und untergeordneten Tabellen sowie Pings an die Multicast-Adressen.
- Pyspinel zur Steuerung des NCP verwenden
- Den NCP mithilfe von OpenThread Border Router in einen Border-Router konvertieren und Ihr Thread-Netzwerk mit dem Internet verbinden
Weitere Informationen
Auf openthread.io und GitHub finden Sie eine Vielzahl von OpenThread-Ressourcen, darunter:
- Unterstützte Plattformen – Hier finden Sie alle Plattformen, die OpenThread unterstützen.
- OpenThread: weitere Informationen zum Erstellen und Konfigurieren von OpenThread
- Thread Primer: deckt alle Thread-Konzepte in diesem Codelab ab
Referenz: