Membuat Jaringan Thread dengan B91 Development Board dan OpenThread

1. Pengantar

OpenThread adalah implementasi open source 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 secara gratis bagi komunitas developer sebagai project open source.

Spesifikasi Thread menciptakan protokol komunikasi nirkabel yang andal, aman, dan hemat energi untuk perangkat dengan resource 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, sehingga memungkinkan kompatibilitas tanpa hambatan 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 di hardware sebenarnya, membuat dan mengelola jaringan Thread, serta bertukar pesan antar-node. Gambar di bawah menunjukkan penyiapan hardware, yang menampilkan Router Pembatas OT (OTBR) dan satu perangkat Thread di codelab.

Yang akan Anda pelajari

• Untuk menyiapkan implementasi OpenThread menggunakan lingkungan pengembangan Telink Zephyr.
• Untuk mem-build sampel CLI OpenThread (ot-cli-ftd dan ot-rcp) lalu mem-flashnya ke Board Pengembangan Telink B91.
• 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 antar-node dalam jaringan Thread menggunakan CLI.

Yang akan Anda butuhkan

Perangkat keras:

• Dua B91 Development Board.
• Satu Raspberry Pi 3B+ atau yang lebih tinggi dengan Raspbian OS Image.
• Komputer Linux dengan minimal 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 lain 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 board pengembangan Thread. Untuk menyelesaikan 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 akan memerlukan alat terminal port serial untuk mengakses perangkat.

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

Kit Pengembangan Telink B91

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 kit lainnya akan berfungsi sebagai FTD (Perangkat Thread Penuh). Jika belum memiliki kit, Anda bisa mendapatkan detail lebih lanjut dari situs resmi Telink. Beberapa komponen yang digunakan adalah sebagai berikut:

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

Dalam codelab ini, diperlukan Raspberry Pi 3B+ atau yang lebih baru dengan image OS Raspbian Bullseye Lite atau Bullseye Raspbian dengan Desktop. Perangkat ini 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 mesin Linux, yang memfasilitasi konfigurasi pengguna Raspberry Pi melalui host.

LinuxBDT

Telink Alat Pembakaran dan Debug (BDT), yang berlaku untuk semua seri Chip Telink, memungkinkan Anda menghapus dan melakukan flash firmware OpenThread ke Board Pengembangan Telink B91. Instal linuxBDT linux berbasis X86 di mesin Linux Anda.

Lainnya

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

3. Siapkan Firmware

Menyiapkan Telink Zephyr Development Environment

Di komputer Linux, buka terminal CLI dan mulai 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.

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

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

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

   $ 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. Siapkan toolchain Zephyr. Unduh toolchain Zephyr (sekitar 1~2 GB) ke direktori lokal agar Anda dapat 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.

   $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, 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 bawah 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 dan 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 melihat Dokumen Zephyr – Panduan Memulai.

Menyiapkan Telink LinuxBDT

Download alat Telink LinuxBDT dan ekstrak ke direktori lokal di mesin Linux Anda, seperti direktori utama ~, yang memungkinkan proses 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", ini menunjukkan bahwa programmer 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 kompilasi adalah sebagai berikut:

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

Sambungkan Papan Pengembangan B91 ke Papan Pembakaran menggunakan kabel USB, seperti ditunjukkan 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 dalam jalur dan nama firmware.

Setelah berkedip, bedakan kedua Papan Pengembangan B91 dengan menandainya. Beri label pada 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 Penyambung FTD

Seperti yang ditunjukkan dalam gambar, colokkan langsung Penyambung FTD ke port USB mesin Linux.

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

Referensi command line OpenThread ada di sini: Referensi CLI OpenThread. Pastikan untuk memberikan 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 berfungsi sebagai Router Pembatas (BR).
• RCP bertanggung jawab atas komunikasi Thread.

Rekan Prosesor Radio(RCP)

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

Rasberi Pi

1. Pastikan Raspbian Bullseye Lite OS image atau Raspbian Bullseye dengan Desktop ditulis dengan benar ke kartu SD.
2. Anda memiliki opsi untuk SSH ke Raspberry Pi atau bekerja langsung dengan Desktop Raspbian. Codelab ini akan menggunakan SSH.
3. Sebelum melanjutkan penginstalan Docker OTBR 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 di langkah sebelumnya, reboot 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 dapat diterapkan.
3. Jika Docker belum dimulai, mulai:

   $ 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 langsung mengambil image Docker OTBR dari OpenThread Docker Hub. Image ini telah diuji dan diverifikasi oleh tim OpenThread.

1. Tarik 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 OTBR Docker 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
  

• Hentikan Docker OTBR:

  $ docker stop otbr
  

• Hapus 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 membangun jaringan Thread.

6. Membuat Jaringan Thread

Membuat Jaringan Thread di RCP

Kita menggunakan shell ot-ctl pada 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.

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

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

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

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 Penyambung FTD awalnya adalah 0xb001. Kemudian, RLOC16 Penyambung FTD menjadi 0x8400 setelah mendapatkan ID Router. 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 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 dari port serial menunjukkan bahwa sisi OTBR telah menerima permintaan ping, dan FTD Joiner telah menerima respons ping yang dikembalikan 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 Router Pembatas. Pengantar mendetail tentang UDP OpenThread API ada dalam OpenThread CLI - Contoh UDP. Codelab ini akan menggunakan beberapa API di dalamnya untuk mengirimkan informasi antara OTBR dan FTD Joiner.

Pertama, dapatkan EID Mesh-Lokal dari 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 menampilkan informasi berikut. OTBR menerima pesan hello dari Penggabungan FTD, 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 mem-build biner ot-cli-ftd dan ot-rcp, serta mem-flash biner tersebut 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 dalam 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
• Mem-build OpenThread — detail lebih lanjut tentang cara mem-build dan mengonfigurasi OpenThread
• Thread Primer — mencakup semua konsep Thread yang ditampilkan dalam codelab ini

Dokumen referensi:

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