When to use services vs topics in ROS - Visual Side-by-Side Comparison

Concept Flow - When to use services vs topics

Start: Need communication?

↓

Is it one-time request/response?

Yes→Use Service

↓

Send request

↓

Is it continuous data stream?

Yes→Use Topic

↓

Publish messages

↓

Reconsider design or use both

Decide communication type: one-time request/response uses services; continuous data streams use topics.

Execution Sample

ROS

def call_service():
    response = service_client.call(request)
    return response

publisher.publish(message)

Shows a service call for one-time request and a topic publisher for continuous messages.

Execution Table

Step	Communication Type	Condition	Action	Result
1	Need communication	Start	Check communication need	Proceed to decide type
2	One-time request/response?	Yes	Use Service	Send request, wait for response
3	One-time request/response?	No	Check if continuous stream	Go to next step
4	Continuous data stream?	Yes	Use Topic	Publish messages continuously
5	Continuous data stream?	No	Reconsider design	Possibly combine or redesign
6	Service call example	Call service_client.call()	Send request and wait	Receive response once
7	Topic publish example	publisher.publish(message)	Send message	Subscribers receive continuously
8	End	All conditions checked	Finish decision	Communication method chosen

💡 Decision ends when communication type matches service or topic use case

Variable Tracker

Variable	Start	After Step 2	After Step 4	Final
communication_type	undefined	service (one-time)	topic (continuous)	chosen method
action_taken	none	service call sent	topic messages published	communication established

Key Moments - 3 Insights

Why do we use services for one-time requests instead of topics?

Services provide a clear request and response pattern, shown in execution_table step 2 and 6, which topics do not support.

Can topics be used for one-time communication?

Topics are designed for continuous data streams (step 4 and 7), so using them for one-time requests can cause delays or missed messages.

What if communication is neither one-time nor continuous?

Step 5 suggests reconsidering design or combining both services and topics to fit the need.

Visual Quiz - 3 Questions

Look at the execution_table, at which step do we decide to use a service?

A Step 2

B Step 4

C Step 5

D Step 7

💡 Hint

Check the 'Condition' and 'Action' columns in step 2 for service decision.

According to variable_tracker, what is the communication_type after step 4?

A service

B topic

C undefined

D none

💡 Hint

Look at the 'communication_type' row under 'After Step 4' column.

If the communication is continuous, which action is taken according to the execution_table?

A Send request and wait for response

B Reconsider design

C Publish messages continuously

D Finish decision

💡 Hint

See step 4 and 7 for continuous communication actions.

Concept Snapshot

Use services for one-time request/response communication.
Use topics for continuous data streaming.
Services wait for a reply; topics do not.
Choose based on communication pattern needs.
Reconsider design if neither fits well.

Full Transcript

This visual guide helps decide when to use ROS services versus topics. First, check if communication is needed. If it is a one-time request and response, use a service, which sends a request and waits for a reply. If communication is continuous, use a topic to publish messages that subscribers receive continuously. If neither fits, reconsider your design or combine both. The execution table shows steps deciding communication type and actions taken. Variable tracking shows how communication_type changes from undefined to service or topic. Key moments clarify why services suit one-time calls and topics suit streams. The quiz tests understanding of these steps and variable states.

Practice

1. In ROS, when should you use a service instead of a topic?

easy

A. When you want to continuously stream sensor data.

B. When you need a single request and a single response.

C. When you want to broadcast messages to many nodes.

D. When you want to log data over time.

Solution

1. Step 1: Understand service communication

   Services in ROS are designed for one-time request and reply interactions between nodes.

2. Step 2: Compare with topic usage

   Topics are used for continuous data streaming or broadcasting messages to multiple subscribers.

3. Final Answer:

   When you need a single request and a single response. -> Option B

4. Quick Check:

   Service = single request-reply [OK]

Hint: Services = one-time ask, Topics = ongoing talk [OK]

Common Mistakes:

• Using topics for single request-response needs
• Using services for continuous data streaming
• Confusing broadcast with one-time communication

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

easy

A. client = rospy.Subscriber('service_name', ServiceType, callback)

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

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

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

Solution

1. Step 1: Recall ROS Python service client syntax

   The correct way to create a service client is using rospy.ServiceProxy with the service name and type.

2. Step 2: Identify incorrect options

   rospy.Service defines a service server, rospy.Subscriber subscribes to topics, and rospy.Publisher publishes to topics.

3. Final Answer:

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

4. Quick Check:

   Service client uses rospy.ServiceProxy [OK]

Hint: Service client uses rospy.ServiceProxy() [OK]

Common Mistakes:

• Confusing service client with service server syntax
• Using Subscriber or Publisher for services
• Missing service type argument

3. Given the following ROS Python code snippet, what will be printed?

import rospy
from std_srvs.srv import SetBool

def call_service():
    rospy.wait_for_service('toggle_led')
    try:
        toggle_led = rospy.ServiceProxy('toggle_led', SetBool)
        response = toggle_led(True)
        print(response.success)
    except rospy.ServiceException as e:
        print('Service call failed:', e)

call_service()

medium

A. True if the service call succeeds, otherwise an error message.

B. Always prints False.

C. SyntaxError due to missing import.

D. No output because the service is not called.

Solution

1. Step 1: Analyze service call behavior

   The code waits for the 'toggle_led' service, then calls it with argument True, and prints the success field from the response.

2. Step 2: Understand possible outputs

   If the service call succeeds, response.success will be True or False depending on service logic; if it fails, an exception message prints.

3. Final Answer:

   True if the service call succeeds, otherwise an error message. -> Option A

4. Quick Check:

   Service call prints success or error [OK]

Hint: ServiceProxy call prints success field if no error [OK]

Common Mistakes:

• Assuming service call always returns False
• Confusing service call with topic subscription
• Ignoring exception handling

4. You wrote a ROS node that uses a service client but it never receives a response. What is the most likely cause?

medium

A. The service server is not running or not advertised.

B. The topic name is misspelled.

C. The node is publishing to the wrong topic.

D. The callback function is missing in the subscriber.

Solution

1. Step 1: Identify service client behavior

   A service client waits for a service server to be available and respond to requests.

2. Step 2: Diagnose no response issue

   If no response arrives, the service server might not be running or the service name is incorrect, so the client cannot connect.

3. Final Answer:

   The service server is not running or not advertised. -> Option A

4. Quick Check:

   No response means server missing [OK]

Hint: No service response? Check if server is running [OK]

Common Mistakes:

• Confusing service client with topic subscriber
• Checking wrong topic instead of service
• Ignoring service server status

5. You want to control a robot arm to move to a specific position and wait for confirmation before sending the next command. Which ROS communication method should you use and why?

hard

A. Use a topic because continuous streaming of positions is required.

B. Use a service because topics do not support multiple subscribers.

C. Use a topic because services cannot send commands.

D. Use a service because you need a request and a reply for each move command.

Solution

1. Step 1: Understand the control requirement

   The robot arm needs to receive a move command and confirm completion before the next command.

2. Step 2: Match communication type to requirement

   Services provide a request-response pattern ideal for commands needing confirmation, unlike topics which are for continuous data streaming without guaranteed replies.

3. Final Answer:

   Use a service because you need a request and a reply for each move command. -> Option D

4. Quick Check:

   Command with confirmation = service [OK]

Hint: Commands needing reply? Use services [OK]

Common Mistakes:

• Choosing topics for commands needing confirmation
• Thinking services can't send commands
• Confusing subscriber limits with communication type