Creating a service client in ROS - Try It Yourself

Creating a service client

📖 Scenario: You are building a ROS node that needs to request data from another node using a service. This is common in robotics when one node needs to ask another node for information or to perform an action.

🎯 Goal: Create a ROS service client node that calls a service named /add_two_ints which adds two integers and returns the sum.

📋 What You'll Learn

Create a ROS node named add_two_ints_client

Create a service client for the service /add_two_ints using the AddTwoInts service type

Send a request with two integers: a = 5 and b = 3

Receive and handle the response from the service

Print the sum received from the service

💡 Why This Matters

🌍 Real World

Robots often need to request information or commands from other nodes. Service clients let one node ask another for specific tasks, like adding numbers or moving a robot arm.

💼 Career

Understanding how to create and use service clients is essential for robotics software engineers working with ROS to build modular and interactive robot applications.

1

Set up the ROS node and import necessary modules

Write code to import rclpy and AddTwoInts from example_interfaces.srv. Then initialize the ROS client library and create a node named add_two_ints_client.

ROS

# Import rclpy and AddTwoInts service
# Initialize rclpy and create node named 'add_two_ints_client'
# Your code here

Hint

Use rclpy.init() to start ROS and Node('add_two_ints_client') to create the node.

2

Create the service client for /add_two_ints

Create a service client named client for the service /add_two_ints using the AddTwoInts service type on the node node.

ROS

import rclpy
from rclpy.node import Node
from example_interfaces.srv import AddTwoInts

rclpy.init()
node = Node('add_two_ints_client')
# Create a client for the '/add_two_ints' service
# Your code here

Hint

Use node.create_client() with the service type and service name.

3

Send a request with two integers and wait for the service

Create a request object from AddTwoInts.Request() and set a = 5 and b = 3. Wait for the service to be available using client.wait_for_service().

ROS

import rclpy
from rclpy.node import Node
from example_interfaces.srv import AddTwoInts

rclpy.init()
node = Node('add_two_ints_client')
client = node.create_client(AddTwoInts, '/add_two_ints')
# Create request and set a=5, b=3
# Wait for service to be available
# Your code here

Hint

Create the request object and assign values before waiting for the service.

4

Call the service and handle the response

Call the service asynchronously with client.call_async(request) and wait for the future to complete using rclpy.spin_until_future_complete(node, future). Then print the sum from future.result().sum. Finally, destroy the node and shutdown rclpy.

ROS

import rclpy
from rclpy.node import Node
from example_interfaces.srv import AddTwoInts

rclpy.init()
node = Node('add_two_ints_client')
client = node.create_client(AddTwoInts, '/add_two_ints')

request = AddTwoInts.Request()
request.a = 5
request.b = 3

client.wait_for_service()
# Call the service asynchronously
# Wait for the response
# Print the sum from the response
# Destroy the node and shutdown rclpy
# Your code here

Hint

Use call_async to send the request and spin_until_future_complete to wait for the reply.

Practice

1. What is the main purpose of creating a service client in ROS?

easy

A. To request data or actions from another node and receive a response

B. To publish messages to a topic continuously

C. To subscribe and listen to messages from a topic

D. To launch multiple nodes at once

Solution

1. Step 1: Understand service client role

   A service client in ROS is used to send a request to another node and wait for a reply.

2. Step 2: Compare with other communication types

   Publishing and subscribing are for continuous message streams, not request-response.

3. Final Answer:

   To request data or actions from another node and receive a response -> Option A

4. Quick Check:

   Service client = request and response [OK]

Hint: Service clients ask and wait for answers, unlike topics [OK]

Common Mistakes:

• Confusing service clients with publishers or subscribers
• Thinking service clients launch nodes
• Assuming service clients send continuous data

2. Which of the following is the correct way to create a service client in ROS Python?

easy

A. client = rospy.ServiceProxy('service_name', ServiceType)

B. client = rospy.ServiceClient('service_name', ServiceType)

C. client = rospy.Service('service_name', ServiceType, callback)

D. client = rospy.Publisher('service_name', ServiceType)

Solution

1. Step 1: Recall ROS Python service client syntax

   In ROS Python, service clients are created using rospy.ServiceProxy with the service name and type.

2. Step 2: Identify incorrect options

   ServiceClient does not exist, Service is for servers, Publisher is for topics.

3. Final Answer:

   client = rospy.ServiceProxy('service_name', ServiceType) -> Option A

4. Quick Check:

   Service client uses ServiceProxy [OK]

Hint: Service clients use ServiceProxy, servers use Service [OK]

Common Mistakes:

• Using rospy.ServiceClient which does not exist
• Confusing service client with service server creation
• Using Publisher instead of ServiceProxy

3. Given this ROS Python code snippet, what will be printed if the service responds with success=True?

import rospy
from example.srv import ExampleService

def call_service():
    rospy.wait_for_service('example_service')
    client = rospy.ServiceProxy('example_service', ExampleService)
    response = client(42)
    print(response.success)

call_service()

medium

A. 42

B. False

C. None

D. True

Solution

1. Step 1: Understand the service call and response

   The client calls the service with argument 42 and receives a response object with a 'success' attribute.

2. Step 2: Identify printed value

   The code prints response.success, which is True as given by the problem statement.

3. Final Answer:

   True -> Option D

4. Quick Check:

   response.success = True [OK]

Hint: Print the response attribute, not the request argument [OK]

Common Mistakes:

• Printing the request argument instead of response
• Assuming response.success is False by default
• Confusing service response with None

4. What is wrong with this ROS Python service client code?

import rospy
from example.srv import ExampleService

client = rospy.ServiceProxy('example_service', ExampleService)
response = client(10)
print(response.result)

medium

A. The service name is invalid

B. ServiceProxy should be called with a string, not a service type

C. Missing rospy.init_node() before creating client

D. The response attribute 'result' may not exist

Solution

1. Step 1: Check ROS node initialization

   ROS nodes must call rospy.init_node() before using any ROS features like ServiceProxy.

2. Step 2: Verify other parts

   ServiceProxy usage is correct, service name format is valid, response attribute depends on service definition but missing init_node is a critical error.

3. Final Answer:

   Missing rospy.init_node() before creating client -> Option C

4. Quick Check:

   Always init node before service client [OK]

Hint: Always call rospy.init_node() before creating clients [OK]

Common Mistakes:

• Forgetting to initialize the ROS node
• Confusing service type and name parameters
• Assuming response attributes without checking service definition

5. You want to create a ROS service client that waits for the service to be available, sends a request asynchronously, and processes the response without blocking the main program. Which approach correctly implements this behavior?

hard

A. Create client with rospy.ServiceProxy, call client() inside a separate thread to avoid blocking

B. Use rospy.wait_for_service(), then call client.call_async() and add a callback to handle response

C. Use rospy.wait_for_service(), then call client() synchronously and block until response

D. Call client() repeatedly in a loop until response is received

Solution

1. Step 1: Wait for service availability

   Using rospy.wait_for_service() ensures the service is ready before sending requests.

2. Step 2: Use asynchronous call with callback

   client.call_async() allows sending request without blocking; a callback handles the response smoothly.

3. Step 3: Avoid blocking main program

   Calling client() synchronously or looping blocks the program; threading is possible but less clean than async calls.

4. Final Answer:

   Use rospy.wait_for_service(), then call client.call_async() and add a callback to handle response -> Option B

5. Quick Check:

   Async call with callback = non-blocking client [OK]

Hint: Use call_async() with callback for smooth non-blocking calls [OK]

Common Mistakes:

• Calling client() synchronously and blocking program
• Using loops to wait for response instead of async
• Not waiting for service before calling client