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

一、参考资料

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文件系统相关命令

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: 编译的基本配置

4.1 launch

launch文件演示

问题引入：一个程序中可能需要启动多个节点，比如: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：设置日志的输出目标。

4.2 package.xml

<?xml version="1.0"?>
<!-- 格式: 以前是 1，推荐使用格式 2 -->
<package format="2">
  <!-- 包名 -->
  <name>demo01_hello_vscode</name>
  <!-- 版本 -->
  <version>0.0.0</version>
  <!-- 描述信息 -->
  <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> -->
  <!-- 维护人员 -->
  <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: -->
  <!-- <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>


  <!-- The export tag contains other, unspecified, tags -->
  <export>
    <!-- Other tools can request additional information be placed here -->

  </export>
</package>

4.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)

4.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>

三、ROS相关概念

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

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

1. 计算图

从计算图的角度来看，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.4 消息——话题的数据

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

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

1.5 服务——同步通信机制

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

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

1.6 参数——全局共享字典

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

2. 文件系统

类似于操作系统，ROS将所有文件按照一定的规则进行组织，不同功能的文件放在不同的文件夹下。

2.1 功能包

ROS功能包是一种重要的ROS组织方式，它将相关的节点、库、配置文件、启动文件等集合在一起，从而实现了一定的功能。通常情况下，一个功能包是一个独立的模块，它实现了某个特定的功能。我们可以将一个或多个功能包组合在一起来创建一个ROS应用程序。

• ROS软件中的基本单元，包含节点源码、配置文件、数据定义等。

2.2 功能包清单

每个功能包都包含一个叫 package.xml 的功能包清单，用于记录功能包的基本信息。

• 记录功能包的基本信息，包含作者信息、编译标志。

2.3 元功能包

元功能包是一种特殊的功能包，只包含一个 package.xml 元功能包清单文件。它的主要作用是将多个功能包整合成一个逻辑上独立的功能包，类似于集合概念。

元功能包清单的package.xml文件相较于功能包的package.xml文件，需要包含一个引用的标签。

<export>
    <metapackage/>
</export>

• 组织多个用于同一目的的功能包。

2.4 消息类型

消息是ROS节点之间发布/订阅的通信消息，可以使用ROS提供的消息类型，也可以使用.msg文件在功能包的msg文件夹下自定义所需要的消息类型。

2.5 服务类型

服务类型定义了ROS客户端/服务端通信模型下的请求和应答数据类型，可以使用ROS系统提供的服务类型，也可以使用.srv文件在功能包的srv文件夹中进行定义。

2.6 工作空间

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

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

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

3. 开源社区

主要是发行版，软件源，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发送参数值。