When to use services vs topics in ROS - Hands-On Comparison

When to use services vs topics in ROS

📖 Scenario: You are building a simple robot communication system using ROS (Robot Operating System). You want to understand when to use services and when to use topics to send messages between parts of your robot.

🎯 Goal: Learn to create a basic ROS setup with a topic for continuous sensor data publishing and a service for one-time commands. This will help you see the difference between topics and services in ROS.

📋 What You'll Learn

Create a ROS publisher node that sends sensor data on a topic called /sensor_data

Create a ROS service server node that responds to a command request on /reset_counter

Use the correct ROS message and service types

Understand the difference between continuous data flow (topics) and request-response (services)

💡 Why This Matters

🌍 Real World

Robots often need to send sensor data continuously to multiple parts of the system while also handling specific commands like resetting counters or changing modes. Using topics and services correctly helps organize this communication clearly.

💼 Career

Understanding when to use topics versus services is essential for ROS developers working on robot software, enabling efficient and clear communication between different robot components.

1

Create a ROS publisher node for sensor data

Create a Python ROS node called sensor_publisher that publishes integer sensor data on the topic /sensor_data using the message type std_msgs.msg.Int32. Initialize the publisher and set the publishing rate to 1 Hz.

ROS

# Your code here to create sensor_publisher node and publisher for /sensor_data topic

Hint

Remember to import rclpy, Node, and Int32. Use create_publisher with topic /sensor_data and message type Int32. Use a timer to publish data every second.

2

Create a ROS service server node for reset command

Create a Python ROS node called reset_service that offers a service named /reset_counter using the service type std_srvs.srv.Trigger. This service will reset the sensor counter to zero when called.

ROS

import rclpy
from rclpy.node import Node
from std_srvs.srv import Trigger

# Your code here to create reset_service node and /reset_counter service

Hint

Import Trigger from std_srvs.srv. Create a service server with create_service on /reset_counter. The callback should reset the counter in the SensorPublisher instance.

3

Use the service to reset the sensor counter

Add a ROS client node called reset_client that calls the /reset_counter service using std_srvs.srv.Trigger. The client should send a request and print the response message.

ROS

import rclpy
from rclpy.node import Node
from std_srvs.srv import Trigger

# Your code here to create reset_client node and call /reset_counter service

Hint

Create a client node with create_client for /reset_counter. Use call_async to send the request and handle the response to print the message.

4

Explain when to use services vs topics in ROS

Add a comment at the top of the code explaining in simple words when to use topics and when to use services in ROS communication.

ROS

# Your comment here explaining when to use topics vs services

Hint

Write a clear comment at the top of the code explaining that topics are for continuous data streams and services are for one-time request-response communication.

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