ROS WIKI 教程 Documentation - ROS Wiki
安装ROS之前要修改软件有源,家庭网一般用阿里源,学校网一般用.edu结尾的。
CTRL + alt + T快捷键打开终端
cd .. :返回上一级目录
mkdir 文件夹名称:创建文件夹
ls :查看当前路径下的文件目录
touch 文件名称:创建一个文件(.txt格式等)
mv 文件名称 路径:将文件剪切到路径下,例如:mv test_file /home/hcx
cp 文件名称 路径/文件的重命名:将文件复制到新的路径下,并且重命名,如果不重命名,则“/”后面可以不写东西,例如:cd test_file test_folder/test_file2,意思是将文件test_file复制到test_folder里面,并且重命名为test_file2
rm 文件名称:删除文件,如:rm test_file
rm -r 文件夹/:删除文件夹,如:rm -r test_folder/
sudo apt-get update :更新系统当前软件源列表
rm --help:查看 “rm” 指令的帮助信息
C++先编译:g++ .cpp文件名 -o 编译后的文件名
再运行:./编译后的文件名
参考网上各种链接。
roscore
rosrun turtlesim turtlesim_node
rosrun turtlesim turtle_teleop_keyrqt_graph
rosnode list 列出系统所有节点
rosnode info /turtlesim
rosnode info /节点 查看节点信息,发布的话题,位置等信息
rostopic
rostopic list 打印系统所有话题列表
(1)rostopic pub /turtle1/cmd_vel geometry_msgs/Twist tab键:
rostopic pub /turtle1/cmd_vel geometry_msgs/Twist "linear:
x: 1.0
y: 0.0
z: 0.0
angular:
x: 0.0
y: 0.0
z: 0.0"
(2)rostopic pub /turtle1/cmd_vel geometry_msgs/Twist "linear:
x: 1.0
y: 0.0
z: 0.0
angular:
x: 0.0
y: 0.0
z: 1.0"
(3)rostopic pub -r 10 /turtle1/cmd_vel geometry_msgs/Twist "linear:
x: 1.0
y: 0.0
z: 0.0
angular:
x: 0.0
y: 0.0
z: 0.0"
rosmsg show geometry_msgs/Twist 显示Twist数据结构
rosservice list 服务
(1)rosservice call /spawn "x: 2.0
y: 0.0
theta: 0.0
name: 'turtle2'"
name: "turtle2"(2)rosservice call /spawn "x: 2.0
y: 2.0
theta: 0.0
name: 'turtle3'"
name: "turtle3"
rostopic list
rosbag record -a -o cmp_record 记录小海龟运行数据
运行完后,CTRL + c即可
rosbag play cmp_record_2022-04-04-19-52-32.bag 复现记录的数据,小海龟复现之前执行的动作
src:代码空间,放置功能包(功能包的代码、launch文件、配置文件等)
build:编译空间,编译过程中产生的中间文件
devel:开发空间,编译生成的可执行文件、库、脚本,最终编译的文件都是在这里运行
install:安装空间
mkdir catkin_ws 创建工作空间
cd catkin_ws/ 进入工作空间
mkdir src 在工作空间下创建src文件
catkin_init_workspace 初始化当前文件夹,编成一个ROS Workspace
catkin_ws//src 下存在 CMakeLists.txt说明当前路径已经是一个ROS工作空间了
cd .. 回到工作空间catkin_ws下
pwd 显示当前路径
catkin_make 编译工作空间catkin_ws
catkin_make install
功能包一定要放在src文件夹下面
cd src/ 进入src文件夹下
创建一个名为test_pkg的功能包,功能包test_pkg下的src文件夹用来放置代码文件,include文件夹放一些.h文件,CMakeLists.txt和package.xml是每个功能包必须存在的两个文件,这样才标志这个文件夹叫功能包,而不是一个普通的文件夹。
catkin_create_pkg test_pkg roscpp rospy std_msgs
cd .. 回到catkin_ws工作空间
catkin_make 编译工作空间
source devel/setup.bash 设置工作空间的环境变量,系统才能找到工作空间和其对应的功能包
echo $ROS_PACKAGE_PATH 通过环境变量检查所有ROS功能包的路径
功能包test_pkg 下的package.xml包含了功能包的依赖(roscpp rospy std_msgs等)以及开发者的信息
功能包test_pkg 下的CMakeLists.txt描述功能包的编译规则,使用的是Cmake语法
同一个工作空间下的功能包不能重名,不同工作空间下功能包可以重名
通过写程序让小海龟动起来,不是之前的命令行形式
cd src/ 进入src文件夹下
catkin_create_pkg learning_topic roscpp rospy std_msgs geometry_msgs turtlesim
创建功能包learning_topic,并添加依赖为roscpp rospy std_msgs geometry_msgs turtlesim
编写 velocity_publisher.cpp文件
/**
* 该例程将发布turtle1/cmd_vel话题,消息类型geometry_msgs::Twist,控制小海龟完成速度指令运动
*/
// velocity_publisher.cpp文件
#include
#include
int main(int argc, char **argv)
{
// ROS节点初始化
ros::init(argc, argv, "velocity_publisher");
// 创建节点句柄
ros::NodeHandle n;
// 创建一个Publisher,发布名为/turtle1/cmd_vel的topic,消息类型为geometry_msgs::Twist,队列长度10
ros::Publisher turtle_vel_pub = n.advertise("/turtle1/cmd_vel", 10);
// 设置循环的频率
ros::Rate loop_rate(10);
int count = 0;
while (ros::ok())
{
// 初始化geometry_msgs::Twist类型的消息
geometry_msgs::Twist vel_msg;
vel_msg.linear.x = 0.5;
vel_msg.angular.z = 0.2;
// 发布消息
turtle_vel_pub.publish(vel_msg);
ROS_INFO("Publsh turtle velocity command[%0.2f m/s, %0.2f rad/s]",
vel_msg.linear.x, vel_msg.angular.z);
// 按照循环频率延时
loop_rate.sleep();
}
return 0;
}
learning_topic/CMakeLists.txt中添加下面两行:
add_executable(velocity_publisher src/velocity_publisher.cpp)
target_link_libraries(velocity_publisher ${catkin_LIBRARIES})
编译:
cd ~/catkin_ws 回到工作空间下
catkin_make 编译工作空间
source devel/setup.bash 设置环境变量,为了避免忘记设置,直接在主文件夹下面的.bashrc文件中添加该设置语句:source /home/cy/catkin_ws/devel/setup.bash,然后重新启动终端,这样就不用在每次运行程序时都重新设置环境变量,并且可以在任意目录下执行rosrun命令
roscore
rosrun turtlesim turtlesim_node 运行小海龟节点
rosrun learning_topic velocity_publisher
python版程序:velocity_publisher.py
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# 该例程将发布turtle1/cmd_vel话题,消息类型geometry_msgs::Twist
# velocity_publisher.py
import rospy
from geometry_msgs.msg import Twist
def velocity_publisher():
# ROS节点初始化
rospy.init_node('velocity_publisher', anonymous=True)
# 创建一个Publisher,发布名为/turtle1/cmd_vel的topic,消息类型为geometry_msgs::Twist,队列长度10
turtle_vel_pub = rospy.Publisher('/turtle1/cmd_vel', Twist, queue_size=10)
#设置循环的频率
rate = rospy.Rate(10)
while not rospy.is_shutdown():
# 初始化geometry_msgs::Twist类型的消息
vel_msg = Twist()
vel_msg.linear.x = 0.5
vel_msg.angular.z = 0.2
# 发布消息
turtle_vel_pub.publish(vel_msg)
rospy.loginfo("Publsh turtle velocity command[%0.2f m/s, %0.2f rad/s]",
vel_msg.linear.x, vel_msg.angular.z)
# 按照循环频率延时
rate.sleep()
if __name__ == '__main__':
try:
velocity_publisher()
except rospy.ROSInterruptException:
pass
/**
* 该例程将订阅/turtle1/pose话题,消息类型turtlesim::Pose
*/
// pose_subscriber.cpp
#include
#include "turtlesim/Pose.h"
// 接收到订阅的消息后,会进入消息回调函数
void poseCallback(const turtlesim::Pose::ConstPtr& msg)
{
// 将接收到的消息打印出来
ROS_INFO("Turtle pose: x:%0.6f, y:%0.6f", msg->x, msg->y);
}
int main(int argc, char **argv)
{
// 初始化ROS节点
ros::init(argc, argv, "pose_subscriber");
// 创建节点句柄
ros::NodeHandle n;
// 创建一个Subscriber,订阅名为/turtle1/pose的topic,注册回调函数poseCallback
ros::Subscriber pose_sub = n.subscribe("/turtle1/pose", 10, poseCallback);
// 循环等待回调函数
ros::spin();
return 0;
}
learning_topic/CMakeLists.txt中添加下面两行:
add_executable(pose_subscriber src/pose_subscriber.cpp)
target_link_libraries(pose_subscriber ${catkin_LIBRARIES})
编译运行:
cd ~/catkin_ws
catkin_make
source devel/setup.bash
roscore
rosrun turtlesim turtlesim_node
rosrun learning_topic velocity_publisherrosrun learning_topic velocity_publisher
python代码:pose_subscriber.py
python代码不需要编译,而是直接运行
rosrun learning_topic pose_subscriber.py
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# 该例程将订阅/turtle1/pose话题,消息类型turtlesim::Pose
# pose_subscriber.py
import rospy
from turtlesim.msg import Pose
def poseCallback(msg):
rospy.loginfo("Turtle pose: x:%0.6f, y:%0.6f", msg.x, msg.y)
def pose_subscriber():
# ROS节点初始化
rospy.init_node('pose_subscriber', anonymous=True)
# 创建一个Subscriber,订阅名为/turtle1/pose的topic,注册回调函数poseCallback
rospy.Subscriber("/turtle1/pose", Pose, poseCallback)
# 循环等待回调函数
rospy.spin()
if __name__ == '__main__':
pose_subscriber()
(1)在路径/home/cy/catkin_ws/src/learning_topic创建msg文件夹;
(2)然后在/home/cy/catkin_ws/src/learning_topic/msg下创建Person.msg文件,Person.msg文件内容如下:string name
uint8 sex
uint8 ageuint8 unknown = 0
uint8 male = 1
uint8 female = 2
(3)在/home/cy/catkin_ws/src/learning_topic/package.xml中添加功能包依赖:message_generation 编译依赖
message_runtime 运行依赖
(4) 在/home/cy/catkin_ws/src/learning_topic/CMakeLists.txt添加编译选项:
• find_package( …… message_generation)
• add_message_files(FILES Person.msg)
generate_messages(DEPENDENCIES std_msgs)
• catkin_package(…… message_runtime)
编译生成语言相关文件::
/home/cy/catkin_ws 回到工作空间下
catkin_make 进行编译
/home/cy/catkin_ws/devel/include/learning_topic目录下生成一个Person.h文件
如何调用Person文件?
person_publisher.cpp代码:
/**
* 该例程将发布/person_info话题,自定义消息类型learning_topic::Person
*/
// person_publisher.cpp
#include
#include "learning_topic/Person.h"
int main(int argc, char **argv)
{
// ROS节点初始化
ros::init(argc, argv, "person_publisher");
// 创建节点句柄
ros::NodeHandle n;
// 创建一个Publisher,发布名为/person_info的topic,消息类型为learning_topic::Person,队列长度10
ros::Publisher person_info_pub = n.advertise("/person_info", 10);
// 设置循环的频率
ros::Rate loop_rate(1);
int count = 0;
while (ros::ok())
{
// 初始化learning_topic::Person类型的消息
learning_topic::Person person_msg;
person_msg.name = "Tom";
person_msg.age = 18;
person_msg.sex = learning_topic::Person::male;
// 发布消息
person_info_pub.publish(person_msg);
ROS_INFO("Publish Person Info: name:%s age:%d sex:%d",
person_msg.name.c_str(), person_msg.age, person_msg.sex);
// 按照循环频率延时
loop_rate.sleep();
}
return 0;
}
person_subscriber.cpp代码:
/**
* 该例程将订阅/person_info话题,自定义消息类型learning_topic::Person
*/
// person_subscriber.cpp
#include
#include "learning_topic/Person.h"
// 接收到订阅的消息后,会进入消息回调函数
void personInfoCallback(const learning_topic::Person::ConstPtr& msg)
{
// 将接收到的消息打印出来
ROS_INFO("Subcribe Person Info: name:%s age:%d sex:%d",
msg->name.c_str(), msg->age, msg->sex);
}
int main(int argc, char **argv)
{
// 初始化ROS节点
ros::init(argc, argv, "person_subscriber");
// 创建节点句柄
ros::NodeHandle n;
// 创建一个Subscriber,订阅名为/person_info的topic,注册回调函数personInfoCallback
ros::Subscriber person_info_sub = n.subscribe("/person_info", 10, personInfoCallback);
// 循环等待回调函数
ros::spin();
return 0;
}
配置代码编译规则:
将下面全复制到/home/cy/catkin_ws/src/learning_topic/CMakeLists.txt文件中
add_executable(person_publisher src/person_publisher.cpp)
target_link_libraries(person_publisher ${catkin_LIBRARIES})
add_dependencies(person_publisher ${PROJECT_NAME}_generate_messages_cpp)
add_executable(person_subscriber src/person_subscriber.cpp)
target_link_libraries(person_subscriber ${catkin_LIBRARIES})
add_dependencies(person_subscriber ${PROJECT_NAME}_generate_messages_cpp)
编译并运行发布者和订阅者:
cd ~/catkin_ws
catkin_make
source devel/setup.bash
roscore
rosrun learning_topic person_subscriber
rosrun learning_topic person_publisher
python版实现:
person_publisher.py代码:
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# 该例程将发布/person_info话题,自定义消息类型learning_topic::Person
# person_publisher.py
import rospy
from learning_topic.msg import Person
def velocity_publisher():
# ROS节点初始化
rospy.init_node('person_publisher', anonymous=True)
# 创建一个Publisher,发布名为/person_info的topic,消息类型为learning_topic::Person,队列长度10
person_info_pub = rospy.Publisher('/person_info', Person, queue_size=10)
#设置循环的频率
rate = rospy.Rate(10)
while not rospy.is_shutdown():
# 初始化learning_topic::Person类型的消息
person_msg = Person()
person_msg.name = "Tom";
person_msg.age = 18;
person_msg.sex = Person.male;
# 发布消息
person_info_pub.publish(person_msg)
rospy.loginfo("Publsh person message[%s, %d, %d]",
person_msg.name, person_msg.age, person_msg.sex)
# 按照循环频率延时
rate.sleep()
if __name__ == '__main__':
try:
velocity_publisher()
except rospy.ROSInterruptException:
pass
person_subscriber.py代码:
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# 该例程将订阅/person_info话题,自定义消息类型learning_topic::Person
# person_subscriber.py
import rospy
from learning_topic.msg import Person
def personInfoCallback(msg):
rospy.loginfo("Subcribe Person Info: name:%s age:%d sex:%d",
msg.name, msg.age, msg.sex)
def person_subscriber():
# ROS节点初始化
rospy.init_node('person_subscriber', anonymous=True)
# 创建一个Subscriber,订阅名为/person_info的topic,注册回调函数personInfoCallback
rospy.Subscriber("/person_info", Person, personInfoCallback)
# 循环等待回调函数
rospy.spin()
if __name__ == '__main__':
person_subscriber()
创建功能包:
cd ~/catkin_ws/src
catkin_create_pkg learning_service roscpp rospy std_msgs geometry_msgs
turtlesim
/home/cy/catkin_ws/src/learning_service/src/路径下建立一个turtle_spawn.cpp文件
/**
* 该例程将请求/spawn服务,服务数据类型turtlesim::Spawn
*/
// turtle_spawn.cpp
#include
#include
int main(int argc, char** argv)
{
// 初始化ROS节点
ros::init(argc, argv, "turtle_spawn");
// 创建节点句柄
ros::NodeHandle node;
// 发现/spawn服务后,创建一个服务客户端,连接名为/spawn的service
ros::service::waitForService("/spawn");
ros::ServiceClient add_turtle = node.serviceClient("/spawn");
// 初始化turtlesim::Spawn的请求数据
turtlesim::Spawn srv;
srv.request.x = 2.0;
srv.request.y = 2.0;
srv.request.name = "turtle2";
// 请求服务调用
ROS_INFO("Call service to spwan turtle[x:%0.6f, y:%0.6f, name:%s]",
srv.request.x, srv.request.y, srv.request.name.c_str());
add_turtle.call(srv);
// 显示服务调用结果
ROS_INFO("Spwan turtle successfully [name:%s]", srv.response.name.c_str());
return 0;
};
在/home/cy/catkin_ws/src/learning_service/ CMakeLists.txt中配置客户端代码编译规则:
add_executable(turtle_spawn src/turtle_spawn.cpp) 设置需要编译的代码和生成的可执行文件;
target_link_libraries(turtle_spawn ${catkin_LIBRARIES}) 设置链接库;
编译并运行客户端:
cd ~/catkin_ws
catkin_make
source devel/setup.bash
roscore
rosrun turtlesim turtlesim_node
rosrun learning_service turtle_spawn
python版本实现:turtle_spawn.py
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# 该例程将请求/spawn服务,服务数据类型turtlesim::Spawn
# turtle_spawn.py
import sys
import rospy
from turtlesim.srv import Spawn
def turtle_spawn():
# ROS节点初始化
rospy.init_node('turtle_spawn')
# 发现/spawn服务后,创建一个服务客户端,连接名为/spawn的service
rospy.wait_for_service('/spawn')
try:
add_turtle = rospy.ServiceProxy('/spawn', Spawn)
# 请求服务调用,输入请求数据
response = add_turtle(2.0, 2.0, 0.0, "turtle2")
return response.name
except rospy.ServiceException, e:
print "Service call failed: %s"%e
if __name__ == "__main__":
#服务调用并显示调用结果
print "Spwan turtle successfully [name:%s]" %(turtle_spawn())
turtle_command_server.cpp
/**
* 该例程将执行/turtle_command服务,服务数据类型std_srvs/Trigger
*/
// turtle_command_server.cpp
#include
#include
#include
ros::Publisher turtle_vel_pub;
bool pubCommand = false;
// service回调函数,输入参数req,输出参数res
bool commandCallback(std_srvs::Trigger::Request &req,
std_srvs::Trigger::Response &res)
{
pubCommand = !pubCommand;
// 显示请求数据
ROS_INFO("Publish turtle velocity command [%s]", pubCommand==true?"Yes":"No");
// 设置反馈数据
res.success = true;
res.message = "Change turtle command state!"
return true;
}
int main(int argc, char **argv)
{
// ROS节点初始化
ros::init(argc, argv, "turtle_command_server");
// 创建节点句柄
ros::NodeHandle n;
// 创建一个名为/turtle_command的server,注册回调函数commandCallback
ros::ServiceServer command_service = n.advertiseService("/turtle_command", commandCallback);
// 创建一个Publisher,发布名为/turtle1/cmd_vel的topic,消息类型为geometry_msgs::Twist,队列长度10
turtle_vel_pub = n.advertise("/turtle1/cmd_vel", 10);
// 循环等待回调函数
ROS_INFO("Ready to receive turtle command.");
// 设置循环的频率
ros::Rate loop_rate(10);
while(ros::ok())
{
// 查看一次回调函数队列
ros::spinOnce();
// 如果标志为true,则发布速度指令
if(pubCommand)
{
geometry_msgs::Twist vel_msg;
vel_msg.linear.x = 0.5;
vel_msg.angular.z = 0.2;
turtle_vel_pub.publish(vel_msg);
}
//按照循环频率延时
loop_rate.sleep();
}
return 0;
}
配置服务器代码编译规则:
add_executable(turtle_command_server src/turtle_command_server.cpp) 设置需要编译的代码和生成的可执行文件;
target_link_libraries(turtle_command_server ${catkin_LIBRARIES}) 设置链接库;
编译并运行服务器:
cd ~/catkin_ws
catkin_make
source devel/setup.bash
roscore
rosrun turtlesim turtlesim_node
rosrun learning_service turtle_command_server 等待请求服务
rosservice call /turtle_command "{}" 发送请求,相当于开关,发送一次开始运动,再发送一次就停止
python版本实现:turtle_command_server.py
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# 该例程将执行/turtle_command服务,服务数据类型std_srvs/Trigger
# turtle_command_server.py
import rospy
import thread,time
from geometry_msgs.msg import Twist
from std_srvs.srv import Trigger, TriggerResponse
pubCommand = False;
turtle_vel_pub = rospy.Publisher('/turtle1/cmd_vel', Twist, queue_size=10)
def command_thread():
while True:
if pubCommand:
vel_msg = Twist()
vel_msg.linear.x = 0.5
vel_msg.angular.z = 0.2
turtle_vel_pub.publish(vel_msg)
time.sleep(0.1)
def commandCallback(req):
global pubCommand
pubCommand = bool(1-pubCommand)
# 显示请求数据
rospy.loginfo("Publish turtle velocity command![%d]", pubCommand)
# 反馈数据
return TriggerResponse(1, "Change turtle command state!")
def turtle_command_server():
# ROS节点初始化
rospy.init_node('turtle_command_server')
# 创建一个名为/turtle_command的server,注册回调函数commandCallback
s = rospy.Service('/turtle_command', Trigger, commandCallback)
# 循环等待回调函数
print "Ready to receive turtle command."
thread.start_new_thread(command_thread, ())
rospy.spin()
if __name__ == "__main__":
turtle_command_server()
(1)在/home/cy/catkin_ws/src/learning_service下创建文件夹srv,定义srv文件;
(2)touch Person.srv
在srv文件夹下创建 Person.srv 文件,并写入:
string name
uint8 age
uint8 sexuint8 unknown = 0
uint8 male = 1
uint8 female = 2
---
string result(3)在package.xml中添加功能包依赖
message_generation
message_runtime
(4)在CMakeLists.txt添加编译选项
• find_package( …… message_generation)
• add_service_files(FILES Person.srv)
generate_messages(DEPENDENCIES std_msgs)
• catkin_package(…… message_runtime)
(5)编译生成语言相关文件
cd ~/catkin_ws
catkin_make
在 /home/cy/catkin_ws/src/learning_service/src路径下创建两个文件:
person_client.cpp person_server.cpp
/**
* 该例程将请求/show_person服务,服务数据类型learning_service::Person
*/
// person_client.cpp
#include
#include "learning_service/Person.h"
int main(int argc, char** argv)
{
// 初始化ROS节点
ros::init(argc, argv, "person_client");
// 创建节点句柄
ros::NodeHandle node;
// 发现/spawn服务后,创建一个服务客户端,连接名为/spawn的service
ros::service::waitForService("/show_person");
ros::ServiceClient person_client = node.serviceClient("/show_person");
// 初始化learning_service::Person的请求数据
learning_service::Person srv;
srv.request.name = "Tom";
srv.request.age = 20;
srv.request.sex = learning_service::Person::Request::male;
// 请求服务调用
ROS_INFO("Call service to show person[name:%s, age:%d, sex:%d]",
srv.request.name.c_str(), srv.request.age, srv.request.sex);
person_client.call(srv);
// 显示服务调用结果
ROS_INFO("Show person result : %s", srv.response.result.c_str());
return 0;
};
/**
* 该例程将执行/show_person服务,服务数据类型learning_service::Person
*/
// person_server.cpp
#include
#include "learning_service/Person.h"
// service回调函数,输入参数req,输出参数res
bool personCallback(learning_service::Person::Request &req,
learning_service::Person::Response &res)
{
// 显示请求数据
ROS_INFO("Person: name:%s age:%d sex:%d", req.name.c_str(), req.age, req.sex);
// 设置反馈数据
res.result = "OK";
return true;
}
int main(int argc, char **argv)
{
// ROS节点初始化
ros::init(argc, argv, "person_server");
// 创建节点句柄
ros::NodeHandle n;
// 创建一个名为/show_person的server,注册回调函数personCallback
ros::ServiceServer person_service = n.advertiseService("/show_person", personCallback);
// 循环等待回调函数
ROS_INFO("Ready to show person informtion.");
ros::spin();
return 0;
}
配置服务器/客户端代码编译规则:
• 设置需要编译的代码和生成的可执行文件;
• 设置链接库;
• 添加依赖项。
add_executable(person_server src/person_server.cpp)
target_link_libraries(person_server ${catkin_LIBRARIES})
add_dependencies(person_server ${PROJECT_NAME}_gencpp)
add_executable(person_client src/person_client.cpp)
target_link_libraries(person_client ${catkin_LIBRARIES})
add_dependencies(person_client ${PROJECT_NAME}_gencpp)
编译并运行客户端和服务端:建议每次运行程序时都重新 roscore 一下,防止变量重名等造成的报错
cd ~/catkin_ws
catkin_make
source devel/setup.bash
roscore
rosrun learning_service person_server
rosrun learning_service person_client
python版代码:略