1. Einführung
OpenThread, das von Google veröffentlicht wurde, ist eine Open-Source-Implementierung des Thread®-Netzwerkprotokolls. Google Nest hat OpenThread veröffentlicht, um Entwicklern die in Nest-Produkten verwendete Technologie allgemein zugänglich zu machen und so die Entwicklung von Produkten für das vernetzte Zuhause zu beschleunigen.
Die Thread-Spezifikation definiert ein IPv6-basiertes, zuverlässiges, sicheres und energiesparendes Kommunikationsprotokoll für drahtlose Geräte zwischen Geräten für Heimanwendungen. OpenThread implementiert alle Thread-Netzwerkschichten, 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 leiten Nachrichten zwischen Knoten weiter.
Lerninhalte
- OpenThread-CLI-Binärdateien erstellen und auf Entwicklungsboards flashen
- RCP aus einem Linux-Computer und einem Dev-Board erstellen
- Über OpenThread Daemon und
ot-ctlmit einem RCP kommunizieren - Thread-Knoten manuell mit GNU Screen und der OpenThread-CLI verwalten
- Sichere Inbetriebnahme von Geräten in einem Thread-Netzwerk
- Funktionsweise von IPv6-Multicast
- Nachrichten zwischen Thread-Knoten mit UDP weiterleiten
Voraussetzungen
Hardware:
- 3 Entwicklungsboards von Nordic Semiconductor nRF52840
- 3 USB-auf-Micro-USB-Kabel zum Verbinden der Karten
- 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 das Codelab für die OpenThread-Simulation durchgehen, um sich mit den grundlegenden Thread-Konzepten und der OpenThread-Befehlszeile vertraut zu machen.
Terminals der seriellen 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. Sie können aber auch jede andere Terminalsoftware verwenden.
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-Entwicklungsboards zu flashen. Alle Schritte wurden unter Ubuntu 14.04.5 LTS (Trusty Tahr) getestet.
nRF52840-Platinen von Nordic Semiconductor
In diesem Codelab werden drei nRF52840-PDK-Boards verwendet.
SEGGER J-Link installieren
Wir verwenden SEGGER J-Link, um die nRF52840-Karten mit integrierten JTAG-Modulen zu programmieren. Installieren Sie diese Datei 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 flashen. Geeignetes nRF5x-Command-Line-Tools-<OS> installieren auf Ihrem Linux-Computer erstellen.
Legen Sie das extrahierte Paket im Stammordner ~/ ab.
ARM GNU-Toolchain installieren
Die ARM GNU-Toolchain dient dem Bauen.
Wir empfehlen, das extrahierte Archiv auf Ihrem Linux-Computer in /opt/gnu-mcu-eclipse/arm-none-eabi-gcc/ zu speichern. Eine Installationsanleitung finden Sie in der Datei readme.txt des Archivs.
Installationsbildschirm (optional)
Screen 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 jede beliebige Terminalanwendung mit seriellem Port verwenden.
$ sudo apt-get install screen
3. Repositories klonen
OpenThread
Klonen und installieren Sie OpenThread. Mit den script/bootstrap-Befehlen wird dafür gesorgt, 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 flashen.
4. RCP Joiner einrichten
Build und Flash
Erstellen Sie das OpenThread-nRF52840-Beispiel mit Joiner und nativer USB-Funktionalität. 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 serielle Übertragung zwischen dem nRF52840 und dem Host.
Bereinigen Sie immer zuerst das Repository vorheriger 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
Gehen Sie zum 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
Stecken Sie das USB-Kabel in den Micro-USB-Debug-Port neben dem externen Stromanschluss der nRF52840-Platine und schließen Sie es dann an den Linux-Computer an. Stellen Sie den Schalter für die nRF-Stromquelle auf der nRF52840-Platine auf VDD. Wenn die Verbindung korrekt hergestellt ist, leuchtet LED5.
Wenn dies das erste an den Linux-Computer angeschlossene Board ist, wird es als serieller Port /dev/ttyACM0 angezeigt (alle nRF52840-Karten verwenden ttyACM als Kennung des seriellen Ports).
$ ls /dev/ttyACM* /dev/ttyACM0
Notieren Sie sich die Seriennummer der für die RCP verwendeten nRF52840-Karte:
Navigieren Sie zum Speicherort der nRFx-Befehlszeilentools und flashen Sie die OpenThread-RCP-Hexadezimaldatei auf die nRF52840-Platine unter Verwendung der Seriennummer der Karte. Wenn Sie das Flag --verify weglassen, wird eine Warnmeldung angezeigt, 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.
Beschriften Sie die Tafel mit „RCP“ damit Sie später die Vorstandsrollen nicht verwechseln.
Mit nativem USB-Kabel verbinden
Da der OpenThread-RCP-Build die Verwendung von nativem USB-CDC-ACM als serielle Übertragung 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-Ende des USB-Kabels vom Debug-Port der geblinkten nRF52840-Karte und schließen Sie es dann wieder an den Micro-USB-nRF USB-Anschluss neben der Schaltfläche Zurücksetzen an. Stellen Sie den Schalter für 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. Beginnen 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'
Bei Erfolg generiert ot-daemon im ausführlichen Modus eine Ausgabe ähnlich der folgenden:
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 die Protokolle 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-CLI-Anwendung. Daher können Sie ot-daemon-Knoten auf dieselbe Weise steuern wie die anderen simulierten Thread-Geräte.
Starten Sie ot-ctl in einem zweiten Terminalfenster:
$ sudo ./build/posix/src/posix/ot-ctl >
Prüfen Sie den 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, die in diesem Codelab verwendet werden, sind Full-Thread-Geräte (FTDs) im standardmäßigen System-on-Chip-Design (SoC). In einer Produktionseinstellung kann zur Steuerung von OpenThread-NCP-Instanzen wpantund verwendet werden, ein produktionstauglicher Netzwerkschnittstellentreiber. In diesem Codelab verwenden wir jedoch ot-ctl, die OpenThread-Befehlszeile.
Ein Gerät fungiert als Commissioner, um Geräte in diesem Netzwerk sicher zu authentifizieren und in Betrieb zu nehmen. Das andere Gerät fungiert als Joiner, das der Commissioner beim Thread-Netzwerk authentifizieren kann.
Build und Flash
Erstellen Sie das OpenThread-FTD-Beispiel für die nRF52840-Plattform und aktivieren Sie die Rollen „Provisioner“ und „Joiner“:
$ cd ~/src/ot-nrf528xx $ rm -rf build $ script/build nrf52840 USB_trans -DOT_JOINER=ON -DOT_COMMISSIONER=ON
Gehen Sie zum Verzeichnis mit dem FTD-Befehlszeilen-Binärprogramm (OpenThread Full Thread Device) und konvertieren Sie es in das Hexadezimalformat:
$ cd ~/src/ot-nrf528xx/build/bin $ arm-none-eabi-objcopy -O ihex ot-cli-ftd ot-cli-ftd.hex
Stecken Sie das USB-Kabel in den Micro-USB-Port neben dem externen Stromanschluss auf der nRF52840-Platine und schließen Sie es dann an den Linux-Computer an. Wenn die RCP noch mit dem Linux-Computer verbunden ist, sollte diese neue Karte als serieller Port /dev/ttyACM1 angezeigt werden. Alle nRF52840-Karten verwenden ttyACM als Kennung des seriellen Ports.
$ ls /dev/ttyACM* /dev/ttyACM0 /dev/ttyACM1
Notieren Sie sich wie zuvor die Seriennummer der für die FTD verwendeten nRF52840-Karte:
Navigieren Sie zum Speicherort der nRFx-Befehlszeilentools und flashen Sie die FTD-Hexadezimaldatei der OpenThread CLI mithilfe der Seriennummer auf der nRF52840-Platine:
$ cd ~/nrfjprog/
$ ./nrfjprog -f nrf52 -s 683704924 --verify --chiperase --program \
~/src/ot-nrf528xx/build/bin/ot-cli-ftd.hex --reset
Beschriften Sie die Tafel mit „Commissioner“.
Mit nativem USB-Kabel verbinden
Da der OpenThread FTD-Build die Verwendung von nativem 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-Ende des USB-Kabels vom Debug-Port der geblinkten nRF52840-Karte und schließen Sie es dann wieder an den Micro-USB-nRF USB-Anschluss neben der Schaltfläche Zurücksetzen an. Stellen Sie den Schalter für nRF-Stromquelle auf USB.
Build überprüfen
Prüfen Sie, ob der Build erfolgreich war, indem Sie in einem Terminalfenster über GNU Screen auf die OpenThread-Befehlszeile zugreifen. Die nRF52840-Boards verwenden eine Baudrate von 115.200.
$ screen /dev/ttyACM1 115200
Drücken Sie im neuen Fenster mehrmals die Eingabetaste auf der Tastatur, um die >-Eingabeaufforderung der OpenThread-Befehlszeile aufzurufen. Rufen Sie die IPv6-Schnittstelle auf und prüfen Sie die Adressen:
> ifconfig up Done > ipaddr fe80:0:0:0:1cd6:87a9:cb9d:4b1d Done
Drücken Sie Strg + A →
d um den Bildschirm der FTD Commissioner CLI zu trennen und zum Linux-Terminal zurückzukehren, damit das nächste Board geflasht werden kann. Sie können die Befehlszeile jederzeit wieder aufrufen. Geben Sie dazu screen -r in der Befehlszeile ein. Mit screen -ls kannst du 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-Joiner einrichten
Wiederholen Sie den obigen Prozess, um das dritte nRF52840-Board mit dem vorhandenen ot-cli-ftd.hex-Build zu flashen. Wenn Sie fertig sind, verbinden Sie die Karte über den nRF-USB-Port wieder mit dem PC und stellen Sie den Schalter für die nRF-Stromquelle auf VDD.
Wenn die anderen beiden Knoten an den Linux-Computer angeschlossen sind, wenn diese dritte Karte angeschlossen ist, sollte sie als serieller Port /dev/ttyACM2 angezeigt werden:
$ ls /dev/ttyACM* /dev/ttyACM0 /dev/ttyACM1 /dev/ttyACM2
Beschriften Sie die Tafel mit dem Namen „Joiner“.
Bei der Überprüfung mit Screen sollten Sie, anstatt eine neue Screen-Instanz über die Befehlszeile zu erstellen, wieder an die vorhandene Instanz anhängen und darin ein neues Fenster öffnen, das Sie für den FTD-Beauftragten verwendet haben:
$ screen -r
Erstellen Sie auf dem Bildschirm ein neues Fenster mit Strg + A → c.
Eine neue Befehlszeilen-Eingabeaufforderung wird angezeigt. Greifen Sie auf die OpenThread-Befehlszeile für den FTD-Joiner zu:
$ screen /dev/ttyACM2 115200
Drücken Sie in diesem neuen Fenster mehrmals die Eingabetaste auf der Tastatur, um die >-Eingabeaufforderung der OpenThread-Befehlszeile aufzurufen. Rufen Sie die IPv6-Schnittstelle auf und prüfen Sie die Adressen:
> ifconfig up Done > ipaddr fe80:0:0:0:6c1e:87a2:df05:c240 Done
Da sich die FTD Joiner-Befehlszeile nun in derselben Bildschirminstanz wie der FTD Provisioner befindet, können Sie mit Strg + A → n zwischen ihnen wechseln.
Drücken Sie Strg + A →
d , um den Bildschirm zu verlassen.
6. Einrichtung des Terminalfensters
In Zukunft wirst du häufig zwischen Thread-Geräten wechseln. Achte also darauf, dass alle aktiv und leicht zugänglich sind. Bisher haben wir Screen verwendet, um auf die beiden FTDs zuzugreifen. Dieses Tool ermöglicht auch den Splitscreen im selben Terminalfenster. Damit können Sie sehen, wie ein Knoten auf Befehle reagiert, die auf einem anderen ausgeführt werden.
Idealerweise sollten Sie vier Fenster sofort zur Hand haben:
ot-daemon-Dienst / Logs- RCP Joiner über
ot-ctl - FTD Commissioner über OpenThread-CLI
- FTD-Joiner über OpenThread-CLI
Wenn Sie Ihre eigene Terminal- bzw. serielle Portkonfiguration oder ein eigenes Tool verwenden möchten, können Sie diesen Schritt überspringen. Konfigurieren Sie die Terminalfenster für alle Geräte so, wie es für Sie am besten passt.
Bildschirm verwenden
Starten Sie aus Gründen der Nutzerfreundlichkeit nur eine Bildschirmsitzung. Sie sollten bereits einen von haben, wenn Sie beide FTDs einrichten.
Alle Befehle auf dem Bildschirm starten mit Strg + A.
Grundlegende Befehle für den Bildschirm:
Erneut 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 die Befehle in screen kann mit Strg + A zugegriffen werden. 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 Screen-Instanz haben. Um den Bildschirm zwischen den beiden zu teilen, rufen Sie zuerst Ihre vorhandene Bildschirmsitzung auf:
$ screen -r
Sie sollten eines der FTD-Geräte verwenden. Gehen Sie auf dem Bildschirm wie folgt vor:
- Strg + A →
S, um das Fenster horizontal zu teilen - Strg + A →
Tab, um den Cursor in das neue leere Fenster zu verschieben - Strg + A →
n, um zum nächsten Fenster zu wechseln - Ist dies mit dem oberen Fenster identisch, drücken Sie Strg + A →
n, um das andere FTD-Gerät aufzurufen.
Sie sind jetzt beide sichtbar. Drücken Sie Strg + A → Tab, um zwischen ihnen zu wechseln. Wir empfehlen, jedes Fenster mit „Strg + A → A“ umzubenennen, um Verwechslungen zu vermeiden.
Erweiterte Nutzung
Um den Bildschirm weiter in Quadranten aufzuteilen und die ot-daemon-Logs und den RCP-Joiner ot-ctl anzusehen, müssen diese Dienste innerhalb derselben Bildschirminstanz gestartet werden. Beenden Sie dazu ot-daemon, beenden Sie ot-ctl und starten Sie die Apps in einem neuen Fenster neu (Strg + A → c).
Diese Einrichtung ist nicht erforderlich und dient dem Nutzer als Übung.
Mit den folgenden Befehlen können Sie Fenster teilen und zwischen Fenstern wechseln:
Neues Fenster erstellen | Strg + A → |
Fenster vertikal teilen | Strg + A → |
Fenster horizontal teilen | Strg + A → |
Zum nächsten angezeigten Fenster wechseln | Strg + A → |
Im angezeigten Fenster vor- oder zurückwechseln | 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 wieder anhängen.
Weitere Informationen zum Bildschirm finden Sie in der Kurzanleitung für den GNU-Bildschirm.
7. Thread-Netzwerk erstellen
Nachdem Sie alle Terminalfenster und -bildschirme konfiguriert haben, können Sie unser Thread-Netzwerk erstellen. Erstellen Sie im FTD Commissioner ein neues operatives Dataset und übergeben Sie einen Commit 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 verwendet wird.
Übernehmen Sie für dieses Dataset ein Commit als aktives Dataset:
> dataset commit active Done
Rufen Sie die IPv6-Schnittstelle auf:
> ifconfig up Done
Thread-Protokollvorgang starten:
> thread start Done
Prüfen Sie nach einem Moment den Gerätestatus. Es sollte der Leader sein. Sie können auch RLOC16 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 „Codelab“ Netzwerk ist jetzt sichtbar, wenn von anderen Thread-Geräten gescannt wird.
Ab ot-ctl im RCP Joiner:
## RCP Joiner ## ---------------- > scan | PAN | MAC Address | Ch | dBm | LQI | +------+------------------+----+-----+-----+ | c0de | 1ed687a9cb9d4b1d | 11 | -36 | 232 |
Über die OpenThread-Befehlszeile im FTD-Joiner:
## 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-Joiner hinzufügen
Thread Commissioning ist im Netzwerk nicht aktiv. Das bedeutet, dass wir den RCP Joiner dem gerade erstellten Thread-Netzwerk über einen Out-of-Band-Inbetriebnahmeprozess hinzufügen müssen.
Im FTD Commissioner haben wir uns den Netzwerkschlüssel notiert, zum Beispiel 1234c0de7ab51234c0de7ab51234c0de. Wenn Sie den Netzwerkschlüssel noch einmal nachschlagen müssen, führen Sie den folgenden Befehl im FTD Commissioner aus:
## FTD Commissioner ## > dataset networkkey 1234c0de7ab51234c0de7ab51234c0de Done
Legen Sie als Nächstes im RCP Joiner den Netzwerkschlüssel des aktiven Datasets auf den Netzwerkschlüssel des FTD Commissioner fest:
## 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
Thread einrichten, damit der RCP-Joiner dem Codelab beitritt Netzwerk. 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 benötigen sie später.
Prüfen Sie im FTD Commissioner den Router und die untergeordneten Tabellen, um sicherzugehen, dass beide Geräte zum selben Netzwerk gehören. Verwenden Sie RLOC16, um den RCP-Joiner 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-Joiner an (die Mesh-Local-Adresse, die aus der ipaddr-Ausgabe des RCP-Joiners abgerufen wird), um die Konnektivität 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, wie in diesem Topologiediagramm dargestellt:
Topologiediagramme
Während Sie den Rest des Codelabs durcharbeiten, wird jedes Mal ein neues Thread-Topologiediagramm angezeigt, wenn sich der Status des Netzwerks ändert. Knotenrollen werden so angegeben:
Router sind immer Fünfecke und Endgeräte immer Kreise. Die Zahlen auf jedem Knoten stellen die Router-ID oder die untergeordnete ID dar, die in der CLI-Ausgabe angezeigt wird, je nach aktueller Rolle und Status des jeweiligen Knotens zum jeweiligen Zeitpunkt.
9. FTD-Joiner in Betrieb nehmen
Jetzt fügen wir dem „Codelab“ das dritte Thread-Gerät hinzu Netzwerk. Dieses Mal verwenden wir den sichereren In-Band-Inbetriebnahmeprozess und gestatten nur dem FTD-Joiner den Beitritt.
Rufen Sie für den FTD Joiner die eui64 ab, damit der FTD-Beauftragte sie identifizieren kann:
## FTD Joiner ## ---------------- > eui64 2f57d222545271f1 Done
Starten Sie den FTD Commissioner und geben Sie die eui64 des Geräts an, das beitreten kann, zusammen mit den Anmeldedaten des Joiners, z. B. J01NME. Die Joiner-Anmeldedaten sind ein gerätespezifischer String zwischen 6 und 32 Zeichen, der alle Großbuchstaben alphanumerischen Zeichen (0–9 und A–Y, ausgenommen I, O, Q und Z) enthält, die zur besseren Lesbarkeit verwendet werden.
## FTD Commissioner ## ---------------------- > commissioner start Done > commissioner joiner add 2f57d222545271f1 J01NME Done
Wechseln Sie zum FTD-Joiner. Starten Sie die Joiner-Rolle mit den Joiner-Anmeldedaten, die Sie gerade im FTD-Beauftragten eingerichtet haben:
## FTD Joiner ## ---------------- > ifconfig up Done > joiner start J01NME Done
Innerhalb etwa einer Minute erhalten Sie eine Bestätigung über eine erfolgreiche Authentifizierung:
## FTD Joiner ## ---------------- > Join success
Thread aufrufen, damit der FTD-Joiner mit dem Codelab verbunden wird und überprüfen Sie sofort den Status und RLOC16:
## FTD Joiner ## ---------------- > thread start Done > state child Done > rloc16 0c02 Done
Prüfen Sie die IPv6-Adressen des Geräts. Beachten Sie, dass es kein ALOC gibt. Das liegt daran, dass dieses Gerät weder der Leader ist noch eine Anycast-spezifische Rolle hat, für die ein ALOC erforderlich ist.
## 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 des Routers und der untergeordneten Tabellen, ob im „Codelab“ drei Geräte vorhanden sind. Netzwerk:
## 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 RLOC16 hat der FTD-Joiner als Endgerät (untergeordnetes Gerät) an das Netzwerk angehängt. Hier ist unsere aktualisierte Topologie:
10. Thread in Aktion
Die Thread-Geräte in diesem Codelab sind eine bestimmte Art von Full-Thread-Gerät (Full Thread Device, FTD), die als Router Allowed End Device (REED) bezeichnet wird. Das heißt, sie können entweder als Router oder als Endgerät fungieren und sich von einem Endgerät zu einem Router hochstufen.
Thread kann bis zu 32 Router unterstützen, versucht jedoch, die Anzahl der Router zwischen 16 und 23 zu halten. Wenn ein REED als Endgerät angehängt wird und die Anzahl der Router unter 16 liegt, wird es nach einem zufälligen Zeitraum innerhalb von zwei Minuten automatisch zu einem Router hochgestuft.
Wenn sich nach dem Hinzufügen des FTD-Joiner in Ihrem Thread-Netzwerk zwei untergeordnete Elemente befinden, warten Sie mindestens zwei Minuten und prüfen Sie dann den Router und die 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-Joiner (Extended MAC = e6cdd2d93249a243) hat sich zu einem Router hochgestuft. Beachte, dass sich RLOC16 unterscheidet (b800 statt 0c02). Das liegt daran, dass RLOC16 auf der Router-ID und der untergeordneten ID eines Geräts basiert. Wenn vom Endgerät zu einem Router gewechselt wird, ändern sich die Werte der Router-ID und der untergeordneten ID. Dies gilt auch für RLOC16.
Bestätigen Sie den neuen Status und RLOC16 auf dem FTD-Joiner:
## FTD Joiner ## ---------------- > state router Done > rloc16 b800 Done
Downgrade des FTD-Joiner durchführen
Sie können dieses Verhalten testen, indem Sie manuell ein Downgrade des FTD-Joiner von einem Router auf ein Endgerät durchführen. Ändern Sie den Status in „Child“ und prüfen Sie RLOC16:
## FTD Joiner ## ---------------- > state child Done > rloc16 0c03 Done
Im FTD Commissioner sollte nun der FTD-Joiner in der untergeordneten Tabelle angezeigt werden (ID = 3). Während des Übergangs kann es sogar in beiden enthalten sein:
## 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 einem RLOC von b800.
Führungselement entfernen
Der Leader wird unter allen Thread-Routern selbst gewählt. Wenn also der aktuelle Leader aus dem Thread-Netzwerk entfernt wird, wird einer der anderen Router zum neuen Leader.
Fahren Sie Thread im FTD Commissioner 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 zu prüfen:
## 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. Sie sehen, dass es ein neues RLOC16 gibt. Dies ist der RCP-Joiner, wie aus seiner ID und seinem erweiterten MAC hervorgeht. Um das Thread-Netzwerk zusammenzuhalten, hat es die übergeordneten Router gewechselt, vom FTD Commissioner zum FTD Joiner. Dies führt zu einem neuen RLOC16 für den RCP-Joiner, da sich seine Router-ID von 3 in 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
Es kann einige Minuten dauern, bis der RCP Joiner als untergeordnetes Element an den FTD-Joiner angehängt wurde. Prüfen Sie den Status und RLOC16, um Folgendes zu bestätigen:
## RCP Joiner ## -------------- > state child > rloc16 b801
FTD-Beauftragter wieder anhängen
Ein Thread-Netzwerk mit zwei Knoten macht nicht viel Spaß. Bringen wir den FTD-Beauftragten wieder online.
Starten Sie Thread im FTD Commissioner neu:
## FTD Commissioner ## ---------------------- > ifconfig up Done > thread start Done
Innerhalb von zwei Minuten wird es automatisch wieder an das Codelab angehängt. Netzwerk als Endgerät und bewirbt sich dann zu einem Router.
## FTD Commissioner ## ---------------------- > state router Done
Überprüfen Sie den Router und die untergeordneten Tabellen im FTD Joiner, um Folgendes zu bestimmen:
## 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 in verschiedenen Terminal- oder Bildschirmfenstern kann kompliziert sein. Befolgen Sie diese Tipps zum „Zurücksetzen“. Status des Netzwerks oder Ihres Arbeitsbereichs, falls Probleme auftreten.
Display
Wenn Sie sich jemals in Ihrer Konfiguration verlieren (zu viele Bildschirmfenster oder „Bildschirme im Bildschirm“), schließen Sie mit Strg + a → K weiter Bildschirmfenster, bis keine vorhanden sind und screen -ls in der Befehlszeile No Sockets found ausgibt. Erstellen Sie dann die Bildschirmfenster für jedes Gerät neu. Der Gerätestatus wird auch bei Beendigung des Bildschirms beibehalten.
Threadknoten
Wenn die Thread-Netzwerktopologie nicht der Beschreibung in diesem Codelab entspricht oder Knoten aus irgendeinem Grund getrennt werden, z. B. weil der Linux-Computer, auf dem sie betrieben werden, in den Ruhezustand gekommen ist, sollten Sie Thread beenden, die Netzwerkanmeldedaten löschen und mit dem Schritt Thread-Netzwerk erstellen noch einmal beginnen.
So setzen Sie die FTDs zurück:
## FTD Commissioner or FTD Joiner ## ------------------------------------ > thread stop Done > ifconfig down Done > factoryreset Done
Der RCP kann auf die gleiche 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 kommunizieren. In einem Thread-Netzwerk werden bestimmte Adressen je nach Umfang für die Multicast-Nutzung mit verschiedenen Gerätegruppen reserviert.
IPv6-Adresse | Ebene | Zugestellt an |
| 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, die über eine einzelne Funkübertragung oder einen einzelnen „Hop“ erreichbar sind. Die Netzwerktopologie gibt vor, welche Geräte auf einen Ping an die Multicast-Adresse ff02::1 reagieren.
Pingen Sie ff02::1 vom FTD Commissioner an:
## 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 befinden sich zwei weitere Geräte (FTD Joiner und RCP Joiner), aber der FTD Commissioner hat nur eine Antwort von der Link-Local-Adresse (LLA) des FTD Joiner erhalten. Das bedeutet, dass der FTD-Joiner das einzige Gerät ist, das der FTD-Beauftragte mit einem einzigen Hop erreichen kann.
Pingen Sie jetzt ff02::1 über den FTD-Joiner an:
## 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 der anderen Geräte stellen wir fest, dass die erste (mit der Endung 4b1d) die LLA des FTD-Beauftragten und die zweite (mit der Endung 943b) die LLA des RCP Joiner ist.
Das bedeutet, dass der FTD-Joiner direkt mit dem FTD-Beauftragten und dem RCP-Joiner verbunden ist, was unsere Topologie bestätigt.
Mesh-Netzwerk (lokal)
Der Mesh-Local-Bereich umfasst alle Thread-Schnittstellen, die innerhalb desselben Thread-Netzwerks erreichbar sind. Sehen wir uns die Antworten auf einen Ping an die Multicast-Adresse ff03::1 an.
Pingen Sie ff03::1 vom FTD Commissioner an:
## 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-Beauftragte zwei Antworten erhalten: eine vom Routing Locator des FTD Joiner (RLOC, endend auf b800) und eine von der Mesh-Local-EID des RCP Joiner (ML-EID, mit der Endung d55f). Das liegt daran, dass der lokale Mesh-Bereich das gesamte Thread-Netzwerk umfasst. Ganz gleich, wo sich ein Gerät im Netzwerk befindet, es wird die ff03::1-Adresse abonniert.
Pingen Sie ff03::1 über den FTD-Joiner an, um das gleiche 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 sich die Antwortzeit für den RCP-Joiner in beiden Ping-Ausgaben. Der RCP-Joiner brauchte viel länger, um den FTD-Beauftragten zu erreichen (68 ms), als er den FTD-Joiner erreichte (23 ms). Das liegt daran, dass zwei Sprünge nötig sind, um den FTD-Beauftragten zu erreichen, im Vergleich zu einem Sprung für den FTD-Joiner.
Möglicherweise haben Sie auch festgestellt, dass der lokale Multicast-Ping mit dem RLOC nur für die beiden FTDs und nicht für den RCP Joiner mit dem RLOC geantwortet hat. Das liegt daran, dass die FTDs Router im Netzwerk sind, während der RCP ein Endgerät ist.
Prüfen Sie zur Bestätigung den Status von RCP Joiner:
## RCP Joiner ## ---------------- > state child
13. Nachrichten mit UDP senden
Einer der von OpenThread bereitgestellten Anwendungsdienste ist das User Datagram Protocol (UDP), ein Transport Layer-Protokoll. Eine auf OpenThread basierende Anwendung könnte die UDP-API verwenden, um Nachrichten zwischen Knoten in einem Thread-Netzwerk oder an andere Geräte in einem externen Netzwerk (z. B. das Internet, wenn das Thread-Netzwerk über einen Border Router verfügt) weiterzuleiten.
UDP-Sockets werden über die OpenThread-Befehlszeile freigegeben. Lassen Sie uns damit Nachrichten zwischen den beiden FTDs übergeben.
Rufen Sie die Mesh-Local-EID-Adresse für den FTD-Joiner ab. Wir verwenden diese Adresse, weil sie von überall 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 an einen Socket für eine beliebige IPv6-Adresse:
## FTD Joiner ## ---------------- > udp open Done > udp bind :: 1212
Wechseln Sie zum FTD Commissioner, starten Sie UDP und stellen Sie mithilfe der ML-EID eine Verbindung zu dem 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-Beauftragten:
## FTD Commissioner ## ---------------------- > udp send hellothere Done
Im FTD Joiner ist die UDP-Nachricht eingegangen.
## 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.
Jetzt wissen Sie:
- Unterschied zwischen Gerätetypen, Rollen und Bereichen für Threads
- wie Thread-Geräte ihren Status im Netzwerk verwalten
- Wie einfache Nachrichten zwischen Knoten mit UDP weitergeleitet werden
Nächste Schritte
Probiere die folgenden Übungen aus, die auf diesem Codelab aufbauen:
- Flashen Sie das FTD-Joiner Board noch einmal als MTD mit dem
ot-cli-mtd-Binärprogramm und stellen Sie fest, dass es sich nie selbst auf einen Router aktualisiert oder versucht, der Leader zu werden - Fügen Sie dem Netzwerk weitere Geräte hinzu (probieren Sie eine andere Plattform aus) und skizzieren Sie die Topologie mithilfe von Routern und untergeordneten Tabellen sowie Pings zu den Multicast-Adressen.
- Pyspinel zur Kontrolle des NCP verwenden
- Konvertieren Sie den NCP mithilfe eines OpenThread-Border-Routers in einen Border-Router und verbinden Sie das Thread-Netzwerk mit dem Internet
Weitere Informationen
Unter openthread.io und GitHub finden Sie eine Vielzahl von OpenThread-Ressourcen, darunter:
- Unterstützte Plattformen – Finden Sie alle Plattformen, die OpenThread unterstützen.
- OpenThread erstellen – weitere Details zum Erstellen und Konfigurieren von OpenThread
- Thread Primer – behandelt alle Thread-Konzepte in diesem Codelab
Referenz: