1. Giới thiệu
OpenThread do Google phát hành là một phương thức triển khai nguồn mở của giao thức kết nối mạng Thread®. Google Nest đã phát hành OpenThread để cung cấp công nghệ dùng trong các sản phẩm Nest cho nhà phát triển nhằm đẩy nhanh quá trình phát triển sản phẩm cho nhà thông minh.
Thông số kỹ thuật của Thread xác định giao thức giao tiếp giữa các thiết bị không dây dựa trên IPv6, đáng tin cậy, an toàn và tiêu thụ điện năng thấp cho các ứng dụng gia đình. OpenThread triển khai tất cả các lớp mạng Thread, bao gồm cả IPv6, 6LoWPAN, IEEE 802.15.4 với tính năng bảo mật MAC, Thiết lập liên kết lưới và Định tuyến lưới.
Trong lớp học lập trình này, bạn sẽ lập trình OpenThread trên phần cứng thực, tạo và quản lý mạng Thread, cũng như truyền thông báo giữa các nút.
Kiến thức bạn sẽ học được
- Tạo và cài đặt ROM tệp nhị phân OpenThread CLI vào bảng phát triển
- Xây dựng một RCP bao gồm một máy Linux và một bảng phát triển
- Giao tiếp với RCP bằng Trình nền OpenThread và
ot-ctl - Quản lý các nút Luồng theo cách thủ công bằng GNU Screen và OpenThread CLI
- Cấu hình thiết bị một cách an toàn trên mạng Thread
- Cách hoạt động của tính năng truyền tin đa điểm IPv6
- Truyền tin nhắn giữa các nút Luồng bằng UDP
Bạn cần có
Phần cứng:
- 3 bảng phát triển nRF52840 của Nordic Semiconductor
- 3 cáp USB sang Micro-USB để kết nối các bảng
- Máy Linux có ít nhất 3 cổng USB
Phần mềm:
- Chuỗi công cụ GNU
- Công cụ dòng lệnh Nordic nRF5x
- Phần mềm Segger J-Link
- OpenThread
- Git
2. Bắt đầu
Mô phỏng OpenThread
Trước khi bắt đầu, bạn nên tham gia Lớp học lập trình mô phỏng OpenThread để làm quen với các khái niệm cơ bản về Luồng và CLI OpenThread.
Thiết bị đầu cuối cổng nối tiếp
Bạn phải nắm rõ cách kết nối với cổng nối tiếp thông qua một thiết bị đầu cuối. Lớp học lập trình này sử dụng GNU Screen và cung cấp thông tin tổng quan về cách sử dụng, nhưng bạn có thể sử dụng bất kỳ phần mềm dòng lệnh nào khác.
Máy Linux
Lớp học lập trình này được thiết kế để sử dụng máy Linux dựa trên i386 hoặc x86 làm máy chủ cho thiết bị Luồng đồng xử lý vô tuyến (RCP) và để cài đặt ROM cho tất cả các bảng phát triển Luồng. Tất cả các bước đều được kiểm thử trên Ubuntu 14.04.5 LTS (Trusty Tahr).
Bảng mạch nRF52840 của Nordic Semiconductor
Lớp học lập trình này sử dụng ba bảng PDK nRF52840.
Cài đặt SEGGER J-Link
Chúng ta sử dụng SEGGER J-Link để lập trình cho các bo mạch nRF52840 có mô-đun JTAG trên bo mạch. Cài đặt ứng dụng này trên máy Linux.
Tải gói thích hợp cho máy của bạn rồi cài đặt gói đó ở vị trí thích hợp. Trên Linux, đó là /opt/SEGGER/JLink.
Cài đặt Công cụ dòng lệnh nRF5x
Công cụ dòng lệnh nRF5x cho phép bạn cài đặt ROM tệp nhị phân OpenThread vào các bo mạch nRF52840. Cài đặt bản dựng nRF5x-Command-Line-Tools-<OS> thích hợp trên máy Linux.
Đặt gói đã giải nén vào thư mục gốc ~/
Cài đặt chuỗi công cụ ARM GNU
Chuỗi công cụ GNU ARM được dùng để tạo bản dựng.
Bạn nên đặt tệp lưu trữ đã trích xuất vào /opt/gnu-mcu-eclipse/arm-none-eabi-gcc/ trên máy Linux. Làm theo hướng dẫn trong tệp readme.txt của tệp lưu trữ để biết hướng dẫn cài đặt.
Màn hình cài đặt (không bắt buộc)
Screen là một công cụ đơn giản để truy cập vào các thiết bị được kết nối bằng cổng nối tiếp. Lớp học lập trình này sử dụng Screen, nhưng bạn có thể sử dụng bất kỳ ứng dụng đầu cuối cổng nối tiếp nào mình muốn.
$ sudo apt-get install screen
3. Sao chép kho lưu trữ
OpenThread
Sao chép và cài đặt OpenThread. Các lệnh script/bootstrap đảm bảo rằng chuỗi công cụ được cài đặt và môi trường được định cấu hình đúng cách:
$ mkdir -p ~/src $ cd ~/src $ git clone --recursive https://github.com/openthread/openthread.git $ cd openthread $ ./script/bootstrap
Tạo trình nền OpenThread:
$ script/cmake-build posix -DOT_DAEMON=ON
Giờ đây, bạn đã sẵn sàng tạo và cài đặt ROM OpenThread cho các bo mạch nRF52840.
4. Thiết lập Trình kết hợp RCP
Tạo và cài đặt ROM
Tạo ví dụ về OpenThread nRF52840 bằng Trình kết nối và chức năng USB gốc. Thiết bị sử dụng vai trò Người tham gia để được xác thực và uỷ quyền một cách an toàn trên mạng Thread. USB gốc cho phép sử dụng USB CDC ACM làm phương thức truyền nối tiếp giữa nRF52840 và máy chủ.
Luôn dọn sạch kho lưu trữ của các bản dựng trước đó trước bằng cách chạy rm -rf build.
$ cd ~/src $ git clone --recursive https://github.com/openthread/ot-nrf528xx.git $ cd ot-nrf528xx $ script/build nrf52840 USB_trans
Chuyển đến thư mục có tệp nhị phân OpenThread RCP rồi chuyển đổi tệp đó sang định dạng hex:
$ cd ~/src/ot-nrf528xx/build/bin $ arm-none-eabi-objcopy -O ihex ot-rcp ot-rcp.hex
Gắn cáp USB vào cổng gỡ lỗi Micro-USB bên cạnh chân nguồn bên ngoài trên bo mạch nRF52840, sau đó cắm vào máy Linux. Đặt nút chuyển nguồn điện nRF trên bo mạch nRF52840 thành VDD. Khi được kết nối đúng cách, LED5 sẽ bật.
Nếu đây là bo mạch đầu tiên được đính kèm vào máy Linux, thì bo mạch này sẽ xuất hiện dưới dạng cổng nối tiếp /dev/ttyACM0 (tất cả bo mạch nRF52840 đều sử dụng ttyACM cho giá trị nhận dạng cổng nối tiếp).
$ ls /dev/ttyACM* /dev/ttyACM0
Lưu ý số sê-ri của bo mạch nRF52840 đang được sử dụng cho RCP:
Chuyển đến vị trí của Công cụ dòng lệnh nRFx và truyền tệp hex OpenThread RCP vào bảng nRF52840 bằng số sê-ri của bảng. Xin lưu ý rằng nếu bỏ qua cờ --verify, bạn sẽ thấy thông báo cảnh báo cho biết quá trình cài đặt ROM có thể không thành công mà không có lỗi.
$ cd ~/nrfjprog/
$ ./nrfjprog -f nrf52 -s 683704924 --verify --chiperase --program \
~/src/ot-nrf528xx/build/bin/ot-rcp.hex --reset
Kết quả sau đây sẽ được tạo khi thành công:
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.
Gắn nhãn "RCP" cho bảng để sau này bạn không nhầm lẫn các vai trò của bảng.
Kết nối với USB gốc
Vì bản dựng OpenThread RCP cho phép sử dụng USB CDC ACM gốc làm phương thức truyền nối tiếp, nên bạn phải sử dụng cổng nRF USB trên bo mạch nRF52840 để giao tiếp với máy chủ RCP (máy Linux).
Tháo đầu Micro-USB của cáp USB khỏi cổng gỡ lỗi của bo mạch nRF52840 đã được cài đặt ROM, sau đó gắn lại vào cổng nRF USB Micro-USB bên cạnh nút RESET (ĐẶT LẠI). Đặt nút chuyển nguồn nRF thành USB.
Khởi động trình nền OpenThread
Trong thiết kế RCP, hãy sử dụng Trình nền OpenThread để giao tiếp và quản lý thiết bị Thread. Khởi động ot-daemon bằng cờ chi tiết -v để bạn có thể xem kết quả nhật ký và xác nhận rằng ứng dụng đang chạy:
$ cd ~/src/openthread
$ sudo ./build/posix/src/posix/ot-daemon -v \
'spinel+hdlc+uart:///dev/ttyACM0?uart-baudrate=460800'
Khi thành công, ot-daemon ở chế độ chi tiết sẽ tạo ra kết quả tương tự như sau:
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
Để cửa sổ dòng lệnh này mở để có thể xem nhật ký từ ot-daemon.
Sử dụng ot-ctl để giao tiếp với nút RCP. ot-ctl sử dụng cùng một CLI với ứng dụng CLI OpenThread. Do đó, bạn có thể kiểm soát các nút ot-daemon theo cách tương tự như các thiết bị Thread được mô phỏng khác.
Trong cửa sổ dòng lệnh thứ hai, hãy khởi động ot-ctl:
$ sudo ./build/posix/src/posix/ot-ctl >
Kiểm tra state của Nút 2 (nút RCP) mà bạn đã bắt đầu bằng ot-daemon:
> state disabled Done
5. Thiết lập FTD
Hai nút Luồng (Thread) khác được sử dụng trong lớp học lập trình này là Thiết bị luồng đầy đủ (FTD) trên thiết kế Hệ thống trên chip (SoC) tiêu chuẩn. Trong chế độ cài đặt Phát hành công khai, bạn có thể sử dụng wpantund, một trình điều khiển giao diện mạng cấp phát hành công khai, để kiểm soát các thực thể OpenThread NCP, nhưng trong lớp học lập trình này, chúng ta sẽ sử dụng ot-ctl, CLI OpenThread.
Một thiết bị đóng vai trò là Ủy viên để xác thực và uỷ quyền cho các thiết bị trên mạng đó một cách an toàn. Thiết bị còn lại hoạt động như một Trình tham gia mà Người uỷ quyền có thể xác thực với mạng Thread.
Tạo và cài đặt ROM
Tạo ví dụ về FTD OpenThread cho nền tảng nRF52840, với vai trò là Người uỷ quyền và Người tham gia:
$ cd ~/src/ot-nrf528xx $ rm -rf build $ script/build nrf52840 USB_trans -DOT_JOINER=ON -DOT_COMMISSIONER=ON
Chuyển đến thư mục có tệp nhị phân CLI của Thiết bị luồng đầy đủ (FTD) OpenThread và chuyển đổi tệp đó sang định dạng hex:
$ cd ~/src/ot-nrf528xx/build/bin $ arm-none-eabi-objcopy -O ihex ot-cli-ftd ot-cli-ftd.hex
Gắn cáp USB vào cổng Micro-USB bên cạnh chân nguồn bên ngoài trên bo mạch nRF52840, sau đó cắm vào máy Linux. Nếu RCP vẫn được đính kèm vào máy Linux, thì bo mạch mới này sẽ xuất hiện dưới dạng cổng nối tiếp /dev/ttyACM1 (tất cả bo mạch nRF52840 đều sử dụng ttyACM cho giá trị nhận dạng cổng nối tiếp).
$ ls /dev/ttyACM* /dev/ttyACM0 /dev/ttyACM1
Giống như trước, hãy ghi lại số sê-ri của bo mạch nRF52840 đang được sử dụng cho FTD:
Chuyển đến vị trí của Bộ công cụ dòng lệnh nRFx và cài đặt ROM tệp hex FTD CLI OpenThread vào bảng nRF52840 bằng số sê-ri của bảng:
$ cd ~/nrfjprog/
$ ./nrfjprog -f nrf52 -s 683704924 --verify --chiperase --program \
~/src/ot-nrf528xx/build/bin/ot-cli-ftd.hex --reset
Gắn nhãn cho bảng "Ủy viên".
Kết nối với USB gốc
Vì bản dựng OpenThread FTD cho phép sử dụng USB CDC ACM gốc làm phương thức truyền nối tiếp, nên bạn phải sử dụng cổng USB nRF trên bo mạch nRF52840 để giao tiếp với máy chủ RCP (máy Linux).
Tháo đầu Micro-USB của cáp USB khỏi cổng gỡ lỗi của bo mạch nRF52840 đã được cài đặt ROM, sau đó gắn lại vào cổng nRF USB Micro-USB bên cạnh nút RESET (ĐẶT LẠI). Đặt nút chuyển nguồn nRF thành USB.
Xác minh bản dựng
Xác minh bản dựng thành công bằng cách truy cập vào OpenThread CLI bằng GNU Screen từ cửa sổ dòng lệnh.
$ screen /dev/ttyACM1
Trong cửa sổ mới, hãy nhấn phím Return trên bàn phím vài lần để hiển thị lời nhắc > của OpenThread CLI. Hiển thị giao diện IPv6 và kiểm tra địa chỉ:
> ifconfig up Done > ipaddr fe80:0:0:0:1cd6:87a9:cb9d:4b1d Done
Sử dụng tổ hợp phím Ctrl+a →
d để tách khỏi màn hình FTD Commissioner CLI và quay lại thiết bị đầu cuối Linux để có thể cài đặt ROM cho bo mạch tiếp theo. Để nhập lại CLI bất cứ lúc nào, hãy sử dụng screen -r qua dòng lệnh. Để xem danh sách màn hình có sẵn, hãy sử dụng screen -ls:
$ screen -ls
There is a screen on:
74182.ttys000.mylinuxmachine (Detached)
1 Socket in /tmp/uscreens/S-username.
Thiết lập Trình kết hợp FTD
Lặp lại quy trình trên để cài đặt ROM cho bo mạch nRF52840 thứ ba, sử dụng bản dựng ot-cli-ftd.hex hiện có. Khi hoàn tất, hãy nhớ kết nối lại bảng mạch với máy tính bằng cổng USB nRF và đặt nút chuyển nguồn điện nRF thành VDD.
Nếu hai nút khác được đính kèm vào máy Linux khi gắn bo mạch thứ ba này, thì bo mạch này sẽ xuất hiện dưới dạng cổng nối tiếp /dev/ttyACM2:
$ ls /dev/ttyACM* /dev/ttyACM0 /dev/ttyACM1 /dev/ttyACM2
Gắn nhãn cho bảng là "Joiner" (Công cụ nối).
Khi xác minh bằng Screen, thay vì tạo một thực thể mới của Screen từ dòng lệnh, hãy đính kèm lại vào thực thể hiện có và tạo một cửa sổ mới trong đó (mà bạn đã sử dụng cho Uỷ viên FTD):
$ screen -r
Tạo cửa sổ mới trong Screen bằng tổ hợp phím Ctrl+a → c.
Một lời nhắc dòng lệnh mới sẽ xuất hiện. Truy cập vào CLI OpenThread cho Trình kết nối FTD:
$ screen /dev/ttyACM2
Trong cửa sổ mới này, hãy nhấn phím Return trên bàn phím vài lần để hiển thị lời nhắc > của OpenThread CLI. Hiển thị giao diện IPv6 và kiểm tra địa chỉ:
> ifconfig up Done > ipaddr fe80:0:0:0:6c1e:87a2:df05:c240 Done
Giờ đây, CLI của trình kết hợp FTD nằm trong cùng một thực thể của Màn hình với FTD Commissioner, bạn có thể chuyển đổi giữa các thực thể này bằng cách sử dụng Ctrl+a → n.
Sử dụng Ctrl+a →
d bất cứ lúc nào để thoát khỏi Màn hình.
6. Thiết lập cửa sổ dòng lệnh
Từ giờ trở đi, bạn sẽ thường xuyên chuyển đổi giữa các thiết bị Thread, vì vậy, hãy đảm bảo tất cả thiết bị đều đang hoạt động và dễ dàng truy cập. Cho đến nay, chúng ta đã sử dụng Screen để truy cập vào hai FTD và công cụ này cũng cho phép chia đôi màn hình trên cùng một cửa sổ dòng lệnh. Sử dụng tính năng này để xem cách một nút phản ứng với các lệnh được đưa ra trên một nút khác.
Tốt nhất là bạn nên có sẵn 4 cửa sổ:
- dịch vụ / nhật ký
ot-daemon - Trình kết hợp RCP thông qua
ot-ctl - Ủy viên FTD thông qua CLI OpenThread
- FTD Joiner thông qua OpenThread CLI
Nếu bạn muốn sử dụng cấu hình hoặc công cụ của riêng mình cho thiết bị đầu cuối / cổng nối tiếp, hãy chuyển sang bước tiếp theo. Định cấu hình cửa sổ dòng lệnh cho tất cả thiết bị theo cách phù hợp nhất với bạn.
Sử dụng tính năng Màn hình
Để dễ sử dụng, chỉ bắt đầu một phiên Màn hình. Bạn đã có một mã này từ khi thiết lập cả hai FTD.
Tất cả lệnh trong Screen đều bắt đầu bằng Ctrl+a.
Các lệnh cơ bản trên màn hình:
Đính kèm lại vào phiên Screen (từ dòng lệnh) |
|
Rời khỏi phiên trên Màn hình | Ctrl+a → |
Tạo cửa sổ mới trong phiên Screen | Ctrl+a → |
Chuyển đổi giữa các cửa sổ trong cùng một phiên Màn hình | Ctrl+a → |
Tắt cửa sổ hiện tại trong phiên Screen | Ctrl+a → |
Chia đôi màn hình
Với Screen, bạn có thể chia thiết bị đầu cuối thành nhiều cửa sổ:
Bạn có thể truy cập các lệnh trong screen bằng cách sử dụng tổ hợp phím Ctrl+a. Mỗi lệnh phải bắt đầu bằng tổ hợp phím truy cập này.
Nếu đã làm theo lớp học lập trình một cách chính xác, bạn sẽ có hai cửa sổ (FTD Commissioner, FTD Joiner) trên cùng một thực thể Màn hình. Để chia đôi màn hình giữa hai ứng dụng, trước tiên, hãy nhập phiên Screen hiện có:
$ screen -r
Bạn phải đang sử dụng một trong các thiết bị FTD. Làm theo các bước sau trong Screen:
- Ctrl+a →
Sđể chia cửa sổ theo chiều ngang - Ctrl+a →
Tabđể di chuyển con trỏ đến cửa sổ trống mới - Ctrl+a →
nđể chuyển cửa sổ mới đó sang cửa sổ tiếp theo - Nếu giống với cửa sổ trên cùng, hãy nhấn tổ hợp phím Ctrl+a →
nmột lần nữa để xem thiết bị FTD khác
Cả hai mục này hiện đều hiển thị. Chuyển đổi giữa các chế độ bằng tổ hợp phím Ctrl+a → Tab. Bạn nên đổi tên từng cửa sổ bằng tổ hợp phím Ctrl+a → A để tránh nhầm lẫn.
Cách sử dụng nâng cao
Để chia màn hình thành các góc phần tư và xem nhật ký ot-daemon và trình kết hợp RCP ot-ctl, bạn phải khởi động các dịch vụ đó trong cùng một thực thể Màn hình này. Để thực hiện việc này, hãy dừng ot-daemon và thoát khỏi ot-ctl, sau đó khởi động lại các ứng dụng đó trong cửa sổ Screen mới (Ctrl+a → c).
Bạn không bắt buộc phải thiết lập và đây là bài tập cho người dùng.
Phân tách và di chuyển giữa các cửa sổ bằng các lệnh sau:
Tạo cửa sổ mới | Ctrl+a → |
Chia cửa sổ theo chiều dọc | Ctrl+a → |
Chia cửa sổ theo chiều ngang | Ctrl+a → |
Chuyển đến cửa sổ hiển thị tiếp theo | Ctrl+a → |
Chuyển cửa sổ hiển thị về trước hoặc về sau | Ctrl+a → |
Đổi tên cửa sổ hiện tại | Ctrl+a → |
Bạn có thể rời khỏi Screen bất cứ lúc nào bằng tổ hợp phím Ctrl+a → d và đính kèm lại bằng screen -r từ dòng lệnh.
Để biết thêm thông tin về Screen, hãy xem tài liệu tham khảo nhanh về GNU Screen.
7. Tạo mạng Thread
Giờ đây, bạn đã định cấu hình tất cả các cửa sổ và màn hình của thiết bị đầu cuối, hãy tạo mạng Luồng. Trên Cục trưởng FTD, hãy tạo một Tập dữ liệu hoạt động mới và xác nhận là tập dữ liệu đang hoạt động. Tập dữ liệu hoạt động là cấu hình cho mạng Thread mà bạn đang tạo.
## 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
Ghi lại Khoá mạng 1234c0de7ab51234c0de7ab51234c0de sẽ được sử dụng sau này.
Cam kết tập dữ liệu này làm tập dữ liệu đang hoạt động:
> dataset commit active Done
Hiển thị giao diện IPv6:
> ifconfig up Done
Bắt đầu thao tác giao thức Luồng:
> thread start Done
Sau một lát, hãy kiểm tra trạng thái thiết bị. Đó phải là Người lãnh đạo. Ngoài ra, hãy lấy RLOC16 để tham khảo sau này.
## FTD Commissioner ## ---------------------- > state leader Done > rloc16 0c00 Done
Kiểm tra địa chỉ IPv6 của thiết bị:
## 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)
Mạng "lớp học lập trình" hiện hiển thị khi quét từ các thiết bị Thread khác.
Từ ot-ctl trên Trình kết hợp RCP:
## RCP Joiner ## ---------------- > scan | PAN | MAC Address | Ch | dBm | LQI | +------+------------------+----+-----+-----+ | c0de | 1ed687a9cb9d4b1d | 11 | -36 | 232 |
Từ CLI OpenThread trên FTD Joiner:
## FTD Joiner ## ---------------- > scan | PAN | MAC Address | Ch | dBm | LQI | +------+------------------+----+-----+-----+ | c0de | 1ed687a9cb9d4b1d | 11 | -38 | 229 |
Nếu mạng "lớp học lập trình" không xuất hiện trong danh sách, hãy thử quét lại.
8. Thêm trình kết hợp RCP
Thread Commissioning không hoạt động trên mạng, nghĩa là chúng ta cần thêm RCP Joiner vào mạng Thread vừa tạo bằng quy trình uỷ quyền ngoài băng thông.
Trên Cục trưởng FTD, chúng ta đã ghi lại Khoá mạng, ví dụ: 1234c0de7ab51234c0de7ab51234c0de. Nếu bạn cần tra cứu lại Khoá mạng, hãy chạy lệnh sau trên Tổng công ty FTD:
## FTD Commissioner ## > dataset networkkey 1234c0de7ab51234c0de7ab51234c0de Done
Tiếp theo, trên RCP Joiner (Trình kết hợp RCP), hãy đặt Khoá mạng của tập dữ liệu đang hoạt động thành Khoá mạng của Uỷ viên FTD:
## RCP Joiner ## ---------------- > dataset networkkey 1234c0de7ab51234c0de7ab51234c0de Done > dataset commit active Done
Kiểm tra tập dữ liệu để đảm bảo bạn đã thiết lập đúng cách.
## RCP Joiner ## ---------------- > dataset Network Key: 1234c0de7ab51234c0de7ab51234c0de
Hiển thị Luồng để Trình kết hợp RCP tham gia mạng "lớp học lập trình". Chờ vài giây, kiểm tra trạng thái, RLOC16 và địa chỉ IPv6:
## 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
Ghi lại Địa chỉ IPv6 cục bộ của mạng lưới (fdc0:de7a:b5c0:0:66bf:99b9:24c0:d55f ở đây), bạn sẽ sử dụng địa chỉ này sau.
Quay lại trang FTD Commissioner (Ủy viên FTD), hãy kiểm tra bảng bộ định tuyến và bảng con để xác nhận cả hai thiết bị đều thuộc cùng một mạng. Sử dụng RLOC16 để xác định Trình kết hợp 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 địa chỉ mesh-local của Trình kết hợp RCP (địa chỉ Mesh-Local thu được từ đầu ra ipaddr của Trình kết hợp RCP) để xác minh khả năng kết nối:
## 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
Bây giờ, chúng ta có một mạng Thread bao gồm hai nút, được minh hoạ bằng sơ đồ cấu trúc liên kết sau:
Sơ đồ cấu trúc liên kết
Khi bạn thực hiện phần còn lại của Lớp học lập trình, chúng tôi sẽ hiển thị sơ đồ cấu trúc liên kết luồng mới bất cứ khi nào trạng thái của mạng thay đổi. Vai trò của nút được biểu thị như sau:
Bộ định tuyến luôn là hình ngũ giác và Thiết bị cuối luôn là hình tròn. Các con số trên mỗi nút đại diện cho Mã định tuyến hoặc Mã con xuất hiện trong kết quả của CLI, tuỳ thuộc vào vai trò và trạng thái hiện tại của mỗi nút tại thời điểm đó.
9. Uỷ quyền cho Trình kết hợp FTD
Bây giờ, hãy thêm thiết bị Thread thứ ba vào mạng "lớp học lập trình". Lần này, chúng ta sẽ sử dụng quy trình uỷ quyền trong băng tần an toàn hơn và chỉ cho phép Trình kết nối FTD tham gia.
Trên FTD Joiner, hãy lấy eui64 để Ủy viên FTD có thể xác định:
## FTD Joiner ## ---------------- > eui64 2f57d222545271f1 Done
Trên FTD Commissioner (Ủy viên FTD), hãy khởi động ủy viên và chỉ định eui64 của thiết bị có thể tham gia, cùng với Thông tin xác thực của người tham gia, ví dụ: J01NME. Thông tin xác thực của người tham gia là một chuỗi dành riêng cho thiết bị, bao gồm tất cả ký tự chữ-số viết hoa (0-9 và A-Y, ngoại trừ I, O, Q và Z để dễ đọc), có độ dài từ 6 đến 32 ký tự.
## FTD Commissioner ## ---------------------- > commissioner start Done > commissioner joiner add 2f57d222545271f1 J01NME Done
Chuyển sang FTD Joiner (Trình kết hợp FTD). Bắt đầu vai trò người tham gia bằng Thông tin xác thực của người tham gia mà bạn vừa thiết lập trên Uỷ viên FTD:
## FTD Joiner ## ---------------- > ifconfig up Done > joiner start J01NME Done
Trong vòng một phút, bạn sẽ nhận được thông báo xác nhận xác thực thành công:
## FTD Joiner ## ---------------- > Join success
Mở Luồng để Trình kết nối FTD tham gia mạng "lớp học lập trình" và kiểm tra ngay trạng thái và RLOC16:
## FTD Joiner ## ---------------- > thread start Done > state child Done > rloc16 0c02 Done
Kiểm tra địa chỉ IPv6 của thiết bị. Lưu ý rằng không có ALOC. Đó là do thiết bị này không phải là thiết bị Chủ đạo, cũng không giữ vai trò dành riêng cho Anycast cần có 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)
Hãy chuyển ngay sang Ủy viên FTD và kiểm tra bộ định tuyến và bảng con để xác nhận rằng có 3 thiết bị trong mạng "lớp học lập trình":
## 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
Dựa trên RLOC16, Trình kết hợp FTD đã đính kèm vào mạng dưới dạng Thiết bị cuối (con). Sau đây là cấu trúc liên kết đã cập nhật:
10. Thread trong thực tế
Thiết bị Thread trong lớp học lập trình này là một loại thiết bị Full Thread Device (FTD) cụ thể, được gọi là Router Eligible End Device (REED). Điều này có nghĩa là chúng có thể hoạt động như một Trình định tuyến hoặc Thiết bị cuối và có thể tự nâng cấp từ Thiết bị cuối lên Trình định tuyến.
Luồng có thể hỗ trợ tối đa 32 Trình định tuyến, nhưng cố gắng giữ số lượng Trình định tuyến trong khoảng từ 16 đến 23. Nếu một REED đính kèm dưới dạng Thiết bị cuối (con) và số lượng Bộ định tuyến dưới 16, thì sau một khoảng thời gian ngẫu nhiên trong vòng 2 phút, thiết bị đó sẽ tự động tự nâng cấp thành Bộ định tuyến.
Nếu bạn có hai phần tử con trong mạng Thread sau khi thêm Trình kết hợp FTD, hãy đợi ít nhất 2 phút rồi kiểm tra lại bộ định tuyến và bảng con trên FTD Commissioner (Ủy viên FTD):
## 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
Trình kết hợp FTD (MAC mở rộng = e6cdd2d93249a243) đã tự nâng cấp lên Bộ định tuyến. Xin lưu ý rằng RLOC16 khác (b800 thay vì 0c02). Đó là do RLOC16 dựa trên Mã định tuyến và Mã con của một thiết bị. Khi chuyển đổi từ Thiết bị cuối sang Bộ định tuyến, giá trị Mã định tuyến và Mã con của thiết bị đó sẽ thay đổi, RLOC16 cũng vậy.
Xác nhận trạng thái mới và RLOC16 trên FTD Joiner:
## FTD Joiner ## ---------------- > state router Done > rloc16 b800 Done
Hạ cấp Trình kết hợp FTD
Bạn có thể kiểm thử hành vi này bằng cách hạ cấp FTD Joiner từ Bộ định tuyến xuống Thiết bị cuối theo cách thủ công. Thay đổi trạng thái thành con và kiểm tra RLOC16:
## FTD Joiner ## ---------------- > state child Done > rloc16 0c03 Done
Quay lại Ủy viên FTD, giờ đây, FTD Joiner sẽ xuất hiện trong bảng con (Mã nhận dạng = 3). Thậm chí, nó có thể nằm trong cả hai trong khi chuyển đổi:
## 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
Sau một thời gian, nó sẽ chuyển về Bộ định tuyến có RLOC là b800.
Xoá người lãnh đạo
Trình điều phối chính được tự bầu chọn trong số tất cả Trình định tuyến luồng. Điều này có nghĩa là nếu Leader hiện tại bị xoá khỏi mạng Thread, thì một trong các Router khác sẽ trở thành Leader mới.
Trên Thành viên Ủy ban FTD, hãy tắt Thread để xoá thiết bị đó khỏi mạng Thread:
## FTD Commissioner ## ---------------------- > thread stop Done > ifconfig down Done
Trong vòng hai phút, FTD Joiner sẽ trở thành Thread leader mới. Kiểm tra trạng thái và địa chỉ IPv6 của Trình kết hợp FTD để xác minh:
## 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
Kiểm tra bảng con. Lưu ý rằng có một RLOC16 mới. Đây là Trình kết hợp RCP, như được chỉ định bằng mã nhận dạng và MAC mở rộng. Để giữ cho mạng Luồng hoạt động cùng nhau, trình kết hợp này đã chuyển đổi Bộ định tuyến mẹ, từ Uỷ viên FTD sang Trình kết hợp FTD. Điều này dẫn đến một RLOC16 mới cho Trình kết hợp RCP (vì Mã định tuyến của trình kết hợp này đã thay đổi, từ 3 thành 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
Bạn có thể phải đợi vài phút để Trình kết hợp RCP đính kèm vào Trình kết hợp FTD dưới dạng phần tử con. Kiểm tra trạng thái và RLOC16 để xác nhận rằng:
## RCP Joiner ## -------------- > state child > rloc16 b801
Đính kèm lại Uỷ viên FTD
Mạng Thread có hai nút không thú vị lắm. Hãy kết nối lại với Ủy viên FTD.
Trên FTD Commissioner, hãy khởi động lại Thread:
## FTD Commissioner ## ---------------------- > ifconfig up Done > thread start Done
Trong vòng hai phút, thiết bị này sẽ tự động đính kèm lại vào mạng "lớp học lập trình" dưới dạng Thiết bị cuối, sau đó tự quảng bá thành Bộ định tuyến.
## FTD Commissioner ## ---------------------- > state router Done
Kiểm tra bộ định tuyến và bảng con trên Trình kết hợp FTD để xác minh:
## 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
Mạng Thread của chúng ta lại bao gồm 3 nút.
11. Khắc phục sự cố
Việc quản lý mạng Luồng có nhiều thiết bị trên nhiều cửa sổ màn hình hoặc thiết bị đầu cuối có thể phức tạp. Hãy sử dụng các mẹo sau để "đặt lại" trạng thái của mạng hoặc không gian làm việc nếu bạn gặp vấn đề.
Màn hình
Nếu bạn bị lạc trong cấu hình (quá nhiều cửa sổ Screen hoặc Screen trong Screen), hãy tiếp tục đóng các cửa sổ Screen bằng tổ hợp phím Ctrl+a → k cho đến khi không còn cửa sổ nào và screen -ls trên dòng lệnh xuất ra No Sockets found. Sau đó, hãy tạo lại các cửa sổ Màn hình cho từng thiết bị. Trạng thái thiết bị được giữ nguyên ngay cả khi Màn hình bị tắt.
Nút luồng
Nếu cấu trúc mạng Thread không như mô tả trong Lớp học lập trình này hoặc các nút bị ngắt kết nối vì lý do nào đó (có thể là do máy Linux cung cấp năng lượng cho các nút đó đã chuyển sang trạng thái ngủ), tốt nhất bạn nên tắt Thread, xoá thông tin xác thực mạng và bắt đầu lại từ bước Tạo mạng Thread.
Cách đặt lại FTD:
## FTD Commissioner or FTD Joiner ## ------------------------------------ > thread stop Done > ifconfig down Done > factoryreset Done
Bạn có thể đặt lại RCP theo cách tương tự thông qua ot-ctl:
## RCP Joiner ## ---------------- > thread stop Done > ifconfig down Done > factoryreset Done
12. Sử dụng tính năng truyền phát đa điểm
Truyền đa điểm được dùng để truyền thông tin đến một nhóm thiết bị cùng một lúc. Trong mạng Thread, các địa chỉ cụ thể được dành riêng cho việc sử dụng truyền nhiều địa chỉ với các nhóm thiết bị khác nhau, tuỳ thuộc vào phạm vi.
Địa chỉ IPv6 | Phạm vi | Đã giao đến |
| Liên kết cục bộ | Tất cả FTD và MED |
| Liên kết cục bộ | Tất cả FTD và Bộ định tuyến biên |
| Mesh-Local | Tất cả FTD và MED |
| Mesh-Local | Tất cả FTD và Bộ định tuyến biên |
Vì chúng ta không sử dụng Bộ định tuyến biên trong lớp học lập trình này, hãy tập trung vào hai địa chỉ truyền tin nhiều điểm FTD và MED.
Liên kết cục bộ
Phạm vi Link-Local bao gồm tất cả giao diện Thread có thể truy cập được bằng một lần truyền tin qua sóng vô tuyến hoặc một "bước nhảy" duy nhất. Cấu trúc mạng sẽ chỉ định thiết bị nào phản hồi ping đến địa chỉ đa hướng ff02::1.
Ping ff02::1 từ Ủy viên FTD:
## FTD Commissioner ## ---------------------- > ping ff02::1 > 8 bytes from fe80:0:0:0:e4cd:d2d9:3249:a243: icmp_seq=2 hlim=64 time=9ms
Có hai thiết bị khác trong mạng (FTD Joiner và RCP Joiner), nhưng Uỷ viên FTD chỉ nhận được một phản hồi từ Địa chỉ liên kết cục bộ (LLA) của FTD Joiner. Điều này có nghĩa là Trình kết hợp FTD là thiết bị duy nhất mà Uỷ viên FTD có thể tiếp cận bằng một bước nhảy.
Bây giờ, hãy ping ff02::1 từ Trình kết hợp FTD:
## 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
Hai câu trả lời! Khi kiểm tra địa chỉ IPv6 của các thiết bị khác, chúng ta có thể thấy địa chỉ đầu tiên (kết thúc bằng 4b1d) là LLA của Uỷ viên FTD và địa chỉ thứ hai (kết thúc bằng 943b) là LLA của Trình kết hợp RCP.
Điều này có nghĩa là Trình kết hợp FTD được kết nối trực tiếp với cả Trình điều phối FTD và Trình kết hợp RCP, xác nhận cấu trúc liên kết của chúng ta.
Mesh-Local
Phạm vi Mesh-Local bao gồm tất cả giao diện Thread có thể truy cập được trong cùng một mạng Thread. Hãy xem các phản hồi của ping đến địa chỉ truyền tin nhiều điểm ff03::1.
Ping ff03::1 từ Ủy viên 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
Lần này, Uỷ viên FTD nhận được hai phản hồi, một từ Trình định tuyến của trình kết hợp FTD (RLOC, kết thúc bằng b800) và một từ EID cục bộ của trình kết hợp RCP (ML-EID, kết thúc bằng d55f). Đó là vì phạm vi cục bộ của lưới bao gồm toàn bộ mạng Thread. Bất kể thiết bị ở đâu trong mạng, thiết bị đó sẽ được đăng ký theo địa chỉ ff03::1.
Ping ff03::1 từ FTD Joiner để xác nhận hành vi tương tự:
## 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
Lưu ý thời gian phản hồi của Trình kết hợp RCP trong cả hai đầu ra ping. Trình kết hợp RCP mất nhiều thời gian hơn để kết nối với Uỷ viên FTD (68 mili giây) so với khi kết nối với Trình kết hợp FTD (23 mili giây). Đó là do lệnh này phải thực hiện hai bước nhảy để đến được Uỷ viên FTD, so với một bước nhảy cho Trình kết hợp FTD.
Bạn cũng có thể nhận thấy rằng ping truyền đa địa phương trên mạng lưới chỉ phản hồi bằng RLOC cho hai FTD chứ không phải Trình kết hợp RCP. Điều này là do FTD là Bộ định tuyến trong mạng, còn RCP là Thiết bị cuối.
Kiểm tra trạng thái của Trình kết hợp RCP để xác nhận:
## RCP Joiner ## ---------------- > state child
13. Gửi thông báo bằng UDP
Một trong những dịch vụ ứng dụng mà OpenThread cung cấp là Giao thức dữ liệu người dùng (UDP), một giao thức Lớp truyền tải. Ứng dụng được xây dựng trên OpenThread có thể sử dụng API UDP để truyền thông báo giữa các nút trong mạng Thread hoặc đến các thiết bị khác trong mạng bên ngoài (chẳng hạn như Internet, nếu mạng Thread có Bộ định tuyến biên).
Các ổ cắm UDP được hiển thị thông qua OpenThread CLI. Hãy sử dụng nó để truyền tin nhắn giữa hai FTD.
Lấy địa chỉ EID Mesh-Local cho FTD Joiner. Chúng tôi đang sử dụng địa chỉ này vì bạn có thể truy cập địa chỉ này từ bất kỳ đâu trong mạng 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
Khởi động UDP và liên kết với một ổ cắm cho bất kỳ địa chỉ IPv6 nào:
## FTD Joiner ## ---------------- > udp open Done > udp bind :: 1212
Chuyển sang FTD Commissioner (Ủy viên FTD), khởi động UDP và kết nối với ổ cắm mà bạn thiết lập trên FTD Joiner (Trình kết hợp FTD) bằng ML-EID của ổ cắm đó:
## FTD Commissioner ## ---------------------- > udp open Done > udp connect fdc0:de7a:b5c0:0:3e2e:66e:9d41:ebcd 1212 Done
Kết nối UDP phải hoạt động giữa hai nút. Gửi thông báo của Uỷ viên FTD:
## FTD Commissioner ## ---------------------- > udp send hellothere Done
Trên FTD Joiner, thông báo UDP đã được nhận!
## FTD Joiner ## ---------------- > 10 bytes from fdc0:de7a:b5c0:0:0:ff:fe00:c00 49153 hellothere
14. Xin chúc mừng!
Bạn đã tạo một mạng Thread thực!
Giờ đây, bạn đã biết:
- sự khác biệt giữa các loại, vai trò và phạm vi thiết bị Luồng
- cách thiết bị Thread quản lý trạng thái của chúng trong mạng
- cách truyền thông báo đơn giản giữa các nút bằng UDP
Các bước tiếp theo
Dựa trên lớp học lập trình này, hãy thử các bài tập sau:
- Hãy cài đặt lại bo mạch FTD Joiner dưới dạng MTD bằng tệp nhị phân
ot-cli-mtdvà quan sát để thấy rằng bo mạch này không bao giờ tự nâng cấp lên Bộ định tuyến hoặc cố gắng trở thành Trình điều khiển - Thêm các thiết bị khác (thử một nền tảng khác!) vào mạng và phác thảo cấu trúc liên kết bằng cách sử dụng bảng con và bộ định tuyến, cùng với ping đến địa chỉ đa điểm
- Sử dụng pyspinel để điều khiển NCP
- Chuyển đổi NCP thành Bộ định tuyến biên bằng Bộ định tuyến biên OpenThread và kết nối mạng Thread với Internet
Tài liệu đọc thêm
Hãy xem openthread.io và GitHub để biết nhiều tài nguyên OpenThread, bao gồm:
- Nền tảng được hỗ trợ – khám phá tất cả nền tảng hỗ trợ OpenThread
- Tạo OpenThread – thông tin chi tiết khác về cách tạo và định cấu hình OpenThread
- Thread Primer (Giới thiệu về luồng) – trình bày tất cả các khái niệm về luồng trong lớp học lập trình này
Tài liệu tham khảo: