How do you create ROS interfaces and messages?

1 Interface types

ROS supports three types of interfaces: messages, services, and actions. Messages are the simplest form of communication, where one node sends data to another node without expecting a response. Services are synchronous requests and responses, where one node asks another node to perform a task and waits for the result. Actions are asynchronous goals and feedback, where one node sends a goal to another node and receives periodic updates on the progress and outcome.

2 Message files

A message file defines the fields and data types of a message. It has the extension .msg and is stored in the msg subdirectory of your package. A message file consists of one or more lines, each specifying a field name and a field type, separated by a space. For example, a message file that represents a point in 3D space could look like this:

float64 x
float64 y
float64 z        

3 Service files

A service file defines the request and response of a service. It has the extension .srv and is stored in the srv subdirectory of your package. A service file consists of two sections, separated by a line with three dashes. The first section defines the fields and data types of the request, and the second section defines the fields and data types of the response. For example, a service file that performs addition on two numbers could look like this:

float64 a
float64 b
---
float64 sum        

4 Action files

An action file defines the goal, feedback, and result of an action. It has the extension .action and is stored in the action subdirectory of your package. An action file consists of three sections, separated by lines with three dashes. The first section defines the fields and data types of the goal, the second section defines the fields and data types of the feedback, and the third section defines the fields and data types of the result. For example, an action file that moves a robot to a target pose could look like this:

geometry_msgs/Pose target_pose
---
float32 percent_complete
geometry_msgs/Pose current_pose
---
bool success
string message        

5 Interface generation

To generate the source code for your interfaces and messages, you need to add the appropriate dependencies and build instructions to your package.xml and CMakeLists.txt files. For example, if you are using C++ and Python, you need to add roscpp and rospy as build and exec dependencies, and message_generation as a build dependency. You also need to add message_runtime as an exec dependency. Then, you need to add the following lines to your CMakeLists.txt file:

find_package(catkin REQUIRED COMPONENTS
  roscpp
  rospy
  message_generation
)
add_message_files(
  FILES
  Point.msg
)
add_service_files(
  FILES
  AddTwoInts.srv
)
add_action_files(
  FILES
  MoveToPose.action
)
generate_messages(
  DEPENDENCIES
  geometry_msgs
)
catkin_package(
  CATKIN_DEPENDS
  roscpp
  rospy
  message_runtime
  geometry_msgs
)        

Finally, you need to build your package using catkin_make or catkin build.

6 Interface usage

To use your interfaces and messages in your nodes, you need to include or import the generated headers or modules. For example, if you are using C++, you need to include the following headers:

#include "your_package/Point.h"
#include "your_package/AddTwoInts.h"
#include "your_package/MoveToPoseAction.h"        

If you are using Python, you need to import the following modules:

from your_package.msg import Point
from your_package.srv import AddTwoInts
from your_package.action import MoveToPoseAction        

Then, you can create and manipulate your messages, services, and actions using the standard ROS APIs for publishers, subscribers, clients, servers, action clients, and action servers.

7 Here’s what else to consider

This is a space to share examples, stories, or insights that don’t fit into any of the previous sections. What else would you like to add?