里面的例子参考官方教程，然后附带一些解释和一些推荐的便于理解的文章。
1 workspace
1.1 工作空间及其层次
空间的创建：ROS2与ROS1一样，创建工作空间目录，并在其中创建/src目录，用于存放package功能包。
层次的概念：ROS2增加了overlay和underlay的概念，用于在多个workspace同时工作时，处理各个workspace之间的层次问题，对于包名相同的package，上层workspace将覆盖(override)下层workspace中的同名package。
层次的配置：层次是通过环境变量配置的先后决定的，ROS通过setup.bash设置环境变量，ROS2安装路径一般设置为最下层的工作空间，即
$ source /opt/ros/foxy/setup.bash运行新建workspace的package功能包，需要在对工作空间编译后的新终端中配置如下
# 设置当前工作空间中功能包的相关环境变量
$ . install/local_setup.sh
# 设置当前工作空间中功能包的相关环境变量，同时设置该工作空间下其他底层工作空间的环境变量
$ . install/setup.sh # 就是说这一个捎带着把ROS2安装路径的环境变量也设置了1.2 检查依赖
编译前，需要对功能包检查依赖情况。
$ rosdep install -i --from-path src --rosdistro foxy -y1.3 编译工具 colcon
# 在workspace根目录编译工程
$ colcon build
# 有选择地编译包
$ colcon build --packages-select <package_name>有关编译，可看一下后续的系列第七篇——编译。
2 编写 package
每一个package都能实现一个相对完整的功能。
2.1 功能包创建
# 创建cmake功能包（在~/ws/src下）
$ ros2 pkg create --build-type ament_cmake <package_name>
# 创建cmake功能包（在~/ws/src下）
# --dependencies 参数会将后边的依赖自动添加到package.xml和CMakeLists.txt中
$ ros2 pkg create --build-type ament_cmake <package_name> --dependencies <depend_name>
# 创建cmake功能包（在~/ws/src下）
# --node-name 参数将创建节点，但只能创建一个节点，注意参数位置
$ ros2 pkg create --build-type ament_cmake --node-name <node_name> <package_name>
# 例如（在~/ws/src下）
$ ros2 pkg create --build-type ament_cmake --node-name my_node my_package --dependencies rclcpp
# 将会在~/ws/src创建如下目录
workspace_folder/
src/
my_package/
src/
my_node.cpp
include/
my_package/
CMakeLists.txt
package.xml2.2 package.xml 和 CMakeLists.txt
使用ament编译系统的功能包会对应生成两个文件package.xml和CMakeLists.txt。
package.xml：描述了功能包的发行信息、依赖信息等，内容如下。在自动创建后，需要手动修改功能包描述、功能包版本、功能包许可证信息等发行信息。以“ _depend”结尾的标签用来描述功能包依赖，在增加新的依赖时，需要添加到其中。
<!-- 功能包基础内容，不用修改 -->
<?xml version="1.0"?>
<?xml-model href="http://download.ros.org/schema/package_format3.xsd" schematypens="http://www.w3.org/2001/XMLSchema"?>
<!-- 下面是功能包的信息 -->
<package format="3">
<!-- 包名，新建的时候就定了，不改 -->
<name>cpp_srvcli</name>
<!-- 关于发行信息 -->
<version>0.0.0</version>
<description>这里写功能描述</description>
<maintainer email="这里写邮箱地址">Your Name</maintainer>
<license>这里写许可证</license>
<!-- 编译系统的依赖 -->
<buildtool_depend>ament_cmake</buildtool_depend>
<!-- 程序所需的依赖，根据需要修改添加 -->
<depend>rclcpp</depend>
<!-- 编译系统，新建功能包的时候可以指定 -->
<export>
<build_type>ament_cmake</build_type>
</export>
</package>CMakeLists.txt：制定各文件或包的编译顺序的文档，如何编写CMakeLists.txt参见本系列第七篇——编译。文档基本结构如下。
cmake_minimum_required(VERSION 3.5) //cmake版本要求
project(my_project) //功能包名，与同一功能包下package.xml中名字一样
ament_package() //配置project，只调用一次，且在最后2.3 功能包编译、设置环境变量、运行
# 记得检查依赖
$ rosdep install -i --from-path src --rosdistro foxy -y
# 编译，见上一小节
$ colcon build
# 新终端设置环境变量
$ . install/setup.bash
# 运行包里的某个节点，运行多个节点、多个包，可使用launch文件
$ ros2 run <package_name> <node_name>3 编写 topic
新建工作空间，并新建话题功能包（这里包名是cpp_pubsub）。
3.1 发布 publisher
在功能包的/src目录下，编写话题发布节点，publisher_member_function.cpp
#include <chrono> //c++11日期和时间库
#include <functional> //参见 注1
#include <memory> //c++内存管理库，使用智能指针必须包含此头文件
#include <string>
#include "rclcpp/rclcpp.hpp" //ROS2，C++接口的头文件
#include "std_msgs/msg/string.hpp" //string类型的msg头文件
using namespace std::chrono_literals;
/* This example creates a subclass of Node and uses std::bind() to register a
* member function as a callback from the timer. */
//定义一个节点类的子类
class MinimalPublisher : public rclcpp::Node
{
public:
//构造函数：初始化节点名 minimal_publisher，然后创建了一个publisher和定时器
MinimalPublisher(): Node("minimal_publisher"), count_(0)
{
//创建一个发布者，发布的话题名为topic，话题消息是String，保存消息的队列长度是10
publisher_ = this->create_publisher<std_msgs::msg::String>("topic", 10);
//创建一个定时器，定时500ms，定时触发回调函数timer_callback。
//这里用到了<functional>的一个特性
timer_ = this->create_wall_timer(500ms, std::bind(&MinimalPublisher::timer_callback, this));
}
private:
//定时触发回调函数
void timer_callback()
{
//定义消息
auto message = std_msgs::msg::String();
message.data = "Hello, world! " + std::to_string(count_++);
//打印日志
RCLCPP_INFO(this->get_logger(), "Publishing: '%s'", message.data.c_str());
//发布
publisher_->publish(message);
}
//定义定时器和发布者指针
rclcpp::TimerBase::SharedPtr timer_;
rclcpp::Publisher<std_msgs::msg::String>::SharedPtr publisher_;
size_t count_;
};
int main(int argc, char * argv[])
{
rclcpp::init(argc, argv);
rclcpp::spin(std::make_shared<MinimalPublisher>());
rclcpp::shutdown();
return 0;
}注：
1、#include < functional > ，感兴趣的读者可以看下这篇博客，写的蛮不错的。
3.2 订阅 subscriber
在功能包的/src目录下，编写话题订阅节点，subscriber_member_function.cpp
#include <memory>
#include "rclcpp/rclcpp.hpp"
#include "std_msgs/msg/string.hpp"
using std::placeholders::_1;
class MinimalSubscriber : public rclcpp::Node
{
public:
MinimalSubscriber() : Node("minimal_subscriber")
{
subscription_ = this->create_subscription<std_msgs::msg::String>(
"topic", 10, std::bind(&MinimalSubscriber::topic_callback, this, _1));
}
private:
void topic_callback(const std_msgs::msg::String::SharedPtr msg) const
{
RCLCPP_INFO(this->get_logger(), "I heard: '%s'", msg->data.c_str());
}
rclcpp::Subscription<std_msgs::msg::String>::SharedPtr subscription_;
};
int main(int argc, char * argv[])
{
rclcpp::init(argc, argv);
rclcpp::spin(std::make_shared<MinimalSubscriber>());
rclcpp::shutdown();
return 0;
}3.3 修改 package.xml / CMakeLists.txt
package.xml 添加如下依赖，如果创建包时，使用了–dependencies，则文件内已有如下语句。
<depend>rclcpp</depend>
<depend>std_msgs</depend>CMakeLists.txt 添加如下编译规则，如果创建包时，使用了–dependencies，则文件内已有find_package相关的语句。
# 搜索依赖
find_package(rclcpp REQUIRED)
find_package(std_msgs REQUIRED)
# 创建可执行程序talker，后续参数是构成可执行文件的所有源文件
add_executable(talker src/publisher_member_function.cpp)
# 链接find_package()找到的包
ament_target_dependencies(talker rclcpp std_msgs)
add_executable(listener src/subscriber_member_function.cpp)
ament_target_dependencies(listener rclcpp std_msgs)
install(TARGETS
talker
listener
DESTINATION
lib/${PROJECT_NAME})3.4 编译、运行两个节点
# 在工作空间根目录下，检查依赖
$ rosdep install -i --from-path src --rosdistro foxy -y
# 编译
$ colcon build
# 配置环境变量，然后运行
$ . install/setup.bash
$ ros2 run cpp_pubsub talker
# 打开另一个终端，配置环境变量，运行
$ . install/setup.bash
$ ros2 run cpp_pubsub listener4 编写 service
新建工作空间，并新建服务功能包（这里包名是cpp_srvcli）。
4.1 服务器端 server
在功能包的/src目录下，创建服务器端节点，add_two_ints_server.cpp
#include "example_interfaces/srv/add_two_ints.hpp"
#include "rclcpp/rclcpp.hpp"
#include <memory>
void add(const std::shared_ptr<example_interfaces::srv::AddTwoInts::Request> request,
std::shared_ptr<example_interfaces::srv::AddTwoInts::Response> response)
{
response->sum = request->a + request->b;
RCLCPP_INFO(rclcpp::get_logger("rclcpp"), "Incoming request\na: %ld" " b: %ld",
request->a, request->b);
RCLCPP_INFO(rclcpp::get_logger("rclcpp"), "sending back response: [%ld]", (long int)response->sum);
}
int main(int argc, char **argv)
{
rclcpp::init(argc, argv);
//创建名为add_two_ints_server的节点
std::shared_ptr<rclcpp::Node> node = rclcpp::Node::make_shared("add_two_ints_server");
//创建名为add_two_ints的服务，绑定回调函数add
rclcpp::Service<example_interfaces::srv::AddTwoInts>::SharedPtr service =
node->create_service<example_interfaces::srv::AddTwoInts>("add_two_ints", &add);
RCLCPP_INFO(rclcpp::get_logger("rclcpp"), "Ready to add two ints.");
//入锁，等待客户端请求
rclcpp::spin(node);
rclcpp::shutdown();
}
4.2 客户端 client
在功能包的/src目录下，创建客户端节点，add_two_ints_client.cpp
#include "rclcpp/rclcpp.hpp"
#include "example_interfaces/srv/add_two_ints.hpp"
#include <chrono>
#include <cstdlib>
#include <memory>
using namespace std::chrono_literals;
int main(int argc, char **argv)
{
rclcpp::init(argc, argv);
if (argc != 3)
{
RCLCPP_INFO(rclcpp::get_logger("rclcpp"), "usage: add_two_ints_client X Y");
return 1;
}
//创建名为add_two_ints_client的节点
std::shared_ptr<rclcpp::Node> node = rclcpp::Node::make_shared("add_two_ints_client");
//创建名为add_two_ints的客户端
rclcpp::Client<example_interfaces::srv::AddTwoInts>::SharedPtr client =
node->create_client<example_interfaces::srv::AddTwoInts>("add_two_ints");
//采集request数据
auto request = std::make_shared<example_interfaces::srv::AddTwoInts::Request>();
request->a = atoll(argv[1]);
request->b = atoll(argv[2]);
//search for service
while (!client->wait_for_service(1s))
{
if (!rclcpp::ok())
{
RCLCPP_ERROR(rclcpp::get_logger("rclcpp"), "Interrupted while waiting for the service. Exiting.");
return 0;
}
RCLCPP_INFO(rclcpp::get_logger("rclcpp"), "service not available, waiting again...");
}
//发送request
auto result = client->async_send_request(request);
// Wait for the result.
if (rclcpp::spin_until_future_complete(node, result) == rclcpp::FutureReturnCode::SUCCESS)
{
RCLCPP_INFO(rclcpp::get_logger("rclcpp"), "Sum: %ld", result.get()->sum);
}
else
{
RCLCPP_ERROR(rclcpp::get_logger("rclcpp"), "Failed to call service add_two_ints");
}
rclcpp::shutdown();
return 0;
}4.3 修改 package.xml / CMakeLists.txt
package.xml 添加如下依赖，如果创建包时，使用了–dependencies，则文件内已有如下语句。
<depend>rclcpp</depend>
<depend>example_interfaces</depend>CMakeLists.txt 添加如下编译规则，如果创建包时，使用了–dependencies，则文件内已有find_package相关的语句。
# 搜索依赖
find_package(rclcpp REQUIRED)
find_package(example_interfaces REQUIRED)
# 创建可执行程序server，后续参数是构成可执行文件的所有源文件
add_executable(server src/add_two_ints_server.cpp)
# 链接find_package()找到的包
ament_target_dependencies(server rclcpp example_interfaces)
add_executable(client src/add_two_ints_client.cpp)
ament_target_dependencies(client rclcpp example_interfaces)
install(TARGETS
server
client
DESTINATION lib/${PROJECT_NAME})4.4 编译、运行两个节点
# 在工作空间根目录下，检查依赖
$ rosdep install -i --from-path src --rosdistro foxy -y
# 编译
$ colcon build
# 配置环境变量，然后运行
$ . install/setup.bash
$ ros2 run cpp_srvcli server
# 打开另一个终端，配置环境变量，运行
$ . install/setup.bash
$ ros2 run cpp_srvcli client 2 35 自定义消息 msg/srv
5.1 创建消息功能包
1、新建工作空间，并新建消息功能包（这里包名是tutorial_interfaces）。在消息功能包下，创建/msg和/srv文件夹（与/src同级），并在其中分别建立.msg和.srv文件，有关消息内容，详见本系列第三篇《ROS2_Foxy学习（三）核心概念》。
Num.msg
int64 numAddThreeInts.srv
int64 a
int64 b
int64 c
---
int64 sum2、在package.xml文件中添加
<build_depend>rosidl_default_generators</build_depend>
<exec_depend>rosidl_default_runtime</exec_depend>
<member_of_group>rosidl_interface_packages</member_of_group>注：rosidl_default_generators为编译依赖，rosidl_default_runtime为运行依赖。
3、在CMakeLists.txt文件中添加
find_package(rosidl_default_generators REQUIRED)
# You can use set to neatly list all of your interfaces:
set(msg_files
"msg/Num.msg"
"msg/Message1.msg"
"msg/Message2.msg"
# etc
)
set(srv_files
"srv/AddThreeInts.srv"
"srv/Service1.srv"
"srv/Service2.srv"
# etc
)
#And generate all lists at once like so:
rosidl_generate_interfaces(${PROJECT_NAME}
${msg_files}
${srv_files}
)
ament_export_dependencies(rosidl_default_runtime)注：可以省略set的步骤，在rosidl_generate_interfaces直接添加，如下，但不建议，还是需要一个良好的编程习惯。
rosidl_generate_interfaces(${PROJECT_NAME}
"msg/Num.msg"
"srv/AddThreeInts.srv"
)5.2 测试自定义消息接口
功能包编译后（没有节点，没有运行），可以通过命令ros2 interface show来查看消息文件。
5.3 应用自定义消息接口
在同一个工作空间下，除消息功能包外，再创建两个功能包，分别是话题功能包和服务功能包，参考3、4部分。
1、CMakeLists.txt和package.xml与第3、4部分基本一致，其中，需要将消息依赖包（std_msgs和example_interfaces）替换成新建的消息功能包名，如tutorial_interfaces。
2、各节点src文件，需要将消息类型进行替换，src文件修改见附件1。
3、之后，编译运行（查依赖、编译包、配置环境、运行节点）。
5.4 使用同一功能包的消息接口
若功能包需要使用自己定义的接口，需要在CMakeLists.txt中添加以下内容（In order to use the messages generated in the same package.）。
rosidl_target_interfaces(publish_address_book
${PROJECT_NAME} "rosidl_typesupport_cpp")注：publish_address_book是编译生成的可执行程序名。
6 使用 parameter
新建工作空间，并新建参数功能包（这里包名是cpp_parameters），使用参数dependencies，自动添加依赖rclcpp。
6.1 参数的声明与获取
在功能包的/src目录下，创建节点，cpp_parameters_node.cpp
#include <rclcpp/rclcpp.hpp>
#include <chrono>
#include <string>
#include <functional>
using namespace std::chrono_literals;
class ParametersClass: public rclcpp::Node
{
public:
ParametersClass() : Node("parameter_node")
{
//声明：定义参数名及其值
this->declare_parameter<std::string>("my_parameter", "world");
//
timer_ = this->create_wall_timer(1000ms, std::bind(&ParametersClass::respond, this));
}
//获取：定时打印参数值
void respond()
{
this->get_parameter("my_parameter", parameter_string_);
RCLCPP_INFO(this->get_logger(), "Hello %s", parameter_string_.c_str());
}
private:
std::string parameter_string_;
rclcpp::TimerBase::SharedPtr timer_;
};
int main(int argc, char** argv)
{
rclcpp::init(argc, argv);
rclcpp::spin(std::make_shared<ParametersClass>());
rclcpp::shutdown();
return 0;
}修改CMakelists.txt，然后编译运行。
add_executable(parameter_node src/cpp_parameters_node.cpp)
ament_target_dependencies(parameter_node rclcpp)
install(TARGETS
parameter_node
DESTINATION lib/${PROJECT_NAME}
)6.2 终端修改参数
有关内容，详见本系列第三篇《ROS2_Foxy学习（三）核心概念》
$ ros2 param list
$ ros2 param set <node_name> <parameter_name> <value>6.3 launch文件修改参数
在功能包的/launch目录下，创建launch文件，cpp_parameters_launch.py，修改parameters。
from launch import LaunchDescription
from launch_ros.actions import Node
def generate_launch_description():
return LaunchDescription([
Node(
package="cpp_parameters",
executable="parameter_node",
name="custom_parameter_node",
output="screen",
emulate_tty=True,
parameters=[
{"my_parameter": "earth"}
]
)
])修改CMakelists.txt，在6.1部分中CMakelists.txt最后增加以下部分。
install(
DIRECTORY launch
DESTINATION share/${PROJECT_NAME}
)编译，然后运行launch文件。
$ ros2 launch cpp_parameters cpp_parameters_launch.py附件1 消息文件应用
1、话题功能包——消息发布节点——publisher_member_function.cpp
#include <chrono>
#include <functional>
#include <memory>
#include <string>
#include "rclcpp/rclcpp.hpp"
#include "tutorial_interfaces/msg/num.hpp"
using namespace std::chrono_literals;
/* This example creates a subclass of Node and uses std::bind() to register a* member function as a callback from the timer. */
class MinimalPublisher : public rclcpp::Node
{
public:
MinimalPublisher(): Node("minimal_publisher"), count_(0)
{
publisher_ = this->create_publisher<tutorial_interfaces::msg::Num>("topic", 10); //10 是消息队列长度
timer_ = this->create_wall_timer(500ms,std::bind(&MinimalPublisher::timer_callback, this));
}
private:
void timer_callback()
{
auto message = tutorial_interfaces::msg::Num();
message.num = this->count_++;
RCLCPP_INFO(this->get_logger(), "Publishing: '%d'", message.num);
publisher_->publish(message);
}
rclcpp::TimerBase::SharedPtr timer_;
rclcpp::Publisher<tutorial_interfaces::msg::Num>::SharedPtr publisher_;
size_t count_;
};
int main(int argc, char * argv[])
{
rclcpp::init(argc, argv);
rclcpp::spin(std::make_shared<MinimalPublisher>());
rclcpp::shutdown();
return 0;
}2、话题功能包——消息订阅节点——subscriber_member_function.cpp
#include <memory>
#include "rclcpp/rclcpp.hpp"
#include "tutorial_interfaces/msg/num.hpp"
using std::placeholders::_1;
class MinimalSubscriber : public rclcpp::Node
{
public:
MinimalSubscriber(): Node("minimal_subscriber")
{
subscription_ = this->create_subscription<tutorial_interfaces::msg::Num>("topic", 10, std::bind(&MinimalSubscriber::topic_callback, this, _1));
}
private:
void topic_callback(const tutorial_interfaces::msg::Num::SharedPtr msg) const
{
RCLCPP_INFO(this->get_logger(), "I heard: '%d'", msg->num);
}
rclcpp::Subscription<tutorial_interfaces::msg::Num>::SharedPtr subscription_;};
int main(int argc, char * argv[])
{
rclcpp::init(argc, argv);
rclcpp::spin(std::make_shared<MinimalSubscriber>());
rclcpp::shutdown();
return 0;
}3、服务功能包——服务器端节点——add_three_ints_server.cpp
#include "tutorial_interfaces/srv/add_three_ints.hpp"
#include "rclcpp/rclcpp.hpp"
#include <memory>
void add(const std::shared_ptr<tutorial_interfaces::srv::AddThreeInts::Request> request,
std::shared_ptr<tutorial_interfaces::srv::AddThreeInts::Response> response)
{
response->sum = request->a + request->b + request->c;
RCLCPP_INFO(rclcpp::get_logger("rclcpp"), "Incoming request\na: %ld" " b: %ld" " c: %ld",
request->a, request->b, request->b);
RCLCPP_INFO(rclcpp::get_logger("rclcpp"), "sending back response: [%ld]", (long int)response->sum);
}
int main(int argc, char **argv)
{
rclcpp::init(argc, argv);
//创建名为add_two_ints_server的节点
std::shared_ptr<rclcpp::Node> node = rclcpp::Node::make_shared("add_three_ints_server");
//创建名为add_two_ints的服务，绑定回调函数add
rclcpp::Service<tutorial_interfaces::srv::AddThreeInts>::SharedPtr service =
node->create_service<tutorial_interfaces::srv::AddThreeInts>("add_three_ints", &add);
RCLCPP_INFO(rclcpp::get_logger("rclcpp"), "Ready to add three ints.");
//入锁，等待客户端请求
rclcpp::spin(node);
rclcpp::shutdown();
}4、服务功能包——客户端节点——add_three_ints_client.cpp
#include "rclcpp/rclcpp.hpp"
#include "tutorial_interfaces/srv/add_three_ints.hpp"
#include <chrono>
#include <cstdlib>
#include <memory>
using namespace std::chrono_literals;
int main(int argc, char **argv)
{
rclcpp::init(argc, argv);
if (argc != 4)
{
RCLCPP_INFO(rclcpp::get_logger("rclcpp"), "usage: add_two_ints_client X Y Z");
return 1;
}
//创建名为add_three_ints_client的节点
std::shared_ptr<rclcpp::Node> node = rclcpp::Node::make_shared("add_three_ints_client");
//创建名为add_three_ints的客户端
rclcpp::Client<tutorial_interfaces::srv::AddThreeInts>::SharedPtr client =
node->create_client<tutorial_interfaces::srv::AddThreeInts>("add_three_ints");
//采集request数据
auto request = std::make_shared<tutorial_interfaces::srv::AddThreeInts::Request>();
request->a = atoll(argv[1]);
request->b = atoll(argv[2]);
request->c = atoll(argv[3]);
//search for service
while (!client->wait_for_service(1s))
{
if (!rclcpp::ok())
{
RCLCPP_ERROR(rclcpp::get_logger("rclcpp"), "Interrupted while waiting for the service. Exiting.");
return 0;
}
RCLCPP_INFO(rclcpp::get_logger("rclcpp"), "service not available, waiting again...");
}
//发送request
auto result = client->async_send_request(request);
// Wait for the result.
if (rclcpp::spin_until_future_complete(node, result) == rclcpp::FutureReturnCode::SUCCESS)
{
RCLCPP_INFO(rclcpp::get_logger("rclcpp"), "Sum: %ld", result.get()->sum);
}
else
{
RCLCPP_ERROR(rclcpp::get_logger("rclcpp"), "Failed to call service add_three_ints");
}
rclcpp::shutdown();
return 0;
}
