grl 4.0 - Robotics tools in C++ with support for the KUKA LBR iiwa

Robotics tools in C++11. Implements real time arm drivers for Kuka LBR iiwa plus V-REP, ROS, Constrained Optimization based planning and Inverse Kinematics integration.

github.com/ahundt/grl

GRL was under the hood for the winning entry to the KUKA Innovation Award 2016.

• jrl-umi3218/Tasks library integration
  • Solve inverse kinematics problems in real time
  • Tasks can use more general constrained optimization optimization for problems like force control
• Dramatically improved JAVA interface drivers
  • Communicates directly with UDP and Flatbuffers
  • Can receive robot status from the JAVA API
  • Thanks to Ashkan Khakzar
• V-REP Upgraded to V3.3.2 rev3
• ROS Kinetic support, indigo works too!

KUKA LBR iiwa R800 and R820

• Supports Sunrise OS 1.9 with Connectivity Suite
• Java based control of a kuka lbr iiwa been heavily tested and works well.
• FRI based monitoring of a kuka works accurately with high performance

ROS Driver

The driver is called grl_kuka_ros_driver and supports ROS indigo with two unique¹ features:

• Publishes millisecond resolution ROS joint states (4ms by default) on your local machine
  • Lowest latency driver for monitoring the arm state available (at the time of release)
  • Up to an order of magnitude lower latency at 1,2,3,4 or 5 ms vs 10-200ms for other drivers
  • experimental support for low latency commanding of the arm over FRI
• No need to modify internal settings of the controller box (other ROS drivers require this)

ROS iiwa_stack integration

grl can utilize the following iiwa_stack packages (quoted from their overview):

• iiwa_control: contains the joint and trajectory controllers used by MoveIt! and Gazebo.
• iiwa_description: URDF for both KUKA LBR IIWA R800 and R820.
• iiwa_gazebo: launch files to run a Gazebo simulation.
• iiwa_moveit: a MoveIt! configuration for controlling the robot (either a Gazebo simulation or a real one).

grl 3.0 particularly integrates with iiwa_stack commit b3ac4c3. Future versions may work too but haven't been tested.

Do not follow the iiwa_stack setup with iiwa_stack + grl in particular do not change the configuration of the KONI port on the robot, because this disables the low latency FRI features of grl. It is ok to follow the general C++ ROS setup and compilation steps. You can even add their java code to your Sunrise Project (it won't run because iiwa_stack currently requires the use of ports reserved by KUKA, this is why they disable FRI and reconfigure KONI).

GRL_Driver.java

New KUKA Sunrise OS + Connectivity Suite driver application to control the KUKA iiwa that installs onto the arm controller box. A C++ application on your computer interfaces with this driver.

• Can start independently of C++ driver and wait for that driver to connect
• Can safely switch between several modes at runtime as controlled by C++ driver:
  • MoveArmJointServo commands the arm in joint space over the sunrise java ethernet port
  • TeachArm initiates Hand guided motions
  • ShutdownArm exits the application
• ProcessData menu on iiwa tablet lets you configure the target communication IP addresses and other configuration directly on your robot without modifying your installation
• Designed to expand functionality (in the future) to support nearly every configuration available in the KUKA iiwa Java API's SmartServo, hand guidance, and FRI interfaces.

C++ Drivers

The C++ driver classes KukaDriver, KukaFRI, and KukaJAVA provide an easy to use interface you can port to your own system and middleware. In essence, these are the C++ driver classes other library authors should use. Typical users would most likely be better served by the V-REP drivers or the ROS drivers.

• The grl C++ drivers depend only on boost, the C++ standard library, ZeroMQ, and google flatbuffers
• C++ drivers have no dependencies on robot middleware such as ROS or V-REP
• Streamlined debugged and simplified C++ drivers
• KukaDriver provides an extremely simple interface
  • Supports all modes of GRL_Driver.java
  • Drive the arm via the Java interface while monitor the arm state via the FRI interface
  • KukaFRIdriver
  • provides a simple, reliable interface realtime Fast Robot Interface
  • Improved instructions for building with the C++ FRI driver
  • receive updates and command motion via the realtime FRI interface with
  • selectable response times from 1-5 milliseconds
  • KukaJAVAdriver
  • No dependency on FRI cpp API
  • Send configuration and commands to the robot

V-REP

• Hand Eye Calibration Algorithms have been fully integrated into V-REP with a plugin.
  • vrep lua APIs for controlling all plugins, including the Optical Tracker, Hand Eye Calibration, and the Kuka LBR iiwa.
• RoboneSimulation.ttt child scripts provide examples of accessing and using these APIs. See vrep documentation for an explanation of child scripts.
• experimental constrained optimization based planning of robot arm motion
• upgraded to V-REP 3.2.3 rev4

Additional Details

Special thanks to:

• @ashkaan372 for the UDP based JAVA driver implementation
• @cpaxton for the ROS driver and other major contributions. Without Chris this release would not be possible!
• @SalvoVirga and @marcoesposito1988 for writing their ROS iiwa_stack and switching the license to BSD. Their effort made the grl + iiwa_stack functionality possible!