Google berkomitmen untuk mendorong terwujudnya keadilan ras bagi komunitas Kulit Hitam. Lihat caranya.

Halaman ini diterjemahkan oleh Cloud Translation API.

Membuat Jaringan Thread dengan B91 Development Board dan OpenThread

1. Pengantar

26b7f4f6b3ea0700.pngS

OpenThread adalah implementasi protokol jaringan Thread® open source, yang merupakan protokol jaringan mesh nirkabel yang kuat dan aman yang dirancang untuk perangkat Internet of Things (IoT). OpenThread dikembangkan oleh tim Nest Google dan tersedia secara gratis untuk komunitas developer sebagai project open source.

Spesifikasi Thread menetapkan protokol komunikasi nirkabel yang andal, aman, dan hemat energi untuk perangkat dengan sumber daya terbatas yang biasa ditemukan di smart home dan bangunan komersial. OpenThread mencakup cakupan lapisan jaringan penuh dalam Thread, seperti IPv6, 6LoWPAN, IEEE 802.15.4 dengan keamanan MAC, pembentukan link mesh, dan perutean mesh.

Telink telah mengintegrasikan implementasi OpenThread ke dalam Zephyr RTOS, yang memungkinkan kompatibilitas yang lancar dengan hardware Telink. Kode sumber untuk integrasi ini mudah diakses di GitHub, dan juga disediakan sebagai software development kit (SDK).

Dalam codelab ini, Anda akan memprogram OpenThread pada hardware sebenarnya, membuat dan mengelola jaringan Thread, serta bertukar pesan antar-node. Gambar di bawah menunjukkan penyiapan hardware, yang menampilkan OT Border Router (OTBR) dan satu perangkat Thread di codelab.

Yang akan Anda pelajari

Untuk menyiapkan implementasi OpenThread menggunakan lingkungan pengembangan Telink Zephyr.
Untuk membuat contoh OpenThread CLI (ot-cli-ftd dan ot-rcp) dan melakukan flash ke Telink B91 Development Boards.
Untuk menyiapkan OpenThread Border Router (OTBR) menggunakan Docker di Raspberry Pi 3B+ atau yang lebih baru.
Untuk membuat jaringan Thread di OTBR.
Untuk menambahkan perangkat ke jaringan Thread menggunakan proses debug out-of-band.
Untuk memvalidasi konektivitas antarnode dalam jaringan Thread menggunakan CLI.

Yang Anda butuhkan

Perangkat keras:

Dua Dewan Pengembangan B91.
Satu Raspberry Pi 3B+ atau yang lebih baru dengan Raspbian OS Image.
Mesin Linux dengan setidaknya dua port USB.
Tombol (atau Router) yang terhubung ke internet dan beberapa kabel Ethernet.

Software:

Alat Pembakaran dan Debug Telink —— LinuxBDT.
Alat terminal porta serial, seperti PuTTY.
Alat lainnya seperti Git dan West.

2. Prasyarat

Konsep Thread dan CLI OpenThread

Sebaiknya baca codelab Simulasi OpenThread untuk memahami konsep dasar Thread dan CLI OpenThread sebelum codelab ini.

Mesin Linux

Mesin Linux (Ubuntu v20.04 LTS atau yang lebih baru) bertindak sebagai mesin build untuk menyiapkan lingkungan pengembangan Telink Zephyr dan mem-flash semua papan pengembangan Thread. Untuk menyelesaikan tugas ini, komputer Linux memerlukan dua port USB dan konektivitas internet yang tersedia.

Terminal dan Koneksi Port Serial

Anda dapat langsung mencolokkan perangkat ke port USB mesin Linux. Selain itu, Anda memerlukan alat terminal port serial untuk mengakses perangkat.

Dalam codelab ini, alat terminal PuTTY digunakan untuk mengontrol FTD Joiner dan Raspberry Pi. Ia menawarkan gambaran umum penggunaannya, tetapi perangkat lunak terminal lainnya juga dapat digunakan.

Kit Pengembangan Telink B91

Codelab ini memerlukan dua set Development Kit B91. Foto di bawah ini menampilkan komponen minimum yang diperlukan dalam satu set.

Salah satu kit ini akan digunakan sebagai RCP (Radio Co-Processor), sedangkan kit lainnya akan berfungsi sebagai FTD (Full Thread Device). Jika Anda belum memiliki kit tersebut, Anda dapat memperoleh detail selengkapnya di situs resmi Telink. Beberapa komponen yang akan digunakan adalah sebagai berikut:

Indeks	Nama
1	Papan Pengembangan Telink B91
2	Papan Pembakaran Telink
3	Antena 2,4 Ghz
4	Kabel USB (USB A ke USB mini)

Raspberry Pi 3B+ atau yang lebih baru dengan Raspbian OS Image

Dalam codelab ini, diperlukan Raspberry Pi 3B+ atau yang lebih baru dengan Raspbian Bullseye Lite OS image atau Raspbian Bullseye dengan Desktop. Router terhubung ke internet melalui Ethernet dan akan dikonfigurasi sebagai host untuk OpenThread Border Router (OTBR).

Koneksi Jaringan

Tombol (atau router) yang terhubung ke internet dan beberapa kabel Ethernet. Mereka digunakan untuk menghubungkan Raspberry Pi ke komputer Linux, memfasilitasi konfigurasi pengguna Raspberry Pi melalui {i>host<i}.

LinuxBDT

Telink Burning and Debugging Tool (BDT), yang berlaku untuk semua seri Chip Telink, memungkinkan Anda menghapus dan mem-flash firmware OpenThread ke Telink B91 Development Boards. Instal linuxBDT versi linux berbasis X86 di komputer Linux Anda.

Lainnya

Git, untuk menyiapkan Telink Zephyr Development Environment.
West, untuk mengelola project Zephyr dan membuat biner OpenThread.

3. Siapkan Firmware

Menyiapkan Telink Zephyr Development Environment

Di mesin Linux, buka terminal CLI dan mulailah dengan menjalankan perintah berikut untuk memastikan bahwa APT Anda sudah yang terbaru.

$ sudo apt update
$ sudo apt upgrade

Setelah selesai, lanjutkan dengan langkah-langkah berikut.

Instal dependensi.

$ wget https://apt.kitware.com/kitware-archive.sh
$ sudo bash kitware-archive.sh
$ sudo apt install --no-install-recommends git cmake ninja-build \
gperf ccache dfu-util device-tree-compiler python3-dev python3-pip \
python3-setuptools python3-tk python3-wheel xz-utils file make gcc \
gcc-multilib g++-multilib libsdl2-dev

Zephyr saat ini memerlukan versi minimum dependensi utama, seperti CMake (3.20.0), Python3 (3.6), dan Devicetree Compiler (1.4.6).

$ cmake --version
$ python3 --version
$ dtc --version

Verifikasi versi yang diinstal di sistem Anda sebelum melanjutkan ke langkah berikutnya. Jika versinya salah, alihkan duplikat APT ke duplikat yang stabil dan terbaru, atau update dependensi ini secara manual.

Instal di wilayah barat.

$ pip3 install --user -U west
$ echo 'export PATH=~/.local/bin:"$PATH"' >> ~/.bashrc
$ source ~/.bashrc

Pastikan ~/.local/bin ada dalam variabel lingkungan $PATH Anda.

Dapatkan kode sumber Zephyr Project.

$ west init ~/zephyrproject
$ cd ~/zephyrproject
$ west update
$ west blobs fetch hal_telink
$ west zephyr-export

Instal dependensi Python tambahan untuk Zephyr.

$ pip3 install --user -r ~/zephyrproject/zephyr/scripts/requirements.txt

Siapkan toolchain Zephyr. Download toolchain Zephyr (sekitar 1~2 GB) ke direktori lokal agar Anda dapat melakukan flash pada sebagian besar board.

$ wget https://github.com/zephyrproject-rtos/sdk-ng/releases/download/v0.16.1/zephyr-sdk-0.16.1_linux-x86_64.tar.xz
$ wget -O - https://github.com/zephyrproject-rtos/sdk-ng/releases/download/v0.16.1/sha256.sum | shasum --check --ignore-missing

