Creating a service server in ROS - Visual Walkthrough

Concept Flow - Creating a service server

Start ROS Node

↓

Define Service Callback

↓

Create Service Server

↓

Wait for Service Requests

↓

On Request: Execute Callback

↓

Send Response

↓

Continue Waiting for Requests

The ROS node starts, defines a callback to handle requests, creates a service server, then waits and responds to incoming service requests.

Execution Sample

ROS

import rospy
from std_srvs.srv import SetBool, SetBoolResponse

def handle_request(req):
    return SetBoolResponse(success=True, message="Service called")

rospy.init_node('service_server')
service = rospy.Service('my_service', SetBool, handle_request)
rospy.spin()

This code creates a ROS service server named 'my_service' that responds to SetBool requests with a success message.

Execution Table

Step	Action	Evaluation	Result
1	Start ROS node 'service_server'	Node initialized	Node running, ready to create service
2	Define callback 'handle_request'	Function ready to process requests	Callback function set
3	Create service server 'my_service'	Service server created	Server listens for requests
4	Wait for service requests	Idle, waiting	No requests yet
5	Receive request with data=True	Call 'handle_request' with req.data=True	Returns success=True, message='Service called'
6	Send response to client	Response sent	Client receives confirmation
7	Wait for next request	Idle again	Ready for next request

💡 ROS node runs continuously until manually stopped

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 5	Final
req	None	None	None	{data: True}	None
response	None	None	None	{success: True, message: 'Service called'}	None
service	None	None	Service object created	Service object active	Service object active

Key Moments - 3 Insights

Why does the service server keep running after sending a response?

Because of rospy.spin() (see execution_table step 7), the node waits continuously for new requests instead of exiting.

What happens if the callback does not return a response?

The client will wait indefinitely or get an error; the callback must return a proper response object as shown in step 5.

How does the server know which function to call on a request?

When creating the service server (step 3), the callback function is passed as an argument, linking requests to that function.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of 'response' after step 5?

A {success: True, message: 'Service called'}

B None

C {success: False, message: 'Error'}

D {data: True}

💡 Hint

Check the 'response' variable in variable_tracker after step 5

At which step does the service server start listening for requests?

A Step 4

B Step 2

C Step 3

D Step 5

💡 Hint

See execution_table where the service server is created

If the callback returned no response, what would happen according to the flow?

A The node would stop running

B The client would wait or error

C The server would crash immediately

D The service would auto-retry

💡 Hint

Refer to key_moments about callback response importance

Concept Snapshot

Creating a ROS service server:
- Initialize node with rospy.init_node()
- Define a callback function to handle requests
- Create service with rospy.Service(name, type, callback)
- Use rospy.spin() to keep node alive
- Callback must return a response object
- Server waits and responds to client requests continuously

Full Transcript

To create a ROS service server, first start a ROS node. Then define a callback function that will process incoming service requests and return responses. Next, create the service server by calling rospy.Service with the service name, service type, and the callback function. The server then waits for requests. When a request arrives, the callback runs and returns a response. The server sends this response back to the client. The node keeps running and waiting for more requests until manually stopped. This process ensures the server can handle multiple requests over time.

Practice

1. What is the main role of a service server in ROS?

easy

A. To publish messages continuously

B. To wait for requests and send back replies

C. To subscribe to topics and process data

D. To log information to the console

Solution

1. Step 1: Understand the service server role

   A service server in ROS waits for incoming requests from clients and sends back replies after processing.

2. Step 2: Differentiate from other ROS nodes

   Unlike publishers or subscribers, a service server handles request-response communication, not continuous data streams.

3. Final Answer:

   To wait for requests and send back replies -> Option B

4. Quick Check:

   Service server = request and reply [OK]

Hint: Service servers handle requests and replies, not continuous data [OK]

Common Mistakes:

• Confusing service servers with publishers
• Thinking service servers subscribe to topics
• Assuming service servers only log data

2. Which of the following is the correct way to create a service server in ROS using rospy?

easy

A. server = rospy.Client('service_name', ServiceType, handler_function)

B. server = rospy.Publisher('service_name', ServiceType, handler_function)

C. server = rospy.Subscriber('service_name', ServiceType, handler_function)

D. server = rospy.Service('service_name', ServiceType, handler_function)

Solution

1. Step 1: Identify the correct rospy function

   The function to create a service server is rospy.Service, which takes the service name, service type, and handler function.

2. Step 2: Exclude other ROS communication methods

   Publisher and Subscriber are for topics, Client is not a rospy function for servers.

3. Final Answer:

   server = rospy.Service('service_name', ServiceType, handler_function) -> Option D

4. Quick Check:

   Service server creation = rospy.Service [OK]

Hint: Use rospy.Service to create service servers, not Publisher or Subscriber [OK]

Common Mistakes:

• Using rospy.Publisher instead of rospy.Service
• Confusing service server with subscriber
• Trying to use a non-existent rospy.Client

3. Given the following ROS service server code snippet, what will be the output when a client sends a request with data=5?

import rospy
from beginner_tutorials.srv import AddTwoInts, AddTwoIntsResponse

def handle_add_two_ints(req):
    return AddTwoIntsResponse(req.a + req.b)

rospy.init_node('add_two_ints_server')
service = rospy.Service('add_two_ints', AddTwoInts, handle_add_two_ints)
rospy.spin()

medium

A. The server returns the sum of req.a and req.b

B. The server returns the product of req.a and req.b

C. The server returns the difference of req.a and req.b

D. The server returns an error because of missing return statement

Solution

1. Step 1: Analyze the handler function

   The function handle_add_two_ints returns the sum of req.a and req.b wrapped in AddTwoIntsResponse.

2. Step 2: Understand the server behavior on request

   When a client sends a request with data=5 (assuming req.a=5 and req.b is provided), the server replies with their sum.

3. Final Answer:

   The server returns the sum of req.a and req.b -> Option A

4. Quick Check:

   Handler returns sum = The server returns the sum of req.a and req.b [OK]

Hint: Handler returns sum of inputs; check return statement carefully [OK]

Common Mistakes:

• Assuming multiplication instead of addition
• Forgetting to return a response object
• Confusing request fields names

4. Identify the error in this ROS service server code snippet:

import rospy
from beginner_tutorials.srv import AddTwoInts, AddTwoIntsResponse

def handle_add(req):
    sum = req.a + req.b

rospy.init_node('add_two_ints_server')
service = rospy.Service('add_two_ints', AddTwoInts, handle_add)
rospy.spin()

medium

A. The handler function does not return a response object

B. The service name is invalid

C. The node is not initialized

D. The service type is incorrect

Solution

1. Step 1: Check the handler function

   The handler function calculates sum but does not return AddTwoIntsResponse, which is required.

2. Step 2: Verify other parts of the code

   The service name, node initialization, and service type are correct and valid.

3. Final Answer:

   The handler function does not return a response object -> Option A

4. Quick Check:

   Handler must return response [OK]

Hint: Always return a response object from the handler function [OK]

Common Mistakes:

• Forgetting to return AddTwoIntsResponse
• Misnaming the handler function
• Not calling rospy.init_node

5. You want to create a ROS service server that returns the maximum of two integers sent by the client. Which handler function correctly implements this behavior?

hard

A. def handle_max(req):
return MaxIntsResponse(max(req.a, req.b))

B. def handle_max(req):
return MaxIntsResponse(req.a + req.b)

C. def handle_max(req):
if req.a > req.b:
return MaxIntsResponse(req.a)
else:
return MaxIntsResponse(req.b)

D. def handle_max(req):
return MaxIntsResponse(min(req.a, req.b))

Solution

1. Step 1: Understand the requirement

   The server must return the maximum of two integers sent by the client.

2. Step 2: Evaluate each handler function

   def handle_max(req): return MaxIntsResponse(max(req.a, req.b)) uses max() but assumes MaxIntsResponse accepts a single argument correctly; def handle_max(req): if req.a > req.b: return MaxIntsResponse(req.a) else: return MaxIntsResponse(req.b) explicitly returns the max value using if-else and returns response properly; def handle_max(req): return MaxIntsResponse(req.a + req.b) returns sum, which is incorrect; def handle_max(req): return MaxIntsResponse(min(req.a, req.b)) returns minimum, which is wrong.

3. Final Answer:

   def handle_max(req): if req.a > req.b: return MaxIntsResponse(req.a) else: return MaxIntsResponse(req.b) -> Option C

4. Quick Check:

   Correct max logic with proper return = def handle_max(req): if req.a > req.b: return MaxIntsResponse(req.a) else: return MaxIntsResponse(req.b) [OK]

Hint: Use if-else to return max value wrapped in response [OK]

Common Mistakes:

• Returning sum instead of max
• Returning min instead of max
• Incorrectly using max() without proper response