Services (Server-Client)¶

Service merupakan cara lain untuk passsing data antar node dalam ROS. Service memungkinkan salah satu node untuk memanggil sebuah fungsi dari node yang lain. Layanan service itu sendiri di atur oleh server node, yang merupakan tempat dimana callback di panggil. Sedangkan request untuk layanan service di panggil oleh client node.

Berbeda dengan topics, service adalah layanan blocking call, dimana pemrosesan di node tersebut akan terhenti sampai servernya menyelesaikan request dari client. Jadi, services seharusnya tidak digunakan untuk layanan yang memerlukan komputasi yang lama. Salah satu penggunanaan service misalnya untuk melakukan komputasi Inverse Kinematic (IK), inference (object classsification).

Petunjuk

ROS command line tools yang bisa digunakan

rossrv: untuk melihat informasi yang berhubungan dengan srv file definition.
rosservice: untuk melihat dan berinteraksi dengan service tersedia.

Service definition file (srv)¶

srv file memiliki kesamaan struktur seperti msg file. Namun, srv memiliki request dan response. Sebagai contoh, misalnya kita akan membuat service untuk menghitung jumlah kata pada kalimat yang diberikan, maka langkah pertama kita perlu membuat service file CountWords.srv dimana input nya adalah kalimat, dan output nya adalah jumlah kata dalam kalimat tersebut. Request dan response dalam service file di pisahkan dengan ---.

std_msgs/string words
---
std_msgs/Int32 counts

Standar penamaan service file selalu di mulai dengan predikat (verb), misalnya CountWords, RecognizeImage, ComputeIK.

Request juga bisa lebih dari satu message, begitu pula responnya. Misalnya kita mau menambahkan opsi (count_articles) apakah kita mau menghilangkan artikel dalam kalimat tersebut. Sementara di responnya, kita juga bisa menambahkan jumlah artikelnya.

std_msgs/string words
std_msgs/Bool count_articles
---
std_msgs/Int32 num_words
std_msgs/Int32 num_articles

Selanjutnya kita bisa menambahkan CountWords.srv ke CMakeList untuk di compile. Penjelasan lebih lanjut mengenai kompilasinya, di jelaskan disini Kostum messages, srv dan action

Server-Client Python¶

Pertama kita perlu membuat ROS package baru dengan nama rospy_simple_service_server. Jika belum paham tentang paham tentang packages, silahkan buka Membuat ROS Package.

catkin_create_package rospy_simple_service_client rospy ros_custom_msgs

Server (simple_server.py) dan client node (simple_client.py) akan tempatkan di package ini.

Python server node

Sama halnya dengan topic, server di dalam service juga menggunakan mekanisme callback. Server menyediakan callback dan akan di panggil ketika request diterima. Berikut adalah contoh service untuk menghitung jumlah kata menggunakan python dan cpp.

#!/usr/bin/env python

"""
This script is a simple python node which advertizes ros service
server rospy_word_count
"""
#-*- encoding: utf-8 -*-
__author__ = 'mohammad wasil'

import rospy
from ros_custom_msgs.srv import CountWords, CountWordsResponse

def server_callback(req):
  rospy.loginfo("Received request: %s", req.words.data)
  
  words = req.words.data.split(" ")
  resp = CountWordsResponse()

  if req.count_articles.data:
    english_articles = ['a', 'an', 'the'] 
    resp.num_articles.data = len([word for word in words if word in english_articles])

  resp.num_words.data = len(words) - resp.num_articles.data

  return resp

if __name__ == '__main__':
  rospy.init_node("rospy_simple_server_node", anonymous=False)
  rospy.Service("rospy_word_count", CountWords, server_callback)  
  rospy.spin()

simple_server.py harus executable dengan cara:

chmod +x simple_server.py

Kemudian jalankan node:

rosrun rospy_simple_service_client simple_server.py

Untuk memastikan service server berjalan dengan baik, kita bisa mengeceknya via terminal.

emha at ThinkPad-E570 in ~$ rosservice list
    /rosout/get_loggers
    /rosout/set_logger_level
    /rospy_simple_server_node/get_loggers
    /rospy_simple_server_node/set_logger_level
    /rospy_word_count

Python client node

#!/usr/bin/env python

