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

Membuat Jaringan Thread dengan B91 Development Board dan OpenThread

1. Pengantar

OpenThread adalah implementasi open source dari protokol jaringan Thread®, yang merupakan protokol jaringan mesh nirkabel yang andal dan aman yang dirancang untuk perangkat Internet of Things (IoT). OpenThread dikembangkan oleh tim Nest Google dan tersedia secara gratis bagi 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 umumnya 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 penerapan OpenThread ke dalam Zephyr RTOS, sehingga memungkinkan kompatibilitas yang lancar dengan hardware Telink. Kode sumber untuk integrasi ini dapat diakses dengan mudah di GitHub, dan juga disediakan sebagai software development kit (SDK).

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

Yang akan Anda pelajari

Untuk menyiapkan penerapan OpenThread menggunakan lingkungan pengembangan Telink Zephyr.
Untuk membuat contoh CLI OpenThread (ot-cli-ftd dan ot-rcp) dan mem-flash-nya ke Telink B91 Development Board.
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 di luar band.
Untuk memvalidasi konektivitas antar-node di jaringan Thread menggunakan CLI.

Yang Anda butuhkan

Hardware:

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

Software:

Telink Burning and Debugging Tool —— LinuxBDT.
Alat terminal port serial, seperti PuTTY.
Alat lain seperti Git dan West.

2. Prasyarat

Konsep Thread dan OpenThread CLI

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

Mesin Linux

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

Koneksi dan Terminal 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. Ringkasan penggunaannya akan ditampilkan, tetapi software terminal lainnya juga dapat digunakan.

Telink B91 Development Kit

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

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

Indeks	Nama
1	Telink B91 Development Board
2	Telink Burning Board
3	Antena 2,4 GHz
4	Kabel USB (USB A ke mini USB)

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

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

Koneksi Jaringan

Switch (atau router) yang terhubung ke internet dan beberapa kabel Ethernet. Keduanya digunakan untuk menghubungkan Raspberry Pi ke mesin Linux, sehingga memudahkan konfigurasi Raspberry Pi oleh pengguna melalui host.

LinuxBDT

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

Lainnya

Git, untuk menyiapkan Lingkungan Pengembangan Telink Zephyr.
West, untuk mengelola project Zephyr dan membuat biner OpenThread.

3. Menyiapkan Firmware

Menyiapkan Lingkungan Pengembangan Telink Zephyr

Di perangkat Linux, buka terminal CLI dan mulai dengan menjalankan perintah berikut untuk memastikan APT Anda sudah diupdate.

$ 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 tidak benar, alihkan mirror APT ke mirror yang stabil dan terbaru, atau perbarui dependensi ini secara manual.

Instal west.

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

Pastikan ~/.local/bin ada di 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 mem-flash sebagian besar papan.

$ 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

Bangun 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 West untuk membangun contoh hello_world dari direktori root repositori Zephyr. Anda dapat menemukan firmware bernama zephyr.bin di bagian 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 mengetahui informasi selengkapnya, Anda dapat membaca Zephyr Doc – Getting Started Guide.

Menyiapkan Telink LinuxBDT

Download alat Telink LinuxBDT dan ekstrak ke direktori lokal di mesin Linux Anda, seperti direktori home ~, sehingga memungkinkan untuk mem-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 mesin 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", berarti programmer BDT telah berhasil terhubung ke mesin Linux.

Kompilasi Firmware

Codelab ini akan membuat dua jenis firmware OpenThread:

ot-cli-ftd,
dan ot-rcp.

Metode kompilasi adalah sebagai berikut:

Radio Co-Processor (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

Hubungkan B91 Development Board ke Burning Board menggunakan kabel USB seperti yang diilustrasikan pada gambar di bawah.

Di command line, jalankan perintah berikut untuk melakukan burning firmware (menggunakan flashing 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 flash untuk ot-cli-ftd. Namun, ada perbedaan pada jalur dan nama firmware.

Setelah melakukan flashing, bedakan kedua B91 Development Board dengan menandainya dengan tepat. Beri label board yang di-flash dengan ot-cli-ftd sebagai "FTD Joiner" dan board yang di-flash dengan ot-rcp sebagai "RCP".

4. Mengonfigurasi Konsol Serial untuk Perangkat Joiner FTD

Seperti yang ditunjukkan pada gambar, colokkan FTD Joiner langsung ke port USB mesin Linux.

Setelah menghubungkan Perangkat Penggabung FTD ke mesin Linux, Buka PuTTY. Kemudian, buat terminal baru, tetapkan informasi port serial, dan buka port serial.

Referensi command line OpenThread ada 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 OpenThread Border Router

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

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

Radio Co-Processor（RCP）

Untuk mem-flash firmware ot-rcp, ikuti langkah-langkah yang sama seperti proses flashing firmware ot-cli-ftd. Hubungkan Papan Pengembangan B91 ke port USB di Raspberry Pi, seperti yang digambarkan pada gambar di bawah.

Raspberry Pi

Pastikan image OS Raspbian Bullseye Lite atau Raspbian Bullseye dengan Desktop ditulis dengan benar ke kartu SD.
Anda memiliki opsi untuk melakukan SSH ke Raspberry Pi atau bekerja langsung dengan Desktop Raspbian. Codelab ini akan menggunakan SSH.
Sebelum melanjutkan untuk menginstal OTBR Docker pada langkah berikutnya, pastikan untuk 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 pengelola paket APT 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 dalam grup Docker untuk memberikan izin sehingga sudo tidak perlu ditambahkan di depan setiap perintah.
```
$ sudo usermod -aG docker $USER
```
Anda harus memulai ulang Raspberry Pi agar perubahan diterapkan.
Jika Docker belum dimulai, mulai Docker:
```
$ sudo dockerd
```
Skrip firewall OTBR menghasilkan aturan di dalam container Docker. Sebelum itu, jalankan modprobe untuk memuat modul kernel iptables.
```
$ sudo modprobe ip6table_filter
```

Mengonfigurasi dan Menjalankan Docker

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

Tarik image 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 OTBR Docker untuk pertama kalinya, dan rujuk port serial RCP (ttyACM0). Jika Anda ingin terus menggunakan OTBR Docker 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 OTBR Docker:
```
$ docker stop otbr
```
Hapus OTBR Docker:
```
$ docker rm otbr
```
Muat ulang Docker OTBR:
```
$ docker restart otbr
```

Pada tahap ini, perangkat FTD Joiner 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 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 baru.	Selesai
2	`dataset commit active`	Lakukan penerapan set data baru ke Set Data Operasional Aktif dalam penyimpanan non-volatile.	Selesai
3	`ifconfig up`	Buka antarmuka IPv6.	Selesai
4	`thread start`	Aktifkan operasi protokol Thread dan hubungkan ke jaringan Thread.	Selesai
			Tunggu 10 detik hingga antarmuka thread aktif.
5	`state`	Periksa status perangkat.Perintah ini dapat dipanggil beberapa kali hingga perangkat menjadi pemimpin dan melanjutkan ke langkah berikutnya.	pemimpin Selesai
6	`dataset active`	Periksa Active Operational Dataset yang lengkap dan catat kunci jaringan.	Active Timestamp: 1 Channel: 13 Channel Mask: 0x07fff800 Ext PAN ID: b07476e168eda4fc Mesh Local Prefix: fd8c:60bc:a98:c7ba::/64 Network Key: c312485187484ceb5992d2343baaf93d Network Name: OpenThread-599c PAN ID: 0x599c PSKc: 04f79ad752e8401a1933486c95299f60 Security Policy: 672 onrc 0 Done

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

Menambahkan FTD Joiner ke Thread melalui commissioning di luar band

Penyiapan di luar band mengacu pada transmisi kredensial jaringan ke perangkat yang menunggu untuk bergabung ke jaringan melalui metode non-nirkabel (misalnya, memasukkan secara manual di OpenThread CLI). Masukkan perintah berikut secara berurutan di 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`	Lakukan penerapan set data baru ke Set Data Operasional Aktif dalam penyimpanan non-volatile.	Selesai
3	`ot ifconfig up`	Buka antarmuka IPv6.	Selesai
4	`ot thread start`	Aktifkan operasi protokol Thread dan hubungkan ke jaringan Thread.	Selesai
			Tunggu 20 detik saat perangkat bergabung dan mengonfigurasi dirinya sendiri.
5	`ot state`	Periksa status perangkat.	child/router Done

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 FTD Joiner awalnya adalah 0xb001. Kemudian, RLOC16 FTD Joiner menjadi 0x8400 setelah mendapatkan Router ID. Dapat dilihat bahwa FTD Joiner telah diupgrade dari turunan menjadi router.

Jaringan Thread saat ini berisi dua node, dan topologinya seperti yang ditunjukkan pada gambar di bawah.

7. Komunikasi Antara Perangkat Thread

Komunikasi ICMPv6

Kita menggunakan perintah ping untuk memeriksa apakah perangkat Thread dalam jaringan yang sama dapat berkomunikasi satu sama lain. 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 kedua perangkat berhasil.

Komunikasi UDP

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

Pertama, dapatkan EID Mesh-Lokal 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 di 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 akan 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.

Sekarang Anda tahu:

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

Bacaan Lebih Lanjut

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

Platform yang Didukung — temukan semua platform yang mendukung OpenThread
Membangun OpenThread — detail lebih lanjut tentang membangun dan mengonfigurasi OpenThread
Pengantar Thread — mencakup semua konsep Thread yang ditampilkan dalam codelab ini

Dokumen referensi: