ROS相关技术（概念版）

重要说明：本文从网上资料整理而来，仅记录博主学习相关知识点的过程，侵删。

一、参考资料

ROS官网

二、相关介绍

ROS学习笔记3：ROS架构（了解）

ROS介绍

1. ROS简介

ROS是一项由通信机制、开发工具、应用功能、生态系统四大部分组成的。 主要目的是提高机器人研发中的软件复用率。ROS是一个松耦合分布式的软件框架。

2. ROS架构

ROS是一个优秀的机器人分布式框架。ROS架构分为三个层次：

• OS层：基于Linux系统的OS层；
• 中间层：实现ROS核心通信机制以及众多机器人开发库；
• 应用层：在ROS Master的管理下保证功能节点的正常运行。
  

2.1 OS层

ROS无法直接运行在计算机硬件上，需要依托于Linux、macOS等操作系统运行。

2.2 中间层

ROS封装了关于机器人开发的中间件，主要包括：

• 基于TCP/UDP协议封装的TCPROS/UDPROS通信系统；
• 一种用于进程内的通信方法Nodelet，为多进行通信提供一种更优化的数据传输方式；
• 在通信机制上提供机器人开发相关的库，如数据类型定义、坐标变换、运动控制等，可以提供给应用层使用。

2.3 应用层

• ROS Master：ROS运行的管理者，负责整个系统的正常运行。
• 功能包：ROS社区内共享的机器人应用功能包，这些功能包内的模块以节点为单位运行。

3. ROS时间戳

ROS时间戳分为两种，一种是ROS的系统时间戳（ROS time），另一种是外部硬件设备的时间戳（例如相机、激光雷达等），也称为硬件时间戳（hardware time）。

ROS系统时间戳在整个ROS系统中是全局唯一的，当ROS系统中的节点需要在时间上进行同步时，ROS时间戳可以作为一个标准，各个点可以基于它来同步。

硬件时间戳由外部设备提供，可以是相对时间戳（相对于设备启动时间或者某个固定时间点的时间差），也可以是绝对时间戳（相对于某个固定的时间点的时间）。

3.1 时间同步

ROS时间同步（相机雷达）

由于外部设备和ROS系统是不同的系统，它们的时钟可能会有差异，因此需要进行时间戳转换，将硬件时间戳转换成ROS系统时间戳，或将ROS系统时间戳转换成硬件时间戳，以便进行时间同步和数据融合等操作。

3.2 时间戳相关指令

# 查看时间信息
rqt_bag <bagname>

4. ROS重映射

在ROS中，程序中任何一个用于命名的字符串都可以在运行时重映射。例如，ROS中一个常用的程序 image_view 将 image 主题实时渲染到窗口上。使用重映射，可以使 image_view 渲染 left/image 主题或者 right/image 主题，并且不需要修改 image_view 代码。

如果工作路径包含 image_view 程序，可以通过以下指令将 image 重映射到 right/image：

./image_view image:=right/image

将一个节点放置到命名空间中，可以通过一个特殊的 __ns 命名空间重映射语法来完成。例如，如果工作路径包含 camera 程序，可以通过以下指令将在 right 命名空间中启动 camera 程序：

./camera __ns:=right

在命令行中，可以使用专门的 __name 重命名语法，修改节点的名称。例如，启动两个talker实例，一个是 talker1，另一个是 talker2：

./talker __name:=talker1
./talker __name:=talker2

三、ROS相关概念

ROS笔记（1）——ROS的核心概念

从系统实现的角度来看，ROS可分为三个层次：计算图，文件系统，开源社区。

1. ROS计算图

从计算图的角度来看，ROS系统软件的功能模块以节点为单位独立运行，可以分布于多个相同或不同的主机中，在系统运行时通过端对端的拓扑结构进行连接。

在ROS中，节点、Topic、消息、服务、参数等都是非常重要的概念。节点是执行实际工作的进程，Topic是节点之间传递消息的通道，消息是在Topic上进行传递的数据，服务是节点之间提供的一种RPC（远程过程调用）机制，参数是一些常量或配置信息，可以在运行时进行修改。这些概念贯穿整个ROS系统。

1.1 节点——执行单元

node节点，又称为“软件模块”，一些执行运算任务的进行，一个系统一般由多个节点组成。

• 执行具体的任务进程，独立运行的可执行文件；
• 每个节点相互独立，可以使用不同的语言开发，可以分布式运行；
• 节点在系统中的名称唯一。

1.2 ROS Master——控制中心

ROS Master节点管理器通过远程调用过程（PRC）提供登记列表和对其他计算图表的查找功能。ROS Master是一个管理者，没有它节点将无法找到彼此，也无法交换信息或调用服务，整个系统也将瘫痪。

• 节点的控制中心；
• 为结点提供命名和注册服务；
• 辅助接点建立联系、相互查找；
• 提供参数服务器。

1.3 话题——异步通信机制

topic话题是发布者节点与订阅者节点之间传输数据的通道，传输的数据叫做message消息。一个节点可以针对一个给定的话题（Topic）发布消息，这个节点称为发布者Talker；也可以关注某个话题并订阅特定类型的数据，这个节点称为订阅者Listener。

• 异步通信机制：发数据、接数据，单向；
• 数据从发布者传递到订阅者。

1.3.1 发布话题

发布话题的流程，主要包括：

1. 创建发布者；
2. 创建消息数据；
3. 消息数据赋值；
4. 发布消息；

ros::Publisher pub = nh.advertise<std_msgs::String>("topic_name", queue.size);
std_msgs::String str;
str.data = "hello world!";
pub.publish(str);

1.3.2 订阅话题

订阅话题的流程，主要包括：

1. 创建订阅者；
2. 创建回调函数；

void callback(const std_msgs::StringConstPtr& str) {
    ...
}
...
ros::Subscriber sub = nh.subscribe("my_topic", queue.size, callback);

1.4 消息——话题的数据

ROS中基于发布/订阅（Publisher/Subcriber）通信机制传递的一种严格的数据结构，由节点处理消息并进行发送或接收，最终实现想要的功能。可以通过rosmsg来查看关于消息的操作。

• 具有一定的数据和数据结构，包括ROS提供的标准类型和用户自定义类型；
• 使用编程语言无关的.msg文件定义，编译过程中生成对应的代码文件。

1.5 服务——同步通信机制

服务是节点之间同步通信的一种方式，其中提供服务者称为服务者节点，被服务者称为客户端节点。客户端节点（Client）可以发布请求（Request），服务者节点（Server）处理后反馈应答（Response）。

• 同步通信机制：使用C/S模型，客户端发送请求数据，服务器完成处理后的应答数据，双向；
• 使用编程语言无关的.srv文件定义请求和应答数据结构，编译过程中生成对应的代码文件。

1.6 参数——全局共享字典

• 全局共享字典；
• 可以通过网络访问的共享、多变量字典；
• 存储系统运行过程中的配置参数；
• 适合存储静态、非二进制的配置参数，不适合存储动态的数据。

2. ROS文件系统

ROS文件系统

ROS文件系统相关命令

ROS文件系统级指的是在硬盘上ROS源代码的组织形式，其结构大致可以如下图所示：

WorkSpace --- 自定义的工作空间

    |--- build:编译空间，用于存放CMake和catkin的缓存信息、配置信息和其他中间文件。

    |--- devel:开发空间，用于存放编译后生成的目标文件，包括头文件、动态&静态链接库、可执行文件等。

    |--- src: 源码

        |-- package：功能包(ROS基本单元)包含多个节点、库与配置文件，包名所有字母小写，只能由字母、数字与下划线组成

            |-- CMakeLists.txt 配置编译规则，比如源文件、依赖项、目标文件

            |-- package.xml 功能包信息，比如:包名、版本、作者、依赖项...(以前版本是 manifest.xml)

            |-- scripts 存储python文件

            |-- src 存储C++源文件

            |-- include 头文件

            |-- msg 消息通信格式文件

            |-- srv 服务通信格式文件

            |-- action 动作格式文件

            |-- launch 可一次性运行多个节点 

            |-- config 配置信息

        |-- CMakeLists.txt: 编译的基本配置

2.1 launch 文件

launch文件演示

2.1.1 引言

一个程序中可能需要启动多个节点，比如:ROS 内置的小乌龟案例，如果要控制乌龟运动，要启动多个窗口，分别启动 roscore、乌龟界面节点、键盘控制节点。如果每次都调用 rosrun 逐一启动，显然效率低下，如何优化?

解决办法：官方给出的优化策略是使用 launch 文件，可以一次性启动多个 ROS 节点。

roslaunch <package_name> <launch文件名>

<launch>
    <node pkg="helloworld" type="demo_hello" name="hello" output="screen" />
    <node pkg="turtlesim" type="turtlesim_node" name="t1"/>
    <node pkg="turtlesim" type="turtle_teleop_key" name="key1" />
</launch>

参数解释

• node：节点标签；
• pkg：该节点所在的功能包；
• type：节点类型；
• name：节点名称；
• output：设置日志的输出目标。如果是 screen，表示将终端输出转储在当前控制台上，而不是日志文件中。这是调试期间常用的方法，一旦调试完成，可以去掉这个属性使终端输出更干净。

2.1.2 launch标签类型

• <launch>...</launch>：根标签。launch文件的标签内容都需要包含在根标签内；
• <include>：嵌套，包含其他launch文件、XML文件；
• <node>：启动节点；
• <remap>：重命名；
• <param>：全局参数；
• <rosparam>：加载参数；
• <group>：节点分组；
• <arg>：局部参数；
• <machine>：远程标签；
• <env>：环境变量；
• <test>：测试节点；

2.1.3 <node>标签

<node>标签的属性，如下表所示：

属性	解释说明
pkg	节点所在的包名
type	可执行文件名
name	重定义节点名
args	传递参数
output	日志输出（log
respawn	“true”，如果节点失效，则重启（默认为false）
required	“true”，如果节点失效，则关闭整个launch文件（默认为不设置）
ns	在命名空间中运行此节点

示例

rosrun <package_name> <executable|python>

rosrun turn_on_wheeltec_robot wheeltec_robot_node

<node pkg="package_name" type="executable|python" name="node_name" />

<node pkg="turn_on_wheeltec_robot" type="wheeltec_robot_node" name="wheeltec_robot" />

2.1.4 参数标签

有三种参数标签，如下表所示：

标签名	解释说明
<param>	在参数服务器添加一个参数
<rosparam>	从".yaml"文件中一次性导入大量参数
<arg>	在launch中声明一个参数

2.1.5 <goup>标签

<!-- 若干个节点划分进同一个命名空间 -->
<group ns="group_name">
...
</group>

<!-- 条件判断执行 -->
<group if="condition">
...
</group>

示例：orb_slam.launch

<launch>
  <!--建图算法-->
  <arg name="camera_mode"  default="AstraS" doc="opt:AstraS,Astrapro,Gemini"/>

  <!-- 开启机器人底层相关节点  -->
  <include file="$(find turn_on_wheeltec_robot)/launch/turn_on_wheeltec_robot.launch">
    <arg name="is_cartographer" value="true"/>
  </include>


  <group if="$(eval camera_mode == 'AstraS')">
    <include file="$(find astra_camera)/launch/astra.launch" />
    <include file="$(find orb_slam2_ros)/ros/launch/orb_slam2_Astra_rgbd.launch" />
  </group>


  <group if="$(eval camera_mode == 'Astrapro')">
    <include file="$(find astra_camera)/launch/astrapro.launch" />
    <include file="$(find orb_slam2_ros)/ros/launch/orb_slam2_Astrapro_rgbd.launch" />
  </group>


  <group if="$(eval camera_mode == 'Gemini')">
     <include file="$(find astra_camera)/launch/gemini.launch" />
    <include file="$(find orb_slam2_ros)/ros/launch/orb_slam2_Astra_gemini_rgbd.launch" />
  </group>

</launch>

2.1.6 <remap>标签

<!-- from:输入，to: 输出 -->
<remap from="/different_topic" to="/needed_topic" />

2.2 package.xml

<?xml version="1.0"?>
<!-- 格式: 以前是 1，推荐使用格式 2 -->
<package format="2">
  <!-- ROS包名，不允许修改 -->
  <name>demo01_hello_vscode</name>
  <!-- 版本号 -->
  <version>0.0.0</version>
  <!-- ROS包功能的描述信息 -->
  <description>The demo01_hello_vscode package</description>

  <!-- One maintainer tag required, multiple allowed, one person per tag -->
  <!-- Example:  -->
  <!-- <maintainer email="jane.doe@example.com">Jane Doe</maintainer> -->
  <!-- 维护人员，维护ROS包和修复bug的人 -->
  <maintainer email="xuzuo@todo.todo">xuzuo</maintainer>


  <!-- One license tag required, multiple allowed, one license per tag -->
  <!-- Commonly used license strings: -->
  <!--   BSD, MIT, Boost Software License, GPLv2, GPLv3, LGPLv2.1, LGPLv3 -->
  <!-- 发布代码依据的许可协议，ROS核心组件默认 BSD -->
  <license>TODO</license>


  <!-- Url tags are optional, but multiple are allowed, one per tag -->
  <!-- Optional attribute type can be: website, bugtracker, or repository -->
  <!-- Example: -->
  <!-- ROS wiki 主页上该ROS包的URL -->
  <!-- <url type="website">http://wiki.ros.org/demo01_hello_vscode</url> -->


  <!-- Author tags are optional, multiple are allowed, one per tag -->
  <!-- Authors do not have to be maintainers, but could be -->
  <!-- Example: -->
  <!-- 程序包的作者，每个作者一组标签 -->
  <!-- <author email="jane.doe@example.com">Jane Doe</author> -->


  <!-- The *depend tags are used to specify dependencies -->
  <!-- Dependencies can be catkin packages or system dependencies -->
  <!-- Examples: -->
  <!-- Use depend as a shortcut for packages that are both build and exec dependencies -->
  <!--   <depend>roscpp</depend> -->
  <!--   Note that this is equivalent to the following: -->
  <!--   <build_depend>roscpp</build_depend> -->
  <!--   <exec_depend>roscpp</exec_depend> -->
  <!-- Use build_depend for packages you need at compile time: -->
  <!--   <build_depend>message_generation</build_depend> -->
  <!-- Use build_export_depend for packages you need in order to build against this package: -->
  <!--   <build_export_depend>message_generation</build_export_depend> -->
  <!-- Use buildtool_depend for build tool packages: -->
  <!--   <buildtool_depend>catkin</buildtool_depend> -->
  <!-- Use exec_depend for packages you need at runtime: -->
  <!--   <exec_depend>message_runtime</exec_depend> -->
  <!-- Use test_depend for packages you need only for testing: -->
  <!--   <test_depend>gtest</test_depend> -->
  <!-- Use doc_depend for packages you need only for building documentation: -->
  <!--   <doc_depend>doxygen</doc_depend> -->
  <!-- 依赖的编译构建工具 -->
  <buildtool_depend>catkin</buildtool_depend>

  <!-- 编译依赖项，指定构建此软件包所需的软件包 -->
  <build_depend>roscpp</build_depend>
  <build_depend>rospy</build_depend>
  <build_depend>std_msgs</build_depend>

  <!-- 导出依赖项 -->
  <build_export_depend>roscpp</build_export_depend>
  <build_export_depend>rospy</build_export_depend>
  <build_export_depend>std_msgs</build_export_depend>

  <!-- 运行依赖项，运行该程序包中的代码所需的程序包 -->  
  <exec_depend>roscpp</exec_depend>
  <exec_depend>rospy</exec_depend>
  <exec_depend>std_msgs</exec_depend>

  <!-- 测试用例依赖项 -->  
  <test_depend>std_msgs</test_depend>
  <test_depend>std_msgs</test_depend>
  <test_depend>std_msgs</test_depend>

  <!-- 文档依赖项 -->  
  <doc_depend>std_msgs</doc_depend>


  <!-- The export tag contains other, unspecified, tags -->
  <!-- catkin以外的其他工具需要的信息 -->
  <export>
    <!-- Other tools can request additional information be placed here -->

  </export>
</package>

2.3 CMakeLists.txt

cmake_minimum_required(VERSION 3.0.2) #所需 cmake 版本
project(demo01_hello_vscode) #包名称，会被 ${PROJECT_NAME} 的方式调用

## Compile as C++11, supported in ROS Kinetic and newer
# add_compile_options(-std=c++11)

## Find catkin macros and libraries
## if COMPONENTS list like find_package(catkin REQUIRED COMPONENTS xyz)
## is used, also find other catkin packages
#设置构建所需要的软件包
find_package(catkin REQUIRED COMPONENTS
  roscpp
  rospy
  std_msgs
)

## System dependencies are found with CMake's conventions
#默认添加系统依赖
# find_package(Boost REQUIRED COMPONENTS system)


## Uncomment this if the package has a setup.py. This macro ensures
## modules and global scripts declared therein get installed
## See http://ros.org/doc/api/catkin/html/user_guide/setup_dot_py.html
# 启动 python 模块支持
# catkin_python_setup()

################################################
## Declare ROS messages, services and actions ##
## 声明 ROS 消息、服务、动作... ##
################################################

## To declare and build messages, services or actions from within this
## package, follow these steps:
## * Let MSG_DEP_SET be the set of packages whose message types you use in
##   your messages/services/actions (e.g. std_msgs, actionlib_msgs, ...).
## * In the file package.xml:
##   * add a build_depend tag for "message_generation"
##   * add a build_depend and a exec_depend tag for each package in MSG_DEP_SET
##   * If MSG_DEP_SET isn't empty the following dependency has been pulled in
##     but can be declared for certainty nonetheless:
##     * add a exec_depend tag for "message_runtime"
## * In this file (CMakeLists.txt):
##   * add "message_generation" and every package in MSG_DEP_SET to
##     find_package(catkin REQUIRED COMPONENTS ...)
##   * add "message_runtime" and every package in MSG_DEP_SET to
##     catkin_package(CATKIN_DEPENDS ...)
##   * uncomment the add_*_files sections below as needed
##     and list every .msg/.srv/.action file to be processed
##   * uncomment the generate_messages entry below
##   * add every package in MSG_DEP_SET to generate_messages(DEPENDENCIES ...)

## Generate messages in the 'msg' folder
# add_message_files(
#   FILES
#   Message1.msg
#   Message2.msg
# )

## Generate services in the 'srv' folder
# add_service_files(
#   FILES
#   Service1.srv
#   Service2.srv
# )

## Generate actions in the 'action' folder
# add_action_files(
#   FILES
#   Action1.action
#   Action2.action
# )

## Generate added messages and services with any dependencies listed here
# 生成消息、服务时的依赖包
# generate_messages(
#   DEPENDENCIES
#   std_msgs
# )

################################################
## Declare ROS dynamic reconfigure parameters ##
## 声明 ROS 动态参数配置 ##
################################################

## To declare and build dynamic reconfigure parameters within this
## package, follow these steps:
## * In the file package.xml:
##   * add a build_depend and a exec_depend tag for "dynamic_reconfigure"
## * In this file (CMakeLists.txt):
##   * add "dynamic_reconfigure" to
##     find_package(catkin REQUIRED COMPONENTS ...)
##   * uncomment the "generate_dynamic_reconfigure_options" section below
##     and list every .cfg file to be processed

## Generate dynamic reconfigure parameters in the 'cfg' folder
# generate_dynamic_reconfigure_options(
#   cfg/DynReconf1.cfg
#   cfg/DynReconf2.cfg
# )

###################################
## catkin specific configuration ##
## catkin 特定配置##
###################################
## The catkin_package macro generates cmake config files for your package
## Declare things to be passed to dependent projects
## INCLUDE_DIRS: uncomment this if your package contains header files
## LIBRARIES: libraries you create in this project that dependent projects also need
## CATKIN_DEPENDS: catkin_packages dependent projects also need
## DEPENDS: system dependencies of this project that dependent projects also need
# 运行时依赖
catkin_package(
#  INCLUDE_DIRS include
#  LIBRARIES demo01_hello_vscode
#  CATKIN_DEPENDS roscpp rospy std_msgs
#  DEPENDS system_lib
)

###########
## Build ##
###########

## Specify additional locations of header files
## Your package locations should be listed before other locations
# 添加头文件路径，当前程序包的头文件路径位于其他文件路径之前
include_directories(
# include
  ${catkin_INCLUDE_DIRS}
)

## Declare a C++ library
# 声明 C++ 库
# add_library(${PROJECT_NAME}
#   src/${PROJECT_NAME}/demo01_hello_vscode.cpp
# )

## Add cmake target dependencies of the library
## as an example, code may need to be generated before libraries
## either from message generation or dynamic reconfigure
# 添加库的 cmake 目标依赖
# add_dependencies(${PROJECT_NAME} ${${PROJECT_NAME}_EXPORTED_TARGETS} ${catkin_EXPORTED_TARGETS})

## Declare a C++ executable
## With catkin_make all packages are built within a single CMake context
## The recommended prefix ensures that target names across packages don't collide
# 声明 C++ 可执行文件
add_executable(Hello_VSCode src/Hello_VSCode.cpp)

## Rename C++ executable without prefix
## The above recommended prefix causes long target names, the following renames the
## target back to the shorter version for ease of user use
## e.g. "rosrun someones_pkg node" instead of "rosrun someones_pkg someones_pkg_node"
#重命名c++可执行文件
# set_target_properties(${PROJECT_NAME}_node PROPERTIES OUTPUT_NAME node PREFIX "")

## Add cmake target dependencies of the executable
## same as for the library above
#添加可执行文件的 cmake 目标依赖
add_dependencies(Hello_VSCode ${${PROJECT_NAME}_EXPORTED_TARGETS} ${catkin_EXPORTED_TARGETS})

## Specify libraries to link a library or executable target against
#指定库、可执行文件的链接库
target_link_libraries(Hello_VSCode
  ${catkin_LIBRARIES}
)

#############
## Install ##
## 安装 ##
#############

# all install targets should use catkin DESTINATION variables
# See http://ros.org/doc/api/catkin/html/adv_user_guide/variables.html

## Mark executable scripts (Python etc.) for installation
## in contrast to setup.py, you can choose the destination
#设置用于安装的可执行脚本
catkin_install_python(PROGRAMS
  scripts/Hi.py
  DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION}
)

## Mark executables for installation
## See http://docs.ros.org/melodic/api/catkin/html/howto/format1/building_executables.html
# install(TARGETS ${PROJECT_NAME}_node
#   RUNTIME DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION}
# )

## Mark libraries for installation
## See http://docs.ros.org/melodic/api/catkin/html/howto/format1/building_libraries.html
# install(TARGETS ${PROJECT_NAME}
#   ARCHIVE DESTINATION ${CATKIN_PACKAGE_LIB_DESTINATION}
#   LIBRARY DESTINATION ${CATKIN_PACKAGE_LIB_DESTINATION}
#   RUNTIME DESTINATION ${CATKIN_GLOBAL_BIN_DESTINATION}
# )

## Mark cpp header files for installation
# install(DIRECTORY include/${PROJECT_NAME}/
#   DESTINATION ${CATKIN_PACKAGE_INCLUDE_DESTINATION}
#   FILES_MATCHING PATTERN "*.h"
#   PATTERN ".svn" EXCLUDE
# )

## Mark other files for installation (e.g. launch and bag files, etc.)
# install(FILES
#   # myfile1
#   # myfile2
#   DESTINATION ${CATKIN_PACKAGE_SHARE_DESTINATION}
# )

#############
## Testing ##
#############

## Add gtest based cpp test target and link libraries
# catkin_add_gtest(${PROJECT_NAME}-test test/test_demo01_hello_vscode.cpp)
# if(TARGET ${PROJECT_NAME}-test)
#   target_link_libraries(${PROJECT_NAME}-test ${PROJECT_NAME})
# endif()

## Add folders to be run by python nosetests
# catkin_add_nosetests(test)

2.4 文件系统相关指令

# 创建功能包
catkin_create_pkg <package_name> <依赖包>

# 安装ROS功能包
sudo apt install <package_name>

# 删除功能包
sudo apt purge <package_name>

# 列出所有功能包
rospack list

# 查找功能包
sorpack find <package_name>

# 加入功能包
roscd <package_name>

# 列出功能包的文件
rosls <package_name>

# 搜索功能包
apt search <package_name>

# 修改功能包的文件
rosed <package_name> <file_name>

2.5 工作空间

工作空间是包（Package）的容器，包含软件包的目录，存放工程开发相关文件。包是ROS系统中基本代码单元，包含了节点、话题、消息、服务等定义。

一个典型的工作空间（catkin_ws）包含以下目录：

• src：源码空间；
• build：编译空间；
• devel：开发空间；
• install：安装空间。
  

2.6 功能包

ROS软件以包括代码、数据和文件在内的包的形式进行管理。ROS生态系统包含了成千上万个公开的包以及几千个隐藏的包。

ROS包（ROS功能包），又称为程序包，程序包包含在工作区的src路径内，每个包必须包含一个 CMakeLists.txt 以及一个 package.xml 文件。其中，package.xml 是包描述文件，用于描述包的内容以及 catkin 如何与之交互。

package功能包，是存放用户功能代码的文件夹。

2.6.1 功能包的内容

• include：.h头文件；
• launch：.launch文件；
• src：.cpp文件；
• config：参数配置文件，包括：yaml，srv，msg，action；
• scripts：可执行脚本文件（Python）；
• CMakeLists.txt：定义编译的规则；
• package.xml：定义package的属性；
• urdf：.urdf文件。

3. ROS开源社区

主要是发行版，软件源，ROS wiki，邮件列表，ROS Answer，Blog。

四、ROS通信机制

ROS的核心是分布式通信机制，基本通信方式分为三种：

• 话题通信机制（异步通信机制）；
• 服务通信机制（同步通信机制）；
• 参数管理通信机制。

1. 话题通信机制（异步）

1.1 话题通信的三个角色

• 发布者Talker：负责向订阅者发布数据；
• 订阅者Listener：负责接收发布者的数据；
• 管理者ROS Master：负责保管发布者和订阅者注册的信息，并匹配话题相同的发布者和订阅者，帮助开发者与订阅者建立连接。

1.2 建立话题通信的过程

1. Talker注册；
2. Listener注册；
3. ROS Master注册；
4. Listener发送连接请求；
5. Talker确认连接请求；
6. Listener尝试与Talker建立网络连接；
7. Talker向Listener发布数据。
   

2. 服务通信机制（同步）

2.1 服务通信的三个角色

• 客户端client：负责向服务端发送请求，并接收服务端发送的数据；
• 服务端server：负责接收处理请求，并对客户端作出应答；
• 管理者ROS Master：负责保管客户端和服务端注册的信息，并匹配话题相同的客户端与服务端，帮助客户端和服务端建立连接。

2.2 建立服务通信的过程

1. Talker注册；
2. Listener注册；
3. ROS Master进行信息匹配；
4. Listener与Talker建立网络连接；
5. Talker向Listener发布服务应答数据。
   

2.3 话题通信机制与服务通信机制对比

	话题	服务
同步性	异步	同步
通信模型	发布/订阅	服务端/客户端
底层协议	ROSTCP/ROSUDP	ROSTCP/ROSUDP
反馈机制	无	有
缓冲区	有	无
实时性	弱	强
节点关系	多对多	一对多（一个server）
适用场景	数据传输	逻辑处理

3. 参数管理通信机制

参数类似于ROS中的全局变量，由ROS Master进行管理，其通信机制较为简单，不涉及TCP/UDP的通信。

3.1 参数服务器的三个角色

• 管理者ROS Master：管理者作为一个公共的容器保存数据；
• 参数设置者Talker：参数设置者往容器中存储数据；
• 参数调用者Listener：参数调用者读取容器中所需的数据。

3.2 建立参数管理通信的过程

1. Talker设置变量；
2. Listener查询参数值；
3. ROS Master向Lisenter发送参数值。