Request-response communication model in ROS - Step-by-Step Execution

Concept Flow - Request-response communication model

Client sends request

↓

Server receives request

↓

Server processes request

↓

Server sends response

↓

Client receives response

↓

End

This flow shows how a client sends a request to a server, the server processes it, and then sends back a response.

Execution Sample

ROS

client.call(request)
# Server receives request
# Server processes and sends response
response = client.get_response()

This code shows a client sending a request and waiting for the server's response.

Execution Table

Step	Action	Component	State Before	State After	Output
1	Client creates request	Client	No request	Request ready	None
2	Client sends request	Client	Request ready	Request sent	Request sent to server
3	Server receives request	Server	No request	Request received	Request data available
4	Server processes request	Server	Request received	Response ready	Response data prepared
5	Server sends response	Server	Response ready	Response sent	Response sent to client
6	Client receives response	Client	Request sent	Response received	Response data available
7	Client processes response	Client	Response received	Response processed	Final output ready
8	End communication	Both	Response processed	Idle	Communication complete

💡 Communication ends after client processes the response and both sides become idle.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	After Step 5	After Step 6	After Step 7	Final
request	None	Created	Sent	Received by server	Processed	Processed	Processed	Processed	Processed
response	None	None	None	None	Prepared	Sent	Received	Processed	Final output

Key Moments - 3 Insights

Why does the client wait after sending the request?

The client waits because it needs the server's response before continuing. This is shown in execution_table step 6 where the client is waiting and then receives the response.

What happens if the server does not send a response?

If the server does not send a response, the client will keep waiting indefinitely or until a timeout occurs. This breaks the flow after step 5 and step 6 would never complete.

Is the request-response communication synchronous or asynchronous?

It is synchronous because the client sends a request and waits for the response before moving on, as shown by the sequential steps in the execution_table.

Visual Quiz - 3 Questions

Look at the execution_table, what is the state of the client after step 2?

A Response received

B Request created

C Request sent

D Idle

💡 Hint

Check the 'State After' column for step 2 in the execution_table.

At which step does the server prepare the response?

A Step 3

B Step 4

C Step 5

D Step 6

💡 Hint

Look for 'Response ready' in the 'State After' column in the execution_table.

If the server delays sending the response, which step is directly affected?

A Step 5

B Step 4

C Step 6

D Step 7

💡 Hint

Refer to the 'Server sends response' action in the execution_table.

Concept Snapshot

Request-response model in ROS:
- Client sends a request message.
- Server receives and processes the request.
- Server sends back a response message.
- Client waits synchronously for the response.
- Communication ends after response is processed.

Full Transcript

In the request-response communication model, a client sends a request to a server. The server receives this request and processes it. After processing, the server sends a response back to the client. The client waits for this response before continuing. This synchronous communication ensures that the client gets the needed data or confirmation from the server before moving on. The process ends when the client processes the response and both client and server return to idle state.

Practice

1. In ROS, what does the request-response communication model primarily allow?

easy

A. One node sends a request and waits for a reply from another node

B. Nodes continuously publish data without expecting a reply

C. Nodes broadcast messages to all other nodes simultaneously

D. Nodes store data locally without communication

Solution

1. Step 1: Understand the request-response model in ROS

   This model involves one node sending a request message and waiting for a response from another node.

2. Step 2: Compare options with this model

   Only One node sends a request and waits for a reply from another node describes this direct ask-and-reply behavior, while others describe different communication types.

3. Final Answer:

   One node sends a request and waits for a reply from another node -> Option A

4. Quick Check:

   Request-response = direct ask and reply [OK]

Hint: Request-response means ask first, then wait for answer [OK]

Common Mistakes:

• Confusing request-response with continuous publishing
• Thinking request-response is broadcasting
• Assuming no reply is needed

2. Which of the following is the correct way to define a ROS service server in Python using the request-response model?

easy

A. service = rospy.Service('service_name', ServiceType, handler_function)

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

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

D. service = rospy.Client('service_name', ServiceType, handler_function)

Solution

1. Step 1: Recall ROS Python service server syntax

   In ROS, a service server is created using rospy.Service with the service name, type, and handler function.

2. Step 2: Identify correct function

   Only rospy.Service matches this pattern; Publisher and Subscriber are for topics, Client is not a rospy function.

3. Final Answer:

   service = rospy.Service('service_name', ServiceType, handler_function) -> Option A

4. Quick Check:

   Service server uses rospy.Service [OK]

Hint: Service server uses rospy.Service, not Publisher or Subscriber [OK]

Common Mistakes:

• Using Publisher or Subscriber instead of Service
• Confusing client and server creation
• Wrong function names like rospy.Client

3. Given this ROS Python service client code snippet, what will be printed if the service responds with response.result = 42?

import rospy
from example.srv import AddTwoInts

def call_service():
    rospy.wait_for_service('add_two_ints')
    try:
        add_two_ints = rospy.ServiceProxy('add_two_ints', AddTwoInts)
        response = add_two_ints(20, 22)
        print(response.result)
    except rospy.ServiceException as e:
        print("Service call failed", e)

call_service()

medium

A. Service call failed

B. 42

C. 20

D. None

Solution

1. Step 1: Understand the service client call

   The client waits for the service, calls it with 20 and 22, and expects a response with a 'result' attribute.

2. Step 2: Analyze the response printing

   The code prints response.result, which is given as 42 in the question.

3. Final Answer:

   42 -> Option B

4. Quick Check:

   Print response.result = 42 [OK]

Hint: Prints the response.result value returned by the service [OK]

Common Mistakes:

• Confusing request parameters with response
• Expecting print of input values instead of response
• Assuming exception without error

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

import rospy
from example.srv import Multiply

def handle_multiply(req):
    return req.a * req.b

rospy.init_node('multiply_server')
service = rospy.Service('multiply', Multiply, handle_multiply)
rospy.spin()

medium

A. The service type Multiply is not imported correctly

B. The service name cannot be 'multiply'

C. The handler must return a response object, not just a number

D. rospy.spin() is missing

Solution

1. Step 1: Check the handler function return type

   In ROS services, the handler must return a response message object, not a raw value.

2. Step 2: Identify the error in return statement

   Returning req.a * req.b (a number) is incorrect; it should return MultiplyResponse(req.a * req.b) or equivalent.

3. Final Answer:

   The handler must return a response object, not just a number -> Option C

4. Quick Check:

   Handler returns response object, not raw value [OK]

Hint: Handler must return response message object, not raw data [OK]

Common Mistakes:

• Returning raw values instead of response objects
• Forgetting to import response message class
• Missing rospy.spin() (though present here)

5. You want to implement a ROS service that returns the sum of two integers only if both are positive; otherwise, it returns zero. Which handler function correctly implements this request-response logic?

hard

A. def handle_sum(req):
return SumTwoIntsResponse(req.a + req.b)

B. def handle_sum(req):
return SumTwoIntsResponse(req.a + req.b if req.a > 0 or req.b > 0 else 0)

C. def handle_sum(req):
if req.a > 0 or req.b > 0:
return SumTwoIntsResponse(req.a + req.b)
else:
return SumTwoIntsResponse(0)

D. def handle_sum(req):
if req.a > 0 and req.b > 0:
return SumTwoIntsResponse(req.a + req.b)
else:
return SumTwoIntsResponse(0)

Solution

1. Step 1: Understand the condition for sum

   The sum should be returned only if both req.a and req.b are positive (greater than zero).

2. Step 2: Check each option's condition logic

   def handle_sum(req): if req.a > 0 and req.b > 0: return SumTwoIntsResponse(req.a + req.b) else: return SumTwoIntsResponse(0) uses 'and' to check both positive, returning sum or zero correctly. def handle_sum(req): return SumTwoIntsResponse(req.a + req.b if req.a > 0 or req.b > 0 else 0) uses 'or' incorrectly and missing parentheses in ternary. def handle_sum(req): if req.a > 0 or req.b > 0: return SumTwoIntsResponse(req.a + req.b) else: return SumTwoIntsResponse(0) uses 'or' which is wrong logic. def handle_sum(req): return SumTwoIntsResponse(req.a + req.b) always returns sum ignoring condition.

3. Final Answer:

   def handle_sum(req): if req.a > 0 and req.b > 0: return SumTwoIntsResponse(req.a + req.b) else: return SumTwoIntsResponse(0) -> Option D

4. Quick Check:

   Both positive check with 'and' = def handle_sum(req): if req.a > 0 and req.b > 0: return SumTwoIntsResponse(req.a + req.b) else: return SumTwoIntsResponse(0) [OK]

Hint: Use 'and' to check both positive before summing [OK]

Common Mistakes:

• Using 'or' instead of 'and' for both positive check
• Returning sum without condition
• Incorrect ternary syntax in return