Download Zephyr SDK dan tempatkan di jalur yang direkomendasikan, seperti yang ditunjukkan di bawah.

$HOME/zephyr-sdk[-x.y.z]
$HOME/.local/zephyr-sdk[-x.y.z]
$HOME/.local/opt/zephyr-sdk[-x.y.z]
$HOME/bin/zephyr-sdk[-x.y.z]
/opt/zephyr-sdk[-x.y.z]
/usr/zephyr-sdk[-x.y.z]
/usr/local/zephyr-sdk[-x.y.z]

Dengan [-x.y.z] adalah teks opsional yang dapat berupa teks apa pun, seperti -0.16.1. Direktori tidak dapat dipindahkan setelah SDK diinstal. Kemudian, instal toolchain Zephyr.

$ tar xvf zephyr-sdk-0.16.1_linux-x86_64.tar.xz
$ cd zephyr-sdk-0.16.1
$ ./setup.sh -t riscv64-zephyr-elf -h -c

Membuat contoh Hello World. Pertama, pastikan konfigurasi project Zephyr resmi sudah benar menggunakan contoh Hello World, lalu lanjutkan dengan menyiapkan project kustom Anda.
```
$ cd ~/zephyrproject/zephyr
$ west build -p auto -b tlsr9518adk80d samples/hello_world
```
Gunakan perintah build Barat untuk membangun contoh hello_world dari direktori root repositori Zephyr. Anda dapat menemukan firmware bernama zephyr.bin di bawah build/zephyr directory.

Tambahkan skrip lingkungan Zephyr ke ~/.bashrc. Jalankan perintah berikut.

$ echo "source ~/zephyrproject/zephyr/zephyr-env.sh" >> ~/.bashrc
$ source ~/.bashrc

Tambahkan repositori jarak jauh Telink Zephyr. Download repositori Telink secara lokal sebagai cabang pengembangan dan perbarui.

$ cd ~/zephyrproject/zephyr
$ git remote add telink-semi https://github.com/telink-semi/zephyr
$ git fetch telink develop
$ git checkout develop
$ west update
$ west blobs fetch hal_telink

Untuk informasi selengkapnya, Anda dapat membaca Dokumen Zephyr – Panduan Memulai.

Menyiapkan Telink LinuxBDT

Download alat Telink LinuxBDT dan ekstrak ke direktori lokal di komputer Linux, seperti direktori beranda ~, yang memungkinkan untuk melakukan flash firmware ke B91 Development Board.

$ cd ~
$ wget http://wiki.telink-semi.cn/tools_and_sdk/Tools/BDT/LinuxBDT.tar.bz2
$ tar -vxf LinuxBDT.tar.bz2

Hubungkan Burning Board ke komputer Linux melalui antarmuka USB, lalu masukkan perintah berikut.

$ cd LinuxBDT
$ sudo ./bdt lsusb -v
Bus 002 Device 001: ID 1d6b:0003 xHCI Host Controller
Bus 001 Device 003: ID 0bda:565a Integrated_Webcam_HD
Bus 001 Device 023: ID 413c:301a Dell MS116 USB Optical Mouse
Bus 001 Device 037: ID 248a:826a Telink Web Debugger v3.6
Bus 001 Device 001: ID 1d6b:0002 xHCI Host Controller

Jika Anda melihat pesan "Telink Web Debugger v3.6", hal ini menunjukkan bahwa programmer BDT telah berhasil terhubung ke mesin Linux.

Kompilasi Firmware

Codelab ini akan membangun dua jenis firmware OpenThread:

ot-cli-ftd,
dan ot-rcp.

Metode kompilasi adalah sebagai berikut:

Rekan Proses Radio{4}ot-rcp)

$ cd ~/zephyrproject
$ rm -rf build_ot_coprocessor
$ west build -b tlsr9518adk80d -d build_ot_coprocessor zephyr/samples/net/openthread/coprocessor -- -DDTC_OVERLAY_FILE="usb.overlay" -DOVERLAY_CONFIG=overlay-rcp-usb-telink.conf

Perangkat Thread Berfitur Lengkap dengan Command Line Interaktif (ot-cli-ftd)

$ cd ~/zephyrproject
$ rm -rf build_ot_cli_ftd
$ west build -b tlsr9518adk80d -d build_ot_cli_ftd zephyr/samples/net/openthread/cli -- -DOVERLAY_CONFIG=overlay-telink-fixed-mac.conf -DCONFIG_OPENTHREAD_FTD=y

Flash Firmware

Sambungkan Board Pengembangan B91 ke Burning Board menggunakan kabel USB seperti yang diilustrasikan pada gambar di bawah.

Pada command line, jalankan perintah berikut untuk melakukan burning firmware (menggunakan flash firmware ot-cli-ftd sebagai contoh).

$ cd ~/zephyrproject/build_ot_cli_ftd/zephyr
$ cp zephyr.bin ~/LinuxBDT/bin/ot-cli-ftd.bin
$ cd ~/LinuxBDT
$ sudo ./bdt 9518 ac
 Activate OK!
$ sudo ./bdt 9518 wf 0 -i bin/ot-cli-ftd.bin
 EraseSectorsize...
 Total Time: 2181 ms
 Flash writing...
 [100%][-] [##################################################]
 File Download to Flash at address 0x000000: 491700 bytes
 Total Time: 30087 ms

Metode flash untuk ot-rcp pada dasarnya sama dengan metode untuk ot-cli-ftd. Namun, ada perbedaan dalam jalur dan nama firmware.

Setelah berkedip, bedakan kedua Papan Pengembangan B91 dengan menandainya sebagaimana mestinya. Label board di-flash dengan ot-cli-ftd sebagai "FTD Joiner" dan board berkedip dengan ot-rcp sebagai "RCP".

4. Mengonfigurasi Konsol Seri untuk Perangkat Penyambung FTD

Seperti yang terlihat di gambar, colokkan FTD Joiner langsung ke port USB mesin Linux.

Setelah menghubungkan FTD Joiner Device ke komputer Linux, Buka PuTTY. Kemudian, buat terminal baru, tetapkan informasi port serial, lalu buka port serial.

Referensi command line OpenThread tersedia di sini: Referensi CLI OpenThread. Pastikan untuk menambahkan awalan ot ke semua perintah.

Contoh:

> ot state
disabled
Done
> ot channel
11
Done
>

5. Menyiapkan Raspberry Pi sebagai Router Pembatas OpenThread

Router Pembatas OpenThread adalah perangkat yang terdiri dari dua bagian utama:

Raspberry Pi berisi semua layanan dan firmware yang diperlukan untuk bertindak sebagai Router Batas (BR).
RCP bertanggung jawab untuk komunikasi Thread.

Rekan Proses Radio (RCP)

Untuk melakukan flash firmware ot-rcp, ikuti langkah yang sama seperti proses flash firmware ot-cli-ftd. Hubungkan {i>Development Board <i}B91 ke porta USB pada Raspberry Pi, seperti ditunjukkan pada gambar di bawah.

Raspberry Pi

Pastikan Raspbian Bullseye Lite OS image atau Raspbian Bullseye dengan Desktop ditulis dengan benar ke kartu SD.
Anda memiliki opsi untuk menjalankan SSH ke Raspberry Pi atau bekerja langsung dengan Raspbian Desktop. Codelab ini akan menggunakan SSH.
Sebelum melanjutkan penginstalan Docker OTBR pada langkah berikutnya, pastikan Anda telah mengupdate repositori lokal dan pengelola paket terlebih dahulu.
```
$ sudo apt-get update
$ sudp apt-get upgrade
```

Instal Docker

Jika Anda baru saja mengupdate repositori lokal dan APT pengelola paket pada langkah sebelumnya, mulai ulang Raspberry Pi lalu buka jendela terminal SSH.

Instal Docker:

$ curl -sSL https://get.docker.com | sh

Masukkan akun saat ini ke grup Docker untuk memberikan izin sehingga sudo tidak perlu ditambahkan di depan setiap perintah.
```
$ sudo usermod -aG docker $USER
```
Anda perlu memulai ulang Raspberry Pi agar berfungsi.
Jika Docker belum dimulai, mulailah:
```
$ sudo dockerd
```
Skrip firewall OTBR menghasilkan aturan di dalam container Docker. Sebelum itu, jalankan modprobe untuk memuat modul kernel iptable.
```
$ sudo modprobe ip6table_filter
```

Mengonfigurasi dan Menjalankan Docker

Codelab ini langsung mengambil image Docker OTBR dari OpenThread Docker Hub. Gambar ini telah diuji dan diverifikasi oleh tim OpenThread.

Ambil gambar terbaru:
```
$ docker pull openthread/otbr:latest
```

Periksa daftar image di container Docker:

$ docker images
REPOSITORY        TAG       IMAGE ID       CREATED      SIZE
openthread/otbr   latest    db081f4de15f   6 days ago   766MB

Tentukan nama port serial perangkat RCP dengan memeriksa /dev, ttyACM0 menunjukkan bahwa RCP terhubung dengan benar.
```
$ ls /dev/tty*
...
/dev/ttyACM0
... 
```

Jalankan Docker OTBR untuk pertama kalinya, dan referensikan port serial RCP (ttyACM0). Jika Anda ingin terus menggunakan Docker OTBR ini, gunakan perintah docker start otbr.

$ docker run --name "otbr" --sysctl "net.ipv6.conf.all.disable_ipv6=0 net.ipv4.conf.all.forwarding=1 net.ipv6.conf.all.forwarding=1" -p 8080:80 --dns=127.0.0.1 -it --volume /dev/ttyACM0:/dev/ttyACM0 --privileged openthread/otbr --radio-url spinel+hdlc+uart:///dev/ttyACM0

Buka jendela terminal SSH baru untuk menguji konektivitas antara Raspberry Pi dan RCP.
```
$ docker exec -ti otbr sh -c "sudo ot-ctl"
> state 
disabled
Done
```

Perintah Docker opsional:

Dapatkan informasi tentang container Docker yang sedang berjalan:
```
$ docker ps -aq
```
Hentikan Docker OTBR:
```
$ docker stop otbr
```
Menghapus Docker OTBR:
```
$ docker rm otbr
```
Muat ulang Docker OTBR:
```
$ docker restart otbr
```

Pada tahap ini, perangkat Penyambung FTD dan OTBR sudah siap, dan Anda dapat melanjutkan ke langkah berikutnya untuk membangun jaringan Thread.

6. Membuat Jaringan Thread

Membuat Jaringan Thread di RCP

Kita menggunakan shell ot-ctl di OTBR untuk membuat jaringan Thread. Jika Anda keluar dari shell di bagian terakhir, masukkan perintah berikut untuk memulainya lagi di terminal SSH:

$ docker exec -ti otbr sh -c "sudo ot-ctl"

Selanjutnya, masukkan perintah dalam urutan yang ditentukan dalam tabel, dan pastikan bahwa setiap langkah mencapai hasil yang diharapkan sebelum melanjutkan ke langkah berikutnya.

Indeks	Perintah	Pengantar	Respons yang Diharapkan
1	`dataset init new`	Buat set data jaringan acak yang baru.	Selesai
2	`dataset commit active`	Meng-commit set data baru ke Set Data Operasional Aktif dalam penyimpanan non-volatil.	Selesai
3	`ifconfig up`	Memunculkan antarmuka IPv6.	Selesai
4	`thread start`	Mengaktifkan operasi protokol Thread dan terhubung ke jaringan Thread.	Selesai
			Tunggu 10 detik hingga antarmuka thread muncul.
5	`state`	Periksa status perangkat.Perintah ini dapat dipanggil beberapa kali hingga menjadi pemimpin dan melanjutkan ke langkah berikutnya.	leader Done
6	`dataset active`	Periksa Set Data Operasional Aktif yang lengkap dan catat kunci jaringan.	. . . . . 1 Channel: 13 : 13 Mask Channel: 0x07fff800 Mask Channel: 0x07fff800 : 0x07fff800 : 0x07fff800 . ID PAN Eks.: b074776e168eda4.

Kunci jaringan yang dibuat secara acak oleh OTBR selama pembuatan jaringan akan digunakan saat ot-cli-ftd perangkat bergabung dengan jaringan Thread ini.

Menambahkan Penyambung FTD ke Thread melalui commissioning out-of-band

commissioning out-of-band mengacu pada transmisi kredensial jaringan ke perangkat yang menunggu untuk bergabung ke jaringan melalui metode non-nirkabel (misalnya, memasukkan secara manual ke OpenThread CLI). Masukkan perintah berikut secara berurutan dalam konsol serial ke FTD Joiner.

Indeks	Perintah	Pengantar	Respons yang Diharapkan
1	`ot dataset networkkey c312485187484ceb5992d2343baaf93d`	Hanya Kunci Jaringan yang diperlukan agar perangkat dapat terhubung ke jaringan Thread.	Selesai
2	`ot dataset commit active`	Meng-commit set data baru ke Set Data Operasional Aktif dalam penyimpanan non-volatil.	Selesai
3	`ot ifconfig up`	Memunculkan antarmuka IPv6.	Selesai
4	`ot thread start`	Mengaktifkan operasi protokol Thread dan terhubung ke jaringan Thread.	Selesai
			Tunggu 20 detik saat perangkat bergabung dan melakukan konfigurasi sendiri.
5	`ot state`	Periksa status perangkat.	turunan/router Selesai

Topologi

Masukkan perintah seperti ipaddr, child table, router table di terminal SSH untuk mendapatkan respons seperti cuplikan kode berikut.

> ipaddr rloc
fd8c:60bc:a98:c7ba:0:ff:fe00:b000
Done
> child table
| ID  | RLOC16 | Timeout    | Age        | LQ In | C_VN |R|D|N|Ver|CSL|QMsgCnt|Suprvsn| Extended MAC     |
+-----+--------+------------+------------+-------+------+-+-+-+---+---+-------+-------+------------------+
|   1 | 0xb001 |        240 |         23 |     3 |   51 |1|1|1|  3| 0 |     0 |   129 | 82bc12fbe783468e |

Done
> router table
| ID | RLOC16 | Next Hop | Path Cost | LQ In | LQ Out | Age | Extended MAC     | Link |
+----+--------+----------+-----------+-------+--------+-----+------------------+------+
| 44 | 0xb000 |       63 |         0 |     0 |      0 |   0 | 7ae354109d611f7e |    0 |

Done
...
> child table
| ID  | RLOC16 | Timeout    | Age        | LQ In | C_VN |R|D|N|Ver|CSL|QMsgCnt|Suprvsn| Extended MAC     |
+-----+--------+------------+------------+-------+------+-+-+-+---+---+-------+-------+------------------+

Done
> router table
| ID | RLOC16 | Next Hop | Path Cost | LQ In | LQ Out | Age | Extended MAC     | Link |
+----+--------+----------+-----------+-------+--------+-----+------------------+------+
| 33 | 0x8400 |       63 |         0 |     3 |      3 |  13 | e61487c1cda940a6 |    1 |
| 44 | 0xb000 |       63 |         0 |     0 |      0 |   0 | 7ae354109d611f7e |    0 |

Done

RLOC16 OTBR adalah 0xb000 dan RLOC16 dari Penggabungan FTD awalnya adalah 0xb001. Kemudian, RLOC16 Penyambung FTD menjadi 0x8400 setelah mendapatkan ID Router. Dapat dilihat bahwa FTD Joiner telah diupgrade dari turunan ke router.

Jaringan Thread saat ini berisi dua {i>node<i}, dan topologinya seperti yang ditunjukkan pada gambar di bawah ini.

7. Komunikasi Antar-Perangkat Thread

Komunikasi ICMPv6

Kita menggunakan perintah ping untuk memeriksa apakah perangkat Thread di jaringan yang sama dapat saling berkomunikasi. Pertama, gunakan perintah ipaddr untuk mendapatkan RLOC perangkat.

> ipaddr
fd8c:60bc:a98:c7ba:0:ff:fe00:fc11
fdbd:7274:649c:1:1d19:9613:f705:a5af
fd8c:60bc:a98:c7ba:0:ff:fe00:fc10
fd8c:60bc:a98:c7ba:0:ff:fe00:fc38
fd8c:60bc:a98:c7ba:0:ff:fe00:fc00
fd8c:60bc:a98:c7ba:0:ff:fe00:b000       # Routing Locator (RLOC)
fd8c:60bc:a98:c7ba:5249:34ab:26d1:aff6
fe80:0:0:0:78e3:5410:9d61:1f7e
Done

Masukkan perintah berikut di konsol serial FTD Joiner untuk menjalankan operasi ping.

> ot ping fd8c:60bc:a98:c7ba:0:ff:fe00:b000
16 bytes from fd8c:60bc:a98:c7ba:0:ff:fe00:b000: icmp_seq=1 hlim=64 time=19ms
1 packets transmitted, 1 packets received. Packet loss = 0.0%. Round-trip min/avg/max = 19/19.0/19 ms.
Done

Respons output port serial menunjukkan bahwa sisi OTBR telah menerima permintaan ping, dan FTD Joiner telah menerima respons ping yang ditampilkan oleh OTBR. Komunikasi antara dua perangkat berhasil.

Komunikasi UDP

Layanan aplikasi yang disediakan oleh OpenThread juga mencakup UDP. Anda dapat menggunakan UDP API untuk meneruskan informasi antar-node di jaringan Thread, atau meneruskan informasi ke jaringan eksternal melalui Border Router. Pengantar mendetail UDP API OpenThread dapat dilihat di OpenThread CLI - Contoh UDP. Codelab ini akan menggunakan beberapa API di dalamnya untuk mengirimkan informasi antara OTBR dan FTD Joiner.

Pertama, dapatkan Mesh-Local EID OTBR. Alamat ini juga merupakan salah satu alamat IPv6 perangkat Thread, dan dapat digunakan untuk mengakses perangkat Thread di partisi jaringan Thread yang sama.

> ipaddr mleid
fd8c:60bc:a98:c7ba:5249:34ab:26d1:aff6
Done

Masukkan perintah berikut di terminal SSH untuk mengaktifkan OTBR UDP dan mengikat port 1022 perangkat.

> udp open
Done
> udp bind :: 1022
Done

Masukkan perintah berikut dalam konsol serial dan aktifkan UDP FTD Joiner. Ikat port 1022 perangkat, lalu kirim pesan hello 5 byte ke OTBR.

> ot udp open 
Done
> ot udp bind :: 1022
Done
> ot udp send fd8c:60bc:a98:c7ba:5249:34ab:26d1:aff6 1022 hello
Done

Terminal SSH menampilkan informasi berikut. OTBR menerima pesan hello dari FTD Joiner, yang berarti komunikasi UDP berhasil.

> 5 bytes from fd8c:60bc:a98:c7ba:9386:63cf:19d7:5a61 1022 hello

8. Selamat

Anda telah membuat jaringan Thread sederhana dan memverifikasi komunikasi dalam jaringan ini.

Anda sekarang mengetahui:

Cara membangun dan menggunakan lingkungan pengembangan Telink Zephyr.
Cara membangun biner ot-cli-ftd dan ot-rcp, serta melakukan flash ke Telink B91 Development Board.
Cara menyiapkan Raspberry Pi 3B+ atau versi yang lebih tinggi sebagai OpenThread Border Router (OTBR) menggunakan Docker.
Cara membuat jaringan Thread di OTBR.
Cara menambahkan perangkat ke jaringan Thread melalui commissioning out-of-band.
Cara memverifikasi konektivitas antar-node di jaringan Thread.

Bacaan Lebih Lanjut

Lihat openthread.io dan GitHub untuk mempelajari berbagai resource OpenThread, termasuk:

Platform yang Didukung — temukan semua platform yang mendukung OpenThread
Membuat OpenThread — detail lebih lanjut tentang cara membuat dan mengonfigurasi OpenThread
Thread Primer — mencakup semua konsep Thread yang ditampilkan dalam codelab ini

Dokumen referensi: