小惠珠哦

这个屌丝很懒，什么也没留下！

热门标签

ROS机器人入门教程（1）

作者：小惠珠哦 | 2024-08-18 23:43:07

踩

ROS机器人入门教程（1）

ROS WIKI 教程 Documentation - ROS Wiki

1. Linux系统基础操作

安装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” 指令的帮助信息

2. C++&python极简基础

C++先编译：g++ .cpp文件名 -o 编译后的文件名

再运行：./编译后的文件名

3. 安装ros

参考网上各种链接。

4. ROS核心概念

5. ROS命令行工具的使用

roscore

rosrun turtlesim turtlesim_node

rosrun turtlesim turtle_teleop_key

rqt_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 复现记录的数据，小海龟复现之前执行的动作

6. 创建工作空间与功能包

6.1 创建工作空间

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

6.2 创建功能包

功能包一定要放在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语法

同一个工作空间下的功能包不能重名，不同工作空间下功能包可以重名

7. 发布者Publisher的编程实现

通过写程序让小海龟动起来，不是之前的命令行形式

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 <ros/ros.h>
#include <geometry_msgs/Twist.h>
 
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<geometry_msgs::Twist>("/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

8. 订阅者Subscriber的编程实现


/**
 * 该例程将订阅/turtle1/pose话题，消息类型turtlesim::Pose
 */
// pose_subscriber.cpp 
 
#include <ros/ros.h>
#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_publisher

rosrun 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()

9. 话题消息的定义与使用

（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 age

uint8 unknown = 0
uint8 male = 1
uint8 female = 2

（3）在/home/cy/catkin_ws/src/learning_topic/package.xml中添加功能包依赖：<build_depend>message_generation</build_depend> 编译依赖
<exec_depend>message_runtime</exec_depend> 运行依赖

（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 <ros/ros.h>
#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<learning_topic::Person>("/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 <ros/ros.h>
#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()

10. 客户端Client的编程实现

创建功能包：

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 <ros/ros.h>
#include <turtlesim/Spawn.h>
 
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<turtlesim::Spawn>("/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())

11. 服务端Server的编程实现

turtle_command_server.cpp


/**
 * 该例程将执行/turtle_command服务，服务数据类型std_srvs/Trigger
 */
 
// turtle_command_server.cpp
 
 
#include <ros/ros.h>
#include <geometry_msgs/Twist.h>
#include <std_srvs/Trigger.h>
 
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<geometry_msgs::Twist>("/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()

12. 服务数据的定义与使用

（1）在/home/cy/catkin_ws/src/learning_service下创建文件夹srv，定义srv文件；

（2）touch Person.srv

在srv文件夹下创建 Person.srv 文件，并写入：

string name
uint8 age
uint8 sex

uint8 unknown = 0
uint8 male = 1
uint8 female = 2
---
string result

（3）在package.xml中添加功能包依赖

<build_depend>message_generation</build_depend>
<exec_depend>message_runtime</exec_depend>

（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 <ros/ros.h>
#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<learning_service::Person>("/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 <ros/ros.h>
#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版代码：略

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小惠珠哦/article/detail/999751