industrial_robot_status_controller repository

Repository Summary

Checkout URI
VCS Type git
VCS Version master
Last Updated 2019-05-23



ROS build Status license - apache 2.0


These packages provide a ros_control compatible controller that publishes "robot status" of (industrial) robots in the form of RobotStatus messages.

hardware_interfaces need to expose an IndustrialRobotStatusHandle resource, which they update with information from a/the robot controller. The IndustrialRobotStatusController will then take this and populate the fields of the RobotStatus message with the information from the IndustrialRobotStatusHandle.

Note: the controller does not implement any logic to derive the values of the fields in RobotStatus, it merely transforms IndustrialRobotStatusHandle into a RobotStatus message. The hardware_interface is responsible for implementing the correct logic to populate the fields based on information about the status of the robot controller that it interfaces with.



These packages have been released through the ROS buildfarm. Only ROS Kinetic is supported on Ubuntu Xenial (i386, amd64, armhf and arm64).

The following command may be used to install the controller on a supported platform:

sudo apt-get install ros-kinetic-industrial-robot-status-controller

Note: industrial_robot_status_interface is only needed when integrating the interface into a hardware_interface.

You can now continue with configuring your ros_control controller stack. See the Example - Controller section below for an example controller configuration.

From source

This should only be needed in case:

  1. there is no release available for a particular platform
  2. the current release does not include a certain feature or fix available in the source repository
  3. changes to the packages are needed

In other cases a binary installation is preferred.

To build the packages, the following commands may be used in a Catkin workspace (example uses catkin_tools, but catkin_make should also work):

# this assumes there is a Catkin workspace at '/path/to/catkin_ws' and it contains a 'src' sub directory
$ git -C /path/to/catkin_ws/src clone
$ rosdep update
$ rosdep install --from-paths /path/to/catkin_ws/src -i
$ cd /path/to/catkin_ws
$ catkin build
$ source devel/setup.bash

At this point the controller can be used with any ros_control-based stack. See the Example - Controller section below for an example controller configuration.



#include the industrial_robot_status_interface/industrial_robot_status_interface.h header and store an instance of industrial_robot_status_interface::IndustrialRobotStatusInterface somewhere in the hardware_interface. Store an instance of IndustrialRobotStatusHandle as well.

Register the IndustrialRobotStatusHandle with the IndustrialRobotStatusInterface and finally register the IndustrialRobotStatusInterface with ros_control via InterfaceManager::registerInterface(..).

Periodically update the IndustrialRobotStatusHandle (typically in RobotHW::read(..)) and set the fields (to TriState::UNKNOWN, TriState::FALSE or TriState::TRUE), based upon information from the robot controller available to the hardware_interface.


As the controller does not implement any logic itself, but merely transforms a IndustrialRobotStatusHandle into a RobotStatus message, it's fully reusable and requires no source code changes (custom robot status derivation logic should be implemented in the hardware_interface).

The controller supports two configurable settings:

  • publish_rate: rate at which RobotStatus messages should be published (default: 10 Hz)
  • handle_name : name of the IndustrialRobotStatusHandle resource exposed by the hardware_interface (default: "industrial_robot_status_handle")

See the Example section below for a full configuration example of the controller.


This section shows how to integrate the interface into a hardware_interface and how to add a stanza to a ros_control configuration file to load the controller.


Initialising and registering the IndustrialRobotStatusHandle and IndustrialRobotStatusInterface:


// these could be class members of course
industrial_robot_status_interface::RobotStatus robot_status_resource_{};
industrial_robot_status_interface::IndustrialRobotStatusInterface robot_status_interface_{};


// somewhere in the initialisation of the hardware_interface
    "industrial_robot_status_handle", robot_status_resource_));


Note: the first argument to the IndustrialRobotStatusHandle ctor can be anything, as long as the controller is configured to look for the same resource handle name. The default is "industrial_robot_status_handle".

Finally: update the members of robot_status_resource_ with data from the controller:


// somewhere in RobotHW::read(..)
using industrial_robot_status_interface::TriState;
using industrial_robot_status_interface::RobotMode;

// set defaults
robot_status_resource_.in_motion       = TriState::UNKNOWN;
// skip other fields for brevity
robot_status_resource_.mode            = RobotMode::UNKNOWN;
robot_status_resource_.error_code      = 0;

// use controller info to set real values
// note: 'latest_robot_data_' is some variable that contains
//       the latest state received from whatever this hw interface
//       is communicating with.
if (latest_robot_data_.state == MyRobot::IS_MOVING)
  robot_status_resource_.in_motion = TriState::TRUE;



Add the controller as usual to a ros_control configuration .yaml:

  type: industrial_robot_status_controller/IndustrialRobotStatusController
  handle_name: my_custom_status_handle
  publish_rate: 10

Here the IndustrialRobotStatusHandle was registered under a different resource name, so handle_name is set to "my_custom_status_handle".

Additional information

Refer to the RobotStatus message documentation for more information on how the values for the fields should be derived.