1. Giới thiệu
OpenThread do Google phát hành là triển khai nguồn mở của giao thức mạng Thread®. Google Nest đã phát hành OpenThread để cung cấp rộng rãi công nghệ cho các sản phẩm Nest cho các nhà phát triển nhằm đẩy nhanh quá trình phát triển sản phẩm cho ngôi nhà thông minh.
Đặc tả luồng xác định một giao thức truyền dữ liệu từ thiết bị tới thiết bị không dây công suất thấp, bảo mật và đáng tin cậy dựa trên IPv6 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 IPv6, 6LoWPAN, IEEE 802.15.4 với 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 Luồng, truyền thông báo giữa các nút.
Kiến thức bạn sẽ học được
- Xây dựng và cài đặt tệp nhị phân OpenLI CLI cho các bảng mạch phát triển
- Xây dựng RCP bao gồm máy Linux và bảng dev
- Giao tiếp với một RCP bằng OpenThread Daemon và
ot-ctl - Quản lý các nút Luồng theo cách thủ công bằng Màn hình GNU và CLI OpenThread
- Ủy quyền bảo mật thiết bị vào mạng Luồng
- Cách hoạt động của tính năng phát đa hướng IPv6
- Truyền thông báo giữa các nút Luồng bằng UDP
Bạn cần có
Phần cứng:
- 3 bo mạch nhà phát triển Bắc Âu Semiconductor nRF52840
- 3 cáp USB với Micro-USB để kết nối bo mạch
- 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 nRF5x của Bắc Âu
- 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 thực hiện 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ề Thread và OpenThread CLI.
Thiết bị đầu cuối cổng nối tiếp
Bạn nên làm quen với cách kết nối với cổng nối tiếp qua thiết bị đầu cuối. Lớp học lập trình này sử dụng Màn hình GNU và cung cấp thông tin tổng quan về việc sử dụng, nhưng bạn có thể dùng bất kỳ phần mềm đầu cuối 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ủ lưu trữ cho thiết bị Luồng xử lý radio (RCP) và để flash tất cả các bảng phát triển Thread. Tất cả các bước đã được thử nghiệm trên Ubuntu 14.04.5 LTS (Trusty Tahr).
Bo mạch bán dẫn Bắc Âu nRF52840
Lớp học lập trình này sử dụng ba bảng nRF52840 PDK.
Cài đặt SEGGER J-Link
Chúng tôi sử dụng SEGGER J-Link để lập trình bo mạch nRF52840 có mô-đun JTAG tích hợp. Cài đặt chương trình này trên máy Linux của bạn.
Tải xuống gói thích hợp cho máy của bạn và cài đặt vào nơi phù hợp. Trên Linux, đây 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 nhị phân OpenThread vào bảng nRF52840. Cài đặt bản dựng nRF5x-Command-Line-Tools-<OS> thích hợp trên máy Linux của bạn.
Đặ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ụ ARM GNU được dùng để xây dựng.
Bạn nên đặt tệp lưu trữ đã trích xuất trong /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 để lưu trữ hướng dẫn cài đặt.
Màn hình cài đặt (không bắt buộc)
Màn hình là một công cụ đơn giản để truy cập 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 Màn hình, nhưng bạn có thể sử dụng bất kỳ ứng dụng thiết bị đầu cuối cổng nối tiếp nào mà bạn 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 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
Bây giờ, bạn đã sẵn sàng tạo và cài đặt OpenThread lên các bo mạch nRF52840.
4. Thiết lập Người tham gia RCP
Tạo và flash
Xây dựng ví dụ OpenThread nRF52840 với Joiner 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à ủy quyền một cách an toàn trên mạng Chuỗi. USB gốc cho phép sử dụng USB CDC ACM như một phương tiện truyền nối tiếp giữa nRF52840 và máy chủ.
Luôn dọn dẹp kho lưu trữ của các bản dựng 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 và chuyển đổi sang định dạng thập lục phân:
$ cd ~/src/ot-nrf528xx/build/bin $ arm-none-eabi-objcopy -O ihex ot-rcp ot-rcp.hex
Cắm cáp USB vào cổng gỡ lỗi Micro-USB bên cạnh chân cắm 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 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 gắn vào máy Linux, nó sẽ xuất hiện dưới dạng cổng nối tiếp /dev/ttyACM0 (tất cả các bo mạch nRF52840 đều sử dụng ttyACM cho mã nhận dạng cổng nối tiếp).
$ ls /dev/ttyACM* /dev/ttyACM0
Lưu ý số sê-ri của bảng nRF52840 đang được sử dụng cho RCP:
Điều hướng đến vị trí của Công cụ dòng lệnh nRFx và cài đặt tệp hex OpenThread RCP lên bảng nRF52840 bằng số sê-ri của bảng. Lưu ý rằng nếu bạn loại bỏ cờ --verify, bạn sẽ thấy thông báo cảnh báo cho bạn biết rằng quá trình flash có thể không thành công mà không xảy ra 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 đượ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 cho bảng này là "RCP" để bạn không nhầm lẫn giữa các vai trò trong 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 gốc CDC ACM làm phương thức truyền tải 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 cắm Micro-USB của cáp USB ra khỏi cổng gỡ lỗi của bo mạch nRF52840 nhấp nháy, sau đó gắn lại phích cắm vào cổng Micro-USB nRF USB bên cạnh nút RESET. Đặ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 OpenThread Daemon để giao tiếp và quản lý thiết bị Thread. Bắt đầu ot-daemon bằng cờ chi tiết -v để bạn có thể xem đầu ra nhật ký và xác nhận rằng đầu ra đang chạy:
$ cd ~/src/openthread
$ sudo ./build/posix/src/posix/ot-daemon -v \
'spinel+hdlc+uart:///dev/ttyACM0?uart-baudrate=115200'
Khi thành công, ot-daemon ở chế độ chi tiết sẽ tạo đầu ra 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 CLI tương tự như ứ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ị Luồng đã 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 Thread còn lại được sử dụng trong Lớp học lập trình này là Full Thread Devices (FTD) trên thiết kế System-on-Chip (SoC) tiêu chuẩn. Trong chế độ cài đặt Sản xuất, người ta có thể sử dụng wpantund (một trình điều khiển giao diện mạng cấp sản xuất) để điều khiển 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ị có chức năng là Ủy viên để xác thực và ủy quyền các thiết bị một cách an toàn cho mạng đó. Thiết bị khác có chức năng như là một Trình liên kết mà Ủy viên có thể xác thực với mạng Chuỗi.
Tạo và flash
Tạo ví dụ OpenThread FTD cho nền tảng nRF52840, trong đó các vai trò Ủy viên và Người tham gia đã được bật:
$ 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 OpenThread Full Thread (FTD) và chuyển đổi 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 gắn vào máy Linux, bảng 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 sử dụng ttyACM cho mã nhận dạng cổng nối tiếp).
$ ls /dev/ttyACM* /dev/ttyACM0 /dev/ttyACM1
Như trước đây, hãy lưu ý số sê-ri của bo mạch nRF52840 đang được sử dụng cho FTD:
Điều hướng đến vị trí của Công cụ dòng lệnh nRFx và flash tệp hex OpenThread CLI FTD lên bo mạch nRF52840, sử dụ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 hội đồng này là "Ủ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 gốc CDC ACM làm phương tiện truyền tải nối tiếp, 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 cắm Micro-USB của cáp USB ra khỏi cổng gỡ lỗi của bo mạch nRF52840 nhấp nháy, sau đó gắn lại phích cắm vào cổng Micro-USB nRF USB bên cạnh nút RESET. Đặ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 CLI OpenThread sử dụng GNU Screen từ cửa sổ dòng lệnh. Bo mạch nRF52840 sử dụng tốc độ truyền là 115200.
$ screen /dev/ttyACM1 115200
Trong cửa sổ mới, hãy nhấn vào nút Quay lại trên bàn phím vài lần để thấy lời nhắc OpenThread CLI >. Hiển thị giao diện IPv6 và kiểm tra các đị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 CLI của Ủy viên FTD và quay lại thiết bị đầu cuối Linux để có thể hiển thị bảng tiếp theo. Để nhập lại CLI bất cứ lúc nào, hãy sử dụng screen -r từ 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 liên kết FTD
Lặp lại quy trình trên để cài đặt flash nRF52840 thứ ba bằng cách 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 bo mạch với PC bằng cổng USB nRF và đặt nút chuyển nguồn nRF thành VDD.
Nếu hai nút còn lại được gắn vào máy Linux khi gắn bảng này, bảng 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 này là "Tham gia".
Khi xác minh bằng Màn hình, thay vì tạo một bản sao mới của Màn hình từ dòng lệnh, hãy đính kèm lại vào bản hiện tại và tạo một cửa sổ mới trong đó (bạn đã sử dụng cho Ủy viên FTD):
$ screen -r
Tạo cửa sổ mới trong Màn hình 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 người tham gia FTD:
$ screen /dev/ttyACM2 115200
Trong cửa sổ mới này, hãy nhấn vào Quay lại trên bàn phím vài lần để thấy lời nhắc OpenThread CLI >. Hiển thị giao diện IPv6 và kiểm tra các địa chỉ:
> ifconfig up Done > ipaddr fe80:0:0:0:6c1e:87a2:df05:c240 Done
Giờ đây, CLI Joiner CLI nằm trong cùng một thực thể của Màn hình với Ủy viên FTD, bạn có thể chuyển đổi giữa chúng bằng cách nhấn tổ hợp phím Ctrl+a → n.
Sử dụng tổ hợp phím 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ị luồng. Vì vậy, hãy đảm bảo rằng tất cả thiết bị đều đang hoạt động và dễ truy cập. Cho đến nay, chúng ta đã sử dụng Màn hình để 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 công cụ 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 bốn cửa sổ:
- Nhật ký dịch vụ
ot-daemon - RCP Joiner qua
ot-ctl - FTD Commissioner thông qua CLI OpenThread
- FTD Joiner thông qua CLI OpenThread
Nếu bạn muốn sử dụng công cụ hoặc cấu hình thiết bị đầu cuối / cổng nối tiếp của riêng mình, 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ả các thiết bị theo cách phù hợp nhất với bạn.
Sử dụng Màn hình
Để dễ sử dụng, bạn chỉ cần bắt đầu một phiên trên Màn hình. Bạn đã có một tài khoản từ khi thiết lập cả hai FTD.
Tất cả các lệnh trong Màn hình đều bắt đầu bằng Ctrl+a.
Các lệnh màn hình cơ bản:
Đính kèm lại phiên Screen (từ dòng lệnh) |
|
Rời khỏi phiê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 → |
Loại bỏ cửa sổ hiện tại trong phiên Màn hình | Ctrl+a → |
Chia đôi màn hình
Với Màn hình, 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 nên bắt đầu bằng tổ hợp phím truy cập này.
Nếu bạn đang làm theo đúng Lớp học lập trình, bạn phải có hai cửa sổ (FTD Commissioner, FTD Joiner) trên cùng một thực thể Screen. Để chia đôi màn hình giữa hai màn hình, trước tiên, hãy nhập phiên Màn hình hiện có của bạn:
$ screen -r
Bạn phải sử dụng một trong các thiết bị FTD. Hãy làm theo các bước sau trên Màn hình:
- Ctrl+a →
Sđể chia cửa sổ theo chiều ngang - Ctrl+a →
Tabđể di chuyển con trỏ tới 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 cửa sổ đó 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
Giờ đây, bạn có thể nhìn thấy cả hai. Chuyển đổi giữa các phím tắt bằng cách sử dụng Ctrl+a → Tab. Bạn nên đặt lại tên của mỗi 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 thêm 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 bắt đầu 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 rồi thoát khỏi ot-ctl, rồi khởi động lại trong cửa sổ Screen mới (Ctrl+a → c).
Quy trình thiết lập này không bắt buộc và người dùng vẫn có thể sử 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 đôi 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ề phía trước hoặc phía sau | Ctrl+a → |
Đổi tên cửa sổ hiện tại | Ctrl+a → |
Rời khỏi Màn hình 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 qua dòng lệnh.
Để biết thêm thông tin về Màn hình, hãy xem Tài liệu tham khảo nhanh về Màn hình GNU.
7. Tạo Mạng chuỗi
Sau khi bạn đã định cấu hình tất cả cửa sổ dòng lệnh và màn hình, hãy tạo mạng Luồng (Thread) của chúng ta. Trên Uỷ viên FTD, tạo Tập dữ liệu hoạt động mới và cam kết tập dữ liệu đó làm tập dữ liệu hoạt động. Tập dữ liệu hoạt động là cấu hình cho mạng Luồng 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 Khóa mạng 1234c0de7ab51234c0de7ab51234c0de để sử dụng sau.
Xác nhận tập dữ liệu này là 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 hoạt động của giao thức Thread:
> thread start Done
Sau giây lát, hãy kiểm tra trạng thái thiết bị. Người đó phải là trưởng nhóm. Đồng thời tải RLOC16 để tham khảo trong tương lai.
## 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 "codelab" hiện hiển thị khi được quét từ các thiết bị Luồng khác.
Từ ot-ctl trên RCP Joiner:
## 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 "codelab" không xuất hiện trong danh sách, hãy thử quét lại.
8. Thêm người tham gia RCP
Tính năng Ủy quyền luồng không hoạt động trên mạng. Điều này có nghĩa là chúng tôi cần thêm Trình kết hợp RCP vào mạng Luồng mà chúng tôi vừa tạo bằng quy trình ủy quyền ngoài băng tần.
Vào Uỷ viên FTD, chúng tôi đã ghi chú về Khóa mạng, ví dụ: 1234c0de7ab51234c0de7ab51234c0de. Nếu bạn cần tra cứu lại Khóa mạng, hãy chạy lệnh sau trên FTD Commissioner:
## FTD Commissioner ## > dataset networkkey 1234c0de7ab51234c0de7ab51234c0de Done
Tiếp theo, trên RCP Joiner, hãy đặt Khóa mạng đang hoạt động của tập dữ liệu thành Khóa mạng ủy viên FTD:
## RCP Joiner ## ---------------- > dataset networkkey 1234c0de7ab51234c0de7ab51234c0de Done > dataset commit active Done
Kiểm tra tập dữ liệu để đảm bảo tập dữ liệu được đặt chính xác.
## RCP Joiner ## ---------------- > dataset Network Key: 1234c0de7ab51234c0de7ab51234c0de
Hiển thị Thread để RCP Joiner tham gia mạng "codelab". Chờ một vài giây, kiểm tra trạng thái, RLOC16 và địa chỉ IPv6 của nó:
## 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 Mesh-Local (fdc0:de7a:b5c0:0:66bf:99b9:24c0:d55f tại đây), bạn sẽ sử dụng địa chỉ này sau.
Quay lại Uỷ viên FTD, kiểm tra bộ định tuyến và bảng con để xác nhận cả hai thiết bị là một phần của cùng một mạng. Sử dụng RLOC16 để xác định Người tham gia 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ỉ cục bộ lưới của Bộ nối RCP (địa chỉ Lưới cục bộ lấy từ đầu ra ipaddr của Bộ nối RCP) để xác minh 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
Hiện tại, chúng ta có một mạng Thread bao gồm 2 nút, được minh hoạ trong sơ đồ cấu trúc liên kết này:
Sơ đồ cấu trúc liên kết
Khi bạn xử lý phần còn lại của Lớp học lập trình, chúng ta 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 mạng thay đổi. Vai trò của nút được biểu thị như sau:
Bộ định tuyến luôn là ngũ giác và Thiết bị cuối luôn là hình tròn. Các số trên mỗi nút thể hiện ID bộ định tuyến hoặc ID con hiển thị trong đầu ra CLI, tùy 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. Ủy quyền người tham gia FTD
Bây giờ, hãy thêm thiết bị Thread thứ 3 vào mạng "codelab". Lần này, chúng tôi sẽ sử dụng quy trình ủy quyền an toàn hơn trong băng tần và chỉ cho phép Người tham gia FTD tham gia.
Trên FTD Joiner, lấy eui64 để Ủy viên FTD có thể xác định:
## FTD Joiner ## ---------------- > eui64 2f57d222545271f1 Done
Trên Uỷ viên FTD, hãy bắt đầu ủ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 người tham gia, ví dụ: J01NME. Thông tin xác thực chung là một chuỗi dành riêng cho thiết bị gồm tất cả các ký tự chữ và số viết hoa (0-9 và A-Y, không bao gồm I, O, Q và Z cho dễ đọc), với độ dài từ 6 đến 32 ký tự.
## FTD Commissioner ## ---------------------- > commissioner start Done > commissioner joiner add 2f57d222545271f1 J01NME Done
Chuyển sang FTD Joiner. Bắt đầu vai trò liên kết với Thông tin xác thực người tham gia mà bạn vừa thiết lập trên Ủy 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 xác nhận xác thực thành công:
## FTD Joiner ## ---------------- > Join success
Hiển thị Thread để FTD Joiner tham gia mạng "codelab", đồng thời kiểm tra trạng thái và RLOC16 ngay lập tức:
## 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à vì thiết bị này không phải là ứng dụng dẫn đầu, cũng như không có vai trò cụ thể nào của Anycast đòi hỏi 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)
Ngay lập tức chuyển sang FTD Commissioner (Kiểm soát viên FTD) rồi 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 "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
Dựa trên RLOC16, FTD Joiner đã gắn vào mạng như một Thiết bị cuối (con). Cấu trúc liên kết được cập nhật của chúng tôi như sau:
10. Chuỗi đang hoạt động
Thiết bị luồng trong lớp học lập trình này là một loại Thiết bị chạy trên toàn bộ luồng (FTD) cụ thể được gọi là Thiết bị kết thúc đủ điều kiện của bộ định tuyến (REED). Điều này có nghĩa là các phím tắt này có thể hoạt động như một Bộ định tuyến hoặc Thiết bị cuối và có thể tự quảng bá từ Thiết bị cuối với Bộ định tuyến.
Thread có thể hỗ trợ tối đa 32 Router, nhưng cố gắng giữ số lượng Router từ 16 đến 23. Nếu REED đính kèm dưới dạng Thiết bị cuối (con) và số Bộ định tuyến dưới 16, thì sau một khoảng thời gian ngẫu nhiên trong vòng hai phút, Bộ định tuyến này sẽ tự động thăng cấp thành Bộ định tuyến.
Nếu bạn có 2 trẻ trong mạng Thread sau khi thêm FTD Joiner, hãy đợi ít nhất 2 phút, sau đó kiểm tra lại bộ định tuyến và bảng con trong 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) đã tự thăng cấp lên một Router. Lưu ý rằng RLOC16 khác (b800 thay vì 0c02). Đó là vì RLOC16 dựa trên ID bộ định tuyến và ID con của thiết bị. Khi chuyển đổi từ Thiết bị cuối sang Bộ định tuyến, các giá trị mã định tuyến và mã con sẽ thay đổi và 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 FTD Joiner
Bạn có thể kiểm tra 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 Uỷ viên FTD, FTD Joiner sẽ xuất hiện trong bảng con (ID = 3). Nó thậm chí có thể ở cả hai trong khi chuyển tiếp:
## 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, thiết bị này sẽ chuyển về Bộ định tuyến có RLOC của b800.
Xóa người lãnh đạo
Người lãnh đạo tự bầu chọn trong số tất cả các Bộ định tuyến luồng. Điều này có nghĩa là nếu Thủ lĩnh hiện tại bị xóa khỏi mạng Chủ đề, một trong các Bộ định tuyến khác sẽ trở thành Thủ lĩnh mới.
Trên FTD Commissioner, tắt Thread để xoá Thread 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 người dẫn dắt Chuỗi mới. Kiểm tra trạng thái và địa chỉ IPv6 của FTD Joiner để 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 ý có RLOC16 mới. Đây là Bộ kết hợp RCP, như được biểu thị bằng mã nhận dạng và MAC mở rộng của họ. Để duy trì mạng Thread cùng nhau, thiết bị đã chuyển Bộ định tuyến mẹ, từ Ủy viên FTD sang Người kết hợp FTD. Điều này dẫn đến RLOC16 mới cho RCP Joiner (vì ID bộ định tuyến của nó đã 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 để Người tham gia RCP đính kèm vào Người tham gia FTD với tư cách là trẻ. 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 Ủy viên FTD
Mạng Thread với hai nút không thú vị lắm. Hãy đưa FTD Commissioner trở lại trực tuyến.
Trên Uỷ viên FTD, khởi động lại chuỗi cuộc trò chuyện:
## FTD Commissioner ## ---------------------- > ifconfig up Done > thread start Done
Trong vòng hai phút, thiết bị sẽ tự động gắn lại vào mạng "codelab" dưới dạng Thiết bị cuối và sau đó tự quảng bá tới Bộ định tuyến.
## FTD Commissioner ## ---------------------- > state router Done
Kiểm tra bộ định tuyến và bảng con trên FTD Joiner để 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 tôi bao gồm 3 nút một lần nữa.
11. Khắc phục sự cố
Công việc quản lý Mạng luồng có nhiều thiết bị trên nhiều thiết bị đầu cuối hoặc Cửa sổ màn hình có thể phức tạp. Sử dụng những mẹo này để "đặt lại" trạng thái mạng hoặc không gian làm việc của bạn nếu bạn gặp sự cố.
Màn hình
Nếu bạn từng bị mất cấu hình (quá nhiều cửa sổ Màn hình hoặc Màn hình trong Màn hình), hãy tiếp tục tắt cửa sổ Màn hình bằng Ctrl+a → k cho đến khi không có cửa sổ nào tồn tại và screen -ls trên dòng lệnh xuất ra No Sockets found. Sau đó, hãy tạo lại cửa sổ Màn hình cho từng thiết bị. Trạng thái thiết bị được giữ lại ngay cả khi Màn hình bị tắt.
Nút luồng
Nếu cấu trúc liên kết mạng Thread không giố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ể do máy Linux cung cấp năng lượng cho chế độ ngủ), tốt nhất là hạ cấp Thread, xoá thông tin đăng nhập mạng rồi bắt đầu lại từ bước Create Thread network (Tạo mạng luồng).
Để đặ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ự qua ot-ctl:
## RCP Joiner ## ---------------- > thread stop Done > ifconfig down Done > factoryreset Done
12. Sử dụng phát đa hướng
Phát đa hướng được dùng để truyền thông tin đến một nhóm thiết bị cùng lúc. Trong mạng Thread, các địa chỉ cụ thể được dành để sử dụng phát đa hướng 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 | Đã gửi tới |
| Liên kết-Địa phương | Tất cả FTD và MED |
| Liên kết-Địa phương | Tất cả các FTD và bộ định tuyến biên |
| Lưới địa phương | Tất cả FTD và MED |
| Lưới địa phương | Tất cả các FTD và bộ định tuyến biên |
Vì chúng ta không sử dụng Bộ định tuyến biên (Border Router) trong Lớp học lập trình này, nên hãy tập trung vào 2 địa chỉ phát đa hướng FTD và MED.
Liên kết-Địa phương
Phạm vi Link-Local bao gồm tất cả giao diện Luồng có thể truy cập được bằng một đường truyền radio hoặc một "bước". Cấu trúc liên kết mạng cho biết thiết bị nào phản hồi lệnh ping tới địa chỉ phát đ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 Ủy 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à FTD Joiner là thiết bị duy nhất mà Uỷ viên FTD có thể tiếp cận chỉ bằng một bước nhảy.
Hiện đang ping ff02::1 từ 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
Hai câu trả lời! Kiểm tra địa chỉ IPv6 cho 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 Ủy viên FTD và địa chỉ thứ hai (kết thúc bằng 943b) là LLA của người tham gia RCP.
Điều này có nghĩa là Người tham gia FTD được kết nối trực tiếp với cả Ủy viên FTD và Người tham gia RCP, điều này xác nhận cấu trúc liên kết của chúng tôi.
Lưới địa phương
Phạm vi Mesh-Local bao gồm tất cả các giao diện Luồng (Thread) có thể truy cập được trong cùng một mạng Luồng (Thread). Hãy xem các phản hồi cho lệnh ping tới địa chỉ phát đa hướng 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, Ủy viên FTD đã nhận được hai phản hồi, một từ Bộ định tuyến định tuyến của người liên kết FTD (RLOC, kết thúc bằng b800) và một từ EID cục bộ lưới của bộ nối RCP (ML-EID, kết thúc bằng d55f). Đó là vì phạm vi cục bộ lưới bao gồm toàn bộ mạng Chủ đề. Thiết bị sẽ được đăng ký theo địa chỉ ff03::1 cho dù thiết bị đó đang ở đâu trong mạng.
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 Bộ ghép nối RCP trong cả hai đầu ra ping. RCP Joiner mất nhiều thời gian hơn để tiếp cận Ủy viên FTD (68ms) so với để tiếp cận FTD Joiner (23ms). Đó là bởi vì nó phải thực hiện hai bước để tiếp cận Ủy viên FTD, so với một bước đối với FTD Joiner.
Bạn cũng có thể nhận thấy rằng lệnh ping đa hướng cục bộ dạng lưới chỉ phản hồi với RLOC cho hai FTD chứ không phải là RCP Joiner. Lý do là FTD là các Bộ định tuyến trong mạng, trong khi RCP là Thiết bị cuối.
Kiểm tra trạng thái của RCP Joiner để xác nhận:
## RCP Joiner ## ---------------- > state child
13. Gửi tin nhắn bằng UDP
Một trong những dịch vụ ứng dụng mà OpenThread cung cấp là Giao thức biểu đồ dữ liệu người dùng (UDP), một giao thức Lớp truyền tải. Một ứ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 tới các thiết bị khác trong mạng bên ngoài (như Internet, nếu mạng Thread có bộ định tuyến biên).
Các cổng UDP được hiển thị thông qua CLI OpenThread. Hãy sử dụng hàm này để chuyển thông báo giữa 2 FTD.
Nhận địa chỉ EID cục bộ Mesh cho FTD Joiner. Chúng tôi đang sử dụng địa chỉ này vì địa chỉ này có thể liên lạc được từ bất kỳ đâu trong mạng Chuỗi.
## 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 UDP với ổ cắm cho bất kỳ địa chỉ IPv6 nào:
## FTD Joiner ## ---------------- > udp open Done > udp bind :: 1212
Chuyển sang FTD Commissioner, khởi động UDP và kết nối với ổ cắm bạn đã thiết lập trên FTD Joiner bằng ML-EID:
## 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 tin nhắn từ Ủy viên FTD:
## FTD Commissioner ## ---------------------- > udp send hellothere Done
Trên FTD Joiner, đã nhận được thông báo UDP!
## 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:
- điểm khác biệt giữa loại thiết bị Thread, vai trò và phạm vi
- cách thiết bị Luồng quản lý trạng thái của chúng trong mạng
- cách chuyể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:
- Đổ lại bảng FTD Joiner với tư cách MTD sử dụng tệp nhị phân
ot-cli-mtdvà quan sát thấy rằng bảng 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ưởng nhóm - Thêm nhiều thiết bị hơn (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ộ định tuyến và bảng con, cùng với ping tới các địa chỉ phát đa hướng
- Sử dụng pyspinel để điều khiển NCP
- Chuyển đổi NCP thành Bộ định tuyến biên bằng cách sử dụng Bộ định tuyến đường viền OpenThread và kết nối mạng Thread của bạn 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ả các nền tảng hỗ trợ OpenThread
- Tạo OpenThread – chi tiết hơn về cách tạo và định cấu hình OpenThread
- Luồng Primer – bao gồm tất cả các khái niệm về Thread được nêu trong Lớp học lập trình này
Tham khảo: