Creating a service client in ROS - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to import the ROS service client library.

ROS

from [1] import ServiceProxy

Drag options to blanks, or click blank then click option'

Arospy

Broslib

Crosservice

Drosnode

Attempts:

3 left

💡 Hint

Common Mistakes

Importing ServiceProxy from roslib or rosservice instead of rospy.

Forgetting to import ServiceProxy.

You need to import ServiceProxy from rospy to create a service client in ROS.

2fill in blank

medium

Complete the code to create a service client for the 'add_two_ints' service.

ROS

client = ServiceProxy('[1]', AddTwoInts)

Drag options to blanks, or click blank then click option'

AaddInts

Badd_two_ints

C/add_two_ints

D/addInts

Attempts:

3 left

💡 Hint

Common Mistakes

Omitting the leading slash in the service name.

Using incorrect service names.

The service name must include the leading slash / to correctly specify the service in ROS.

3fill in blank

hard

Fix the error in the code to call the service client with two integers.

ROS

response = client([1], 5)

Drag options to blanks, or click blank then click option'

ANone

Bx

Ca

D3

Attempts:

3 left

💡 Hint

Common Mistakes

Using undefined variables as arguments.

Passing None or wrong types.

The service call requires two integer arguments. Using a literal integer like 3 is correct.

4fill in blank

hard

Fill both blanks to import the service type and initialize the ROS node.

ROS

from [1].srv import AddTwoInts
rospy.[2]('add_two_ints_client')

Drag options to blanks, or click blank then click option'

Abeginner_tutorials

Bstd_srvs

Crospy

Dinit_node

Attempts:

3 left

💡 Hint

Common Mistakes

Importing service from wrong package.

Forgetting to initialize the node.

You import the service type from your package (e.g., beginner_tutorials) and initialize the node with rospy.init_node.

5fill in blank

hard

Fill all three blanks to create a complete service client call and print the result.

ROS

rospy.wait_for_service('[1]')
client = ServiceProxy('[2]', AddTwoInts)
response = client([3], 7)
print(f"Sum is: {response.sum}")

Drag options to blanks, or click blank then click option'

A/add_two_ints

C5

D3

Attempts:

3 left

💡 Hint

Common Mistakes

Using different service names in wait and client.

Passing wrong argument types to the client.

You wait for the service /add_two_ints, create the client for the same service, call it with 5 and 7, then print the sum.

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