Thread-Netzwerk mit nRF52840-Boards und OpenThread erstellen

1. Einführung

26b7f4f6b3ea0700.png

OpenThread ist eine Open-Source-Implementierung des Thread®-Netzwerkprotokolls. Google Nest hat OpenThread veröffentlicht, um Entwicklern die Technologie, die in Nest-Produkten verwendet wird, allgemein zur Verfügung zu stellen und so die Entwicklung von Produkten für das Smart Home zu beschleunigen.

In der Thread-Spezifikation wird ein IPv6-basiertes zuverlässiges, sicheres und energiesparendes Kommunikationsprotokoll für Geräte zwischen Geräten für Home-Anwendungen definiert. OpenThread implementiert alle Thread-Netzwerkebenen, einschließlich IPv6, 6LoWPAN, IEEE 802.15.4 mit MAC-Sicherheit, Mesh-Link-Etablierung und Mesh-Routing.

In diesem Codelab programmieren Sie OpenThread auf echter Hardware, erstellen und verwalten ein Thread-Netzwerk und übergeben Nachrichten zwischen Knoten.

4806d16a8c137c6d.jpeg

Lerninhalte

  • OpenThread-Befehlszeilen-Binärdateien auf Entwicklungsboards erstellen und blinken lassen
  • RCP erstellen, die aus einer Linux-Maschine und einem Entwicklungsboard besteht
  • Kommunikation mit einem RCP mit OpenThread Daemon und ot-ctl
  • Thread-Knoten mit dem GNU-Bildschirm und der OpenThread-Befehlszeile manuell verwalten
  • Sichere Inbetriebnahme von Geräten in einem Thread-Netzwerk
  • So funktioniert IPv6-Multicast
  • Nachrichten zwischen Thread-Knoten mit UDP übergeben

Voraussetzungen

Hardware:

  • 3 Nord-Halbleiter-nRF52840-Entwicklerplatinen
  • 3 USB-zu-Micro-USB-Kabel zum Verbinden der Karten
  • Eine Linux-Maschine mit mindestens drei USB-Anschlüssen

Software:

  • GNU-Toolchain
  • Nordische Befehlszeilentools nRF5x
  • Segger J-Link-Software
  • OpenThread
  • Git

2. Erste Schritte

OpenThread-Simulation

Bevor Sie beginnen, können Sie das OpenThread Simulation Codelab ausführen, um sich mit den grundlegenden Thread-Konzepten und der OpenThread-Befehlszeile vertraut zu machen.

Terminals für serielle Ports

Sie sollten wissen, wie Sie eine Verbindung zu einem seriellen Port über ein Terminal herstellen. Dieses Codelab verwendet GNU Screen und bietet eine Nutzungsübersicht, es kann aber auch jede andere Terminalsoftware verwendet werden.

Linux-Maschine

Dieses Codelab wurde entwickelt, um eine i386- oder x86-basierte Linux-Maschine zu verwenden, die als Host für ein RCP-Thread-Gerät (Radio Co-Processor) verwendet wird, sowie zum Flashieren aller Thread-Entwicklungsboards. Alle Schritte wurden unter Ubuntu 14.04.5 LTS (Trusty Tahr) getestet.

Nordische Halbleiterplatinen nRF52840

Dieses Codelab verwendet drei nRF52840 PDK-Karten.

Logo: A6693da3ce213856.png

Wir verwenden SEGGER J-Link, um die nRF52840-Boards zu programmieren, die JTAG-Module enthalten. Installieren Sie das Programm auf Ihrem Linux-Computer.

Laden Sie das entsprechende Paket für Ihren Computer herunter und installieren Sie es am richtigen Speicherort. Unter Linux ist dies /opt/SEGGER/JLink.

nRF5x-Befehlszeilentools installieren

Mit den nRF5x-Befehlszeilentools können Sie die OpenThread-Binärdateien auf die nRF52840-Boards blinken lassen. Installieren Sie den entsprechenden Build nRF5x-Command-Line-Tools-<OS> auf Ihrem Linux-Rechner.

Platzieren Sie das extrahierte Paket im Stammverzeichnis ~/.

ARM GNU Toolchain installieren

Die ARM GNU Toolchain wird für das Erstellen verwendet.

Wir empfehlen, das extrahierte Archiv in /opt/gnu-mcu-eclipse/arm-none-eabi-gcc/ auf Ihrem Linux-Computer zu speichern. Die Installationsanleitung finden Sie in der Datei readme.txt des Archivs.

Installationsbildschirm (optional)

Der Bildschirm ist ein einfaches Tool für den Zugriff auf Geräte, die über einen seriellen Port verbunden sind. In diesem Codelab wird "Screen" verwendet. Sie können jedoch eine beliebige Anwendung des seriellen Ports mit Terminal verwenden.

$ sudo apt-get install screen

3. Repositories klonen

OpenThread

OpenThread klonen und installieren Die script/bootstrap-Befehle sorgen dafür, dass die Toolchain installiert und die Umgebung ordnungsgemäß konfiguriert ist:

$ mkdir -p ~/src
$ cd ~/src
$ git clone --recursive https://github.com/openthread/openthread.git
$ cd openthread
$ ./script/bootstrap

Erstellen Sie den OpenThread Daemon:

$ script/cmake-build posix -DOT_DAEMON=ON

Jetzt können Sie OpenThread erstellen und auf die nRF52840-Boards blinken.

4. RCP-Join einrichten

Build und Flash

Erstellen Sie das OpenThread nRF52840-Beispiel mit Joiner und nativer USB-Funktionalität. Ein Gerät verwendet die Rolle "Joiner", um sich sicher zu authentifizieren und in einem Thread-Netzwerk in Betrieb zu nehmen. Natives USB ermöglicht die Verwendung von USB CDC ACM als seriellen Transport zwischen dem nRF52840 und dem Host.

Führen Sie zuerst rm -rf build aus, um das Repository vorheriger Builds immer zu bereinigen.

$ cd ~/src
$ git clone --recursive https://github.com/openthread/ot-nrf528xx.git
$ cd ot-nrf528xx
$ script/build nrf52840 USB_trans

Wechseln Sie in das Verzeichnis mit der OpenThread RCP-Binärdatei und konvertieren Sie es in das Hexadezimalformat:

$ cd ~/src/ot-nrf528xx/build/bin
$ arm-none-eabi-objcopy -O ihex ot-rcp ot-rcp.hex

Verbinden Sie das USB-Kabel mit dem Micro-USB-Debug-Port neben dem externen Stromanschluss der nRF52840-Karte und verbinden Sie es mit dem Linux-Computer. Setzen Sie den Schieberegler für die nRF-Stromquelle auf der nRF52840-Karte auf VDD. Wenn die Verbindung richtig hergestellt ist, ist LED5 eingeschaltet.

20a3b4b480356447.png

Wenn dies das erste Board ist, das an den Linux-Computer angeschlossen ist, wird es als serieller Port /dev/ttyACM0 angezeigt. Alle nRF52840-Boards verwenden ttyACM für die ID des seriellen Ports.

$ ls /dev/ttyACM*
/dev/ttyACM0

Notieren Sie sich die Seriennummer des nRF52840-Boards, das für den RCP verwendet wird:

c00d519ebec7e5f0.jpeg

Gehen Sie zum Speicherort der nRFx-Befehlszeilentools und blinken Sie die OpenThread RCP-Hex-Datei mithilfe der Seriennummer des Boards in das nRF52840-Board. Wenn Sie das Flag --verify weglassen, erscheint eine Warnmeldung, dass der Flash-Prozess ohne Fehler fehlschlagen kann.

$ cd ~/nrfjprog/
$ ./nrfjprog -f nrf52 -s 683704924  --verify --chiperase --program \
       ~/src/ot-nrf528xx/build/bin/ot-rcp.hex --reset

Bei Erfolg wird die folgende Ausgabe generiert:

Parsing hex file.
Erasing user available code and UICR flash areas.
Applying system reset.
Checking that the area to write is not protected.
Programing device.
Applying system reset.
Run.

Kennzeichnen Sie das Board mit "RCP", damit Sie später die Board-Rollen nicht verwechseln.

Mit nativem USB-Anschluss verbinden

Da der OpenThread RCP-Build das native USB CDC ACM als seriellen Transport ermöglicht, müssen Sie den nRF-USB-Port auf der nRF52840-Karte verwenden, um mit dem RCP-Host (Linux-Computer) zu kommunizieren.

Trennen Sie das Micro-USB-Kabel des USB-Kabels vom Debug-Port der blinkenden nRF52840-Karte und schließen Sie es wieder an den Micro-USB-Port an.nRF-USB Port neben demZURÜCKSETZEN Schaltfläche Setzen Sie den nRF-Stromquelle auf USB.

46e7b670d2464842.png

OpenThread Daemon starten

Verwenden Sie im RCP-Design OpenThread Daemon, um mit dem Thread-Gerät zu kommunizieren und es zu verwalten. Starten Sie ot-daemon mit dem ausführlichen Flag -v, damit Sie die Logausgabe sehen und prüfen können, ob sie ausgeführt wird:

$ cd ~/src/openthread
$ ./build/posix/src/posix/ot-daemon -v \
    'spinel+hdlc+uart:///dev/ttyACM0?uart-baudrate=115200'

Bei Erfolg generiert ot-daemon im ausführlichen Modus eine Ausgabe, die in etwa so aussieht:

ot-daemon[228024]: Running OPENTHREAD/20191113-00831-gfb399104; POSIX; Jun  7 2020 18:05:15
ot-daemon[228024]: Thread version: 2
ot-daemon[228024]: RCP version: OPENTHREAD/20191113-00831-gfb399104; SIMULATION; Jun  7 2020 18:06:08

Lassen Sie dieses Terminalfenster geöffnet, damit Logs von ot-daemon angezeigt werden können.

Verwenden Sie ot-ctl, um mit dem RCP-Knoten zu kommunizieren. ot-ctl verwendet dieselbe Befehlszeile wie die OpenThread-Befehlszeilenanwendung. Daher können Sie ot-daemon-Knoten genauso wie die anderen simulierten Thread-Geräte steuern.

Starten Sie ot-ctl in einem zweiten Terminalfenster:

$ ./build/posix/bin/ot-ctl
>

Prüfen Sie den state von Knoten 2 (den RCP-Knoten), den Sie mit ot-daemon gestartet haben:

> state
disabled
Done

5 FTDs einrichten

Die beiden anderen in diesem Codelab verwendeten Threadknoten sind Full-Thread-Geräte (FTDs) im Standard-System-on-Chip-Design (SoC). In einer Produktionseinstellung könnten Sie wpantund verwenden, einen produktionstauglichen Netzwerkschnittstellen-Treiber, um OpenThread NCP-Instanzen zu steuern, aber in diesem Codelab verwenden wir ot-ctl, den OpenThread Befehlszeile

Ein Gerät dient als Provisionsstelle, um Geräte sicher in diesem Netzwerk zu authentifizieren und in Betrieb zu nehmen. Das andere Gerät fungiert als Joiner, sodass der Commissioner sich beim Thread-Netzwerk authentifizieren kann.

Build und Flash

Erstellen Sie das OpenThread FTD-Beispiel für die nRF52840-Plattform mit den Rollen CommissionProvision“ und JoinJoiner“:

$ cd ~/src/ot-nrf528xx
$ rm -rf build
$ script/build nrf52840 USB_trans -DOT_JOINER=ON -DOT_COMMISSIONER=ON

Wechseln Sie in das Verzeichnis mit der Binärdatei des OpenThread Full Thread Device (FTD) und konvertieren Sie es in das Hex-Format:

$ cd ~/src/ot-nrf528xx/build/bin
$ arm-none-eabi-objcopy -O ihex ot-cli-ftd ot-cli-ftd.hex

Verbinden Sie das USB-Kabel mit dem Micro-USB-Port neben dem externen Stromanschluss der nRF52840-Karte und verbinden Sie es mit dem Linux-Computer. Wenn der RCP noch an den Linux-Computer angeschlossen ist, sollte dieses neue Board als serieller Port /dev/ttyACM1 angezeigt werden (alle nRF52840-Boards verwenden ttyACM für die ID des seriellen Ports).

$ ls /dev/ttyACM*
/dev/ttyACM0  /dev/ttyACM1

Notieren Sie wie zuvor die Seriennummer der nRF52840-Karte, die für die FTD verwendet wird:

c00d519ebec7e5f0.jpeg

Gehen Sie zum Speicherort der nRFx-Befehlszeilentools und blinken Sie die FTD-HDE-Datei der OpenThread-Befehlszeile auf das nRF52840-Board. Verwenden Sie dazu die Seriennummer des Boards:

$ cd ~/nrfjprog/
$ ./nrfjprog -f nrf52 -s 683704924 --verify --chiperase --program \
       ~/src/ot-nrf528xx/build/bin/ot-cli-ftd.hex --reset

Kennzeichnen Sie das Board mit "Provision".

Mit nativem USB-Anschluss verbinden

Da der OpenThread FTD-Build das native USB CDC ACM als seriellen Transport ermöglicht, müssen Sie den nRF-USB-Port auf dem nRF52840-Board verwenden, um mit dem RCP-Host (Linux-Computer) zu kommunizieren.

Trennen Sie das Micro-USB-Kabel des USB-Kabels vom Debug-Port der blinkenden nRF52840-Karte und schließen Sie es wieder an den Micro-USB-Port an.nRF-USB Port neben demZURÜCKSETZEN Schaltfläche Setzen Sie den nRF-Stromquelle auf USB.

46e7b670d2464842.png

Build prüfen

Prüfen Sie, ob ein Build erfolgreich war. Rufen Sie dazu die OpenThread-Befehlszeile über einen GNU-Bildschirm in einem Terminalfenster auf. Die nRF52840-Boards verwenden eine Baudrate von 115200.

$ screen /dev/ttyACM1 115200

Drücken Sie im neuen Fenster mehrmals die Eingabetaste auf der Tastatur, um die Eingabeaufforderung > für OpenThread aufzurufen. Rufen Sie die IPv6-Schnittstelle auf und suchen Sie nach Adressen:

> ifconfig up
Done
> ipaddr
fe80:0:0:0:1cd6:87a9:cb9d:4b1d
Done

Strg + A → verwenden

d Trennen Sie sie vom Bildschirm "FTD Commissioner CLI" und kehren Sie zum Linux-Terminal zurück, damit das nächste Board blinkt. Sie können die Befehlszeile jederzeit wieder eingeben, indem Siescreen -r über die Befehlszeile. Verwenden Sie screen -ls, um eine Liste der verfügbaren Bildschirme aufzurufen:

$ screen -ls
There is a screen on:
        74182.ttys000.mylinuxmachine        (Detached)
1 Socket in /tmp/uscreens/S-username.

FTD Joiner einrichten

Wiederholen Sie den obigen Vorgang, um das dritte nRF52840-Board mit dem vorhandenen ot-cli-ftd.hex-Build zu blinken. Verbinden Sie das Board anschließend wieder mit dem PC über den nRF-USB-Port und stellen Sie den nRF-Stromquelle auf VDD ein.

Wenn die beiden anderen Knoten mit dem Linux-Computer verbunden sind, wenn dieses dritte Board angeschlossen wird, sollte es als serieller Port /dev/ttyACM2 angezeigt werden:

$ ls /dev/ttyACM*
/dev/ttyACM0  /dev/ttyACM1  /dev/ttyACM2

Kennzeichnen Sie das Board mit "Joiner".

Wenn Sie den Bildschirm prüfen, statt eine neue Instanz des Bildschirms über die Befehlszeile zu erstellen, verknüpfen Sie ihn wieder mit dem vorhandenen Bildschirm und erstellen Sie darin ein neues Fenster, das Sie für den FTD Commissioner verwendet haben:

$ screen -r

Neues Fenster im Bildschirm mit Strg + A erstellen. c aus.

Eine neue Eingabeaufforderung wird angezeigt. Rufen Sie die OpenThread-Befehlszeile für den FTD Joiner auf:

$ screen /dev/ttyACM2 115200

Drücken Sie in diesem neuen Fenster einige Mal die Eingabetaste, um die Eingabeaufforderung > der OpenThread-Befehlszeile aufzurufen. Rufen Sie die IPv6-Schnittstelle auf und suchen Sie nach Adressen:

> ifconfig up
Done
> ipaddr
fe80:0:0:0:6c1e:87a2:df05:c240
Done

Da sich die FTD Joiner-Befehlszeile jetzt in derselben Instanz des Bildschirms befindet wie der FTD Commissioner, können Sie mithilfe von Strg + A → n zwischen ihnen wechseln.

Strg + A → verwenden

d , um den Bildschirm zu verlassen.

6. Terminalfenstereinrichtung

Künftig wechseln Sie häufig zwischen Thread-Geräten. Achten Sie also darauf, dass alle Geräte live sind und leicht zugänglich sind. Bisher verwenden wir den Bildschirm, um auf die beiden FTDs zuzugreifen. Außerdem ermöglicht dieses Tool das Teilen des Bildschirms im selben Terminalfenster. So sehen Sie, wie ein Knoten auf Befehle reagiert, die für einen anderen Knoten ausgeführt werden.

Idealerweise sollten Ihnen vier Fenster zur Verfügung stehen:

  1. ot-daemon-Dienst/-Logs
  2. RCP Joiner über ot-ctl
  3. FTD Commissioner über OpenThread CLI
  4. FTD Joiner über die OpenThread-Befehlszeile

Wenn Sie Ihre eigene Terminal- oder serielle Portkonfiguration oder ein eigenes Tool verwenden möchten, können Sie mit dem nächsten Schritt fortfahren. Sie können die Terminalfenster für alle Geräte so konfigurieren, wie es für Sie am besten ist.

Bildschirm wird verwendet

Der Einfachheit halber sollten Sie nur eine Bildschirmsitzung starten. Wenn Sie beide FTDs einrichten, sollten Sie bereits einen haben.

Alle Befehle auf dem Bildschirm beginnen mit Strg + a.

Grundlegende Bildschirmbefehle:

Verbinden Sie sich noch einmal über die Befehlszeile mit der Bildschirmsitzung.

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 (vorwärts) Strg + a → p (Zurück)

Das aktuelle Fenster in der Bildschirmsitzung beenden

Strg + A → k

Bildschirm teilen

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

f1cbf1258cf0a5a.png

Die Befehle in screen werden über Strg + A aufgerufen. Jeder Befehl sollte mit dieser Zugriffsschlüsselkombination beginnen.

Wenn Sie das Codelab genau befolgt haben, sollten Sie zwei Fenster (FTD Commissioner, FTD Joiner) auf derselben Bildschirminstanz haben. Wenn Sie den Bildschirm aufteilen möchten, müssen Sie zuerst Ihre vorhandene Bildschirmsitzung starten:

$ screen -r

Sie sollten eines der FTD-Geräte verwenden. Gehen Sie so vor:

  1. Strg + A → S, um das Fenster horizontal zu teilen
  2. Strg + A → Tab, um den Cursor in das neue leere Fenster zu bewegen
  3. Strg + A → n, um zum nächsten Fenster zu wechseln
  4. Wenn es mit dem oberen Fenster identisch ist, drücken Sie noch einmal Strg + A → n, um das andere FTD-Gerät aufzurufen

Beide sind jetzt sichtbar. Verwenden Sie die Tastenkombination Strg + A → Tab. Es wird empfohlen, die Fenster mit Strg + A → A umzubenennen, um Verwechslungen zu vermeiden.

Erweiterte Nutzung

Damit der Bildschirm weiter in Quadranten aufgeteilt wird und die ot-daemon-Logs und der RCP-Joiner ot-ctl angezeigt werden, müssen diese Dienste innerhalb derselben Screen-Instanz gestartet werden. Beenden Sie dazu ot-daemon, beenden Sie ot-ctl und starten Sie sie in einem neuen Bildschirmfenster neu (Strg + A → c).

Diese Einrichtung ist nicht erforderlich und bleibt als Übung für den Nutzer übrig.

Mit den folgenden Befehlen können Sie Fenster aufteilen und zwischen ihnen wechseln:

Neues Fenster erstellen

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

Strg + A → n oder p

Aktuelles Fenster umbenennen

Strg + A → A

Sie können den Bildschirm jederzeit mit +Strg + → → d“ verlassen und mit screen -r über die Befehlszeile wieder verbinden.

Weitere Informationen zum Bildschirm finden Sie in der Kurzübersicht des GNU-Bildschirms.

7. Thread-Netzwerk erstellen

Nachdem Sie alle Terminalfenster und Bildschirme konfiguriert haben, erstellen Sie das Thread-Netzwerk. Erstellen Sie auf dem FTD Commissioner ein neues operatives Dataset und führen Sie ein Commit als aktives Dataset aus. Das operative Dataset ist die Konfiguration für das Thread-Netzwerk, das Sie erstellen.

## FTD Commissioner ##
----------------------

> dataset init new
Done
> dataset
Active Timestamp: 1
Channel: 11
Channel Mask: 07fff800
Ext PAN ID: c0de7ab5c0de7ab5
Mesh Local Prefix: fdc0:de7a:b5c0/64
Network Key: 1234c0de7ab51234c0de7ab51234c0de
Network Name: OpenThread-c0de
PAN ID: 0xc0de
PSKc: ebb4f2f8a68026fc55bcf3d7be3e6fe4
Security Policy: 0, onrcb
Done

Notieren Sie sich den Netzwerkschlüssel 1234c0de7ab51234c0de7ab51234c0de. Er wird später verwendet.

Speichern Sie dieses Dataset als aktiv:

> dataset commit active
Done

IPv6-Schnittstelle aufrufen:

> ifconfig up
Done

Starten Sie den Thread-Protokollvorgang:

> thread start
Done

Prüfen Sie nach kurzer Zeit den Gerätestatus. Er sollte die beste Variante sein. Sie können den RLOC16 auch zur späteren Verwendung abrufen.

## FTD Commissioner ##
----------------------

> state
leader
Done
> rloc16
0c00
Done

Prüfen Sie die IPv6-Adressen des Geräts:

## FTD Commissioner ##
----------------------

> ipaddr
fdc0:de7a:b5c0:0:0:ff:fe00:fc00        # Leader Anycast Locator (ALOC)
fdc0:de7a:b5c0:0:0:ff:fe00:c00         # Routing Locator (RLOC)
fdc0:de7a:b5c0:0:6394:5a75:a1ad:e5a    # Mesh-Local EID (ML-EID)
fe80:0:0:0:1cd6:87a9:cb9d:4b1d         # Link-Local Address (LLA)

Das Netzwerk "Codelab" ist jetzt sichtbar, wenn es von anderen Thread-Geräten gescannt wird.

Über ot-ctl in der RCP-Join-Ressource:

## RCP Joiner ##
----------------

> scan
| J | Network Name     | Extended PAN     | PAN  | MAC Address      | Ch | dBm | LQI |
+---+------------------+------------------+------+------------------+----+-----+-----+
| 0 | OpenThread-c0de  | c0de7ab5c0de7ab5 | c0de | 1ed687a9cb9d4b1d | 11 | -36 | 232 |

Über die OpenThread-Befehlszeile im FTD Joiner:

## FTD Joiner ##
----------------

> scan
| J | Network Name     | Extended PAN     | PAN  | MAC Address      | Ch | dBm | LQI |
+---+------------------+------------------+------+------------------+----+-----+-----+
| 0 | OpenThread-c0de  | c0de7ab5c0de7ab5 | c0de | 1ed687a9cb9d4b1d | 11 | -38 | 229 |

Wenn das Netzwerk codeCodelab“ nicht in der Liste angezeigt wird, wiederholen Sie den Scanvorgang.

Beachten Sie, dass das Netzwerk bei beiden Scans nicht teilbar ist (Spalte J im RCP-Join und FTD-Join). Dies bedeutet nur, dass Thread Commissioning im Netzwerk nicht aktiv ist. Sie können weiterhin Out-of-Band verknüpfen, indem Sie den Netzwerkschlüssel manuell im Joiner-Gerät eingeben.

8. RCP-Join hinzufügen

Fügen Sie den RCP-Join dem soeben erstellten Thread-Netzwerk mit einem Out-of-Band-Prozess hinzu. Suchen Sie im RCP Joiner nach Netzwerken:

## RCP Joiner ##
----------------

> scan
| J | Network Name     | Extended PAN     | PAN  | MAC Address      | Ch | dBm | LQI |
+---+------------------+------------------+------+------------------+----+-----+-----+
| 0 | OpenThread-c0de  | c0de7ab5c0de7ab5 | c0de | 1ed687a9cb9d4b1d | 11 | -38 | 229 |

Fügen Sie den Netzwerkschlüssel, den wir gerade vom FTD Commissioner erhalten haben, für den RCP Joiner im aktiven Dataset ein.

## RCP Joiner ##
----------------

> dataset networkkey 1234c0de7ab51234c0de7ab51234c0de
Done
> dataset commit active
Done

Prüfen Sie, ob das Dataset richtig festgelegt ist.

## RCP Joiner ##
----------------

> dataset
Network Key: 1234c0de7ab51234c0de7ab51234c0de

Rufen Sie den Thread auf, damit der RCP-Join dem "Codelab"-Netzwerk beigetreten ist. Warten Sie einige Sekunden und prüfen Sie dann den Status, RLOC16 und seine IPv6-Adressen:

## RCP Joiner ##
----------------

> thread start
Done
> state
child
Done
> rloc16
0c01
Done
> ipaddr
fdc0:de7a:b5c0:0:0:ff:fe00:0c01         # Routing Locator (RLOC)
fdc0:de7a:b5c0:0:66bf:99b9:24c0:d55f    # Mesh-Local EID (ML-EID)
fe80:0:0:0:18e5:29b3:a638:943b          # Link-Local Address (LLA)
Done

Notieren Sie sich die Mesh-Local-IPv6-Adresse (hier fdc0:de7a:b5c0:0:66bf:99b9:24c0:d55f), da Sie sie später benötigen.

Rufen Sie den FTD Commissioner wieder auf und prüfen Sie anhand der Router- und untergeordneten Tabellen, dass beide Geräte zum selben Netzwerk gehören. Ermitteln Sie mit dem RLOC16 den RCP-Join.

## FTD Commissioner ##
----------------------

> router table
| ID | RLOC16 | Next Hop | Path Cost | LQ In | LQ Out | Age | Extended MAC     |
+----+--------+----------+-----------+-------+--------+-----+------------------+
|  3 | 0x0c00 |        3 |         0 |     0 |      0 |  35 | 1ed687a9cb9d4b1d |

Done
> child table
| ID  | RLOC16 | Timeout    | Age        | LQ In | C_VN |R|S|D|VER| Extended MAC     |
+-----+--------+------------+------------+-------+------+-+-+-+---+------------------+
|   1 | 0x0c01 |        240 |         25 |     3 |   89 |1|1|1|  2| 1ae529b3a638943b |
Done

Pingen Sie die Mesh-lokale Adresse des RCP-Joins an (die aus der ipaddr-Ausgabe des RCP-Joiner-Client erhaltene Mesh-Local-Adresse), um die Verbindung zu prüfen:

## FTD Commissioner ##
----------------------

> ping fdc0:de7a:b5c0:0:66bf:99b9:24c0:d55f
> 8 bytes from fdc0:de7a:b5c0:0:66bf:99b9:24c0:d55f: icmp_seq=1 hlim=64 time=40ms

Wir haben jetzt ein Thread-Netzwerk mit zwei Knoten, wie in diesem Topologiediagramm veranschaulicht:

otcodelab_top01C_2knoten.png

Topologiediagramme

Während Sie den Rest des Codelab durchgehen, wird immer ein neues Diagramm zur Threadtopologie angezeigt, sobald sich der Status des Netzwerks ändert. Knotenrollen werden so angegeben:

b75a527be4563215.png

Router sind immer Fünfeckschilder und Endgeräte sind immer Kreise. Die Zahlen auf den einzelnen Knoten stellen die Router-ID oder die untergeordnete ID dar, die in der Befehlszeilenausgabe angezeigt werden, je nachdem, welche Rolle der Knoten aktuell hat.

9. FTD Joiner in Betrieb nehmen

Jetzt fügen wir das dritte Thread-Gerät dem Codelab-Netzwerk hinzu. Diesmal verwenden wir die sicherere In-Band-Inbetriebnahme. Suchen Sie im FTD Joiner nach dem Netzwerk:

## FTD Joiner ##
----------------

> scan
| J | Network Name     | Extended PAN     | PAN  | MAC Address      | Ch | dBm | LQI |
+---+------------------+------------------+------+------------------+----+-----+-----+
| 0 | OpenThread-c0de  | c0de7ab5c0de7ab5 | c0de | f65ae2853ff0c4e4 | 11 | -36 |  57 |

Ein 0 in der Spalte J gibt an, dass Thread Commissioning auf dem Gerät nicht aktiv ist.

Gehen wir bei der Inbetriebnahme dieses nächsten Geräts konkret aus und lassen Sie nur den FTD Joiner zu. Rufen Sie noch den FTD Joiner ab, um den eui64 abzurufen, damit der FTD Commissioner es identifizieren kann:

## FTD Joiner ##
----------------

> eui64
2f57d222545271f1
Done

Geben Sie in der Hilfe des FTD Commissioner den Commissioner ein und geben Sie die eui64 des Geräts, das beitreten darf, sowie die Joiner-Anmeldedaten an, z. B. J01NME. Die Joiner-Anmeldedaten sind ein gerätespezifischer String aus allen alphanumerischen Großbuchstaben in Großbuchstaben (0–9 und AY, ohne I, O, Q und Z für Lesbarkeit), die zwischen 6 und 32 Zeichen lang ist.

## FTD Commissioner ##
----------------------

> commissioner start
Done
> commissioner joiner add 2f57d222545271f1 J01NME
Done

Wechseln Sie zum FTD Joiner und scannen Sie noch einmal:

## FTD Joiner ##
----------------

> scan
| J | Network Name     | Extended PAN     | PAN  | MAC Address      | Ch | dBm | LQI |
+---+------------------+------------------+------+------------------+----+-----+-----+
| 1 | OpenThread-c0de  | c0de7ab5c0de7ab5 | c0de | 1ed687a9cb9d4b1d | 11 | -45 | 196 |

Wie durch die 1 in der Spalte J angegeben, ist Thread Commissioning jetzt im Netzwerk aktiv. Starten Sie die Joiner-Rolle mit den Anmeldedaten, die Sie gerade auf dem FTD Commissioner eingerichtet haben:

## FTD Joiner ##
----------------

> ifconfig up
Done
> joiner start J01NME
Done

Sie erhalten innerhalb von etwa einer Minute eine Bestätigung über eine erfolgreiche Authentifizierung:

## FTD Joiner ##
----------------

>
Join success

Starten Sie den Thread, damit der FTD Joiner dem "Codelab"-Netzwerk beitritt, und prüfen Sie sofort den Status und das RLOC16:

## FTD Joiner ##
----------------

> thread start
Done
> state
child
Done
> rloc16
0c02
Done

Prüfen Sie die IPv6-Adressen des Geräts. Beachten Sie, dass kein ALOC vorhanden ist. Das liegt daran, dass dieses Gerät nicht der Leader ist und es auch keine Anycast-spezifische Rolle hat, die ein ALOC erfordert.

## FTD Joiner ##
----------------

> ipaddr
fdc0:de7a:b5c0:0:0:ff:fe00:c02         # Routing Locator (RLOC)
fdc0:de7a:b5c0:0:3e2e:66e:9d41:ebcd    # Mesh-Local EID (ML-EID)
fe80:0:0:0:e4cd:d2d9:3249:a243         # Link-Local Address (LLA)

Wechseln Sie sofort zum FTD Commissioner und prüfen Sie anhand der Router- und untergeordneten Tabellen, ob im Codelab-Netzwerk drei Geräte vorhanden sind:

## FTD Commissioner ##
----------------------

> router table
| ID | RLOC16 | Next Hop | Path Cost | LQ In | LQ Out | Age | Extended MAC     |
+----+--------+----------+-----------+-------+--------+-----+------------------+
|  3 | 0x0c00 |        3 |         0 |     0 |      0 |  50 | 1ed687a9cb9d4b1d |

> child table
| ID  | RLOC16 | Timeout    | Age        | LQ In | C_VN |R|S|D|N| Extended MAC     |
+-----+--------+------------+------------+-------+------+-+-+-+-+------------------+
|   1 | 0x0c01 |        240 |         25 |     3 |   89 |1|1|1|1| 1ae529b3a638943b |
|   2 | 0x0c02 |        240 |         15 |     3 |   44 |1|1|1|1| e6cdd2d93249a243 |
Done

Basierend auf dem RLOC16 wurde der FTD Joiner als Endgerät (untergeordnet) an das Netzwerk angehängt. Hier unsere aktualisierte Topologie:

otcodelab_top01C_ed01.png

10. Unterhaltung in Aktion

Die Thread-Geräte in diesem Codelab sind eine bestimmte Art von Full Thread Device (FTD), einem sogenannten Router-fähigen Endgerät. Das heißt, sie können entweder als Router oder als Endgerät fungieren und sich selbst von einem Endgerät zu einem Router hochstufen.

Der Thread kann bis zu 32 Router unterstützen, aber es wird versucht, die Anzahl der Router zwischen 16 und 23 zu halten. Wenn ein REED als Endgerät (untergeordnet) angehängt wird und die Anzahl der Router unter 16 liegt, wird es nach einem zufälligen Zeitraum innerhalb von 2 Minuten automatisch zu einem Router hochgestuft.

Wenn Sie nach dem Hinzufügen des FTD Joiner zwei untergeordnete Elemente in Ihrem Thread-Netzwerk hatten, warten Sie mindestens zwei Minuten und prüfen Sie dann die Router- und untergeordneten Tabellen im FTD Commissioner noch einmal:

## FTD Commissioner ##
----------------------

> router table
| ID | RLOC16 | Next Hop | Path Cost | LQ In | LQ Out | Age | Extended MAC     |
+----+--------+----------+-----------+-------+--------+-----+------------------+
|  3 | 0x0c00 |        3 |         0 |     0 |      0 |  50 | 1ed687a9cb9d4b1d |
| 46 | 0xb800 |       63 |         0 |     3 |      3 |   1 | e6cdd2d93249a243 |

> child table
| ID  | RLOC16 | Timeout    | Age        | LQ In | C_VN |R|S|D|N| Extended MAC     |
+-----+--------+------------+------------+-------+------+-+-+-+-+------------------+
|   1 | 0x0c01 |        240 |         61 |     3 |   89 |1|1|1|1| 1ae529b3a638943b |
Done

Der FTD Joiner (Extended MAC = e6cdd2d93249a243) hat sich selbst zu einem Router hochgestuft. Der RLOC16 ist anders (b800 statt 0c02). Das liegt daran, dass der RLOC16 auf der Router-ID und der untergeordneten ID eines Geräts basiert. Bei der Umstellung von einem Endgerät auf einen Router ändern sich die Werte für die Router-ID und die untergeordnete ID, ebenso wie der RLOC16.

otcodelab_top01C.png

Bestätigen Sie den neuen Status und RLOC16 im FTD Joiner:

## FTD Joiner ##
----------------

> state
router
Done
> rloc16
b800
Done

FTD Joiner herunterstufen

Sie können dieses Verhalten testen, indem Sie für den FTD Joiner ein manuelles Downgrade von einem Router auf ein Endgerät ausführen. Ändern Sie den Status in "child" und prüfen Sie den RLOC16:

## FTD Joiner ##
----------------

> state child
Done
> rloc16
0c03
Done

otcodelab_top01C_ed02.png

Auf dem FTD Commissioner sollte der FTD Joiner nun in der untergeordneten Tabelle angezeigt werden (ID = 3). Es kann sogar während des Übergangs in beiden vorkommen:

## FTD Commissioner ##
----------------------

> router table
| ID | RLOC16 | Next Hop | Path Cost | LQ In | LQ Out | Age | Extended MAC     |
+----+--------+----------+-----------+-------+--------+-----+------------------+
|  3 | 0x0c00 |        3 |         0 |     0 |      0 |  50 | 1ed687a9cb9d4b1d |
| 46 | 0xb800 |       63 |         0 |     3 |      3 |   1 | e6cdd2d93249a243 |

> child table
| ID  | RLOC16 | Timeout    | Age        | LQ In | C_VN |R|S|D|N| Extended MAC     |
+-----+--------+------------+------------+-------+------+-+-+-+-+------------------+
|   1 | 0x0c01 |        240 |         61 |     3 |   89 |1|1|1|1| 1ae529b3a638943b |
|   3 | 0x0c03 |        240 |         16 |     3 |   94 |1|1|1|1| e6cdd2d93249a243 |
Done

Nach einiger Zeit wechselt es wieder zu einem Router mit dem RLOC b800.

otcodelab_top01C.png

Führungsperson entfernen

Der Leader wird von allen Thread-Routern selbst ausgewählt. Wenn also der aktuelle Leader aus dem Thread-Netzwerk entfernt wird, wird einer der anderen Router zum neuen Leader.

Fahren Sie im FTD Commissioner den Thread herunter, um ihn aus dem Thread-Netzwerk zu entfernen:

## FTD Commissioner ##
----------------------

> thread stop
Done
> ifconfig down
Done

Innerhalb von zwei Minuten wird der FTD Joiner zum neuen Thread-Leader. Prüfen Sie den Status und die IPv6-Adressen des FTD Joiner, um Folgendes zu verifizieren:

## FTD Joiner ##
----------------

> state
leader
Done
> ipaddr
fdc0:de7a:b5c0:0:0:ff:fe00:fc00       # Now it has the Leader ALOC!
fdc0:de7a:b5c0:0:0:ff:fe00:b800
fdc0:de7a:b5c0:0:3e2e:66e:9d41:ebcd
fe80:0:0:0:e4cd:d2d9:3249:a243
Done

otcodelab_top02C_01.png

Prüfen Sie die untergeordnete Tabelle. Beachten Sie, dass es ein neues RLOC16 gibt. Das ist der RCP-Join, wie durch seine ID und erweiterte MAC angegeben. Damit das Thread-Netzwerk zusammen erhalten bleibt, hat es übergeordnete Router vom FTD Commissioner zum FTD Joiner gewechselt. Dies führt zu einem neuen RLOC16 für den RCP-Join (weil sich seine Router-ID von 3 auf 46 geändert hat).

## FTD Joiner ##
----------------

> child table
| ID  | RLOC16 | Timeout    | Age        | LQ In | C_VN |R|S|D|N| Extended MAC     |
+-----+--------+------------+------------+-------+------+-+-+-+-+------------------+
|   1 | 0xb801 |        240 |         27 |     3 |  145 |1|1|1|1| 1ae529b3a638943b |
Done

Möglicherweise müssen Sie einige Minuten warten, bis der RCP Joiner als FTD Joiner als untergeordnetes Element angehängt wurde. Prüfen Sie den Status und den RLOC16, um Folgendes zu bestätigen:

## RCP Joiner ##
--------------

> state
child
> rloc16
b801

Hängen Sie den FTD Commissioner wieder an

Ein Thread-Netzwerk mit zwei Knoten macht keinen großen Spaß. Stellen Sie den FTD Commissioner wieder online.

Starten Sie den Thread auf dem FTD Commissioner neu:

## FTD Commissioner ##
----------------------

> ifconfig up
Done
> thread start
Done

Innerhalb von zwei Minuten wird er automatisch wieder dem Codelab-Netzwerk als Endgerät hinzugefügt und dann automatisch zum Router hochgestuft.

## FTD Commissioner ##
----------------------

> state
router
Done

Prüfen Sie die Router- und untergeordneten Tabellen im FTD Joiner, um Folgendes zu überprüfen:

## FTD Joiner ##
----------------

> router table
| ID | RLOC16 | Next Hop | Path Cost | LQ In | LQ Out | Age | Extended MAC     |
+----+--------+----------+-----------+-------+--------+-----+------------------+
|  3 | 0x0c00 |       63 |         0 |     3 |      3 |   0 | 1ed687a9cb9d4b1d |
| 46 | 0xb800 |       46 |         0 |     0 |      0 |  15 | e6cdd2d93249a243 |

> child table
| ID  | RLOC16 | Timeout    | Age        | LQ In | C_VN |R|S|D|N| Extended MAC     |
+-----+--------+------------+------------+-------+------+-+-+-+-+------------------+
|   1 | 0xb801 |        240 |        184 |     3 |  145 |1|1|1|1| 1ae529b3a638943b |
Done

otcodelab_top02C_02

Unser Thread-Netzwerk besteht wieder aus drei Knoten.

11. Fehlerbehebung

Die Verwaltung eines Thread-Netzwerks mit mehreren Geräten auf verschiedenen Terminal- oder Bildschirmfenstern kann kompliziert sein. Mit diesen Tipps können Sie den Status des Netzwerks oder Ihres Arbeitsbereichs zurücksetzen, falls Probleme auftreten.

Display

Sollten Sie Ihre Konfiguration verlieren (zu viele Bildschirmfenster oder Bildschirme im Bildschirm), beenden Sie das Fenster mit der Tastenkombination +Strg + A → k“, bis kein Fenster mehr angezeigt wird.screen -ls und in der Befehlszeile wird No Sockets found ausgegeben. Erstellen Sie dann die Bildschirmfenster für jedes Gerät neu. Gerätestatus bleiben auch dann erhalten, wenn der Bildschirm beendet wird.

Threadknoten

Wenn die Thread-Netzwerktopologie nicht wie in diesem Codelab beschrieben wird oder Knoten aus irgendeinem Grund getrennt werden (z. B. weil die Linux-Maschine, die sie verwendet), in den Ruhemodus versetzt wurde, sollten Sie den Thread herunterfahren, die Anmeldedaten für das Netzwerk löschen und noch einmal von vorn beginnenThread-Netzwerk erstellen an.

So setzen Sie die FTDs zurück:

## FTD Commissioner or FTD Joiner ##
------------------------------------

> thread stop
Done
> ifconfig down
Done
> factoryreset
Done

Der RCP kann auf dieselbe Weise über ot-ctl zurückgesetzt werden:

## RCP Joiner ##
----------------

> thread stop
Done
> ifconfig down
Done
> factoryreset
Done

12. Multicast verwenden

Multicast wird verwendet, um Informationen an eine Gruppe von Geräten gleichzeitig zu übertragen. In einem Thread-Netzwerk sind bestimmte Adressen, je nach Umfang, für die Multicast-Nutzung bei verschiedenen Gerätegruppen reserviert.

IPv6-Adresse

Umfang

Zugestellt

ff02::1

Link-Local

Alle FTDs und MEDs

ff02::2

Link-Local

Alle FTDs und Border Router

ff03::1

Mesh-Netzwerk-Lokal

Alle FTDs und MEDs

ff03::2

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.

Der Link-Local-Bereich umfasst alle Thread-Schnittstellen, auf die über eine einzelne Funkübertragung oder ein einzelner "Hop" zugegriffen werden kann. Die Netzwerktopologie gibt vor, welche Geräte auf einen Ping an die ff02::1-Multicast-Adresse reagieren.

Pingen Sie ff02::1 vom FTD Commissioner:

## FTD Commissioner ##
----------------------

> ping ff02::1
> 8 bytes from fe80:0:0:0:e4cd:d2d9:3249:a243: icmp_seq=2 hlim=64 time=9ms

Im Netzwerk gibt es zwei weitere Geräte (FTD Joiner und RCP Joiner), aber der FTD Commissioner hat nur eine Antwort von der Link-Local Address (LLA) des FTD Joiner erhalten. Das bedeutet, dass der FTD Joiner das einzige Gerät ist, das der FTD Commissioner mit einem einzigen Hop erreichen kann.

otcodelab_top02C_02_LL.png

Pingen Sie ff02::1 über den FTD Joiner:

## FTD Joiner ##
----------------

> ping ff02::1
> 8 bytes from fe80:0:0:0:1cd6:87a9:cb9d:4b1d: icmp_seq=1 hlim=64 time=11ms
8 bytes from fe80:0:0:0:18e5:29b3:a638:943b: icmp_seq=1 hlim=64 time=24ms

Zwei Antworten! Wenn wir die IPv6-Adressen der anderen Geräte prüfen, sehen wir, dass die erste (endet auf 4b1d) die LAD des FTD-Verantwortlichen und die zweite (endet auf 943b) die LAA des RCP-Joiner.

otcodelab_top02C_02_LL02.png

Dies bedeutet, dass der FTD Joiner direkt mit dem FTD Commissioner und dem RCP Joiner verbunden ist, der unsere Topologie bestätigt.

Mesh-Netzwerk-Lokal

Der Bereich "Mesh-Local" umfasst alle Thread-Schnittstellen, die im selben Thread-Netzwerk erreichbar sind. Sehen Sie sich die Antworten auf einen Ping an die Multicast-Adresse ff03::1 an.

Pingen Sie ff03::1 vom FTD Commissioner:

## FTD Commissioner ##
----------------------

> ping ff03::1
> 8 bytes from fdc0:de7a:b5c0:0:0:ff:fe00:b800: icmp_seq=3 hlim=64 time=9ms
8 bytes from fdc0:de7a:b5c0:0:66bf:99b9:24c0:d55f: icmp_seq=3 hlim=64 time=68ms

Diesmal hat der FTD Commissioner zwei Antworten erhalten: eine vom FTD Joiner's Routing Locator (RLOC, mit der Endung b800) und eine vom RCP Joiner (Mesh-Local EID, enden mit d55f). Der Grund dafür ist, dass der lokale Mesh-Netzwerkbereich das gesamte Thread-Netzwerk umfasst. Unabhängig davon, wo sich das Gerät im Netzwerk befindet, wird es die ff03::1-Adresse abonnieren.

otcodelab_top02C_02_ML.png

Pingen Sie ff03::1 vom FTD Joiner aus, um dasselbe Verhalten zu bestätigen:

## FTD Joiner ##
----------------

> ping ff03::1
> 8 bytes from fdc0:de7a:b5c0:0:0:ff:fe00:c00: icmp_seq=2 hlim=64 time=11ms
8 bytes from fdc0:de7a:b5c0:0:66bf:99b9:24c0:d55f: icmp_seq=2 hlim=64 time=23ms

otcodelab_top02C_02_LL02.png

Notieren Sie die Antwortzeit für den RCP-Join in beiden Ping-Ausgaben. Der RCP-Joiner brauchte viel länger, um den FTD Joiner (68 ms) zu erreichen als den FTD Joiner (23 ms). Der Grund dafür ist, dass der FTD Commissioner mit zwei Hops verbunden ist – im Vergleich zum FTD Joiner.

Möglicherweise haben Sie auch bemerkt, dass der mit dem Mesh-Netzwerk verbundene Multicast-Ping nur bei den beiden FTDs mit dem RLOC antwortet, nicht mit dem RCP-Join. Das liegt daran, dass die FTDs Router im Netzwerk sind, während der RCP ein Endgerät ist.

Prüfen Sie den Status des RCP Joiner, um Folgendes zu bestätigen:

## RCP Joiner ##
----------------

> state
child

13. Nachrichten mit UDP senden

Einer der Anwendungsdienste von OpenThread ist das User Datagram Protocol (UDP), ein Transport Layer-Protokoll. Eine Anwendung, die auf OpenThread basiert, könnte die UDP API für die Übertragung von Nachrichten zwischen Knoten in einem Thread-Netzwerk oder an andere Geräte in einem externen Netzwerk verwenden, z. B. wenn das Thread-Netzwerk einen Border-Router hat.

UDP-Sockets werden über die OpenThread-Befehlszeile bereitgestellt. Wir leiten damit Nachrichten zwischen den beiden FTDs weiter.

Rufen Sie die Mesh-Local-EID-Adresse für den FTD Joiner ab. Wir verwenden diese Adresse, da sie von überall aus im Thread-Netzwerk erreichbar ist.

## FTD Joiner ##
----------------

> ipaddr
fdc0:de7a:b5c0:0:0:ff:fe00:fc00        # Leader Anycast Locator (ALOC)
fdc0:de7a:b5c0:0:0:ff:fe00:b800        # Routing Locator (RLOC)
fe80:0:0:0:e4cd:d2d9:3249:a243         # Link-Local Address (LLA)
fdc0:de7a:b5c0:0:3e2e:66e:9d41:ebcd    # Mesh-Local EID (ML-EID)
Done

Starten Sie UDP und binden Sie es für jede IPv6-Adresse an einen Socket:

## FTD Joiner ##
----------------

> udp open
Done
> udp bind :: 1212

Wechseln Sie zum FTD Commissioner, starten Sie UDP und stellen Sie mit der ML-EID eine Verbindung zum Socket her, den Sie im FTD Joiner eingerichtet haben:

## FTD Commissioner ##
----------------------

> udp open
Done
> udp connect fdc0:de7a:b5c0:0:3e2e:66e:9d41:ebcd 1212
Done

Die UDP-Verbindung sollte zwischen den beiden Knoten aktiv sein. Senden Sie eine Nachricht vom FTD Commissioner:

## FTD Commissioner ##
----------------------

> udp send hellothere
Done

In der FTD Joiner-Instanz wurde die UDP-Nachricht empfangen.

## FTD Joiner ##
----------------

> 10 bytes from fdc0:de7a:b5c0:0:0:ff:fe00:c00 49153 hellothere

14. Glückwunsch!

Sie haben ein physisches Thread-Netzwerk erstellt.

b915c433e7027cc7.png.

Jetzt weißt du:

  • den Unterschied zwischen Gerätetypen, Rollen und Bereichen von Threads
  • Wie Thread-Geräte ihren Status innerhalb des Netzwerks verwalten
  • Einfache Nachrichten zwischen Knoten mit UDP übergeben

Weiteres Vorgehen

Erstellen Sie auf Grundlage dieses Codelabs die folgenden Übungen:

  • Blenden Sie das FTD Joiner Board mithilfe der Binärdatei ot-cli-mtd als MTD neu ein und achten Sie darauf, dass es sich nie auf einen Router aktualisiert oder versucht, zum Leader zu werden.
  • Fügen Sie dem Netzwerk weitere Geräte hinzu (versuchen Sie es mit einer anderen Plattform!) und skizzieren Sie die Topologie mithilfe von Router- und untergeordneten Tabellen sowie Pings an die Multicast-Adressen.
  • NCP mit pyspinel steuern
  • Konvertieren Sie den NCP mithilfe des OpenThread Border Routers in einen Border-Router und verbinden Sie das Thread-Netzwerk mit dem Internet.

Weitere Informationen

Sehen Sie sich openthread.io und GitHub für eine Vielzahl von OpenThread-Ressourcen an, einschließlich:

Referenz: