Mem-build 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 kuat dan aman yang dirancang untuk perangkat Internet of Things (IoT). OpenThread dikembangkan oleh tim Nest Google dan tersedia gratis untuk komunitas developer sebagai project open source.

Spesifikasi Thread menetapkan protokol komunikasi nirkabel yang andal, aman, dan hemat energi untuk perangkat dengan resource terbatas yang umumnya ditemukan di smart home dan gedung komersial. OpenThread menyertakan cakupan lapisan jaringan lengkap dalam Thread, seperti IPv6, 6LoWPAN, IEEE 802.15.4 dengan keamanan MAC, pembuatan link mesh, dan perutean mesh.

Telink telah mengintegrasikan implementasi OpenThread ke dalam Zephyr RTOS, sehingga memungkinkan kompatibilitas yang lancar dengan hardware Telink. Kode sumber untuk integrasi ini dapat diakses 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 menunjukkan penyiapan hardware, menampilkan OT Border Router (OTBR) dan satu perangkat Thread dalam codelab.

Yang akan Anda pelajari

• Untuk menyiapkan implementasi OpenThread menggunakan lingkungan pengembangan Telink Zephyr.
• Untuk membuat sampel OpenThread CLI (ot-cli-ftd dan ot-rcp) lalu mem-flash sampel tersebut 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 out-of-band.
• Untuk memvalidasi konektivitas antara node di jaringan Thread menggunakan CLI.

Yang Anda butuhkan

Perangkat keras:

• Dua Papan Pengembangan B91.
• Satu Raspberry Pi 3B+ atau lebih besar dengan Image OS Raspbian.
• Mesin Linux dengan minimal dua port USB.
• Tombol akses internet (atau Router) dan beberapa kabel Ethernet.

Software:

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

2. Prasyarat

Konsep Thread dan CLI OpenThread

Sebaiknya ikuti codelab Simulasi OpenThread untuk memahami konsep Thread dasar 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 board pengembangan Thread. Untuk melakukan tugas ini, mesin 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. Dokumen ini menawarkan ringkasan penggunaannya, tetapi software terminal lainnya juga dapat digunakan.

Kit Pengembangan Telink B91

Codelab ini memerlukan dua set Kit Pengembangan 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 yang lainnya akan berfungsi sebagai FTD (Full Thread Device). Jika belum memiliki kit, Anda dapat memperoleh detail selengkapnya dari situs resmi Teelink. Beberapa komponen yang akan digunakan adalah sebagai berikut:

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

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

Koneksi Jaringan

Tombol akses (atau router) yang terhubung internet dan beberapa kabel Ethernet. Mereka digunakan untuk menghubungkan Raspberry Pi ke mesin Linux, memfasilitasi konfigurasi pengguna Raspberry Pi melalui host.

LinuxBDT

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

Lainnya

• Git, untuk menyiapkan Lingkungan Pengembangan Telink Zephyr.
• West, untuk mengelola project Zephyr dan mem-build biner OpenThread.

3. Siapkan Firmware

Menyiapkan Lingkungan Pengembangan Telink Zephyr

Di komputer Linux, buka terminal CLI dan mulai dengan menjalankan perintah berikut untuk memastikan APT Anda sudah yang terbaru.

$ sudo apt update
$ sudo apt upgrade

Setelah melakukannya, lanjutkan dengan langkah-langkah berikut.

1. 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 terinstal di sistem Anda sebelum melanjutkan ke langkah berikutnya. Jika versi salah, alihkan pencerminan APT ke cermin yang stabil dan terbaru, atau perbarui dependensi ini secara manual.
2. Instal barat.

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

   Pastikan ~/.local/bin berada dalam variabel lingkungan $PATH Anda.
3. Dapatkan kode sumber Zephyr Project.

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

4. Instal dependensi Python tambahan untuk Zephyr.

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

5. Menyiapkan toolchain Zephyr. Download toolchain Zephyr (sekitar 1~2 GB) ke direktori lokal untuk memungkinkan Anda mem-flash 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 ini.

   $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
   

6. Membuat contoh Halo Dunia. Pertama-tama, verifikasi bahwa 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 membuat contoh hello_world dari direktori utama repositori Zephyr. Anda dapat menemukan firmware bernama zephyr.bin di bagian build/zephyr directory.
7. Tambahkan skrip lingkungan Zephyr ke ~/.bashrc. Jalankan perintah berikut.

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

8. Tambahkan repositori jarak jauh Telink Zephyr. Download repo Telink secara lokal sebagai cabang pengembangan, lalu update.

   $ 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.

Siapkan Telink LinuxBDT

Download alat Telink LinuxBDT dan ekstrak ke direktori lokal di mesin Linux Anda, seperti direktori beranda ~, yang 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", artinya programer BDT telah berhasil terhubung ke mesin Linux.

Kompilasi Firmware

Codelab ini akan mem-build dua jenis firmware OpenThread:

• ot-cli-ftd,
• dan ot-rcp.

Metode kompilasinya adalah sebagai berikut：

1. Radio Pemroses (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
   

2. 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 digambarkan dalam gambar di bawah.

Pada command line, jalankan perintah berikut untuk melakukan pembakaran 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 untuk ot-cli-ftd. Namun, ada perbedaan di jalur dan nama firmware.

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

4. Mengonfigurasi Konsol Serial untuk Perangkat Gabungan FTD

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

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

Referensi command line OpenThread adalah di sini: OpenThread CLI Reference. Pastikan untuk memberi awalan pada semua perintah dengan ot.

Contoh：

> ot state
disabled
Done
> ot channel
11
Done
>

5. Menyiapkan Raspberry Pi sebagai Router Thread OpenThread

Router Thread 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 untuk komunikasi Thread.

Koprosesor Radio（RCP）

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

Kue Raspberry Pi

1. Pastikan gambar Raspbian Bullseye Lite OS atau Raspbian Bullseye with Desktop ditulis dengan benar ke kartu SD.
2. Anda memiliki opsi untuk menerapkan SSH ke Raspberry Pi atau bekerja langsung dengan Desktop Raspbian. Codelab ini akan menggunakan SSH.
3. Sebelum melanjutkan untuk menginstal OTBR Docker di langkah berikutnya, pastikan Anda 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.

1. Instal Docker:

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

2. 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 perlu memulai ulang Raspberry Pi agar diterapkan.
3. Jika Docker belum dimulai, mulai project tersebut:

   $ sudo dockerd
   

4. Skrip firewall OTBR membuat 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 OpenThread Docker Hub. Gambar ini telah diuji dan diverifikasi oleh tim OpenThread.

1. Ambil gambar terbaru:

   $ docker pull openthread/otbr:latest
   

2. Periksa daftar image di container Docker:

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

3. Tentukan nama port serial perangkat RCP dengan memeriksa /dev, ttyACM0 menunjukkan bahwa RCP terhubung dengan benar.

   $ ls /dev/tty*
   ...
   /dev/ttyACM0
   ... 
   

4. 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
   

5. 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 berjalan:

  $ docker ps -aq
  

• Menghentikan Docker OTBR:

  $ docker stop otbr
  

• Menghapus Docker OTBR:

  $ 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 mem-build 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 di tabel, dan pastikan setiap langkah mencapai hasil yang diharapkan sebelum melanjutkan ke langkah berikutnya.

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

Menambahkan Joiner FTD ke Thread melalui komisi yang tidak umum

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

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

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

7. Komunikasi Antar-Perangkat Thread

Komunikasi ICMPv6

Kita menggunakan perintah ping untuk memeriksa apakah perangkat Thread di 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 Joiner FTD 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 Joiner FTD telah menerima respons ping yang ditampilkan oleh OTBR. Komunikasi antara dua perangkat berhasil.

Komunikasi UDP

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

Pertama, dapatkan Esh Mesh-Local 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 UDP OTBR dan mengikat port 1022 perangkat.

> udp open
Done
> udp bind :: 1022
Done

Masukkan perintah berikut di konsol serial dan aktifkan UDP dari 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 menghasilkan 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 mem-build dan menggunakan lingkungan pengembangan Telink Zephyr.
• Cara mem-build biner ot-cli-ftd dan ot-rcp, serta mem-flash-nya ke Dewan Pengembangan Telink B91.
• 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 komisi luar biasa.
• Cara memverifikasi konektivitas antara 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:

• Referensi CLI OpenThread
• Referensi CLI UDP OpenThread
• Referensi OpenThread UDP API