话题编程
 服务编程
 动作编程

话题编程流程

 创建发布者
  初始化ROS节点；
  向ROS Master注册节点信息，包括发布的话题名和话题中的消息类型；
  按照一定的频率循环发布消息
  实践：在src中创建一个talker.cpp的文件

/**
 *该例程将发布chatter话题，消息类型为String
 */

#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);
                        //发布话题的信息类型 话题名   缓冲区长度

    //设置循环频率      10HZ ->100ms(循环周期
    ros::Rate loop_rate(10);

    while (ros::ok())
    {
        //初始化std_msg::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;
}

 创建订阅者
  初始化ROS节点；
  订阅需要的话题
  循环等待话题消息，接收到消息后进入回调函数；
  在回调函数中完成函数处理。
  实践：在src中创建一个listen.cpp的文件。

/**
 *该例程将订阅chatter话题，消息类型为String
 */

#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;

    //订阅chatter话题
    ros::Subscriber sub = n.subscribe("chatter",1000,chatterCallback);

    //循环等待话题
    ros::spin();

}

 添加编译选项
  设置需要编译的代码和生成的可执行文件
    由于CMakeLists是关于编译的，所以需要修改该文件

add_executable(talker src/talker.cpp) #生成可执行文件talker
target_link_libraries(talker ${catkin_LIBRARIES})                        #许多可执行文件是依赖第三方的库的，因此需要target_link_libraries(...),由于没有第三方的库，所以链接默认的库
add_executable(listener src/listener.cpp) 
target_link_libraries(listener ${catkin_LIBRARIES}) 

  设置链接库
  设置依赖
 运行可执行程序

自定义话题消息

1.定义msg文件
2.在package.xml中添加功能包依赖
3.在CMakeList.txt中添加编译选项
实践：一般自定义的话题在功能包的文件夹下面：

新建msg文件夹

创建Person.msg

在package.xml中添加功能包

在CMakeLists.txt添加编译选项

在CMakeLists.txt添加依赖

在CMakeLists.txt添加文件信息

查看消息是否编译成功

服务编程流程

 1.创建服务器
 2.创建客户端
 3.添加编译选项
 4.运行可执行程序
实践：与自定义话题步骤相似。由于请求/应答数据在ros中没有，所以应当自定义服务请求与应答。
 定义srv文件；

在~/catkin_ws/src/learning_communication/srv中添加.srv文件

定义srv文件

在package.xml中添加功能依赖

在CMakeList.txt中添加编译选项

在CMakeList.txt中添加编译选项

在CMakeList.txt中添加编译选项

编译检查是否成功

1.创建服务端

如何实现一个服务器：

1.初始化ROS节点；
2.创建Server实例；
3.循环等待服务请求，进入回调函数；
4.在回调函数中完成服务功能的处理，并反馈应答数据。
实践：
编写server.cpp:

/**
 *AddTwoInts Server
 */

#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 =%ld,y=%ld",(long int)req.a,(long int)req.b);
    ROS_INFO("sending back response:{%ld}",(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;

}

2.创建客户端

如何实现一个客户端

 初始化ROS节点；
 创建一个Client实例；
 发布服务请求数据；
 等待Server处理之后的应答结果；
实践：

#include <cstdlib>
#include "ros/ros.h"
#include "learning_communication/AddTwoInts.h"

int main(int argc,char **argv)
{
    //初始化节点
    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类型的srv消息
    learning_communication::AddTwoInts srv;
    srv.request.a = atoll(argv[1]);
    srv.request.b = atoll(argv[2]);

    //发布service请求，等待加法运算的应答结果
    if(client.call(srv))
    {
        ROS_INFO("Sum:%ld",(long int)srv.response.sum);
    }
    else
    {
        ROS_ERROR("Failed to call service add_two_ints");
        return 1;
    }

    return 0;

}

3.添加编译选项

如何编译代码

 设置需要编译的代码和生成的可执行文件；
 设置链接库；
 设置依赖。
实践：

修改CMakeList.txt

编译成功

生成可执行文件

4.运行可执行程序

运行可执行程序

动作编程

什么是动作：

 一种问答通信机制；
 带有连续反馈；
 可以在任务过程中终止运行
 基于ROS的消息机制实现

Action的接口

 goal:发布任务目标；
 cancel:请求取消任务；
 status:通知客户端当前的状态；
 feesback:周期反馈任务运行的监控数据
 result:向客户端发送任务的执行结果，只发布一次。

如何自定义动作消息

 定义action文件；

定义action文件

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

添加功能包依赖

添加编译选项

添加编译选项

如何实现一个动作的服务器

 初始化ROS节点；
 创建动作服务器实例；
 启动服务器，等待动作请求；
 在回调函数中完成动作服务器功能的处理，并反馈进度信息；
 动作完成，发送结束信息。
实践：

#include <ros/ros.h>
#include <actionlib/server/simple_action_server.h>
#include "learning_communication/DoDishesAction.h"

typedef actionlib::SimpleActionServer<learning_communication::DoDishesAction> Server;

//收到action的goal后调用该回调函数
void execute(const learning_communication::DoDishesGoalConstPtr& goal,Server* as)
{
    ros::Rate r(1);
    learning_communication::DoDishesFeedback feedback;

    ROS_INFO("Dishwasher %d is working.",goal->dishwasher_id);
    
    //假设洗盘子的进度，并且按照1Hz的频率发布进度feedback
    for(int i=1;i<=10;i++)
    {
        feedback.percent_complete = i*10;
        as->publishFeedback(feedback);
        r.sleep();
    }
    
    //当action完成后,向客户端返回结果
    ROS_INFO("Dishwasher %d finish working.",goal->dishwasher_id);
    as->setSucceeded();
}




int main(int argc,char** argv)
{

    //初始化ROS节点
    ros::init(argc,argv,"do_dishes_server");
    
    //创建句柄
    ros::NodeHandle n;

    //定义一个服务器
    Server server(n,"do_dishes",boost::bind(&execute,_1,&server),false);

    //服务器开始运行
    server.start();

    ros::spin();

    return 0;
}

如何实现一个动作客户端

 初始化ROS节点；
 创建动作客户端实例；
 连接动作服务端；
 发送动作目标；
 根据不同类型的服务端反馈处理回调函数。

#include <actionlib/client/simple_action_client.h>
#include "learning_communication/DoDishesAction.h"

typedef actionlib::SimpleActionClient<learning_communication::DoDishesAction> Client;

//当action完成后会调用改回调函数一次
void doneCb(const actionlib::SimpleClientGoalState& state,
    const learning_communication::DoDishesResultConstPtr& result)
{
    ROS_INFO("Yay! The dishes are now clean");
    ros::shutdown();
}

//当action激活后会调用该回调函数一次
void activeCb()
{
    ROS_INFO("Goal just went active");
}

//收到feedback后调用改回调函数
void feedbackCb(const learning_communication::DoDishesFeedbackConstPtr& feedback)
{
    ROS_INFO(" percent_complete : %f",feedback->percent_complete);
}



int main(int argc,char** argv)
{
    //初始化ROS
    ros::init(argc,argv,"do_dishes_client");
    
    //定义一个客户端
    Client client("do_dishes",true);

    //等待服务器端
    ROS_INFO("Waiting for action server to start.");
    client.waitForServer();
    ROS_INFO("Action server started,sending goal.");

    //创建一个action的goal
    learning_communication::DoDishesGoal goal;
    goal.dishwasher_id = 1;
    
    //发送action的goal给服务器端，并且设置回调函数
    client.sendGoal(goal,&doneCb,&activeCb,&feedbackCb);

    ros::spin();
    
    return 0;
}

如何编译代码

 设置需要编译的代码和生成的可执行文件；
 设置链接库
 设置依赖
实践：

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

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

如何运行可执行文件

编译并执行

注意：在编译的时候报了这样的错误

zyt@zyt:~$ rosrun learning_communication DoDishes_server 
terminate called after throwing an instance of 'ros::InvalidNameException'
  what():  Character [ ] at element [2] is not valid in Graph Resource Name [do dishes server].  Valid characters are a-z, A-Z, 0-9, / and _.
已放弃 (核心已转储)

原因是在DoDishes_server.cpp中ros::init(argc,argv,"do_dishes_server");这一句的"_"写成了空格，空格是不能用来命名的。