Jetson ROS2 组件调试

记录在 Jetson Orin Nano Super 开发板的机器人组件环境配置测试、学习资料。

开源项目资料

刷机

官方板使用的是 SD card。

命令如下：

1
2
3
4
# 解压下载的镜像
cd jp62-orin-nano-sd-card-image/
dmesg | tail | awk '$3 == "sd" {print}'
sudo /bin/dd if=sd-blob.img of=/dev/sdc bs=1M status=progress

安装 jtop

1
2
3
4
sudo apt-get install python3-pip -y
sudo pip3 install -U jetson-stats
sudo systemctl restart jtop.service
jtop

目标识别组件

参考: YOLO环境搭建

  • 遇到网络问题就在主机上下载好传到设备上手动下载。Github无法链接就下载zip包。
  • 注意 torch 一定要支持 cuda
  • 注意安装 GStreamer 和重新安装 OpenCV 需要的时间较久，可以提前下载好 opencv 4.10 的包

测试 yolo11

参考：Yolo CLI使用

1
2
3
4
5
cd ~/software/ultralytics/ultralytics/
yolo predict model=yolo11n source='/home/sjl/software/ultralytics/ultralytics/assets'

# 重启一下机器加载 USB Camera 驱动
yolo predict model=yolo11n.pt source=0 save=False show

使用 tensorRT 加速

安装 onnxslim：

1
sudo pip3 install onnxslim -i https://mirrors.aliyun.com/pypi/simple/

代码：

  • 可以保存 tensorrt 模型，使用 int8 量化
    • 第一运行会下载coco数据集并进行校准，时间较长
  • 修改了相机输入的格式，以满足 30 fps
  • 画面可以缩放
  • 左上角显示帧数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
import cv2
import time
import os
from ultralytics import YOLO

# Paths
onnx_model_path = "/home/sjl/software/ultralytics/ultralytics/yolo11n.pt"
engine_model_path = "yolo11n.engine"
output_path = "/home/sjl/software/ultralytics/ultralytics/output/01.detection_camera_usb.mp4"

# Load or export TensorRT engine
if os.path.exists(engine_model_path):
    print("Loading existing TensorRT engine...")
    model = YOLO(engine_model_path)
else:
    print("Exporting TensorRT engine from ONNX...")
    initial_model = YOLO(onnx_model_path)
    initial_model.export(format="engine", int8=True)  # optimize=True可以加速推理
    model = YOLO(engine_model_path)

# Open the camera
cap = cv2.VideoCapture(0)

# 设置采集格式为MJPG压缩格式，才能拿到30fps
cap.set(cv2.CAP_PROP_FOURCC, cv2.VideoWriter_fourcc(*"MJPG"))

# Set initial camera resolution (optional)
cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)

# （可选）设置帧率30
cap.set(cv2.CAP_PROP_FPS, 30)

# Get frame size and fps
frame_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
frame_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
fps = cap.get(cv2.CAP_PROP_FPS)
if fps == 0:  # 有些摄像头返回fps=0，这时手动设一个默认值
    fps = 30

# Create output video writer
fourcc = cv2.VideoWriter_fourcc(*'mp4v')
print("frame_width = {}, frame_height = {}".format(frame_width, frame_height))
out = cv2.VideoWriter(output_path, fourcc, fps, (640, 480))

# Create named window that is resizable
cv2.namedWindow("YOLO Inference", cv2.WINDOW_NORMAL)

# Variables for FPS calculation
prev_time = time.time()

# Loop through frames
while cap.isOpened():
    success, frame = cap.read()
    # frame = cv2.resize(frame, (160, 96))
    if not success:
        break

    results = model(frame)

    # Draw detections
    annotated_frame = results[0].plot()

    # Calculate FPS
    current_time = time.time()
    fps_display = 1 / (current_time - prev_time)
    prev_time = current_time

    # Draw FPS on the frame
    fps_text = f"FPS: {fps_display:.2f}"
    cv2.putText(annotated_frame, fps_text, (10, 30), 
                cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)

    # Write and show
    out.write(annotated_frame)
    cv2.imshow("YOLO Inference", annotated_frame)

    # Press 'q' to exit
    if cv2.waitKey(1) & 0xFF == ord("q"):
        break

# Cleanup
cap.release()
out.release()
cv2.destroyAllWindows()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# 查看格式
sjl@sjl-desktop:~$ v4l2-ctl --list-formats-ext -d /dev/video0
ioctl: VIDIOC_ENUM_FMT
        Type: Video Capture

        [0]: 'MJPG' (Motion-JPEG, compressed)
                Size: Discrete 1920x1080
                        Interval: Discrete 0.033s (30.000 fps)
                Size: Discrete 1280x720
                        Interval: Discrete 0.033s (30.000 fps)
                Size: Discrete 640x480
                        Interval: Discrete 0.033s (30.000 fps)
        [1]: 'YUYV' (YUYV 4:2:2)
                Size: Discrete 1920x1080
                        Interval: Discrete 0.200s (5.000 fps)
                Size: Discrete 1280x720
                        Interval: Discrete 0.100s (10.000 fps)
                Size: Discrete 640x480
                        Interval: Discrete 0.033s (30.000 fps)

sudo python3 test_usb_camera_opt.py

ROS2

参考：ROS 2 安装指南

注意这一步：

1
2
sudo curl -sSL https://raw.githubusercontent.com/ros/rosdistro/master/ros.key -o \
     /usr/share/keyrings/ros-archive-keyring.gpg

如果网络不好，就下载 ros.key 传进设备。然后

1
sudo mv ros.key /usr/share/keyrings/ros-archive-keyring.gpg

上面安装 GStreamer 和重新安装 OpenCV会卸载ros2的一些组件，因此后安装ros2

参考：小鱼的一键安装系列

注意是在 bash 下运行：

1
wget http://fishros.com/install -O fishros && . fishros

可以在安装 ROS2 的时候让它自动帮我们选择速度最快的源。然后安装 Humble(Ubuntu 22.04)。安装完成后：

1
2
3
source /opt/ros/humble/setup.bash

which ros2

ros2 bookcode:

拓展资料：

Gazebo

Gazebo是一个机器人仿真环境。因为 gazebo 官方源没有包含 arm64 版本，所以需要手动添加源并安装：

1
2
3
4
5
sudo add-apt-repository ppa:openrobotics/gazebo11-non-amd64
sudo apt install gazebo
sudo apt install ros-humble-gazebo-*

gazebo

Moveit2

MoveIt2 是基于 ROS2 的机器人操作平台，其集成了运动规划，操作，3D感知，运动学，控制和导航方面的最新技术与一体。

环境配置参考：

源教程有一些适配的错误，以下是在 Jetson Orin Nano Super 上验证步骤。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# 需要下载 humble 分支，不然不兼容
git clone -b humble git@github.com:moveit/moveit2.git ~/moveit2_ws/src/moveit2

# 安装依赖
cd ~/moveit2_ws
rosdepc update
rosdepc install --from-path src --ignore-src -r -y


# 直接编译会炸，需要增大 swap
sudo fallocate -l 16G /swapfile                                                                  
sudo chmod 600 /swapfile                                                                         
sudo mkswap /swapfile                                                                            
sudo swapon /swapfile                                                                            
free -h

# 编译
colcon build --cmake-args -DCMAKE_BUILD_TYPE=Release

# 查看资源
jtop

测试demo

1
2
3
cd moveit2_ws/
source install/setup.zsh
ros2 launch moveit_resources_panda_moveit_config demo.launch.py

测试 dummy2

1
2
3
4
5
6
git clone https://gitee.com/switchpi/dummy2.git
cd dummy2/ros2/dummy2_ws

# 不要装依赖，会和已经编译的 moveit2 的包冲突
# rosdep install --from-path src --ignore-src -r -y -i --rosdistro ${ROS_DISTRO}
sudo apt-get install ros-humble-ros2-controllers ros-humble-warehouse-ros ros-humble-moveit-ros-warehouse

这里有个包安装不了，参考：

主要的问题是，ros-humble-warehouse-ros-mongo 未在 jammy ubuntu 22.04 humble 上发行。为了编译通过，先将相关的库安装上。注意实测运行时，mongoDB 仍然不可用，因为缺少依赖。

1
colcon build --cmake-args -DCMAKE_BUILD_TYPE=Release

这里有个库 dummy2_hw 依赖其他库，为了编译顺利通过，可以把 src/dummy2_hw 先移动到其他目录，将其余的 package 编译并安装，然后再复原 dummy2_hw，重新编译：

1
2
3
4
5
6
mv src/dummy2_hw ..
colcon build --cmake-args -DCMAKE_BUILD_TYPE=Release
. install/setup.zsh

mv ../dummy2_hw src/
colcon build --cmake-args -DCMAKE_BUILD_TYPE=Release

测试：

1
2
3
4
5
# 显示模型
ros2 launch dummy2-gripperv2_description display.launch.py

# 规划
ros2 launch dummy2-gripperv2_moveit_config demo.launch.py

深度相机

1
2
3
4
cd script
sudo chmod +x install_udev_rules.sh
sudo ./install_udev_rules.sh
sudo udevadm control --reload-rules && sudo udevadm trigger
1
2
# 打开窗口，如果初始化失败，重启一下系统
./OrbbecViewer

1
2
3
ros2 launch orbbec_camera gemini_330_series.launch.py

rviz2

添加 topic：

显示深度：

附 mac 安装 ros2 jazzy

安装虚拟机

购买 UTM 软件，参考 MAC M2安装ubuntu虚拟机.

注意：

  • 安装完系统后，在 UTM 虚拟机 CD/DVD 中弹出 iso。
  • 安装 desktop 会设置 snapd，一个非常垃圾的软件包，如果hang住多重启几次。
  • 虚拟机扩容参考：MAC-VM虚拟机Ubuntu硬盘容量扩充
  • 如果df查看没有成功扩容，参考如下方法

从你提供的信息来看，/dev/mapper/ubuntu--vg-ubuntu--lv 是一个逻辑卷（LV），而你提到的分区 /dev/vda3 有 54.9GB 的 Linux 文件系统，应该有足够的空间来扩展 ubuntu--vg-ubuntu--lv。

然而，虽然物理磁盘有空间，但逻辑卷没有自动扩展，可能是因为你还没有在逻辑卷上执行扩展操作。具体来说，需要完成以下几个步骤：

  1. 扩展物理卷（PV）：
    首先，确保物理卷已经扩展到 /dev/vda3 中的新空间。如果没有扩展，可以使用以下命令来扩展物理卷：
1
sudo pvresize /dev/vda3
  1. 扩展卷组（VG）：
    确保卷组 ubuntu-vg 已经包含了新的空间。你可以通过以下命令检查卷组的大小：
1
sudo vgdisplay ubuntu-vg

如果卷组已经包含新的空间，你就可以直接扩展逻辑卷了。

  1. 扩展逻辑卷（LV）：
    接下来，使用 lvextend 扩展逻辑卷 ubuntu--lv：
1
sudo lvextend -l +100%FREE /dev/ubuntu-vg/ubuntu-lv

这将把所有可用的空间分配给该逻辑卷。如果你只想使用部分空间，可以调整 +100%FREE 为适当的大小。

  1. 扩展文件系统：
    扩展逻辑卷之后，需要扩展文件系统才能使用新的空间。对于 ext4 文件系统，你可以使用：
1
sudo resize2fs /dev/ubuntu-vg/ubuntu-lv

对于 xfs 文件系统，使用：

1
sudo xfs_growfs /dev/ubuntu-vg/ubuntu-lv

总结：

  • 扩展物理卷（pvresize）。
  • 扩展卷组（vgextend）。
  • 扩展逻辑卷（lvextend）。
  • 扩展文件系统（resize2fs 或 xfs_growfs）。

完成这些步骤后，应该就能看到你在 df -h 命令输出中获得的更多可用空间了。

安装 ros2

参考 fishros

安装 gazebo

这里我们从源码编译安装，因为 arm64 的二进制安装只支持到 ubuntu 22.04。参考

安装完成后，运行

1
gz sim

安装 moveit2

参考官方最新版本：Create A Colcon Workspace and Download Tutorials

注意，编译时会报错这样的问题：aarch64 is not supported解决办法如下，因为它官方不支持x86-64，我们进入这个仓库下，将 cmake 的检查注释掉，并且导入arch64版本的库：https://artifactory.kinovaapps.com:443/artifactory/generic-public/kortex/API/2.6.0/linux_aarch64_gcc_7.4.zip。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
diff --git a/kortex_api/CMakeLists.txt b/kortex_api/CMakeLists.txt
index ddf42b7..a99a25f 100644
--- a/kortex_api/CMakeLists.txt
+++ b/kortex_api/CMakeLists.txt
@@ -1,13 +1,15 @@
 cmake_minimum_required(VERSION 3.14)
 include(FetchContent)
 #include(ExternalProject)
-FetchContent_Declare(
-  kinova_binary_api
-  URL https://artifactory.kinovaapps.com:443/artifactory/generic-public/kortex/API/2.5.0/linux_x86-64_x86_gcc.zip
-  URL_HASH MD5=64bd86e7ab8bda90ef1fc7d6a356e080
-)
+# FetchContent_Declare(
+#   kinova_binary_api
+#   URL https://artifactory.kinovaapps.com:443/artifactory/generic-public/kortex/API/2.5.0/linux_x86-64_x86_gcc.zip
+#   URL_HASH MD5=64bd86e7ab8bda90ef1fc7d6a356e080
+# )
 
-FetchContent_MakeAvailable(kinova_binary_api)
+# FetchContent_MakeAvailable(kinova_binary_api)
+
+set(KINOVA_BINARY_API_DIR "/home/sjl/workspace/src/ros2_kortex/linux_aarch64")
 
 project(kortex_api)
 
@@ -19,12 +21,12 @@ project(kortex_api)
 # string(TOLOWER ${CMAKE_SYSTEM_NAME} URL_OS) # Linux -> linux
 
 #Current: only support Linux x86_64
-if(CMAKE_SYSTEM_NAME STREQUAL "Linux" AND CMAKE_SYSTEM_PROCESSOR STREQUAL "x86_64")
-  set(API_URL https://artifactory.kinovaapps.com:443/artifactory/generic-public/kortex/API/2.5.0/linux_x86-64_x86_gcc.zip)
-else()
-  set(API_URL "")
-  message(FATAL_ERROR "Unsupported System: currently support is for Linux x68_64. Detected ${CMAKE_SYSTEM_NAME} and ${CMAKE_SYSTEM_PROCESSOR}")
-endif()
+# if(CMAKE_SYSTEM_NAME STREQUAL "Linux" AND CMAKE_SYSTEM_PROCESSOR STREQUAL "x86_64")
+#   set(API_URL https://artifactory.kinovaapps.com:443/artifactory/generic-public/kortex/API/2.5.0/linux_x86-64_x86_gcc.zip)
+# else()
+#   set(API_URL "")
+#   message(FATAL_ERROR "Unsupported System: currently support is for Linux x68_64. Detected ${CMAKE_SYSTEM_NAME} and ${CMAKE_SYSTEM_PROCESSOR}")
+# endif()
 
 #ExternalProject_Add(kinova_binary_api
 #  URL ${API_URL}
@@ -37,10 +39,10 @@ find_package(ament_cmake REQUIRED)
 
 ament_export_include_directories(include/kortex_api)
 
-install(DIRECTORY ${kinova_binary_api_SOURCE_DIR}/include/client/ DESTINATION include/kortex_api)
-install(DIRECTORY ${kinova_binary_api_SOURCE_DIR}/include/common/ DESTINATION include/kortex_api)
-install(DIRECTORY ${kinova_binary_api_SOURCE_DIR}/include/messages/ DESTINATION include/kortex_api)
-install(DIRECTORY ${kinova_binary_api_SOURCE_DIR}/include/client_stubs/ DESTINATION include/kortex_api)
-install(DIRECTORY ${kinova_binary_api_SOURCE_DIR}/include/google/protobuf DESTINATION include/kortex_api/google)
+install(DIRECTORY ${KINOVA_BINARY_API_DIR}/include/client/ DESTINATION include/kortex_api)
+install(DIRECTORY ${KINOVA_BINARY_API_DIR}/include/common/ DESTINATION include/kortex_api)
+install(DIRECTORY ${KINOVA_BINARY_API_DIR}/include/messages/ DESTINATION include/kortex_api)
+install(DIRECTORY ${KINOVA_BINARY_API_DIR}/include/client_stubs/ DESTINATION include/kortex_api)
+install(DIRECTORY ${KINOVA_BINARY_API_DIR}/include/google/protobuf DESTINATION include/kortex_api/google)
 
 ament_package()
diff --git a/kortex_driver/CMakeLists.txt b/kortex_driver/CMakeLists.txt
index 6e47d72..3b88281 100644
--- a/kortex_driver/CMakeLists.txt
+++ b/kortex_driver/CMakeLists.txt
@@ -1,11 +1,13 @@
 cmake_minimum_required(VERSION 3.14)
 include(FetchContent)
-FetchContent_Declare(
-  kinova_binary_api
-  URL https://artifactory.kinovaapps.com:443/artifactory/generic-public/kortex/API/2.5.0/linux_x86-64_x86_gcc.zip
-  URL_HASH MD5=64bd86e7ab8bda90ef1fc7d6a356e080
-)
-FetchContent_MakeAvailable(kinova_binary_api)
+# FetchContent_Declare(
+#   kinova_binary_api
+#   URL https://artifactory.kinovaapps.com:443/artifactory/generic-public/kortex/API/2.5.0/linux_x86-64_x86_gcc.zip
+#   URL_HASH MD5=64bd86e7ab8bda90ef1fc7d6a356e080
+# )
+# FetchContent_MakeAvailable(kinova_binary_api)
+
+set(KINOVA_BINARY_API_DIR "/home/sjl/workspace/src/ros2_kortex/linux_aarch64")
 
 project(kortex_driver)
 
@@ -29,20 +31,20 @@ find_package(rclcpp REQUIRED)
 find_package(kortex_api REQUIRED)
 
 #Current: only support Linux x86_64
-if(CMAKE_SYSTEM_NAME STREQUAL "Linux" AND CMAKE_SYSTEM_PROCESSOR STREQUAL "x86_64")
-  set(API_URL https://artifactory.kinovaapps.com:443/artifactory/generic-public/kortex/API/2.5.0/linux_x86-64_x86_gcc.zip)
-else()
-  # TODO(future) to support ARM or other builds logic could go here to fetch the precompiled libKortexApiCpp.a
-  # see notes in kortex_api CMakeList.txt
-  message(WARNING "Detected ${CMAKE_SYSTEM_NAME} and ${CMAKE_SYSTEM_PROCESSOR}")
-  message(FATAL_ERROR "Unsupported System: currently support is for Linux x68_64.")
-endif()
+# if(CMAKE_SYSTEM_NAME STREQUAL "Linux" AND CMAKE_SYSTEM_PROCESSOR STREQUAL "x86_64")
+#   set(API_URL https://artifactory.kinovaapps.com:443/artifactory/generic-public/kortex/API/2.5.0/linux_x86-64_x86_gcc.zip)
+# else()
+#   # TODO(future) to support ARM or other builds logic could go here to fetch the precompiled libKortexApiCpp.a
+#   # see notes in kortex_api CMakeList.txt
+#   message(WARNING "Detected ${CMAKE_SYSTEM_NAME} and ${CMAKE_SYSTEM_PROCESSOR}")
+#   message(FATAL_ERROR "Unsupported System: currently support is for Linux x68_64.")
+# endif()
 
 # CMake does not allow IMPORTED libraries to be installed
 # The package kortex_api will download and setup the include directories
 add_library(KortexApiCpp STATIC IMPORTED)
 set_target_properties(KortexApiCpp PROPERTIES
-  IMPORTED_LOCATION ${kinova_binary_api_SOURCE_DIR}/lib/release/libKortexApiCpp.a
+  IMPORTED_LOCATION ${KINOVA_BINARY_API_DIR}/lib/release/libKortexApiCpp.a
   INTERFACE_LINK_LIBRARIES KortexApiCpp
 )
 target_link_libraries(KortexApiCpp INTERFACE pthread)

编译成功后，运行：

1
ros2 launch moveit2_tutorials demo.launch.py

Mac 虚拟机运行 moveit 超级卡，需要更多的核心，更大的内存。

WSL ubuntu24.04 安装 ros2 jazzy

大体流程和上述 mac 安装相同，在使用升读相机时，需要注意在 powershell 中将相机 bind 到 wsl2 上。

WSL ubuntu22.04 安装 ros2 humble

测试 dummy2:

不要直接 rosdep 安装依赖，主要缺以下依赖：

1
2
3
sudo apt-get install ros-humble-ros2-controllers ros-humble-warehouse-ros ros-humble-moveit-ros-warehouse
# ...
ros2 launch dummy2-gripperv2_moveit_config demo.launch.py