Thread-Netzwerk mit nRF52840-Boards und OpenThread erstellen

Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

1. Einführung

26b7f4f6b3ea0700.png

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.

4806d16a8c137c6d.jpeg

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-ctl kommunizieren
  • 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.

a6693da3ce213856.png

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.

20a3b4b480356447.png

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:

c00d519ebec7e5f0.jpeg

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.

46e7b670d2464842.png

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:

c00d519ebec7e5f0.jpeg

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.

46e7b670d2464842.png

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:

  1. ot-daemon-Dienst/Logs
  2. RCP Joiner über ot-ctl
  3. FTD Commissioner über die OpenThread-Befehlszeile
  4. 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)

screen -r

Bildschirmsitzung verlassen

Strg + A → d

Neues Fenster in der Bildschirmsitzung erstellen

Strg + A → c

Zwischen Fenstern in derselben Bildschirmsitzung wechseln

Strg+a → n (Weiter)Strg+a → p (Zurück)

Das aktuelle Fenster in der Bildschirmsitzung schließen

Strg + A → k

Bildschirm teilen

Mit Screen können Sie das Terminal in mehrere Fenster aufteilen:

Logo: f1cbf1258cf0a5a.png

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:

  1. Strg+a → S, um das Fenster horizontal zu teilen
  2. Strg+a → Tab, um den Cursor in das neue leere Fenster zu verschieben
  3. Strg+a → n, um zum neuen Fenster zu wechseln
  4. 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 → c

Fenster vertikal aufteilen

Strg+A →

Fenster horizontal aufteilen

Strg + A → S

Zum nächsten angezeigten Fenster wechseln

Strg + A → Tab

Angezeigtes Fenster vor- oder zurückbewegen

Strg+A → n oder p

Aktuelles Fenster umbenennen

Strg + A → 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:

Logo: otcodelab_top01C_2nodes.png

Topologiediagramme

Während Sie den Rest des Codelabs durchgehen, wird bei jeder Änderung des Netzwerkstatus ein neues Thread-Topologiediagramm angezeigt. Knotenrollen werden so angegeben:

b75a527be4563215.png

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:

Logo: otcodelab_top01C_ed01.png

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.

Logo: otcodelab_top01C.png

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

Logo: otcodelab_top01C_ed02.png

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.

Logo: otcodelab_top01C.png

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

Logo: otcodelab_top02C_01.png

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

Logo: otcodelab_top02C_02.png

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

ff02::1

Link-Local

Alle FTDs und MEDs

ff02::2

Link-Local

Alle FTDs und Border-Router

ff03::1

Mesh-Local

Alle FTDs und MEDs

ff03::2

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.

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.

otcodelab_top02C_02_LL

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.

otcodelab_top02C_02_LL02

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.

Logo: otcodelab_top02C_02_ML.png

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

otcodelab_top02C_02_LL02

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.

b915c433e7027cc7.png

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-mtd noch 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:

Referenz: