v2.1.4

What's Changed

• Added arg to enable/disable launch of ursim by @urmahp in #679
• Added support for UR30 by @VinDp in #688

New Contributors

• @VinDp made their first contribution in #688

Full Changelog: v2.1.3...v2.1.4

v2.0.0

We are happy to announce that those features have just been merged into the master branch of the driver while many features have been released standalone to also be used in conjunction with ros_control drivers and applications.

New ROS-Control features

We've created ros_control extensions making ROS manipulator drivers in general and the Universal Robots ROS driver in special more capable:

• Cartesian control and trajectory execution:
  cartesian_control_msgs,
  ros_controllers_cartesian

  For executing Cartesian trajectories we created a message definition structure for executing Cartesian trajectories similar to the joint_trajectory_controller. Based upon this trajectory definition we created a new set of Cartesian controllers trying to mimic the joint_trajectory_controller. For this, we created a ros_control hardware interface for Cartesian robot commands and states and a Cartesian trajectory controller using this and the trajectory definition from above.

  For robots that don't offer a Cartesian hardware interface we've created a controller using an IK solver and a joint-based hardware interface, so robot drivers not offering a Cartesian hardware interface (yet) can be used in conjunction with the new Cartesian trajectory controller. The IK method used for calculating the joint commands is exchangeable by using pluginlib.

  With the Cartesian interfaces created, we also added a TwistController, that can be used to command a geometry_msgs/Twist for the robot's tcp velocity which is useful e.g. in visual servoing or teleoperation applications.

• Generalized speed scaling interface: scaled_controllers

  Speed-scale trajectory execution. All trajectory executions (both Cartesian and joint-based) can be speed-scaled within 0 to 100% at runtime. This gives you flexibility in setting-up new applications and during test runs. While this is integrated into the Universal Robots ROS driver, this feature can be leveraged for other ROS-Control-based drivers, as well.

• Trajectory interpolation on robot controller: pass_through_controllers

  In certain situations it is beneficial to leave trajectory execution to the robot vendor controller. The vendor controller usually knows best about optimal acceleration ramps, waypoint blending and physical restrictions regarding a requested motion. Also, in terms of real-time requirements any streaming controller raises the need for a certain level of real-time requirements on the ROS system, the driver implementation and the communication between the ROS machine and the actual robot. Leaving trajectory execution to the robot controller and only sending the complete trajectory removes the requirement of a real-time control PC or even a fast network connection.

  In this driver, the tracejtory will be executed using the movel or movej instructions with blends in between the trajectory waypoints.

  We've created a set of controllers to perform this task, so that switching between these different control paradigms is possible using standard ROS-control mechanisms such as the controller_manager. These controllers basically forward a complete trajectory (joint-based and Cartesian interfaces do exist) to the robot controller, reading feedback and the final goal status from the robot controller directly.

Package summary

The following additional repositories/metapackages have been developed inside this project:

• scaled_controllers -- Scaling interface to achieve speed-scaling
  functionality
  https://github.com/UniversalRobots/Universal_Robots_ROS_scaled_controllers

• cartesian_control_msgs -- Message definition for Cartesian
  trajectories
  https://github.com/UniversalRobots/Universal_Robots_ROS_cartesian_control_msgs

• ros_controllers_cartesian -- ros_control hardware interface
  definitions and controllers for Cartesian control of robot
  manipulators
  https://github.com/UniversalRobots/Universal_Robots_ROS_controllers_cartesian

• pass_through_controllers -- A set of controllers to forward
  complete trajectories (joint-based and Cartesian) to the robot
  hardware and leave interpolation to the robot controller
  https://github.com/UniversalRobots/Universal_Robots_ROS_passthrough_controllers

All packages of the repositories mentioned above are released for ROS melodic and noetic.

We hope that this contribution will not only improve your experience with Universal Robots manipulators inside a ROS environment, but also improve ros_control as a whole.