Creating a service client in ROS

Introduction

Creating a service client lets your program ask another part of the robot system to do something and wait for the answer.

When you want your robot to request data from another node, like sensor info.

When you need to ask another node to perform an action, like moving an arm.

When your program depends on a response before continuing.

When you want to keep parts of your robot system separate but still communicate.

When you want to test how nodes interact by sending requests and getting replies.

Syntax

ROS

client = node.create_client(ServiceType, 'service_name')

while not client.wait_for_service(timeout_sec=1.0):
    print('Waiting for service...')

request = ServiceType.Request()
request.some_field = value

future = client.call_async(request)

rclpy.spin_until_future_complete(node, future)

response = future.result()

You first create a client object for the service you want to call.

Then you wait until the service is available before sending a request.

Examples

Create a client for the 'example_service' using the ExampleService type.

ROS

client = node.create_client(ExampleService, 'example_service')

Wait up to 2 seconds repeatedly until the service is available.

ROS

while not client.wait_for_service(timeout_sec=2.0):
    print('Waiting for service to be ready...')

Prepare a request message with the needed data.

ROS

request = ExampleService.Request()
request.data = 'hello'

Send the request asynchronously and wait for the response.

ROS

future = client.call_async(request)
rclpy.spin_until_future_complete(node, future)
response = future.result()

Sample Program

This program creates a client node that calls the 'add_two_ints' service to add 5 and 3.

It waits for the service, sends the request, waits for the response, then prints the sum.

ROS

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

class AddTwoIntsClient(Node):
    def __init__(self):
        super().__init__('add_two_ints_client')
        self.client = self.create_client(AddTwoInts, 'add_two_ints')
        while not self.client.wait_for_service(timeout_sec=1.0):
            self.get_logger().info('Waiting for service...')
        self.request = AddTwoInts.Request()

    def send_request(self, a, b):
        self.request.a = a
        self.request.b = b
        self.future = self.client.call_async(self.request)


def main(args=None):
    rclpy.init(args=args)
    node = AddTwoIntsClient()
    node.send_request(5, 3)
    rclpy.spin_until_future_complete(node, node.future)
    response = node.future.result()
    node.get_logger().info(f'Result: {response.sum}')
    node.destroy_node()
    rclpy.shutdown()

if __name__ == '__main__':
    main()

Important Notes

Always wait for the service to be available before calling it to avoid errors.

Use asynchronous calls to keep your program responsive while waiting.

Check the service type and request fields carefully to send correct data.

Summary

Creating a service client lets your program ask another node for help and get answers.

Wait for the service before sending requests to avoid problems.

Use asynchronous calls and wait for the response to keep your program smooth.

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