第1章 ROS概述与环境搭建

1.1 ROS简介

ROS全称Robot Operating System（机器人操作系统）.

  • ROS是适用于机器人的开源元操作系统
  • ROS集成了大量的工具，库，协议，提供类似OS所提供的功能，简化对机器人的控制
  • 还提供了用于在多台计算机上获取，构建，编写和运行代码的工具和库，ROS在某些方面类似 于“机器人框架
  • ROS设计者将ROS表述为“ROS = Plumbing + Tools + Capabilities + Ecosystem”，即ROS是通讯 机制、工具软件包、机器人高层技能以及机器人生态系统的集合体

机器人操作系统（ROS，Robot Operating System）的设计目标是提供一个灵活、模块化且可复用的框架，以简化复杂机器人系统的开发。

ROS的发行版本（ROS distribution）指ROS软件包的版本，其与Linux的发行版本（如Ubuntu） 的概念类似。推出ROS发行版本的目的在于使开发人员可以使用相对稳定的代码库，直到其准备好 将所有内容进行版本升级为止。因此，每个发行版本推出后，ROS开发者通常仅对这一版本的bug 进行修复，同时提供少量针对核心软件包的改进。

版本特点: 按照英文字母顺序命名，ROS 目前已经发布了 ROS1 的终极版本: noetic，并建议后期过渡至 ROS2 版本。noetic 版本之前默认使用的是 Python2，noetic 支持 Python3。

建议版本: noetic 或 melodic 或 kinetic

1.2 ROS安装

我使用的是 ROS 版本是 Noetic，那么可以在 ubuntu20.04、Mac 或 windows10 系统上安装，虽然 一般用户平时使用的操作系统以windows居多,但是ROS之前的版本基本都不支持windows,所以当前我们选用的操作系统是 ubuntu,以方便向历史版本过渡。ubuntu安装常用方式有两种:

两种方式比较，各有优缺点：

  • 方案1可以保证性能，且不需要考虑硬件兼容性问题，但是和windows系统交互不便；
  • 方案2可以方便的实现 windows 与 ubuntu 交互，不过性能稍差，且与硬件交互不便。

在 ROS 中，一些仿真操作是比较耗费系统资源的，且经常需要和一些硬件(雷达、摄像头、imu、 STM32、arduino….)交互，因此，原则上建议采用方案1。

不过如果只是出于学习目的，那么方案2也基本够用，且方案2在windows与ubuntu的交互上更为方便，对于学习者更为友好，因此本教程在此选用 的是方案2。当然，具体采用哪种实现方案，请按需选择。

1.2.1 清华源配置

安装好Ubuntu后，打开Ubuntu的终端，输入下面的命令

1
2
3
4
5
6
7
sudo apt update

# 将 sources.list 拷贝到桌面
cp /etc/apt/sources.list ~/Desktop 

# 打开 sources.list 进行编辑
sudo gedit /etc/apt/sources.list

打开文件后，将里面的所有内容替换为之前网页内文本框里的内容，例如

1
2
3
4
5
6
7
8
9
10
11
12
13
# 默认注释了源码镜像以提高 apt update 速度，如有需要可自行取消注释
deb https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ focal main restricted universe multiverse
# deb-src https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ focal main restricted universe multiverse
deb https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ focal-updates main restricted universe multiverse
# deb-src https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ focal-updates main restricted universe multiverse
deb https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ focal-backports main restricted universe multiverse
# deb-src https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ focal-backports main restricted universe multiverse
deb https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ focal-security main restricted universe multiverse
# deb-src https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ focal-security main restricted universe multiverse

# 预发布软件源，不建议启用
# deb https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ focal-proposed main restricted universe multiverse
# deb-src https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ focal-proposed main restricted universe multiverse

1.2.2 配置公钥

1
sudo apt-key adv --keyserver 'hkp://keyserver.ubuntu.com:80' --recv-key C1CF6E31E6BADE8868B172B4F42ED6FBAB17C654

1.2.3 包更新

1
sudo apt-get update

1.2.4 安装ros

1
2
3
4
5
# Ubuntu 20.04 
sudo apt install ros-noetic-desktop-full

# Ubuntu 18.04 
sudo apt install ros-melodic-desktop-full

1.2.5 初始化rosdep

1
sudo rosdep init && rosdep update

该步如果报错，安装鱼香rosdepc，没有请跳过下面的代码进入1.2.6步

1
sudo pip install rosdepc

如果显示没有pip可以试试pip3。

1
sudo pip3 install rosdepc

如果pip3还没有

1
2
sudo apt-get install python3-pip 
sudo pip install rosdepc

然后使用rosdepc初始化。

1
2
sudo rosdepc init
rosdepc update

1.2.6 环境变量设置

注意对应自己的版本修改目录名

1
2
echo "source /opt/ros/noetic/setup.bash" >> ~/.bashrc
source ~/.bashrc

1.2.7 安装 rosinstall

1
sudo apt install python3-rosinstall python3-rosinstall-generator python3-wstool build-essential

1.2.8 测试

打开第一个终端，运行：

1
roscore

出现ros版本信息，服务信息等证明运行成功。

打开第二个终端，运行：

1
rosrun turtlesim turtlesim_node

当出现有一个海龟的窗口，证明运行成功了。

打开第三个终端窗口，输入：

1
rosrun turtlesim  turtle_teleop_key

我们用鼠标聚焦第三个终端窗口，便可以通过按下 ↑ ↓ ← →键来对小海龟进行控制了。

1.3 ROS快速体验

编写 ROS 程序，在控制台输出文本: Hello World，分别使用 C++ 和 Python 实现。

ROS中涉及的编程语言以C++和Python为主，ROS中的大多数程序两者都可以实现。

ROS中的程序即便使用不同的编程语言，实现流程也大致类似，以当前HelloWorld程序为例，实现流程大致如下：

  1. 先创建一个工作空间；
  2. 再创建一个功能包；
  3. 编辑源文件；
  4. 编辑配置文件；
  5. 编译并执行。

1.3.1 初始化

1.创建工作空间并初始化

首先创建一个工作空间以及一个 src 子目录，然后再进入工作空间调用 catkin_make命令 编译。

1
2
3
mkdir -p 自定义空间名称/src
cd 自定义空间名称
catkin_make

2.进入src创建ros包并添加依赖

1
2
cd src
catkin_create_pkg 自定义ROS包名 roscpp rospy std_msgs

上述命令，会在工作空间下生成一个功能包，该功能包依赖于 roscpp、rospy 与 std_msgs，其中 roscpp是使用C++实现的库，而rospy则是使用python实现的库，std_msgs是标准消息库，创建ROS功 能包时，一般都会依赖这三个库实现。

注意 在ROS中，虽然实现同一功能时，C++和Python可以互换，但是具体选择哪种语言，需要视需求而定，因为两种语言相较而言:C++运行效率高但是编码效率低，而Python则反之，基于二者互补的特点，ROS设计者分别设计了roscpp与rospy库，前者旨在成为ROS的高性能库，而后者则一般用于对性能无要求的场景，旨在提高开发效率。

1.3.2 C++实现

1.进入ros包的src目录编辑源文件

1
cd 自定义的包/src

C++源码实现(文件名自定义，例如helloworld.cpp)

1
2
3
4
5
6
7
8
9
10
11
#include "ros/ros.h"
 int main(int argc, char *argv[])
 {
    //执行 ros 节点初始化
    ros::init(argc,argv,"hello");
    //创建 ros 节点句柄(非必须)
    ros::NodeHandle n;
    //控制台输出 hello world
    ROS_INFO("hello world!");
    return 0;
 }

2.编辑自定义ros包下的Cmakelist.txt文件

1
2
3
4
5
6
add_executable(自定义节点名（推荐与源文件对应）
src/helloworld.cpp
)
target_link_libraries(和上面一样的自定义节点名
${catkin_LIBRARIES}
)

3.进入工作空间目录并编译

1
2
cd 自定义空间名称
catkin_make

4.执行

打开终端一：

1
roscore

再打开一个终端

1
2
3
cd 工作空间
source ./devel/setup.bash
rosrun 包名 C++节点

命令行输出: HelloWorld!

1.3.3 Python实现

1.进入ros包添加scripts目录并编辑python文件

1
2
cd 包名
mkdir scripts

新建 python 文件:(文件名自定义，例如helloworld.py)

1
2
3
4
5
6
7
8
#! /usr/bin/env python
"""
   Python 版 HelloWorld
"""
import rospy
if __name__ == "__main__":
    rospy.init_node("Hello")
    rospy.loginfo("Hello World!!!!")

2.为python文件添加可执行权限

1
chmod +x 自定义文件名.py

3.编辑自定义ros包下的Cmakelist.txt文件

1
2
3
catkin_install_python(PROGRAMS scripts/自定义文件名.py
	DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION}
)

4.进入工作空间目录并编译

1
2
cd 自定义空间名称
catkin_make

5.执行

打开终端一：

1
roscore

再打开一个终端

1
2
3
cd 工作空间
source ./devel/setup.bash
rosrun 包名 自定义文件名.py

1.4 ROS集成开发环境搭建

工欲善其事必先利其器，为了提高开发效率，可以先安装集成开发工具和使用方便的工具.

1.4.1 安装vscode

ubuntu里安装vscode很简单，只需要在Ubuntu Software里搜索vscode下载安装即可。

或者去官方网站：https://code.visualstudio.com/下载安装包双击安装即可。

1.4.2 vscode集成ROS插件

需要先安装一些插件，常用插件如下:

  • C/C++
  • CMake Tools
  • Python
  • ROS

统一为Microsoft认证插件。

1.4.3 vscode使用基本配置

1.创建ROS工作空间

1
2
3
mkdir -p 自定义空间名称/src(必须得有 src)
cd 自定义空间名称
catkin_make

2.启动vscode

进入工作空间启动 vscode,工作空间名称以xxx_ws为例

1
2
cd xxx_ws
code .

3.vscode中编译ros

快捷键 ctrl + shift + B 调用编译，选择: catkin_make:build

可以点击配置设置为默认，修改.vscode/tasks.json 文件,没有就创建

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
{
 // 有关 tasks.json 格式的文档，请参见
    // https://go.microsoft.com/fwlink/?LinkId=733558
    "version": "2.0.0",
    "tasks": [
        {
            "label": "catkin_make:debug", //代表提示的描述性信息
            "type": "shell",  //可以选择shell或者process,如果是shell代码是在shell里面运行一个命令，如果是
            "command": "catkin_make",//这个是我们需要运行的命令
            "args": [],//如果需要在命令后面加一些后缀，可以写在这里，比如-DCATKIN_WHITELIST_PACKAGES=“pac1;pac2”
            "group": {"kind":"build","isDefault":true},
            "presentation": {
                "reveal": "always"//可选always或者silence，代表是否输出信息
            },
            "problemMatcher": "$msCompile"
        }
    ]
}

这样配置完之后ctrl + shift + B会直接进行catkin_make:build 编译。不需要选择操作。

4.创建功能包

选定 src 右击 —> create catkin package

编辑框上弹出Package name，然后输入自定义包名

1
helloworld

回车

然后会让你继续添加依赖Dependencies,这里输入要用的依赖例如：

1
roscpp rospy std_msgs

上面的操作等同于1.3中的 catkin_create_pkg 自定义ROS包名 roscpp rospy std_msgs

5.C++实现

在功能包的src下新建cpp文件，

1
2
3
4
5
6
7
8
9
10
11
12
13
/*
    控制台输出 HelloVSCode !!!
*/
#include "ros/ros.h"
int main(int argc, char *argv[])
{
   setlocale(LC_ALL,"");
   //执行节点初始化
   ros::init(argc,argv,"HelloVSCode");
   //输出日志
   ROS_INFO("Hello VSCode!!!哈哈哈哈哈哈哈哈哈哈");
   return 0;
}

**PS1:**如果没有代码提示,修改.vscode/c_cpp_properties.json 设置 “cppStandard”: “c++17”

PS2:main函数的参数不可以被const修饰

PS3:当ROS_INFO终端输出有中文时，会出现乱码.

解决办法：在函数开头加入下面代码的任意一句

1
2
setlocale(LC_CTYPE, "zh_CN.utf8");
setlocale(LC_ALL, "");

6.python实现

在功能包下新建 scripts 文件夹，添加 python 文件，并添加可执行权限，参照1.3

1
2
3
4
5
6
7
8
9
10
11
12
#! /usr/bin/env python
"""
   Python 版本的 HelloVScode，执行在控制台输出 HelloVScode
   实现:
   1.导包
   2.初始化 ROS 节点
   3.日志输出 HelloWorld
"""
import rospy # 1.导包
if __name__ == "__main__":
    rospy.init_node("Hello_Vscode_p")  # 2.初始化 ROS 节点
    rospy.loginfo("Hello VScode, 我是 Python ....")  #3.日志输出

7.配置CMakelist.txt

C++ 配置:

1
2
3
4
5
6
add_executable(节点名称
 src/C++源文件名.cpp
)
target_link_libraries(节点名称
 ${catkin_LIBRARIES}
)

Python 配置:

1
2
3
catkin_install_python(PROGRAMS scripts/自定义文件名.py
 DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION}
)

8.编译执行

编译: ctrl + shift + B

执行: 和之前一致，只是可以在 VScode 中添加终端，首先执行: 

1
source ./devel/setup.bash

1.5 ROS文件系统

1.5.1文件系统架构

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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: 编译的基本配置

主要学习package.xml和CMakeLists.txt 这两个配置文件。

1.5.2 package.xml

该文件定义有关软件包的属性，例如软件包名称，版本号，作者，维护者以及对其他catkin软件包的依 赖性。请注意，该概念类似于旧版 rosbuild 构建系统中使用的manifest.xml文件。

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
<?xml version="1.0"?>
<package format="2">
  <name>helloworld</name>
  <version>0.0.0</version>
  <description>The helloworld package</description>

  <!-- One maintainer tag required, multiple allowed, one person per tag -->
  <!-- Example:  -->
  <!-- <maintainer email="jane.doe@example.com">Jane Doe</maintainer> -->
  <maintainer email="ylm123@todo.todo">ylm123</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 -->
  <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/helloworld</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>

1.5.3 CMakelists.txt

文件CMakelists.txt是CMake构建系统的输入，用于构建软件包。任何兼容CMake的软件包都包含一 个或多个CMakeLists.txt文件，这些文件描述了如何构建代码以及将代码安装到何处。

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
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
cmake_minimum_required(VERSION 3.0.2)
project(helloworld)

## 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 helloworld
#  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}/helloworld.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
# add_executable(${PROJECT_NAME}_node src/helloworld_node.cpp)
# 声明 C++ 可执行文件
add_executable(helloworld
src/helloworld.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(${PROJECT_NAME}_node ${${PROJECT_NAME}_EXPORTED_TARGETS} ${catkin_EXPORTED_TARGETS})

## Specify libraries to link a library or executable target against
# target_link_libraries(${PROJECT_NAME}_node
#   ${catkin_LIBRARIES}
# )
#指定库、可执行文件的链接库
target_link_libraries(helloworld
${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/my_python_script
#   DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION}
# )
#设置用于安装的可执行脚本
catkin_install_python(PROGRAMS scripts/helloworld.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_helloworld.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)

1.5.4 ROS文件系统相关命令

ROS 的文件系统本质上都还是操作系统文件，我们可以使用Linux命令来操作这些文件，不过，在ROS 中为了更好的用户体验，ROS专门提供了一些类似于Linux的命令，这些命令较之于Linux原生命令，更为简洁、高效。文件操作，无外乎就是增删改查与执行等操作，接下来，我们就从这五个维度，来介绍 ROS文件系统的一些常用命令。

1.增

1
2
3
4
# 创建新的ROS功能包
catkin_create_pkg 自定义包名 依赖包 
# 安装 ROS功能包
sudo apt install xxx

2.删

1
2
# 删除某个功能包
sudo apt purge xxx

3.查

1
2
3
4
5
6
7
8
9
10
# 列出所有功能包
rospack list
# 查找某个功能包是否存在，如果存在返回安装路径
rospack find 包名
# 进入某个功能包
roscd 包名
# 列出某个包下的文件
rosls 包名
# 搜索某个功能包
apt search xxx

4.改

1
2
3
4
# 修改功能包文件
rosed 包名 文件名
#需要安装 vim 例如
rosed turtlesim Color.msg

5.执行

5.1 roscore
1
2
3
roscore
# 或(指定端口号)
roscore -p xxxx

roscore是 ROS 的系统先决条件节点和程序的集合， 必须运行 roscore 才能使 ROS 节点进行通 roscore 将启动:

  • ros master
  • ros 参数服务器
  • rosout 日志节点
5.2 rosrun
1
2
3
4
# 运行指定的ROS节点
rosrun 包名 可执行文件名
# 例如
rosrun turtlesim turtlesim_node
5.3 roslaunch
1
2
执行某个包下的 launch 文件
roslaunch 包名 文件名

1.6 ROS计算图

前面介绍的是ROS文件结构，是磁盘上 ROS 程序的存储结构，是静态的，而 ros 程序运行之后，不同的节点之间是错综复杂的，ROS 中提供了一个实用的工具:rqt_graph。 rqt_graph能够创建一个显示当前系统运行情况的动态图形。ROS 分布式系统中不同进程需要进行数据 交互，计算图可以以点对点的网络形式表现数据交互过程。rqt_graph是rqt程序包中的一部分。

1.6.1 计算图安装

如果未安装则在终端（terminal）中输入

1
2
sudo apt install ros-版本名称-rqt
sudo apt install ros-版本名称-rqt-common-plugins

请使用你的ROS版本名称（比如:kinetic、melodic、Noetic等）来替换掉。 例如当前版本是 Noetic,就在终端窗口中输入 

1
2
sudo apt install ros-noetic-rqt
sudo apt install ros-noetic-rqt-common-plugins

运行完项目后然后，启动新终端，键入: 

1
rqt_graph 或 rosrun rqt_graph rqt_graph

可以看到节点的网络拓扑图，该图可以显示不同节点之间的关系。