Client Access Server在哪 client service

1.服务（service）

当一些节点只是临时而非周期性的需要某些数据，如果用topic通信方式时就会消耗大量不必要的系统资源，这时，就需要使用ROS通信中的另一种通信方式——service(服务)。

service通信是双向的，它不仅可以发送消息，同时还会有反馈。所以service包括两部分，一部分是请求方（Clinet），另一部分是应答方/服务提供方（Server）。这时请求方（Client）就会发送一个request，要等待Server处理，反馈回一个reply，这样通过类似请求-应答的机制完成整个服务通信。

service是同步通信方式，所谓同步就是说，node1发布请求后会在原地等待reply，直到node2处理完了请求并且完成了reply，node1才会继续执行。node1等待过程中，是处于阻塞状态的成通信。这样的通信模型没有频繁的消息传递，没有冲突与高系统资源的占用，只有接受请求才执行服务，简单而且高效。

2.如何实现一个客户端（Client）

以请求生成第二只小海龟为例，写一个客户端程序，服务名为/spawn，服务数据类型为turtlesim::Spawn

1. 初始化ROS节点
2. 创建一个Client实例
3. 发布服务请求数据
4. 等待Server处之后的应答结果

(1) Client的C++实现

创建learning_service功能包

其中roscpp， rospy， std_msgs， geometry_msgs， turtlesim为此功能包的依赖

cd ~/my_ws/src
catkin_create_pkg learning_service roscpp rospy std_msgs geometry_msgs turtlesim

接下来在/my_ws/src/learning_service/src路径下创建turtle_spawn.cpp文件，C++代码如下：

#include <ros/ros.h>
#include <turtlesim/Spawn.h>

int main(int argc, char** argv)
{
    ros::init(argc, argv, "turtle_spawn");

    ros::NodeHandle n;

    ros::service::waitForService("/spawn");  //等待发现/spawn服务
    ros::ServiceClient add_turtle = n.serviceClient<turtlesim::Spawn>("/spawn");  //创建一个服务客户端

    //初始化服务请求数据
    turtlesim::Spawn srv;
    srv.request.x = 2.0;
    srv.request.y = 2.0;
    srv.request.name = "turtle2";

    //请求服务调用
    ROS_INFO("Call service to spawn 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("Spawn turtle successfully [name:%s]", srv.response.name.c_str());

    return 0;
}

在/my_ws/src/learning_service路径下CMakeLists.txt中配置发布者代码的编译规则

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

编译运行

cd ~/my_ws
catkin_make
source ~/my_ws/devel/setup.bash
roscore
rosrun turtlesim turtlesim_node
rosrun learning_service turtle_spawn

(2) Client的Python实现

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import sys
import rospy
from turtlesim.srv import Spawn

def turtle_spawn():
    rospy.init_node('turtle_spawn')

    rospy.wait_for_service('/spawn')
    try:
        add_turtle = rospy.ServiceProxy('/spawn', Spawn)

        request = add_turtle(2.0, 2.0, 0.0, "turtle2")
        return request.name
    except rospy.ServiceException, e:
        print "Service call failed: %s"%e

if __name__ == "__main__":
    print "Spawn turtle successfully [name:%s]" %(turtle_spawn())

运行

注意在ROS中运行python文件一定要让其有可执行权限，右键点击属性->权限->勾选允许作为程序执行文件

roscore
rosrun turtlesim turtlesim_node
rosrun learning_service turtle_spawn.py

3.如何实现一个服务端（Server）

下面的例子通过服务的方式给小海龟发送速度指令，通过topic发送，Client端发布request控制Server是否要给海龟发指令，相当于一个小海龟运动和停止的开关；Server端接收Client指令，并完成topic指令的发送，反馈response告诉Client端请求是否执行成功。自定义名为/turtle_command的service，服务数据类型用的是ROS中针对服务的标准定义Trigger

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

(1) Server的C++实现

#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
//服务数据类型std_srvs/Trigger
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::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();
    }
}

在/my_ws/src/learning_service路径下CMakeLists.txt中配置发布者代码的编译规则

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

编译运行

cd ~/my_ws
catkin_make
source ~/my_ws/devel/setup.bash
roscore
rosrun turtlesim turtlesim_node
rosrun learning_service turtle_command_server
rosservice call /turtle_command "{}"

初始状态pubCommand为false，请求调用一次服务，pubCommand变为true，向小海龟发布速度指令，小海龟按照指定速度运动；再次调用服务，pubCommand变为false，不再向小海龟发布速度指令，小海龟停止运动

(2) Server的Python实现

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import rospy
import thread, time
from geometry_msgs.msg import Twist
from std_srvs.srv import Trigger, TriggerResponse

pubCommand = False
#创建一个Publisher，发布名为/turtle1/cmd_vel的topic，消息类型为Twist，队列长度10
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[%s]", pubCommand)

    #反馈数据
    return TriggerResponse(1, "Change turtle command state!")

def turtle_command_server():
    rospy.init_node('turtlr_command_server')
    
    #创建一个名为/turtle_command的server，服务数据类型Trigger，注册回调函数CommandCallback
    command_service = rospy.Service('/turtle_command', Trigger, commandCallback)

    #循环等待回调函数
    print "Ready to receive turtle command"
    thread.start_new_thread(command_thread,())  #一直在运行，如果标志位为真，按固定频率发送指令，否则一直在while True循环
    rospy.spin()  #一旦有请求，触发回调函数，就会改变pubCommand标志位

if __name__ == "__main__":
    turtle_command_server()

这里需要注意的是，C++代码中while里用的是spinOnce()，查看一次请求队列，继续往下执行判断是否需要发送话题消息；Python中只有spin()，没有spinOnce()，spin()是一个死循环，无法在spin()当中单独判断标志位，所以单独开一个线程去判断标志位

程序具体运行过程是spin()当中会不断循环查看是否有request进来，一旦有request进来会进入callback，callback会对全局标志位pubCommand取反，显示请求数据和反馈数据

课程弹幕中有同学问为什么不把发送话题消息写在回调函数里，这是不可以的
首先回调函数调用完成后需要回到spin()中继续查看请求队列，如果把发送话题消息写在回调函数中，而且如果pubCommand为True，意味着一直要停在回调函数中按照指定频率循环发送话题消息，无法查看下一次请求是否到来。

运行

注意在ROS中运行python文件一定要让其有可执行权限，右键点击属性->权限->勾选允许作为程序执行文件

roscore
rosrun turtlesim turtlesim_node
rosrun learning_service turtle_command_server.py
rosservice call /turtle_command "{}"

4. 自定义服务类型

(1) 定义Person.srv文件

request部分与response部分用---分开

string name
uint8  age
uint8  sex

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

---
string result

(2) 在package.xml文件中添加功能包依赖

在/my_ws/src/learning_service路径下的package.xml文件中添加编译依赖和执行依赖

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

(3) 在CMakeLists.txt添加编译选项

在/my_ws/src/learning_service路径下的CMakeLists.txt文件中添加

1. 依赖的功能包message_generation
2. 把.srv文件编译成对应的不同程序文件的配置项
3. 创建执行依赖

find_package(message_generation)  # 找到编译需要的其他CMake/Catkin package 

add_service_files(FILES Person.srv)  # catkin新加宏，添加自定义Message/Service/Action文件
generate_messages(DEPENDENCIES std_msgs)  # catkin新加宏，生成不同语言版本的msg/srv/action接口，指定编译此msg时需要依赖哪些已有的库和包

catkin_package(message_runtime)  # catkin新加宏，生成当前package的cmake配置，供依赖本包的其他软件包调用

(4) 编译生成语言相关文件

cd ~/my_ws
catkin_make

编译完成后,在/my_ws/devel/include/learning_service路径下会生成三个文件Person.h、PersonRequest.h、PersonResponse.h，因为Person.srv文件用横线分成了两部分，上半部分生成的头文件放到Request.h里，下半部分生成的头文件放到Response.h里，而Person.h包含了上述两个头文件。

5.自定义服务类型的使用

(1) Client的Ｃ++实现

#include <ros/ros.h>
#include "learning_service/Person.h"

int main(int argc, char** argv)
{
    // 初始化ROS节点
    ros::init(argc, argv, "person_client");

    // 创建节点句柄
    ros::NodeHandle n;

    // 发现/show_person服务后，创建一个服务客户端，连接名为/show_person的service
    ros::service::waitForService("/show_person"); // 处于阻塞状态的通信
    ros::ServiceClient person_client = n.serviceClient<learning_service::Person>("show_person");

    // 初始化learning_service::Person的请求数据
    learning_service::Person person_srv;
    person_srv.request.name = "Tom";
    person_srv.request.age = 20;
    person_srv.request.sex = learning_service::Person::Request::male;

    // 请求服务调用
    ROS_INFO("Call service to show person[name:%s  age:%d  sex:%d]",
             person_srv.request.name.c_str(), person_srv.request.age, person_srv.request.sex);

    person_client.call(person_srv);

    // 显示服务调用结果
    ROS_INFO("Show person result: %s", person_srv.response.result.c_str());

    return 0;         
}

(2) Server的Ｃ++实现

#include <ros/ros.h>
#include "learning_service/Person.h"

// service回调函数，输入参数req，输出参数res
// 服务数据类型learning_service::Person
// Request段和Response段的命名空间是ROS强制定义的
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 information.");
    ros::spin();

    return 0;
}

(3) 修改编译规则

在CMakeLists.txt中build部分添加如下依赖

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)

(4) 编译与运行

cd ~/my_ws
catkin_make
source ~/my_ws/devel/setup.bash
rosrun learning_service person_server
rosrun learning_service person_client

先运行Server，再运行Client

先运行Client，再运行Server

注意运行程序前重新启动roscore，因为参数服务器的存在，参数一样的情况下会有冲突

参考：

1. 古月居ROS入门21讲
2. 中国大学MOOC—《机器人操作系统入门》课程讲义