1. Pengantar
OpenThread yang dirilis oleh Google adalah implementasi open source dari protokol jaringan Thread®. Google Nest telah merilis OpenThread agar teknologi yang digunakan pada produk Nest tersedia secara luas bagi developer untuk mempercepat pengembangan produk bagi rumah yang terhubung.
Spesifikasi Thread mendefinisikan protokol komunikasi perangkat ke perangkat nirkabel berbasis IPv6 yang andal, aman, dan berdaya rendah untuk aplikasi rumah. OpenThread mengimplementasikan semua lapisan jaringan Thread termasuk IPv6, 6LoWPAN, IEEE 802.15.4 dengan keamanan MAC, Mesh Link Establishment, dan Mesh Perutean.
Dalam Codelab ini, Anda akan memprogram OpenThread di hardware sungguhan, membuat dan mengelola jaringan Thread, dan meneruskan pesan antar-node.
Yang akan Anda pelajari
- Membuat dan melakukan flash biner OpenThread CLI ke board dev
- Membuat RCP yang terdiri dari mesin Linux dan dev board
- Berkomunikasi dengan RCP menggunakan OpenThread Daemon dan
ot-ctl - Mengelola node Thread secara manual dengan GNU Screen dan OpenThread CLI
- Penetapan perangkat yang aman ke jaringan Thread
- Cara kerja multicast IPv6
- Meneruskan pesan di antara node Thread dengan UDP
Yang Anda butuhkan
Perangkat keras:
- 3 board dev Nordic Semiconductor nRF52840
- 3 kabel USB ke Micro-USB untuk menghubungkan board
- Mesin Linux dengan minimal 3 port USB
Software:
- Toolchain GNU
- Alat command line Nordic nRF5x
- Software J-Link Segger
- OpenThread
- Git
2. Memulai
Simulasi OpenThread
Sebelum memulai, Anda mungkin ingin menjalankan Codelab Simulasi OpenThread untuk memahami konsep Thread dasar dan CLI OpenThread.
Terminal port serial
Anda seharusnya telah memahami cara menghubungkan ke port serial melalui terminal. Codelab ini menggunakan GNU Screen dan menyediakan ringkasan penggunaan, tetapi software terminal lainnya dapat digunakan.
Mesin Linux
Codelab ini dirancang untuk menggunakan mesin Linux berbasis i386 atau x86 untuk berfungsi sebagai host perangkat Thread Radio Co-Processor (RCP), dan mem-flash semua board pengembangan Thread. Semua langkah telah diuji di Ubuntu 14.04.5 LTS (Trusty Tahr).
Papan Nordic Semiconductor nRF52840
Codelab ini menggunakan tiga board nK55880 PDK.
Instal JGG Link SEGGER
Kami menggunakan SEGGER J-Link untuk memprogram board nRF52840, yang memiliki modul JTAG onboard. Instal ini di komputer Linux Anda.
Download paket yang sesuai untuk mesin Anda, dan instal di lokasi yang tepat. Di Linux, ini adalah /opt/SEGGER/JLink.
Menginstal Alat Command Line nRF5x
Alat Command Line nRF5x memungkinkan Anda mem-flash biner OpenThread ke board nRF52840. Instal build nRF5x-Command-Line-Tools-<OS> yang sesuai di komputer Linux Anda.
Tempatkan paket yang diekstrak di folder root ~/
Menginstal Toolchain ARM GNU
Toolchain ARM GNU digunakan untuk proses build.
Sebaiknya tempatkan arsip yang diekstrak di /opt/gnu-mcu-eclipse/arm-none-eabi-gcc/ pada komputer Linux Anda. Ikuti petunjuk dalam file readme.txt arsip untuk petunjuk penginstalan.
Instal Layar (opsional)
Layar adalah alat sederhana untuk mengakses perangkat yang terhubung oleh port serial. Codelab ini menggunakan Screen, tetapi Anda dapat menggunakan aplikasi terminal port serial apa pun yang diinginkan.
$ sudo apt-get install screen
3. Meng-clone repositori
OpenThread
Clone dan instal OpenThread. Perintah script/bootstrap memastikan toolchain diinstal dan lingkungan dikonfigurasi dengan benar:
$ mkdir -p ~/src $ cd ~/src $ git clone --recursive https://github.com/openthread/openthread.git $ cd openthread $ ./script/bootstrap
Membuat OpenThread Daemon:
$ script/cmake-build posix -DOT_DAEMON=ON
Sekarang Anda siap untuk mem-build dan mem-flash OpenThread ke board nRF52840.
4. Menyiapkan Penyambung RCP
Buat dan flash
Membuat contoh OpenThread nRF52840 dengan Joiner dan fungsi USB native. Perangkat menggunakan peran Penggabung untuk diautentikasi dan ditugaskan ke jaringan Thread dengan aman. USB native memungkinkan penggunaan ACM CDC USB sebagai transpor serial antara nRF52840 dan host.
Selalu bersihkan repo build sebelumnya terlebih dahulu dengan menjalankan rm -rf build.
$ cd ~/src $ git clone --recursive https://github.com/openthread/ot-nrf528xx.git $ cd ot-nrf528xx $ script/build nrf52840 USB_trans
Buka direktori dengan biner RCP OpenThread, dan konversikan ke format hex:
$ cd ~/src/ot-nrf528xx/build/bin $ arm-none-eabi-objcopy -O ihex ot-rcp ot-rcp.hex
Pasang kabel USB ke port debug Micro-USB di samping pin daya eksternal pada board nRF52840, lalu colokkan ke mesin Linux. Setel tombol sumber daya nRF di board nRF52840 ke VDD. Jika terhubung dengan benar, LED5 akan aktif.
Jika ini adalah board pertama yang terpasang ke mesin Linux, board ini muncul sebagai port serial /dev/ttyACM0 (semua board nRF52840 menggunakan ttyACM untuk ID port serial).
$ ls /dev/ttyACM* /dev/ttyACM0
Perhatikan nomor seri board nRF52840 yang digunakan untuk RCP:
Buka lokasi nRFx Command Line Tools, dan flash file hex RCP OpenThread ke board nRF52840, menggunakan nomor seri board. Perlu diketahui bahwa jika Anda tidak menyertakan flag --verify, Anda akan melihat pesan peringatan yang memberi tahu bahwa proses flash bisa gagal tanpa error.
$ cd ~/nrfjprog/
$ ./nrfjprog -f nrf52 -s 683704924 --verify --chiperase --program \
~/src/ot-nrf528xx/build/bin/ot-rcp.hex --reset
Output berikut dihasilkan setelah berhasil:
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.
Beri label board "RCP" sehingga nantinya Anda tidak bingung dengan peran board.
Hubungkan ke USB native
Karena build RCP OpenThread memungkinkan penggunaan ACM CDC USB native sebagai transpor serial, Anda harus menggunakan port USB nRF di board nRF52840 untuk berkomunikasi dengan host RCP (mesin Linux).
Lepaskan ujung USB mikro dari kabel USB dari port debug board nRF52840 yang di-flash, lalu pasang kembali ke port nRF USB USB Mikro di sebelah tombol RESET. Setel tombol sumber daya nRF ke USB.
Memulai OpenThread Daemon
Dalam desain RCP, gunakan OpenThread Daemon untuk berkomunikasi dengan dan mengelola perangkat Thread. Mulai ot-daemon dengan flag panjang -v agar Anda dapat melihat output log dan mengonfirmasi bahwa output tersebut berjalan:
$ cd ~/src/openthread
$ sudo ./build/posix/src/posix/ot-daemon -v \
'spinel+hdlc+uart:///dev/ttyACM0?uart-baudrate=115200'
Jika berhasil, ot-daemon dalam mode panjang menghasilkan output yang mirip dengan berikut ini:
ot-daemon[12463]: Running OPENTHREAD/thread-reference-20200818-1938-g0f10480ed; POSIX; Aug 30 2022 10:55:05 ot-daemon[12463]: Thread version: 4 ot-daemon[12463]: Thread interface: wpan0 ot-daemon[12463]: RCP version: OPENTHREAD/thread-reference-20200818-1938-g0f10480ed; SIMULATION; Aug 30 2022 10:54:10
Biarkan jendela terminal ini terbuka sehingga log dari ot-daemon dapat dilihat.
Gunakan ot-ctl untuk berkomunikasi dengan node RCP. ot-ctl menggunakan CLI yang sama dengan aplikasi OpenThread CLI. Oleh karena itu, Anda dapat mengontrol node ot-daemon dengan cara yang sama seperti perangkat Thread simulasi lainnya.
Di jendela terminal kedua, mulai ot-ctl:
$ sudo ./build/posix/src/posix/ot-ctl >
Periksa state Node 2 (node RCP) yang Anda mulai dengan ot-daemon:
> state disabled Done
5. Menyiapkan FTD
Dua node Thread lainnya yang digunakan dalam Codelab ini adalah Perangkat Thread Penuh (FTD) pada desain Sistem di Chip (SoC) standar. Di setelan Produksi, Anda mungkin menggunakan wpantund, driver antarmuka jaringan tingkat produksi, untuk mengontrol instance NCP OpenThread, tetapi dalam codelab ini, kita akan menggunakan ot-ctl, CLI OpenThread.
Satu perangkat berfungsi sebagai Komisaris, untuk mengautentikasi dan mengamankan perangkat ke jaringan tersebut dengan aman. Perangkat lain berfungsi sebagai Penggabung yang dapat diautentikasi oleh Komisaris ke jaringan Thread.
Buat dan flash
Buat contoh OpenThread FTD untuk platform nRF52840, dengan peran Commissioner dan Joiner diaktifkan:
$ cd ~/src/ot-nrf528xx $ rm -rf build $ script/build nrf52840 USB_trans -DOT_JOINER=ON -DOT_COMMISSIONER=ON
Buka direktori dengan biner CLI OpenThread Thread Device (FTD), dan konversikan ke format hex:
$ cd ~/src/ot-nrf528xx/build/bin $ arm-none-eabi-objcopy -O ihex ot-cli-ftd ot-cli-ftd.hex
Pasang kabel USB ke port Micro-USB di samping pin daya eksternal pada board nRF52840, lalu colokkan ke mesin Linux. Jika RCP masih terpasang ke mesin Linux, board baru ini akan muncul sebagai port serial /dev/ttyACM1 (semua board nRF52840 menggunakan ttyACM untuk ID port serial).
$ ls /dev/ttyACM* /dev/ttyACM0 /dev/ttyACM1
Seperti sebelumnya, perhatikan nomor seri nRF52840 board yang digunakan untuk FTD:
Buka lokasi nRFx Command Line Tools, dan flash file hex FTD OpenThread CLI ke board nRF52840, menggunakan nomor seri board:
$ cd ~/nrfjprog/
$ ./nrfjprog -f nrf52 -s 683704924 --verify --chiperase --program \
~/src/ot-nrf528xx/build/bin/ot-cli-ftd.hex --reset
Beri label dewan "Komisaris".
Hubungkan ke USB native
Karena build FTD OpenThread memungkinkan penggunaan ACM CDC USB native sebagai transpor serial, Anda harus menggunakan port nRF USB di board nRF52840 untuk berkomunikasi dengan host RCP (mesin Linux).
Lepaskan ujung USB mikro dari kabel USB dari port debug board nRF52840 yang di-flash, lalu pasang kembali ke port nRF USB USB Mikro di sebelah tombol RESET. Setel tombol sumber daya nRF ke USB.
Memverifikasi build
Verifikasi build yang berhasil dengan mengakses OpenThread CLI menggunakan GNU Screen dari jendela terminal. Board nRF52840 menggunakan baud rate 115200.
$ screen /dev/ttyACM1 115200
Di jendela baru, tekan Return pada keyboard beberapa kali untuk memunculkan perintah > OpenThread CLI. Tampilkan antarmuka IPv6 dan periksa alamat:
> ifconfig up Done > ipaddr fe80:0:0:0:1cd6:87a9:cb9d:4b1d Done
Gunakan Ctrl+a →
d untuk melepaskan dari layar FTD Commissioner CLI dan kembali ke terminal Linux sehingga board berikutnya dapat di-flash. Untuk memasukkan kembali CLI kapan saja, gunakan screen -r dari command line. Untuk melihat daftar layar yang tersedia, gunakan screen -ls:
$ screen -ls
There is a screen on:
74182.ttys000.mylinuxmachine (Detached)
1 Socket in /tmp/uscreens/S-username.
Menyiapkan FTD Joiner
Ulangi proses di atas untuk melakukan flash board nRF52840 ketiga, menggunakan build ot-cli-ftd.hex yang ada. Setelah selesai, pastikan Anda menyambungkan kembali board ke PC menggunakan port USB nRF dan setel tombol sumber daya nRF ke VDD.
Jika dua node lainnya terpasang ke mesin Linux saat board ketiga ini terpasang, node tersebut akan muncul sebagai port serial /dev/ttyACM2:
$ ls /dev/ttyACM* /dev/ttyACM0 /dev/ttyACM1 /dev/ttyACM2
Beri label pada papan "Gabunger".
Saat memverifikasi menggunakan Screen, daripada membuat instance Screen baru dari command line, lampirkan kembali ke layar yang ada dan buat jendela baru di dalamnya (yang Anda gunakan untuk FTD Commissioner):
$ screen -r
Buat jendela baru dalam Layar dengan Ctrl+a → c.
Perintah command line baru akan muncul. Akses CLI OpenThread untuk Joiner FTD:
$ screen /dev/ttyACM2 115200
Di jendela baru ini, tekan Return pada keyboard beberapa kali untuk memunculkan perintah > OpenThread CLI. Tampilkan antarmuka IPv6 dan periksa alamat:
> ifconfig up Done > ipaddr fe80:0:0:0:6c1e:87a2:df05:c240 Done
Setelah CLI FTD Joiner CLI berada dalam instance Layar yang sama dengan FTD Commissioner, Anda dapat beralih di antara keduanya menggunakan Ctrl+a → n.
Gunakan Ctrl+a →
d kapan saja untuk keluar dari Layar.
6. Penyiapan jendela terminal
Ke depannya, Anda akan sering beralih antar-perangkat Thread, jadi pastikan semuanya aktif dan mudah diakses. Sejauh ini, kita telah menggunakan Screen untuk mengakses dua FTD, dan alat ini juga memungkinkan layar terpisah di jendela terminal yang sama. Gunakan metode ini untuk melihat bagaimana satu node bereaksi terhadap perintah yang dikeluarkan di node lainnya.
Idealnya, Anda harus memiliki empat jendela yang tersedia:
- Layanan / log
ot-daemon - Penggabung RCP melalui
ot-ctl - Komisioner FTD melalui CLI OpenThread
- Gabungan FTD melalui CLI OpenThread
Jika Anda ingin menggunakan alat atau konfigurasi terminal / port serial, silakan lewati ke langkah berikutnya. Konfigurasikan jendela terminal untuk semua perangkat dengan cara yang paling sesuai untuk Anda.
Menggunakan Layar
Untuk kemudahan penggunaan, hanya mulai satu sesi Layar. Anda harus sudah memiliki salah satunya saat menyiapkan kedua FTD.
Semua perintah di dalam Layar dimulai dengan Ctrl+a.
Perintah Layar Dasar:
Lampirkan kembali ke sesi Layar (dari command line) |
|
Keluar dari sesi Layar | Ctrl+a → |
Membuat jendela baru dalam sesi Layar | Ctrl+a → |
Beralih antar-jendela dalam sesi Layar yang sama | Ctrl+a → |
Menghentikan jendela saat ini dalam sesi Layar | Ctrl+a → |
Layar Terpisah
Dengan Screen, Anda dapat membagi terminal menjadi beberapa jendela:
Perintah di screen diakses dengan menggunakan Ctrl+a. Setiap perintah harus dimulai dengan kombo kunci akses ini.
Jika Anda telah mengikuti Codelab dengan tepat, Anda akan memiliki dua jendela (FTD Commissioner, FTD Joiner) pada instance Layar yang sama. Untuk memisahkan layar di antara keduanya, pertama-tama masukkan sesi Layar yang ada:
$ screen -r
Anda harus menggunakan salah satu perangkat FTD. Ikuti langkah-langkah berikut di Layar:
- Ctrl+a →
Suntuk memisahkan jendela secara horizontal - Ctrl+a →
Tabuntuk memindahkan kursor ke jendela kosong baru - Ctrl+a →
nuntuk mengalihkan jendela baru ke jendela berikutnya - Jika sama dengan jendela atas, tekan Ctrl+a →
nlagi untuk melihat perangkat FTD lainnya
Sekarang keduanya terlihat. Beralihlah menggunakan Ctrl+a → Tab. Sebaiknya ubah judul setiap jendela dengan Ctrl+a → A agar tidak membingungkan.
Penggunaan lanjutan
Untuk memisahkan layar lebih lanjut menjadi kuadran dan melihat log ot-daemon serta Joiner RCP ot-ctl, layanan tersebut harus dimulai dalam instance Layar yang sama ini. Untuk melakukannya, hentikan ot-daemon dan keluar dari ot-ctl, lalu mulai ulang dalam jendela Layar baru (Ctrl+a → c).
Penyiapan ini tidak diperlukan dan dibiarkan sebagai latihan bagi pengguna.
Pisahkan dan navigasikan antar-jendela dengan perintah berikut:
Buat jendela baru | Ctrl+a → |
Pisahkan jendela secara vertikal | Ctrl+a → |
Pisahkan jendela secara horizontal | Ctrl+a → |
Beralih ke jendela berikutnya yang ditampilkan | Ctrl+a → |
Mengalihkan jendela yang ditampilkan ke depan atau ke belakang | Ctrl+a → |
Mengganti nama jendela saat ini | Ctrl+a → |
Keluar dari Layar kapan saja dengan Ctrl+a → d dan lampirkan ulang dengan screen -r dari command line.
Untuk mengetahui informasi selengkapnya tentang Layar, lihat referensi cepat Layar GNU.
7. Membuat jaringan Thread
Setelah Anda mengonfigurasi semua jendela dan layar terminal, mari buat jaringan Thread. Di FTD Commissioner, buat Set Data Operasional baru dan commit sebagai Set Data Aktif. Set Data Operasional adalah konfigurasi untuk jaringan Thread yang Anda buat.
## 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
Catat Kunci Jaringan 1234c0de7ab51234c0de7ab51234c0de yang akan digunakan nanti.
Commit set data ini sebagai set data aktif:
> dataset commit active Done
Tampilkan antarmuka IPv6:
> ifconfig up Done
Mulai operasi protokol Thread:
> thread start Done
Setelah beberapa saat, periksa status perangkat. Harus berupa Leader. Dapatkan juga RLOC16 untuk referensi di masa mendatang.
## FTD Commissioner ## ---------------------- > state leader Done > rloc16 0c00 Done
Periksa alamat IPv6 perangkat:
## 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)
Jaringan "codelab" kini terlihat saat dipindai dari perangkat Thread lain.
Dari ot-ctl di RCP Joiner:
## RCP Joiner ## ---------------- > scan | PAN | MAC Address | Ch | dBm | LQI | +------+------------------+----+-----+-----+ | c0de | 1ed687a9cb9d4b1d | 11 | -36 | 232 |
Dari OpenThread CLI di FTD Joiner:
## FTD Joiner ## ---------------- > scan | PAN | MAC Address | Ch | dBm | LQI | +------+------------------+----+-----+-----+ | c0de | 1ed687a9cb9d4b1d | 11 | -38 | 229 |
Jika jaringan "codelab" tidak muncul dalam daftar, coba pindai lagi.
8. Menambahkan Joiner RCP
Threading Commissioning tidak aktif di jaringan. Artinya, kita perlu menambahkan Joiner RCP ke jaringan Thread yang baru saja dibuat menggunakan proses komisiing out-of-band.
Di Komisioner FTD, kami mencatat Kunci Jaringan, misalnya 1234c0de7ab51234c0de7ab51234c0de. Jika Anda perlu mencari Kunci Jaringan lagi, jalankan perintah berikut pada FTD Commissioner:
## FTD Commissioner ## > dataset networkkey 1234c0de7ab51234c0de7ab51234c0de Done
Berikutnya, di RCP Joiner, tetapkan Kunci Jaringan set data aktif ke Kunci Jaringan FTD Commissioner:
## RCP Joiner ## ---------------- > dataset networkkey 1234c0de7ab51234c0de7ab51234c0de Done > dataset commit active Done
Periksa set data untuk memastikannya ditetapkan dengan benar.
## RCP Joiner ## ---------------- > dataset Network Key: 1234c0de7ab51234c0de7ab51234c0de
Tampilkan Thread sehingga Joiner RCP bergabung ke jaringan "codelab". Tunggu beberapa detik, periksa status, RLOC16, dan alamat IPv6-nya:
## RCP Joiner ## ---------------- > ifconfig up Done > 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
Catat Alamat IPv6 Lokal Mesh (fdc0:de7a:b5c0:0:66bf:99b9:24c0:d55f di sini), Anda akan menggunakannya nanti.
Kembali ke FTD Commissioner, periksa router dan tabel turunan untuk mengonfirmasi bahwa kedua perangkat merupakan bagian dari jaringan yang sama. Gunakan RLOC16 untuk mengidentifikasi Joiner RCP.
## 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
Ping alamat mesh-local dari RCP Joiner (alamat Mesh-Local yang diperoleh dari output ipaddr RCP Joiner) untuk memverifikasi konektivitas:
## 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
Kita sekarang memiliki jaringan Thread yang terdiri dari dua node, yang diilustrasikan oleh diagram topologi ini:
Diagram topologi
Selama Anda mengerjakan Codelab, kami akan menampilkan diagram topologi Thread baru setiap kali status jaringan berubah. Peran node ditunjukkan sebagai berikut:
Router selalu berbentuk segi lima, dan Perangkat Akhir selalu berbentuk lingkaran. Angka pada setiap node mewakili ID Router atau ID Turunan yang ditampilkan dalam output CLI, bergantung pada peran dan status saat ini dari setiap node.
9. Membuat Gabungan FTD
Sekarang, mari tambahkan perangkat Thread ketiga ke jaringan "codelab". Kali ini kita akan menggunakan proses komisi in-band yang lebih aman, dan hanya mengizinkan FTD Joiner untuk bergabung.
Di FTD Joiner, dapatkan eui64, sehingga FTD Commissioner dapat mengidentifikasinya:
## FTD Joiner ## ---------------- > eui64 2f57d222545271f1 Done
Di FTD Commissioner, mulai komisioner dan tentukan eui64 perangkat yang dapat bergabung, beserta Kredensial Penggabung, misalnya J01NME. Kredensial Joiner adalah string khusus perangkat dari semua karakter alfanumerik huruf besar (0-9 dan AY, tidak termasuk I, O, Q, dan Z agar mudah dibaca), dengan panjang antara 6 hingga 32 karakter.
## FTD Commissioner ## ---------------------- > commissioner start Done > commissioner joiner add 2f57d222545271f1 J01NME Done
Beralih ke Gabungan FTD. Mulai peran join dengan Kredensial Joiner yang baru saja Anda siapkan di Komisaris FTD:
## FTD Joiner ## ---------------- > ifconfig up Done > joiner start J01NME Done
Dalam sekitar satu menit, Anda akan mendapatkan konfirmasi bahwa autentikasi berhasil:
## FTD Joiner ## ---------------- > Join success
Tampilkan Thread sehingga Joiner FTD bergabung dengan jaringan "codelab", dan segera periksa status dan RLOC16:
## FTD Joiner ## ---------------- > thread start Done > state child Done > rloc16 0c02 Done
Periksa alamat IPv6 perangkat. Perhatikan bahwa tidak ada ALOC. Itu karena perangkat ini bukan Leader, atau tidak memegang peran khusus Anycast yang memerlukan ALOC.
## 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)
Segera beralih ke FTD Commissioner dan periksa tabel router dan turunan untuk mengonfirmasi bahwa tiga perangkat ada di jaringan "codelab":
## 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
Berdasarkan RLOC16, Joiner FTD telah terhubung ke jaringan sebagai Perangkat Akhir (turunan). Berikut adalah topologi kami yang telah diperbarui:
10. Cara kerja rangkaian pesan
Perangkat Thread di Codelab ini adalah jenis Perangkat Thread Penuh (FTD) tertentu yang disebut Perangkat Akhir yang Memenuhi Syarat Router (REED). Artinya perangkat tersebut dapat berfungsi sebagai Router atau Perangkat Akhir, serta dapat mempromosikan dirinya sendiri dari Perangkat Akhir ke Router.
Thread dapat mendukung hingga 32 Router, tetapi mencoba mempertahankan jumlah Router antara 16 dan 23. Jika REED terpasang sebagai Perangkat Akhir (turunan) dan jumlah Router di bawah 16, setelah jangka waktu acak dalam waktu dua menit, REED akan otomatis mempromosikan dirinya sendiri ke Router.
Jika Anda memiliki dua turunan di jaringan Thread setelah menambahkan FTD Joiner, tunggu setidaknya dua menit, lalu periksa kembali router dan tabel turunan di FTD Commissioner:
## 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
FTD Joiner (Extended MAC = e6cdd2d93249a243) telah mempromosikan dirinya sendiri ke Router. Perlu diperhatikan bahwa RLOC16 berbeda (b800, bukan 0c02). Hal ini karena RLOC16 didasarkan pada ID Router dan ID Turunan perangkat. Saat bertransisi dari End Device ke Router, nilai Router ID dan Child ID-nya berubah, begitu pula RLOC16.
Konfirmasi status baru dan RLOC16 di FTD Joiner:
## FTD Joiner ## ---------------- > state router Done > rloc16 b800 Done
Mendowngrade FTD Joiner
Anda dapat menguji perilaku ini dengan mendowngrade Gabungan FTD secara manual dari Router ke Perangkat Akhir. Ubah status menjadi turunan dan periksa RLOC16:
## FTD Joiner ## ---------------- > state child Done > rloc16 0c03 Done
Kembali ke FTD Commissioner, FTD Joiner sekarang akan muncul di tabel turunan (ID = 3). Bahkan, keduanya mungkin berada di keduanya saat bertransisi:
## 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
Setelah beberapa saat, perangkat akan beralih kembali ke Router dengan RLOC b800.
Hapus Pemimpin
Leader dipilih sendiri di antara semua Thread Router. Artinya, jika Pemimpin saat ini dihapus dari jaringan Thread, salah satu Router lainnya akan menjadi Pemimpin baru.
Di Komisi FTD, nonaktifkan Thread untuk menghapusnya dari jaringan Thread:
## FTD Commissioner ## ---------------------- > thread stop Done > ifconfig down Done
Dalam waktu dua menit, FTD Joiner akan menjadi Thread baru yang terdepan. Periksa status dan alamat IPv6 dari FTD Joiner untuk memverifikasi:
## 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
Periksa tabel turunan. Perhatikan bahwa ada RLOC16 baru. Ini adalah Penyambung RCP, seperti yang ditunjukkan oleh ID dan Perluasan MAC-nya. Untuk menjaga jaringan Thread bersama-sama, jaringan telah berganti Router induk, dari Komisaris FTD ke Penggabung FTD. Tindakan ini akan menghasilkan RLOC16 baru untuk RCP Joiner (karena ID Router-nya berubah, dari 3 menjadi 46).
## 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
Anda mungkin harus menunggu beberapa menit hingga RCP Joiner dapat dikaitkan ke FTD Joiner sebagai turunan. Periksa status dan RLOC16 untuk mengonfirmasi bahwa:
## RCP Joiner ## -------------- > state child > rloc16 b801
Lampirkan Kembali Komisioner FTD
Jaringan Thread dengan dua node tidak terlalu menyenangkan. Mari kita kembalikan Commissioner FTD.
Di FTD Commissioner, mulai ulang Thread:
## FTD Commissioner ## ---------------------- > ifconfig up Done > thread start Done
Dalam waktu dua menit, perangkat akan otomatis terpasang ulang ke jaringan "codelab" sebagai Perangkat Akhir, lalu mempromosikan dirinya sendiri ke Router.
## FTD Commissioner ## ---------------------- > state router Done
Periksa router dan tabel turunan di FTD Joiner untuk memverifikasi:
## 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
Jaringan Thread kita terdiri dari tiga node lagi.
11. Pemecahan masalah
Mengelola jaringan Thread dengan beberapa perangkat di terminal atau jendela Layar yang berbeda dapat menyulitkan. Gunakan tips ini untuk "mereset" status jaringan atau ruang kerja jika Anda mengalami masalah.
Layar
Jika Anda tersesat dalam konfigurasi (terlalu banyak jendela Layar, atau Layar dalam Layar), tutup jendela Jendela dengan Ctrl+a → k hingga tidak ada, dan screen -ls pada command line menghasilkan No Sockets found. Kemudian, buat ulang jendela Layar untuk setiap perangkat. Status perangkat dipertahankan bahkan saat Layar dihentikan.
Node thread
Jika topologi jaringan Thread tidak seperti yang dideskripsikan dalam Codelab ini, atau node terputus karena beberapa alasan (mungkin karena mesin Linux mendukungnya masuk ke mode tidur), sebaiknya hapus Thread, hapus kredensial jaringan, dan mulai lagi dari langkah Create the Thread network.
Untuk mereset FTD:
## FTD Commissioner or FTD Joiner ## ------------------------------------ > thread stop Done > ifconfig down Done > factoryreset Done
RCP dapat direset dengan cara yang sama melalui ot-ctl:
## RCP Joiner ## ---------------- > thread stop Done > ifconfig down Done > factoryreset Done
12. Menggunakan multicast
Multicast digunakan untuk menyampaikan informasi ke grup perangkat sekaligus. Dalam jaringan Thread, alamat tertentu dicadangkan untuk penggunaan multicast dengan grup perangkat yang berbeda, bergantung pada cakupannya.
Alamat IPv6 | Cakupan | Dikirim ke |
| Link-Lokal | Semua FTD dan MED |
| Link-Lokal | Semua FTD dan Border Router |
| Mesh-Lokal | Semua FTD dan MED |
| Mesh-Lokal | Semua FTD dan Border Router |
Karena kita tidak menggunakan Router Border dalam Codelab ini, mari kita fokuskan pada dua alamat multicast FTD dan MED.
Link-Lokal
Cakupan Link-Local terdiri dari semua antarmuka Thread yang dapat dijangkau dengan satu transmisi radio atau satu "hop". Topologi jaringan menentukan perangkat mana yang merespons ping ke alamat multicast ff02::1.
Ping ff02::1 dari Komisioner FTD:
## FTD Commissioner ## ---------------------- > ping ff02::1 > 8 bytes from fe80:0:0:0:e4cd:d2d9:3249:a243: icmp_seq=2 hlim=64 time=9ms
Ada dua perangkat lain di jaringan (FTD Joiner dan RCP Joiner), tetapi FTD Commissioner hanya menerima satu respons, dari Link-Local Address (LLA) FTD Joiner. Ini berarti Joiner FTD adalah satu-satunya perangkat yang dapat dijangkau oleh Komisaris FTD dengan satu hop.
Sekarang, lakukan ping ke ff02::1 dari 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
Dua respons! Dengan memeriksa alamat IPv6 untuk perangkat lain, kita dapat melihat alamat pertama (yang berakhiran 4b1d) adalah LLA Commissioner FTD, dan yang kedua (berakhir 943b) adalah LLA Joiner RCP.
Ini berarti FTD Joiner terhubung langsung ke FTD Commissioner dan RCP Joiner, yang menegaskan topologi kami.
Mesh-Lokal
Cakupan Mesh-Local terdiri dari semua antarmuka Thread yang dapat dijangkau dalam jaringan Thread yang sama. Mari kita lihat respons terhadap ping ke alamat multicast ff03::1.
Ping ff03::1 dari Komisioner FTD:
## 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
Kali ini FTD Commissioner menerima dua respons, satu dari FTD Joiner's Route Locator (RLOC, yang diakhiri dengan b800) dan satu dari Mesh-Local EID dari RCP Joiner (ML-EID, yang diakhiri dengan d55f). Hal ini karena cakupan mesh-local terdiri dari seluruh jaringan Thread. Di mana pun jaringan berada, perangkat akan berlangganan ke alamat ff03::1.
Ping ff03::1 dari FTD Joiner untuk mengonfirmasi perilaku yang sama:
## 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
Perhatikan waktu respons untuk Joint RCP dalam kedua output ping. RCP Joiner membutuhkan waktu lebih lama untuk mencapai FTD Commissioner (68 md) dibandingkan dengan FTD Joiner (23 md). Itu karena harus membuat dua hop untuk mencapai FTD Commissioner, dibandingkan dengan satu hop untuk FTD Joiner.
Anda mungkin juga telah memperhatikan bahwa ping multicast lokal mesh merespons dengan RLOC hanya untuk dua FTD—bukan RCP Joiner. Ini karena FTD adalah Router dalam jaringan, sedangkan RCP adalah Perangkat Akhir.
Periksa status RCP Joiner untuk mengonfirmasi:
## RCP Joiner ## ---------------- > state child
13. Mengirim pesan dengan UDP
Salah satu layanan aplikasi yang disediakan OpenThread adalah Protokol Datagram Pengguna (UDP), yaitu protokol Lapisan Transportasi. Aplikasi yang di-build di OpenThread dapat menggunakan UDP API untuk meneruskan pesan antar-node dalam jaringan Thread, atau ke perangkat lain di jaringan eksternal (seperti internet, jika jaringan Thread memiliki Border Router).
Soket UDP diekspos melalui CLI OpenThread. Mari kita gunakan untuk meneruskan pesan di antara dua FTD.
Dapatkan alamat EID Mesh-Local untuk Gabungan FTD. Kami menggunakan alamat ini karena dapat dijangkau dari mana saja dalam jaringan Thread.
## 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
Mulai UDP dan ikatkan ke soket untuk alamat IPv6 apa pun:
## FTD Joiner ## ---------------- > udp open Done > udp bind :: 1212
Beralih ke FTD Commissioner, mulai UDP, dan hubungkan ke soket yang Anda siapkan di FTD Joiner, menggunakan ML-EID-nya:
## FTD Commissioner ## ---------------------- > udp open Done > udp connect fdc0:de7a:b5c0:0:3e2e:66e:9d41:ebcd 1212 Done
Koneksi UDP harus berada di antara dua node. Kirim pesan dari Komisaris FTD:
## FTD Commissioner ## ---------------------- > udp send hellothere Done
Di Gabungan FTD, pesan UDP telah diterima.
## FTD Joiner ## ---------------- > 10 bytes from fdc0:de7a:b5c0:0:0:ff:fe00:c00 49153 hellothere
14. Selamat!
Anda telah membuat jaringan Thread fisik.
Sekarang Anda tahu:
- perbedaan antara jenis, peran, dan cakupan perangkat Thread
- cara perangkat Thread mengelola statusnya dalam jaringan
- cara meneruskan pesan sederhana antarnode menggunakan UDP
Langkah berikutnya
Dari Codelab ini, coba latihan berikut:
- Reflash board FTD Joiner sebagai MTD menggunakan biner
ot-cli-mtd, dan amati bahwa papan tidak pernah mengupgrade sendiri ke Router atau mencoba menjadi Leader - Tambahkan lebih banyak perangkat (coba platform lain) ke jaringan dan buat sketsa topologi dengan menggunakan router dan tabel turunan, beserta ping ke alamat multicast
- Menggunakan pyspinel untuk mengontrol NCP
- Konversikan NCP menjadi Border Router menggunakan OpenThread Border Router dan hubungkan jaringan Thread Anda ke internet
Bacaan lebih lanjut
Lihat openthread.io dan GitHub untuk 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
Referensi: