【Ubuntu 20.04】ROS——话题、服务与动作编程

工作空间

1.创建工作空间

	mkdir -p ~/catkin_ws/src           	 #创建文件夹
	cd ~/catkin_ws/src					#进入目录
	catkin_init_workspace				#初始化，使其成为ROS的工作空间

2.编译工作空间

cd ..
catkin_make

3.设置环境变量

source /home/mozart/catkin_ws/devel/setup.bash		#该环境变量设置只对当前终端有效，mozart是用户名
	#将上面命令放置到~/.bashrc文件中，让其对所有终端都有效
sudo nano ~/.bashrc

4.检查环境变量

echo $ROS_PACKAGE_PATH

功能包

1.创建功能包

cd ~/catkin_ws/src
catkin_create_pkg learning_communication std_msgs rospy roscpp
#catkin_create_pkg 功能包名字 依赖
#std_msgs：定义的标准的数据结构
#rospy：提供python编程接口 
#roscpp：提供c++编程接口

2.编译功能包

cd ~/catkin_ws
catkin_make

一、话题

（一）创建发布者

在功能包中新建talker.cpp，并将以下内容写入文件中：

#include<sstream>
#include"ros/ros.h"
#include"std_msgs/String.h"
int main(int argc,char **argv)
{
	//ROS节点初始化
	ros::init(argc,argv,"talker");
	//创建节点句柄
	ros::NodeHandle n;
	//创建一个Publisher，发布名为chatter的topic，消息类型为std_msgs::String
	ros::Publisher chatter_pub=n.advertise<std_msgs::String>("chatter",1000);
	//设置循环的频率
	ros::Rate loop_rate(10);
	int count=0;
	while(ros::ok())
	{
		//初始化std_msgs::String类型的消息
		std_msgs::String msg;
		std::stringstream ss;
		ss<<"hello world"<<count;
		msg.data=ss.str();
		//发布消息
		ROS_INFO("%s",msg.data.c_str());
		chatter_pub.publish(msg);
		//循环等待回调函数
		ros::spinOnce();
		//接受循环频率延时
		loop_rate.sleep();
		++count;
	}
	return 0;
}

（二）创建订阅者

在功能包中新建listener.cpp，并将以下内容写入文件中：

#include"ros/ros.h"
#include"std_msgs/String.h"
//接收到订阅的消息，会进入消息的回调函数
void chatterCallback(const std_msgs::String::ConstPtr& msg)
{
	//将接收到的消息打印处理
	ROS_INFO("I heard:{%s}",msg->data.c_str());
}
int main(int argc,char **argv)
{
	//初始化ROS节点
	ros::init(argc,argv,"listener");
	//创建节点句柄
	ros::NodeHandle n;
	//创建一个Subscriber，订阅名为chatter的topic，注册回调函数chatterCallback
	ros::Subscriber sub=n.subscribe("chatter",1000,chatterCallback);
	//循环等待回调函数
	ros::spin();
	return 0;
}

（三）编译代码

设置CMakeLists.txt文件

add_executable(talker src/talker.cpp)
target_link_libraries(talker ${catkin_LIBRARIES})

add_executable(listener src/listener.cpp)
target_link_libraries(listener ${catkin_LIBRARIES})

编译

catkin_make

（四）运行可执行程序

roscore
rosrun learning_communication talker
rosrun learning_communication listener

订阅者可接收到发布者发布的消息

二、服务

• 定义服务请求与应答的方式:
  定义srv文件

mkdir ~/catkin_ws/src/learning_communication/srv
sudo nano AddTwoInts.srv

AddTwoInts.srv中的内容

int64 a
int64 b
---
int64 sum

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

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

在CMakeLists.txt添加编译选项
返回工作空间进行编译，编译后可在devel中看到.h头文件

（一）创建服务器

server.cpp

#include<ros/ros.h>
#include"learning_communication/AddTwoInts.h"
//service回调函数，输入参数req，输出参数res
bool add(learning_communication::AddTwoInts::Request &req,learning_communication::AddTwoInts::Response &res)
{
	//将输入的参数中的请求数据相加，结果放到应答变量中
	res.sum=req.a+req.b;
	ROS_INFO("request: x=%1d,y=%1d",(long int)req.a,(long int)req.b);
	ROS_INFO("sending back response:[%1d]",(long int)res.sum);
	return true;
}
int main(int argc,char **argv)
{
	//ROS节点初始化
	ros::init(argc,argv,"add_two_ints_server");
	//创建节点句柄
	ros::NodeHandle n;
	//创建一个名为add_two_ints的server,注册回调函数add()
	ros::ServiceServer service=n.advertiseService("add_two_ints",add);
	//循环等待回调函数
	ROS_INFO("Ready to add two ints.");
	ros::spin();
	return 0;
}

（二）创建客户端

client.cpp

#include<cstdlib>
#include<ros/ros.h>
#include"learning_communication/AddTwoInts.h"
int main(int argc,char **argv)
{
	//ROS节点初始化
	ros::init(argc,argv,"add_two_ints_client");
	//从终端命令行获取两个加数
	if(argc!=3)
	{
		ROS_INFO("usage:add_two_ints_client X Y");
		return 1;
	}
	//创建节点句柄
	ros::NodeHandle n;
	//创建一个client，请求add_two_ints_service
	//service消息类型是learning_communication::AddTwoInts
	ros::ServiceClient client=n.serviceClient<learning_communication::AddTwoInts>("add_two_ints");
	//创建learning_communication::AddTwoInts类型的service消息
	learning_communication::AddTwoInts srv;
	srv.request.a=atoll(argv[1]);
	srv.request.b=atoll(argv[2]);
	//发布service请求，等待加法运算的应答请求
	if(client.call(srv))
	{
		ROS_INFO("sum: %1d",(long int)srv.response.sum);
	}
	else
	{
		ROS_INFO("Failed to call service add_two_ints");
		return 1;
	}
	return 0;
}

（三）编译代码

设置CMakeLists.txt文件

# add_executable(server src/server.cpp)
# target_link_libraries(server ${catkin_LIBRARIES})
# add_dependencies(server ${PROJECT_NAME}_gencpp)

# add_executable(client src/client.cpp)
# target_link_libraries(client ${catkin_LIBRARIES})
# add_dependencies(client ${PROJECT_NAME}_gencpp)

编译(存在一些警告，可以不用管)

（四）运行可执行程序

先运行server，再运行client

roscore
rosrun learning_communication server
rosrun learning_communication client 10 8

三、动作编程

自定义action文件

（1）定义action文件，以checkaction.action为例

在工作空间catkin_ws/src/learning_communication下创建action文件夹，在其中创建checkaction.action文件，内容为:

int32 requestnumber
---
int32 resultnumber
---
int32 feedbacknumber

（2）在package.xml中添加功能包依赖,添加完成后应该有以下内容

  <buildtool_depend>catkin</buildtool_depend>
  <build_depend>actionlib</build_depend>
  <build_depend>actionlib_msgs</build_depend>
  <build_depend>roscpp</build_depend>
  <build_export_depend>actionlib</build_export_depend>
  <build_export_depend>actionlib_msgs</build_export_depend>
  <build_export_depend>roscpp</build_export_depend>
  <build_depend>message_generation</build_depend>
  <exec_depend>actionlib</exec_depend>
  <exec_depend>actionlib_msgs</exec_depend>
  <exec_depend>roscpp</exec_depend>
  <exec_depend>message_runtime</exec_depend>

（3）在CMakeList.txt中添加编译选项

find_package(…)中添加 actionlib 和 actionlib_msgs 项
找到add_action_files(…)，在其中添加自定义的 .action 文件到 FILES 中
找到generate_messages(…),在其中添加消息类型 actionlib_msgs 到 DEPENDENCIES中
catkin_package在exec执行的依赖项 CATKIN_DEPENDS 后添加 actionlib 和 actionlib_msgs
添加结果应该如下

find_package(catkin REQUIRED COMPONENTS
  actionlib_msgs
  roscpp
  actionlib
)
add_action_files(
   FILES
   checkaction.action 
)
generate_messages(
   DEPENDENCIES
   actionlib_msgs
)

编译

（一）创建动作服务器

checkaction_server.cpp

#include "ros/ros.h"
#include "actionlib/server/simple_action_server.h"
#include "learning_communication/checkactionAction.h"
typedef actionlib::SimpleActionServer<learning_communication::checkactionAction> Server;
void execute(const learning_communication::checkactionGoalConstPtr &goal, Server *as)
{
        ros::Rate r(1);
        learning_communication::checkactionFeedback feedback;
        ROS_INFO("开始检测 %d 个零件.", goal->requestnumber);
        for (int i = 1; i <= 40; i++)
        {
                feedback.feedbacknumber = i;
                as->publishFeedback(feedback);
                r.sleep();
        }
        ROS_INFO("已经检测完 %d 个零件", goal->requestnumber);
        as->setSucceeded();
}
int main(int argc, char** argv)
{
 setlocale(LC_ALL, "");
        ros::init(argc, argv, "check_server");
        ros::NodeHandle hNode;
        Server server(hNode, "check", boost::bind(&execute, _1, &server), false);
        server.start();
        ros::spin();
        return 0;
}

（二）创建动作客户端

checkaction_client.cpp

#include <actionlib/client/simple_action_client.h>
#include "learning_communication/checkactionAction.h"
 
typedef actionlib::SimpleActionClient<learning_communication::checkactionAction> Client;
 
void doneCb(const actionlib::SimpleClientGoalState& state,
        const learning_communication::checkactionResultConstPtr& result)
{
        ROS_INFO("检测完成！");
        ros::shutdown();
}
 
void activeCb()
{
        ROS_INFO("开始检测了");
}
 
void feedbackCb(const learning_communication::checkactionFeedbackConstPtr& feedback)
{
        double t = feedback->feedbacknumber;
    double n = t / 40;
        ROS_INFO(" 检测进度 : %.2f%% ", n*100);
}
 
int main(int argc, char** argv)
{
        setlocale(LC_ALL, "");
        ros::init(argc, argv, "check_client");
        Client client("check", true);
 
        ROS_INFO("等待服务器响应.");
        client.waitForServer();
        ROS_INFO("服务启动, 发送目标");
 
        learning_communication::checkactionGoal goal;
        goal.requestnumber = 40;
 
        client.sendGoal(goal, &doneCb, &activeCb, &feedbackCb);
 
        ros::spin();
 
        return 0;
}
	

（三）编译代码

在CMakeList.txt中添加

add_executable(checkaction_server. src / checkaction_server..cpp)
target_link_libraries(checkaction_server ${catkin_LIBRARIES})
add_dependencies(checkaction_server ${${PROJECT_NAME}_EXPORTED_TARGETS})
 
add_executable(checkaction_client src / checkaction_client.cpp)
target_link_libraries(checkaction_client ${catkin_LIBRARIES})
add_dependencies(checkaction_client ${${PROJECT_NAME}_EXPORTED_TARGETS})

编译

（四) 运行可执行程序

roscore
rosrun learning_communication checkaction_client
rosrun learning_communication checkaction_server

四、总结

在这次学习中，我学会了在ROS中创建工作空间以及功能包，并对话题、服务与动作有了更深的了解。

五、引用

【HarrietLH】ROS基础——话题、服务、动作编程
【rngeu】ROS话题、服务、动作基本操作