"""
This script is a simple python node which calls ros service
rospy_word_count and send request to the server.
"""
#-*- encoding: utf-8 -*-
__author__ = 'mohammad wasil'

import rospy
from ros_custom_msgs.srv import CountWords, CountWordsRequest

if __name__ == '__main__':

  #you are not necessarilt inilitialize node
  #since service client does not have to be a node
  rospy.init_node("rospy_simple_client_node", anonymous=False)
  rate = rospy.Rate(10)

  while not rospy.is_shutdown():
    rospy.wait_for_service('rospy_word_count')
    try:
      word_count = rospy.ServiceProxy('rospy_word_count', CountWords)

      req = CountWordsRequest()
      req.words.data =  "a test from the client node for a simple server client"
      req.count_articles.data = True

      resp = word_count.call(req)

      rospy.loginfo("Result -> Num of words: %s"%resp.num_words.data)
      rospy.loginfo("Result -> Num of articles: %s"%resp.num_articles.data)

    except rospy.ServiceException, e:
      print "Service call failed: %s"%e

    rate.sleep()

Server-Client C++¶

C++ Server node

#include <ros/ros.h>
#include <ros_custom_msgs/CountWords.h>
#include <boost/algorithm/string.hpp>

bool serverCallback(ros_custom_msgs::CountWordsRequest &req,
                    ros_custom_msgs::CountWordsResponse &resp)
{
  ROS_INFO_STREAM("Request received: "<<req.words.data);
  
  std::vector<std::string> words;
  boost::split(words, req.words.data, boost::is_any_of("\t "));
  
  resp.num_words.data = words.size();
  
  if (req.count_articles.data)
  {
    std::vector<std::string> english_articles = {"a", "an", "the"};
    int num_of_articles = 0;
    for (auto const& word: words)
    {
      std::string lower_word = boost::algorithm::to_lower_copy(word);
      if (std::find(english_articles.begin(), english_articles.end(), 
          lower_word ) != english_articles.end())
      {
        num_of_articles ++;
      }
    }
    
    resp.num_articles.data = num_of_articles;
    resp.num_words.data -= num_of_articles;
  }
  return true;
}

int main(int argc, char **argv)
{
  ros::init(argc, argv, "roscpp_simple_server_node");
  ros::NodeHandle nh;
  ros::ServiceServer service = nh.advertiseService("roscpp_word_count", serverCallback);
  ros::spin();
  
  return 0;
}

C++ Client node

#include <ros/ros.h>
#include <ros_custom_msgs/CountWords.h>

int main (int argc, char **argv)
{
  ros::init(argc, argv, "roscpp_simple_client_node");
  ros::NodeHandle nh;
  ros::ServiceClient service_client = nh.serviceClient<ros_custom_msgs::CountWords>("roscpp_word_count");
  ros::Rate loop_rate(10);
  while(ros::ok())
  {
    ros_custom_msgs::CountWords srv;
    srv.request.words.data = "A sample request from a client for a simple service client test";
    srv.request.count_articles.data = true;

    if (service_client.call(srv))
    {
      ROS_INFO_STREAM("Result -> Num of words: "<<srv.response.num_words.data);
      ROS_INFO_STREAM("Result -> Num of articles: "<<srv.response.num_articles.data);
    }
    else
    {
      ROS_ERROR("Failed to call the service server");
    }

    loop_rate.sleep();
  }
  return 0;
}

Contoh CMakeList.txt

cmake_minimum_required(VERSION 2.8.3)
project(roscpp_simple_service_client)

## Compile as C++11, supported in ROS Kinetic and newer
add_compile_options(-std=c++11)

find_package(catkin REQUIRED COMPONENTS
  ros_custom_msgs
  roscpp
)

catkin_package(
)

include_directories(
# include
  ${catkin_INCLUDE_DIRS}
)

#Executable
add_executable(simple_server
  ros/src/simple_server.cpp
)
add_dependencies(simple_server 
  ${catkin_EXPORTED_TARGETS}
)
target_link_libraries(simple_server
  ${catkin_LIBRARIES}
)

add_executable(simple_client
  ros/src/simple_client.cpp
)
add_dependencies(simple_client
  ${catkin_EXPORTED_TARGETS}
)
target_link_libraries(simple_client
  ${catkin_LIBRARIES}
)