1. Einführung
OpenThread ist eine Open-Source-Implementierung des Netzwerkprotokolls Thread® von Google. Google Nest hat OpenThread veröffentlicht, um die in Nest-Produkten verwendete Technologie allgemein für Entwickler verfügbar zu machen. So kann die Entwicklung von Produkten für das Smart Home beschleunigt werden.
In der Thread-Spezifikation ist ein IPv6-basiertes zuverlässiges, sicheres und energiesparendes Kommunikationsprotokoll für Geräte zwischen Geräten für Heimanwendungen definiert. 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 leiten Nachrichten zwischen Knoten weiter.
Lerninhalte
- OpenThread-Befehlszeilen-Binärprogramme erstellen und blinken, um Entwicklungsboards zu erstellen
- RCP mit einem Linux-Computer und einem Entwicklungsboard erstellen
- Mit einem RCP über OpenThread Daemon und
ot-ctlkommunizieren - Thread-Knoten mit GNU Screen 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 Entwicklungsboards für Nordic Semiconductor nRF52840
- 3 USB-zu-Micro-USB-Kabel zum Verbinden der Boards
- Linux-Computer mit mindestens 3 USB-Ports
Software:
- GNU-Toolchain
- Nordische nRF5x-Befehlszeilentools
- Segger J-Link-Software
- OpenThread
- Git
2. Erste Schritte
OpenThread-Simulation
Bevor Sie beginnen, sollten Sie das OpenThread Simulation Codelab durchgehen, um sich mit den grundlegenden Thread-Konzepten und der OpenThread-CLI vertraut zu machen.
Terminals für serielle Ports
Sie sollten mit dem Herstellen einer Verbindung zu einem seriellen Port über ein Terminal vertraut sein. Dieses Codelab verwendet GNU Screen und bietet eine Nutzungsübersicht. Es kann aber jede andere Terminalsoftware verwendet werden.
Linux-Computer
Dieses Codelab wurde entwickelt, um auf einem i386- oder x86-basierten Linux-Computer den Host für ein RCP-Gerät (Radio Co-Processor) zu erstellen und alle Thread-Entwicklerplatinen zu blinken. Alle Schritte wurden auf Ubuntu 14.04.5 LTS (Trusty Tahr) getestet.
Boards für Nordic Semiconductor nRF52840
Dieses Codelab verwendet drei nRF52840 PDK-Boards.
SEGGER J-Link installieren
Wir nutzen SEGGER J-Link, um die nRF52840-Boards zu programmieren, die integrierte JTAG-Module haben. 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 dies /opt/SEGGER/JLink.
nRF5x-Befehlszeilentools installieren
Mit den nRF5x-Befehlszeilentools können Sie die OpenThread-Binärdateien auf den nRF52840-Karten installieren. Installieren Sie den entsprechenden nRF5x-Command-Line-Tools-lt> auf Ihrem Linux-Computer.
Extrahieren Sie das extrahierte Paket im Stammordner ~/.
ARM-GNU-Toolchain installieren
Die ARM-GNU-Toolchain wird zum Erstellen von Gebäuden verwendet.
Wir empfehlen dir, das extrahierte Archiv in /opt/gnu-mcu-eclipse/arm-none-eabi-gcc/ auf deinem Linux-Computer zu speichern. Folgen Sie der Installationsanleitung 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 Screens. Sie können jedoch jede beliebige Anwendung mit seriellem Port 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 ordnungsgemäß konfiguriert ist:
$ mkdir -p ~/src $ cd ~/src $ git clone --recursive https://github.com/openthread/openthread.git $ cd openthread $ ./script/bootstrap
Erstellen Sie einen OpenThread-Daemon:
$ script/cmake-build posix -DOT_DAEMON=ON
Jetzt können Sie OpenThread erstellen und auf den nRF52840-Karten installieren.
4. RCP-Join einrichten
Build und Flash
Erstellen Sie das Beispiel „OpenThread nRF52840“ mit Joiner und nativen USB-Funktionen. Ein Gerät verwendet die Rolle „Joiner“, um es sicher zu authentifizieren und in einem Thread-Netzwerk in Betrieb zu nehmen. Natives USB ermöglicht das Verwenden des USB-CDC-ACM als seriellen Transport zwischen dem nRF52840 und dem Host.
Führen Sie immer eine Bereinigung des Repositorys vorheriger Builds durch, 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 zum 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 der externen Steckdose auf der nRF52840-Karte und schließen Sie es an den Linux-Computer an. Stellen Sie den Schalter nRF-Stromquelle auf der nRF52840-Karte auf VDD ein. Wenn die Verbindung korrekt ist, ist LED5 an.
Wenn dies das erste Board ist, das mit dem Linux-Computer verbunden ist, erscheint es als serieller Port /dev/ttyACM0. Alle nRF52840-Boards verwenden ttyACM als ID des seriellen Ports.
$ ls /dev/ttyACM* /dev/ttyACM0
Notieren Sie sich die Seriennummer des für den RCP verwendeten nRF52840-Boards:
Gehen Sie zum Speicherort der nRFx-Befehlszeilentools und öffnen Sie die OpenThread RCP-Hexadezimaldatei mit der Seriennummer des Boards auf der Boardkarte. Wenn Sie das Flag --verify weglassen, erscheint eine Warnung mit dem Hinweis, dass der Flash-Vorgang 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 das Board mit RCP, damit Sie die Board-Rollen später nicht verwechseln können.
Mit nativem USB-Kabel verbinden
Da der OpenThread RCP-Build das native USB-CDC ACM als seriellen Transport ermöglicht, müssen Sie den nRF-USB-Port auf dem nRF52840-Board für die Kommunikation mit dem RCP-Host (Linux-Computer) verwenden.
Trennen Sie das Micro-USB-Ende des USB-Kabels vom Debug-Port des nRF52840-Bretts und schließen Sie es wieder an den Micro-USB-nRF-USB-Port neben der Taste RESET an. Stellen Sie den Schalter für die nRF-Stromquelle auf USB.
OpenThread-Daemon starten
Verwenden Sie im RCP-Design den OpenThread-Daemon für die Kommunikation und Verwaltung des Thread-Geräts. 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 ist, generiert ot-daemon im ausführlichen Modus eine Ausgabe wie diese:
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 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-CLI-App. 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 die state von Knoten 2 (dem RCP-Knoten), die 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 könnte man wpantund, einen produktionsräumlichen Netzwerkschnittstellentreiber, verwenden, um OpenThread-NCP-Instanzen zu steuern. In diesem Codelab verwenden wir aber ot-ctl, die OpenThread-CLI.
Ein Gerät fungiert als Commissioner, um Geräte sicher zu authentifizieren und in diesem Netzwerk in Betrieb zu nehmen. Das andere Gerät fungiert als Joiner, den der Kommissar beim Thread-Netzwerk authentifizieren kann.
Build und Flash
Erstellen Sie das OpenThread-FTD-Beispiel für die nRF52840-Plattform 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 Befehlszeilen-Binärprogramm „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-Anschluss neben der externen Steckdose auf der nRF52840-Karte und schließen Sie es an den Linux-Computer an. Wenn der RCP noch mit dem Linux-Computer verbunden ist, sollte dieses neue Board als serieller Port /dev/ttyACM1 angezeigt werden. Alle nRF52840-Boards verwenden ttyACM als ID des seriellen Ports.
$ ls /dev/ttyACM* /dev/ttyACM0 /dev/ttyACM1
Notieren Sie sich wie zuvor die Seriennummer des nRF52840-Boards, das für das FTD verwendet wird:
Gehen Sie zum Speicherort der nRFx-Befehlszeilentools und öffnen Sie die Hexadezimaldatei der OpenThread-Befehlszeile auf der nRF52840-Karte. 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 „&comter“.
Mit nativem USB-Kabel 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 für die Kommunikation mit dem RCP-Host (Linux-Computer) verwenden.
Trennen Sie das Micro-USB-Ende des USB-Kabels vom Debug-Port des nRF52840-Bretts und schließen Sie es wieder an den Micro-USB-nRF-USB-Port neben der Taste RESET an. Stellen Sie den Schalter für die nRF-Stromquelle auf USB.
Build überprüfen
Prüfen Sie einen erfolgreichen Build, indem Sie über ein Terminalfenster über GNU Screen auf die OpenThread-Befehlszeile zugreifen. Die nRF52840-Karten verwenden eine Baudrate von 115200.
$ screen /dev/ttyACM1 115200
Drücken Sie in dem neuen Fenster mehrmals die Eingabetaste auf der Tastatur, 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:1cd6:87a9:cb9d:4b1d Done
Strg + A →
d um sie vom Bildschirm „FTD Commissioner CLI“ zu trennen und zum Linux-Terminal zurückzukehren, damit das nächste Board geladen werden kann. Sie können screen -r jederzeit über die Befehlszeile eingeben. 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-Join einrichten
Wiederholen Sie den obigen Vorgang, um das dritte nRF52840-Board mithilfe des vorhandenen ot-cli-ftd.hex-Builds zu blinken. Wenn Sie fertig sind, verbinden Sie das Board ü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, sollte das dritte Board als serieller Port /dev/ttyACM2 angezeigt werden:
$ ls /dev/ttyACM* /dev/ttyACM0 /dev/ttyACM1 /dev/ttyACM2
Label für die Tafel "&Joint."
Wenn Sie die Überprüfung mit Screen ausführen, anstatt eine neue Instanz von Screen über die Befehlszeile zu erstellen, hängen Sie noch einmal die vorhandene Instanz an und erstellen Sie darin ein neues Fenster, das Sie für den FTD Commissioner verwendet haben:
$ screen -r
Erstellen Sie ein neues Fenster auf dem Bildschirm mit Strg + a → c.
Eine neue Befehlszeile wird angezeigt. Öffnen Sie die OpenThread-CLI für den FTD-Join:
$ screen /dev/ttyACM2 115200
Drücken Sie in diesem neuen Fenster mehrmals 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 CLI auf dem gleichen Bildschirm befindet wie der FTD Commissioner, können Sie mit Strg + a → n zwischen ihnen wechseln.
Strg + A →
d jederzeit beenden.
6. Terminalfenster einrichten
Künftig wechseln Sie häufig zwischen Thread-Geräten. Sorgen Sie also dafür, dass alle aktiv und leicht zugänglich sind. Bisher haben wir Bildschirm verwendet, um auf die beiden FTDs zuzugreifen. Dieses Tool ermöglicht auch einen geteilten Bildschirm im selben Terminal-Fenster. So sehen Sie, wie ein Knoten auf Befehle reagiert, die auf einem anderen ausgeführt werden.
Im Idealfall sollten vier Fenster verfügbar sein:
ot-daemon-Dienst/Logs- RCP Joiner über
ot-ctl - FTD Commissioner über die OpenThread-Befehlszeile
- FTD Joiner über OpenThread CLI
Wenn Sie Ihre Konfiguration für ein Terminal / einen seriellen Port oder ein eigenes Tool verwenden möchten, können Sie mit dem nächsten Schritt fortfahren. Konfigurieren Sie die Terminalfenster für alle Geräte so, wie es für Sie am besten ist.
Bildschirm verwenden
Aus Gründen der Nutzerfreundlichkeit starten Sie nur eine Bildschirmsitzung. Sie sollten bereits ein solches Konto haben, wenn Sie beide FTDs einrichten.
Alle Befehle auf dem Bildschirm beginnen mit Strg + a.
Grundlegende Befehle auf dem Bildschirm:
Noch einmal an die Bildschirmsitzung anhängen (über die Befehlszeile) |
|
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 schließen | Strg + A → |
Bildschirm teilen
Mit Screen können Sie das Terminal in mehrere Fenster aufteilen:
Befehle in screen werden mit Strg + a aufgerufen. Jeder Befehl sollte mit dieser Kombination von Zugriffsschlüsseln beginnen.
Wenn Sie sich genau an das Codelab halten, sollten Sie auf derselben Bildschirminstanz zwei Fenster haben (FTD Commissioner, FTD Joiner). Wenn Sie den Bildschirm zwischen den beiden Bildschirmen aufteilen möchten, geben Sie zuerst Ihre vorhandene Bildschirmsitzung ein:
$ screen -r
Sie sollten sich auf einem der FTD-Geräte befinden. Folgen Sie diesen Schritten auf dem Bildschirm:
- 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 neuen Fenster zu wechseln - Wenn er mit dem obersten Fenster übereinstimmt, drücken Sie noch einmal Strg + a →
n, um das andere FTD-Gerät aufzurufen.
Beide sind jetzt sichtbar. Mit Strg + A → Tab können Sie zwischen ihnen wechseln. Um Verwechslungen zu vermeiden, empfiehlt es sich, jedem Fenster mit Strg + a → A einen neuen Namen zu geben.
Erweiterte Nutzung
Um den Bildschirm weiter in Quadranten zu unterteilen und die ot-daemon-Logs sowie den RCP-Joiner ot-ctl aufzurufen, müssen diese Dienste in derselben Bildschirminstanz gestartet werden. Beenden Sie dazu ot-daemon und beenden Sie ot-ctl. Starten Sie sie dann in den neuen Bildschirmfenstern (Strg + a → c).
Diese Einrichtung ist nicht erforderlich und wird dem Nutzer als Übung überlassen.
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ückbewegen | Strg+A → |
Aktuelles Fenster umbenennen | Strg + A → |
Du kannst den Bildschirm jederzeit mit Strg + a → d verlassen und ihn dann über die Befehlszeile mit screen -r anhängen.
Weitere Informationen zum Bildschirm finden Sie in der GNU-Kurzübersicht zu Bildschirmen.
7. Thread-Netzwerk erstellen
Nachdem Sie alle Terminalfenster und -bildschirme konfiguriert haben, erstellen Sie unser Thread-Netzwerk. 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.
Übernehmen Sie dieses Dataset 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 kurz den Gerätestatus. Es sollte die führende Person sein. Sie erhalten auch den RLOC16 als Referenz.
## 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.
Von ot-ctl auf dem RCP Joiner:
## RCP Joiner ## ---------------- > scan | PAN | MAC Address | Ch | dBm | LQI | +------+------------------+----+-----+-----+ | c0de | 1ed687a9cb9d4b1d | 11 | -36 | 232 |
Über die OpenThread-Befehlszeile auf dem FTD Joiner:
## FTD Joiner ## ---------------- > scan | PAN | MAC Address | Ch | dBm | LQI | +------+------------------+----+-----+-----+ | c0de | 1ed687a9cb9d4b1d | 11 | -38 | 229 |
Wenn das Netzwerk im Codelab nicht in der Liste angezeigt wird, wiederholen Sie den Scanvorgang.
8. RCP-Join hinzufügen
Die Thread-Inbetriebnahme ist im Netzwerk nicht aktiv. Das bedeutet, dass der RCP-Joiner dem Thread-Netzwerk hinzugefügt werden muss, das Sie gerade mit einem Out-of-Band-Inbetriebnahmeprozess erstellt haben.
Auf der FTD Commissioner haben wir uns den Netzwerkschlüssel notiert, zum Beispiel 1234c0de7ab51234c0de7ab51234c0de. Wenn Sie den Netzwerkschlüssel noch einmal suchen müssen, führen Sie den folgenden Befehl im FTD Commissioner aus:
## FTD Commissioner ## > dataset networkkey 1234c0de7ab51234c0de7ab51234c0de Done
Legen Sie anschließend im RCP Joiner den aktiven Netzwerk-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 richtig festgelegt ist.
## RCP Joiner ## ---------------- > dataset Network Key: 1234c0de7ab51234c0de7ab51234c0de
Thread aufrufen, damit der RCP-Joiner dem Codelab-Netzwerk beitritt. 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), die Sie später benötigen.
Prüfen Sie wieder auf der FTD Commissioner, ob die Router- und untergeordneten Tabellen zum selben Netzwerk gehören. Verwenden Sie den 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-Joins (die Mesh-Local-Adresse, die aus dem RCP-Join ipaddr abgerufen wurde) an, 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, wie in diesem Topologiediagramm dargestellt:
Topologiediagramme
Während Sie den Rest des Codelabs durchgehen, wird bei jeder Änderung des Netzwerkstatus ein neues Thread-Topologiediagramm angezeigt. Knotenrollen werden so angegeben:
Router sind immer Fünfecke und Endgeräte sind immer Kreise. Die Zahlen auf jedem Knoten stellen die Router-ID oder untergeordnete ID dar, die in der CLI-Ausgabe angezeigt wird, abhängig von der aktuellen Rolle und dem Status jedes Knotens zu diesem Zeitpunkt.
9. FTD-Jointer beauftragen
Fügen Sie nun dem dritten Thread-Gerät das Netzwerk des Codelabs hinzu. Dieses Mal wird der sicherere In-Band-Inbetriebnahmeprozess verwendet und nur der FTD-Joiner kann teilnehmen.
Rufen Sie für den FTD Joiner den eui64 ab, damit der FTD Commissioner es identifizieren kann:
## FTD Joiner ## ---------------- > eui64 2f57d222545271f1 Done
Starten Sie den Commissioner (FTD) für FTD und geben Sie die eui64 des Geräts an, das teilnehmen kann, sowie die Joiner-Anmeldedaten, z. B. J01NME. Die Anmeldedaten des Joiners sind ein gerätespezifischer String aller alphanumerischen Zeichen in Großbuchstaben (0–9 und A–Y, mit Ausnahme von I, O, Q und Z zur besseren Lesbarkeit) mit einer Länge zwischen 6 und 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 etwa einer Minute erhalten Sie eine Bestätigung, dass die Authentifizierung erfolgreich war:
## FTD Joiner ## ---------------- > Join success
Öffnen Sie den Thread, damit der FTD-Join in das Netzwerk des Codelabs eingebunden wird, und prüfen Sie sofort den Status und RLOC16:
## FTD Joiner ## ---------------- > thread start Done > state child Done > rloc16 0c02 Done
IPv6-Adressen des Geräts prüfen Beachten Sie, dass es keine ALOC gibt. Das liegt daran, dass dieses Gerät nicht der Leader ist und auch keine Anycast-spezifische Rolle hat, die eine 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 drei Geräte im Netzwerkcode 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 ist der FTD-Joiner als Endgerät mit dem Netzwerk verbunden. 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 infrage kommendes 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 können.
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 (untergeordnetes Gerät) angehängt wird und die Anzahl der Router unter 16 liegt, wird er nach einem zufälligen Zeitraum innerhalb von zwei Minuten automatisch zu einem Router hochgestuft.
Wenn in Ihrem Thread-Netzwerk zwei untergeordnete Elemente vorhanden waren, nachdem Sie den FTD-Join hinzugefügt haben, warten Sie mindestens zwei Minuten und prüfen Sie dann 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 (Extended MAC = e6cdd2d93249a243) hat sich zu einem Router hochgestuft. Beachten Sie, dass der RLOC16 anders ist (b800 statt 0c02). Das liegt daran, dass der RLOC16 auf der Router- und untergeordneten ID eines Geräts basiert. Bei der Umstellung von einem Endgerät auf einen Router ändern sich seine Router-ID und die Werte der untergeordneten IDs ebenso wie die RLOC16-Werte.
Prüfen Sie den neuen Status und RLOC16 auf dem FTD Joiner:
## FTD Joiner ## ---------------- > state router Done > rloc16 b800 Done
FTD-Join downgraden
Sie können dieses Verhalten testen, indem Sie ein manuelles Downgrade des FTD Joiner 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
In der FTD Commissioner sollte jetzt der FTD Joiner in der untergeordneten Tabelle (ID = 3) erscheinen. Sie kann sich sogar während eines Übergangs in beiden befinden:
## 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 wird wieder auf einen Router mit dem RLOC von b800 umgestellt.
Führungsperson entfernen
Der Leader ist 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 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 Joiners:
## 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. Das ist der RCP-Joinr, wie durch seine ID und seinen erweiterten MAC angegeben. Um das Thread-Netzwerk zusammenzuhalten, wurde der übergeordnete Router vom FTD Commissioner zum FTD Joiner gewechselt. Dies führt zu einem neuen RLOC16-Wert 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
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 nicht viel Spaß. FTD Commissioner wieder online schalten lassen.
Starten Sie Thread im FTD Commissioner neu:
## FTD Commissioner ## ---------------------- > ifconfig up Done > thread start Done
Innerhalb von zwei Minuten wird das Gerät automatisch wieder als Endgerät mit dem Netzwerk „codelab“ verbunden und anschließend von einem Router hochgestuft.
## FTD Commissioner ## ---------------------- > state router Done
Prüfen Sie die Router- und untergeordneten Tabellen im FTD-Join, 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 über verschiedene Terminal- oder Bildschirmfenster kann kompliziert sein. Mit diesen Tipps können Sie den Zustand des Netzwerks oder Ihres Arbeitsbereichs zurücksetzen, falls Probleme auftreten.
Display
Falls Sie bei der Konfiguration zu viele Bildschirmfenster oder Bildschirme auf dem Bildschirm verlieren, beenden Sie die Fenster mit Strg+a → k so lange, bis keine mehr vorhanden sind. screen -lsIn der Befehlszeile wird No Sockets found ausgegeben. Erstellen Sie dann die Bildschirmfenster für jedes Gerät neu. Gerätestatus werden auch dann beibehalten, wenn der Bildschirm deaktiviert wird.
Thread-Knoten
Wenn die Thread-Netzwerktopologie in diesem Codelab nicht beschrieben wird oder Knoten aus irgendeinem Grund getrennt werden (z. B. weil die Linux-Maschine in den Ruhemodus wechselte), sollten Sie 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
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 übermitteln. In einem Thread-Netzwerk sind bestimmte Adressen für die Multicast-Nutzung mit verschiedenen Gerätegruppen reserviert, je nach Umfang.
IPv6-Adresse | Umfang | Zugestellt an |
| Link-Local | Alle FTDs und MEDs |
| Link-Local | Alle FTDs und Border-Router |
| Mesh-Local | Alle FTDs und MEDs |
| Mesh-Local | 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 antworten.
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
Es gibt zwei weitere Geräte im Netzwerk (FTD Joiner und RCP Joiner), aber der FTD Commissioner hat nur eine Antwort von der FTD Joiner-Adresse (LLA) erhalten. Das heißt, der FTD Joiner ist das einzige Gerät, das der FTD Commissioner mit einem einzigen Hop erreichen kann.
Pingen Sie nun 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) den LLA des FTD-Kommissions und der zweite (endet auf 943b) der RCP Joiner-LLA.
Das bedeutet, dass der FTD-Joiner sowohl mit dem FTD Commissioner als auch mit dem RCP Joiner direkt verbunden ist, was unsere Topologie bestätigt.
Mesh-Local
Der Bereich „Mesh-Local“ umfasst alle Thread-Schnittstellen, die innerhalb desselben Thread-Netzwerks 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
Dieses Mal hat der FTD-Kommission zwei Antworten erhalten: eine vom Routing FcC (FLOC) mit der Endung „b800“ und eine vom RCP-Joiner (Mesh-Local EID, ML-EID, endet auf d55f). Das liegt daran, dass der Mesh-Netzwerk-Bereich das gesamte Thread-Netzwerk umfasst. Egal, wo im Netzwerk sich ein Gerät befindet, es wird die Adresse ff03::1 abonniert.
Pingen Sie ff03::1 über den FTD Joiner, 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-Join in beiden Ping-Ausgaben. Der RCP-Joiner dauerte viel länger, um den FTD-Kommissionsmitglied (68 ms) zu erreichen als der FTD-Joiner (23 ms). Das liegt daran, dass der FTD-Beauftragte zwei Hops erreichen muss, verglichen mit einem Hop für den FTD Joiner.
Möglicherweise ist Ihnen auch aufgefallen, dass der Mesh-Netzwerk-Multicast-Ping nur für die beiden FTDs mit dem RLOC und nicht mit dem RCP-Join geantwortet hat. 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:
## RCP Joiner ## ---------------- > state child
13. Nachrichten mit UDP senden
Einer der Anwendungsdienste, die OpenThread bietet, ist User Datagram Protocol (UDP), ein Transport Layer-Protokoll. Eine auf OpenThread entwickelte Anwendung kann die UDP API verwenden, um Nachrichten zwischen Knoten in einem Thread-Netzwerk oder an andere Geräte in einem externen Netzwerk (z. B. Internet, wenn das Thread-Netzwerk einen Border Router hat) zu übergeben.
UDP-Sockets werden über die OpenThread-Befehlszeile bereitgestellt. Hiermit können Nachrichten zwischen den beiden FTDs übergeben werden.
Rufen Sie die Mesh-Local-EID-Adresse für den FTD-Join ab. Wir verwenden diese Adresse, weil sie von überall im Thread-Netzwerk aus 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 mit seiner 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 bestehen. Sende eine Nachricht vom FTD Commissioner:
## FTD Commissioner ## ---------------------- > udp send hellothere Done
Im 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!
Sie haben ein physisches Thread-Netzwerk erstellt.
Sie wissen jetzt:
- den Unterschied zwischen Thread-Gerätetypen, Rollen und Bereichen
- wie Thread-Geräte ihren Status innerhalb des Netzwerks verwalten
- Wie einfache Nachrichten zwischen Knoten mithilfe von UDP übergeben werden
Weitere Informationen
Basierend auf diesem Codelab können Sie folgende Übungen ausprobieren:
- Das FTD Joiner Board mit der Binärdatei
ot-cli-mtdnoch einmal als MTD aktualisieren und feststellen, dass es nie ein Upgrade auf einen Router ausführt oder versucht, der Leader zu werden - Fügen Sie dem Netzwerk weitere Geräte hinzu und versuchen Sie es mit einer anderen Plattform. Skizzieren Sie dazu die Topologie mithilfe von Router- und untergeordneten Tabellen sowie Pings an die Multicast-Adressen.
- NCP mit pyspinel steuern
- Verwenden Sie OpenThread Border Router, um den NCP in einen Border-Router umzuwandeln, und verbinden Sie Ihr Thread-Netzwerk mit dem Internet.
Weitere Informationen
Auf openthread.io und GitHub finden Sie eine Vielzahl von OpenThread-Ressourcen, darunter:
- Unterstützte Plattformen – Alle Plattformen, die OpenThread unterstützen
- OpenThread erstellen: Weitere Informationen zum Erstellen und Konfigurieren von OpenThread
- Thread Primer: behandelt alle in diesem Codelab vorgestellten Thread-Konzepte
Referenz: