ROS1 ROS2 包结构及构建方法

文章目录

• ROS1 ROS2 包结构及构建方法
• • 一、ROS 1（Noetic/Melodic等）
  • • 1. 纯Python包（示例包名：`ros1_py_pkg`）
    • • （1）文件放置位置
      • （2）构建步骤
      • （3）编译方法
      • （4）source指令
    • 2. 纯C++包（示例包名：`ros1_cpp_pkg`）
    • • （1）文件放置位置
      • （2）构建步骤
      • （3）编译方法
      • （4）source指令
    • 3. C++与Python混合包（示例包名：`ros1_mixed_pkg`）
    • • （1）文件放置位置
      • （2）构建步骤
      • （3）编译方法
      • （4）source指令
  • 二、ROS 2（Humble/Iron等）
  • • 1. 纯Python包（示例包名：`ros2_py_pkg`）
    • • （1）文件放置位置
      • （2）构建步骤
      • （3）编译方法
      • （4）source指令
    • 2. 纯C++包（示例包名：`ros2_cpp_pkg`）
    • • （1）文件放置位置
      • （2）构建步骤
      • （3）编译方法
      • （4）source指令
    • 3. C++与Python混合包（示例包名：`ros2_mixed_pkg`）
    • • （1）文件放置位置
      • （2）构建步骤
      • （3）编译方法
      • （4）source指令
  • 三、核心差异与总结
  • • 1. 关键差异对照表
    • 2. 核心要点回顾

ROS1 ROS2 包结构及构建方法

一、ROS 1（Noetic/Melodic等）

ROS 1的构建工具为catkin_make/catkin build，工作空间核心目录为src/（源码）、devel/（编译产物）、build/（编译中间文件），所有包均放在src/目录下。

1. 纯Python包（示例包名：ros1_py_pkg）

（1）文件放置位置

# 工作空间整体结构 ros1_ws/ ├── build/ # 编译中间文件（自动生成） ├── devel/ # 编译产物（自动生成） └── src/ # 源码目录 └── ros1_py_pkg/ # 纯Python包根目录 ├── CMakeLists.txt # Python包极简配置 ├── package.xml # 包信息与依赖声明 └── scripts/ # Python脚本存放目录（核心） ├── py_node_1.py # Python节点1（可直接执行） └── py_node_2.py # Python节点2

• 关键：Python脚本直接放在scripts/目录，无需创建与包名同名的模块目录，也无需setup.py。

（2）构建步骤

1. 创建工作空间与src目录：

   mkdir-p ~/ros1_ws/srccd~/ros1_ws/src

2. 创建纯Python包（指定依赖rospy）：

   catkin_create_pkg ros1_py_pkg rospy std_msgs# rospy是Python核心依赖

3. 在ros1_py_pkg/scripts/目录下编写Python节点（如py_node_1.py），并添加可执行权限：

   chmod+x ~/ros1_ws/src/ros1_py_pkg/scripts/py_node_1.py

4. 配置CMakeLists.txt（默认已生成核心配置，无需额外修改，确保包含以下内容）：

   cmake_minimum_required(VERSION 3.0.2) project(ros1_py_pkg) find_package(catkin REQUIRED COMPONENTS rospy std_msgs) catkin_python_setup() # 启用Python支持（关键） catkin_package() include_directories(${catkin_INCLUDE_DIRS}) # 无需手动配置节点，直接通过scripts目录识别

5. 配置package.xml（默认已声明依赖，确保包含以下内容）：

   <build_depend>rospy</build_depend><exec_depend>rospy</exec_depend><exec_depend>std_msgs</exec_depend>

（3）编译方法

在工作空间根目录执行（二选一，catkin build需提前安装catkin_tools）：

cd~/ros1_ws# 方法1：默认编译所有包catkin_make# 方法2：仅编译指定Python包（更高效）catkin_make --cmake-args -DCATKIN_WHITELIST_PACKAGES="ros1_py_pkg"# 方法3：使用catkin build（推荐，支持并行编译）catkin build ros1_py_pkg

（4）source指令

编译后必须source才能识别包，指令固定（工作空间根目录执行）：

# 临时source（当前终端有效）sourcedevel/setup.bash# 永久source（所有终端生效，需重启终端）echo"source ~/ros1_ws/devel/setup.bash">>~/.bashrc

2. 纯C++包（示例包名：ros1_cpp_pkg）

（1）文件放置位置

ros1_ws/ ├── build/ ├── devel/ └── src/ └── ros1_cpp_pkg/ # 纯C++包根目录 ├── CMakeLists.txt # C++编译核心配置 ├── package.xml # 依赖声明 ├── include/ # 头文件目录（核心） │ └── ros1_cpp_pkg/ # 与包名同名，存放.h/.hpp │ └── cpp_node_1.hpp └── src/ # C++源文件目录（核心） └── cpp_node_1.cpp # C++节点源文件

• 关键：头文件放include/<包名>/，源文件放src/，需通过CMakeLists.txt配置编译规则。

（2）构建步骤

1. 进入工作空间src目录：

   cd~/ros1_ws/src

2. 创建纯C++包（指定依赖roscpp）：

   catkin_create_pkg ros1_cpp_pkg roscpp std_msgs# roscpp是C++核心依赖

3. 在include/ros1_cpp_pkg/编写头文件（如cpp_node_1.hpp），在src/编写源文件（如cpp_node_1.cpp）。
4. 配置CMakeLists.txt（核心编译配置，补充以下内容）：

   cmake_minimum_required(VERSION 3.0.2) project(ros1_cpp_pkg) find_package(catkin REQUIRED COMPONENTS roscpp std_msgs) # 声明头文件路径 include_directories( include ${catkin_INCLUDE_DIRS} ) # 编译C++节点可执行文件 add_executable(cpp_node_1 src/cpp_node_1.cpp) # 链接依赖库 target_link_libraries(cpp_node_1 ${catkin_LIBRARIES}) # 安装可执行文件到devel目录 install(TARGETS cpp_node_1 RUNTIME DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION} ) catkin_package()

（3）编译方法

与纯Python包一致，工作空间根目录执行：

cd~/ros1_ws catkin_make# 或 catkin build ros1_cpp_pkg

（4）source指令

与纯Python包一致：

sourcedevel/setup.bash# 临时# 或永久添加到.bashrc

3. C++与Python混合包（示例包名：ros1_mixed_pkg）

（1）文件放置位置

ros1_ws/ ├── build/ ├── devel/ └── src/ └── ros1_mixed_pkg/ # 混合包根目录 ├── CMakeLists.txt # 同时配置C++和Python ├── package.xml # 声明roscpp和rospy依赖 ├── include/ # C++头文件目录 │ └── ros1_mixed_pkg/ │ └── cpp_node.hpp ├── src/ # C++源文件目录 │ └── cpp_node.cpp └── scripts/ # Python脚本目录 └── py_node.py

• 关键：整合纯C++和纯Python包的目录结构，配置文件同时支持两种语言。

（2）构建步骤

1. 进入src目录创建混合包（同时声明roscpp和rospy依赖）：

   cd~/ros1_ws/src catkin_create_pkg ros1_mixed_pkg roscpp rospy std_msgs

2. 分别在include/、src/放置C++代码，在scripts/放置Python代码，并给Python脚本添加可执行权限。
3. 配置CMakeLists.txt（整合C++编译配置和Python支持）：

   cmake_minimum_required(VERSION 3.0.2) project(ros1_mixed_pkg) find_package(catkin REQUIRED COMPONENTS roscpp rospy std_msgs) # Python支持（关键） catkin_python_setup() # C++头文件路径 include_directories( include ${catkin_INCLUDE_DIRS} ) # C++节点编译 add_executable(cpp_node src/cpp_node.cpp) target_link_libraries(cpp_node ${catkin_LIBRARIES}) install(TARGETS cpp_node RUNTIME DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION} ) catkin_package()

4. 配置package.xml（默认已声明两种依赖，无需额外修改）。

（3）编译方法

工作空间根目录执行，自动编译两种语言代码：

cd~/ros1_ws catkin_make# 或 catkin build ros1_mixed_pkg

（4）source指令

与纯包一致：

sourcedevel/setup.bash

---

二、ROS 2（Humble/Iron等）

ROS 2的构建工具为colcon build，工作空间核心目录为src/（源码）、install/（编译产物）、build/（中间文件）、log/（日志），所有包放在src/目录下。

1. 纯Python包（示例包名：ros2_py_pkg）

（1）文件放置位置

ros2_ws/ ├── build/ ├── install/ # 编译产物（自动生成） ├── log/ └── src/ └── ros2_py_pkg/ # 纯Python包根目录 ├── package.xml # 包信息与依赖 ├── setup.py # Python安装配置（核心） ├── setup.cfg # Python路径配置（固定） └── ros2_py_pkg/ # 与包名同名的Python模块目录（核心） ├── __init__.py # 标记Python模块（可空） ├── py_node_1.py # Python节点1 └── py_node_2.py # Python节点2

• 关键：Python脚本放<包名>/<包名>/，需setup.py和setup.cfg配置。

（2）构建步骤

1. 创建工作空间与src目录：

   mkdir-p ~/ros2_ws/srccd~/ros2_ws/src

2. 自动创建纯Python包（指定ament_python构建类型）：

   ros2 pkg create --build-type ament_python --dependencies rclpy std_msgs ros2_py_pkg

3. 在ros2_py_pkg/ros2_py_pkg/目录下编写Python节点，修改setup.py的entry_points注册节点：

   entry_points={'console_scripts':['py_node_1 = ros2_py_pkg.py_node_1:main','py_node_2 = ros2_py_pkg.py_node_2:main',],},

4. setup.cfg内容固定，无需修改；package.xml默认已声明依赖，无需额外修改。

（3）编译方法

工作空间根目录执行，仅编译指定Python包：

cd~/ros2_ws colcon build --packages-select ros2_py_pkg# 可选：Python包编译时跳过缓存，加快调试colcon build --packages-select ros2_py_pkg --cmake-args -DCMAKE_BUILD_TYPE=Debug

（4）source指令

ROS 2的编译产物在install/目录，指令如下：

# 临时source（当前终端有效）sourceinstall/setup.bash# 永久source（所有终端生效，重启终端后生效）echo"source ~/ros2_ws/install/setup.bash">>~/.bashrc

2. 纯C++包（示例包名：ros2_cpp_pkg）

（1）文件放置位置

ros2_ws/ ├── build/ ├── install/ ├── log/ └── src/ └── ros2_cpp_pkg/ # 纯C++包根目录 ├── CMakeLists.txt # C++编译核心配置 ├── package.xml # 依赖声明 ├── include/ # C++头文件目录（核心） │ └── ros2_cpp_pkg/ # 与包名同名 │ └── cpp_node_1.hpp └── src/ # C++源文件目录（核心） └── cpp_node_1.cpp

• 关键：无需setup.py和setup.cfg，通过CMakeLists.txt配置编译规则。

（2）构建步骤

1. 进入src目录创建纯C++包（指定ament_cmake构建类型）：

   cd~/ros2_ws/src ros2 pkg create --build-type ament_cmake --dependencies rclcpp std_msgs ros2_cpp_pkg

2. 在include/ros2_cpp_pkg/编写头文件，在src/编写源文件。
3. 配置CMakeLists.txt（核心编译配置，默认已生成关键内容，补充/确认以下内容）：

   cmake_minimum_required(VERSION 3.8) project(ros2_cpp_pkg) find_package(ament_cmake REQUIRED) find_package(rclcpp REQUIRED) find_package(std_msgs REQUIRED) # 编译C++可执行文件 add_executable(cpp_node_1 src/cpp_node_1.cpp) # 链接依赖 ament_target_dependencies(cpp_node_1 rclcpp std_msgs) # 声明头文件路径 target_include_directories(cpp_node_1 PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include> $<INSTALL_INTERFACE:include>) # 安装可执行文件 install(TARGETS cpp_node_1 DESTINATION lib/${PROJECT_NAME}) ament_package()

（3）编译方法

工作空间根目录执行，仅编译指定C++包：

cd~/ros2_ws colcon build --packages-select ros2_cpp_pkg# C++包可开启编译优化colcon build --packages-select ros2_cpp_pkg --cmake-args -DCMAKE_BUILD_TYPE=Release

（4）source指令

与纯Python包一致：

sourceinstall/setup.bash# 临时# 或永久添加到.bashrc

3. C++与Python混合包（示例包名：ros2_mixed_pkg）

（1）文件放置位置

ros2_ws/ ├── build/ ├── install/ ├── log/ └── src/ └── ros2_mixed_pkg/ # 混合包根目录 ├── CMakeLists.txt # ament_cmake类型，支持C++编译 ├── package.xml # 声明rclcpp和rclpy依赖 ├── setup.py # Python安装配置 ├── setup.cfg # Python路径配置 ├── include/ # C++头文件目录 │ └── ros2_mixed_pkg/ │ └── cpp_node.hpp ├── src/ # C++源文件目录 │ └── cpp_node.cpp └── ros2_mixed_pkg/ # Python模块目录 ├── __init__.py └── py_node.py

• 关键：以ament_cmake为基础（支持C++编译），手动添加Python相关文件（setup.py、setup.cfg、Python模块目录）。

（2）构建步骤

1. 先创建ament_cmake类型包（C++基础）：

   cd~/ros2_ws/src ros2 pkg create --build-type ament_cmake --dependencies rclcpp rclpy std_msgs ros2_mixed_pkg

2. 手动添加Python相关文件：
   • 包根目录创建setup.py（参考纯Python包模板，修改包名和entry_points）
   • 包根目录创建setup.cfg（内容与纯Python包一致，固定不变）
   • 包根目录创建与包名同名的ros2_mixed_pkg/目录，添加__init__.py和Python节点
3. 修改CMakeLists.txt，添加Python文件安装配置（在ament_package()前添加）：

   # 安装Python相关文件（调用setup.py） install(DIRECTORY ros2_mixed_pkg DESTINATION share/${PROJECT_NAME} ) # 执行Python setup.py安装 find_package(ament_python REQUIRED) ament_python_install_package(${PROJECT_NAME})

4. 修改package.xml，确保同时声明rclcpp和rclpy依赖，并添加Python构建依赖：

   <buildtool_depend>ament_cmake</buildtool_depend><buildtool_depend>ament_python</buildtool_depend><depend>rclcpp</depend><depend>rclpy</depend><depend>std_msgs</depend>

（3）编译方法

工作空间根目录执行，自动编译两种语言代码：

cd~/ros2_ws colcon build --packages-select ros2_mixed_pkg

（4）source指令

与纯包一致：

sourceinstall/setup.bash

三、核心差异与总结

1. 关键差异对照表

对比项	ROS 1	ROS 2
构建工具	catkin_make/catkin build	colcon build
编译产物目录	devel/	install/
Python脚本存放	scripts/目录（直接执行）	<包名>/<包名>/（模块目录）
Python配置文件	无需setup.py/setup.cfg	必须setup.py/setup.cfg
C++构建类型	无显式声明（默认catkin）	ament_cmake
Python构建类型	无显式声明（catkin_python_setup()）	ament_python
混合包基础	直接整合scripts/和src/	以ament_cmake为基础，手动添加Python配置

2. 核心要点回顾

1. ROS 1：

• 所有包的source指令均为source devel/setup.bash，编译用catkin_make/catkin build。
• Python包依赖rospy，脚本放scripts/并添加可执行权限；C++包依赖roscpp，头文件放include/<包名>/，源文件放src/。

2. ROS 2：

• 所有包的source指令均为source install/setup.bash，编译用colcon build --packages-select <包名>。
• Python包需ament_python类型，脚本放同名模块目录，依赖rclpy；C++包需ament_cmake类型，依赖rclcpp，无需Python配置文件。

3. 混合包：

• ROS 1可直接通过catkin_create_pkg同时声明两种依赖，整合目录即可。
• ROS 2需以ament_cmake为基础，手动添加Python的setup.py、setup.cfg和模块目录。