Fast Research Interface Library: Start Page

Introduction

The Fast Research Interface Library intends to provide a simple user interface to the KUKA Light-Weight Robot IV and hides all communication and set-up issues behind interface. It is only an interface and it does not contain any control functionalities. Without much installation efforts, access to different controller interfaces of the KUKA system is provided:

Joint position controller,
Cartesian impedance controller, and
Joint position controller.

The Fast Research Interface Library runs on a remote PC node with is connected to the KRC (KUKA Robot Controller) via an Ethernet connection. In intervals of 1 to 100 milliseconds, UDP packages are periodically sent from the KRC unit to the remote host. These packages contain a complete set of robot control and status data (e.g., joint positions, joint torques, drive temperatures, etc.; cf. FRI User Documentation). The remote host (e.g., with QNX Neutrino RTOS) has to instantaneously send a reply message after the reception of each package. A reply message contains input data for the applied controllers (e.g., joint position set-points, joint stiffness set-points, etc.). This way, users become able to set-up own control architectures and/or application-specific controllers for the light-weight arm as it is often desired at research institutions.

Download

The Fast Research Interface Library is available for

Software Overview

The Fast Research Interface Library can be used in two different ways:

The class FastResearchInterface provides access to all functionalities offered by KUKA. This class has a simple structure, but it consists of a rather huge number of methods.
Based on the class FastResearchInterface, a set of classes has been designed in order to provide an easy-to-use and easy-to-start-with API with all necessary functionalities while hiding all API-irrelevant parts of the library. The base class for this controller interface is the class LWRBaseControllerInterface. Derived from this class, users can select among interfaces for
- joint position control (class LWRJointPositionController),
- Cartesian impedance control (LWRCartImpedanceController), and
- joint impedance control (class LWRJointImpedanceController).

The following section briefly describes how to get started with the robot and this library.

Quick Start Manual

This section gives a very brief overview about all required steps for quickly getting started with the Fast Research Interface (see also FRI User Documentation).

Step 1: Install the Fast Research Interface Technology Package on the KRC unit.

Please refer to the manual of Installation/Uninstallation/Update of Tech Packages SystemTech (KRS) from V5.x.
Step 2: Send your machine information to your KUKA representative in order to receive your FRI license file.

After installing the FRI software on the KRC unit, send the generated log file

C:\KRC\Roboter\Log\lbrBoot.log

from the KRC unit to your KUKA contact to receive your license file and respective KUKA instructions about how obtain an FRI license and how to install it.
Step 3: Configure the KRC node.

Open the file C:\Windows\vxwin.ini on the KRC node and enter its IP address (e.g., 192.168.0.20):
```
[Boot]\n
Bootline=elPci(0,1)pc:vxworks h=192.0.1.2 b=192.0.1.1 e=192.168.0.20 u=target pw=vxworks
```
The KUKA Fast Research Interface running on the KRC node requires the IP address and an open port of the remote host. To specify both, open the file C:\KRC\Roboter\INIT\dlrrc.ini may contain
```
[DLRRC]
FRIHOST=192.168.0.100
FRISOCK=49938,0
```
After a reboot, you may use ping 192.168.0.20 and ping 192.168.0.100 on either node to check whether the connection was successfully established. In order to achieve minimum latencies between both nodes, you may simply use a crossed Ethernet cable.

Copy the KRL Source Files to
```
C:\KRC\Roboter\KRC\R1\Program\FRIDemo
```
on the KRC unit and restart it.
Step 4: Check out the Sample Applications.

Depending on your needs, you may choose one of these simple sample applications in the folder
```
src/FastResearchInterfaceTest 
```
or
```
src/LWRGettingStartedExamples 
```
to start with. The first folder only contains one sample application, FastResearchInterfaceTest.cpp that makes use of the class FastResearchInterface and shows, how this generic API can be used. The second folder contains a number of very simple sample applications, all which make use of one of these interface classes:
- LWRJointPositionControlExample.cpp for an application using the joint position controller
- LWRCartImpedanceControlExample.cpp for an application using the Cartesian impedance controller
- LWRJointImpedanceControlExample.cpp for an application using the joint impedance controller
- LWRLoggingExample.cpp for an application using the interface for logging low-level control data
The respective user APIs for the controller interfaces are defined by the classes
- LWRJointPositionController for the joint position controller,
- LWRCartImpedanceController for the Cartesian impedance controller, and
- LWRJointImpedanceController for the joint impedance controller,
which are all derived from the class LWRBaseControllerInterface. This class contains an object of the class FastResearchInterface, which constitutes the actual interface and provides the full set functionalities. The class LWRBaseControllerInterface and its three derivatives only act as a wrapper and hide the actual (rather voluminous) library with all its relevant communication issues. Only necessary and required functionalities are provided for each controller.

Optionally, a real-time capable printf() function (LWRBaseControllerInterface::printf()) and a low-level real-time data logger may be useful (class DataLogging).
Step 5: Compile the Fast Research Interface Library for the remote host.

Instructions for the following operating systems can be found here:
- QNX Neutrino,
- Linux,
- MacOS, and
- Microsoft Windows.
Step 6: Execute your first application on the remote host.

Remark: Make sure, all network settings are correct (here is an example). The provided KRL file (FRIControl.src) and the initialization file (980039-FRI-Driver.init) are prepared for a sample time of 2 milliseconds.