Data

Tools

Indexes

Applications

Experiments

Awesome

An open API service indexing awesome lists of open source software.

https://github.com/robotlocomotion/drake-iiwa-driver


https://github.com/robotlocomotion/drake-iiwa-driver

Last synced: about 2 months ago
JSON representation

Awesome Lists containing this project

README 

        
# drake-iiwa-driver



This repository contains the application code used to communicate with

the KUKA iiwa are from Drake.  Communicating with the arm requires two

pieces, a Java application to run on the KUKA Sunrise cabinet, and an

local C++ application communicating with the cabinet using the FRI

protocol.



The KUKA control cabinet has two network interfaces which are

configured with static IP addresses.  Both will need to be connected

to communicate with the arm.



 * X66: 172.31.1.147/16 -- This interface is used by Sunrise Workbench to load new software onto the controller.

 * KONI: 192.170.10.2/24 -- This is the interface which FRI clients communicate over.  That's not in the reserved IP space, so it could potentially cause a conflict if you happen to want to contact a host in that subnet.



Selecting the command mode to use for the arm (position vs. torque) is

done by starting a different Java application on the arm

(DrakeFRIPositionDriver vs. DrakeFRITorqueDriver).  The C++ driver

will detect which mode the FRI connection is in and send commands

appropriately.



## Sunrise Workbench



Provisioning the IIWA arm must be done from Sunrise Workbench. Please ensure

that you have Sunrise Workbench 1.14 installed, and that it is compatible with

your control cabinet (see below). If you need instructions for older

versions, please see [`1faf413`](https://github.com/RobotLocomotion/drake-iiwa-driver/tree/1faf413).



When installing, the default checkboxes for Connectivity Software should cover

the use cases needed here.



The computer running Sunrise Workbench must be configured with an

address which can communicate with 172.31.1.147/16, and which is

connected to the X66 port.



**Note**: Try to briefly familiarize yourself with first-party documentation

from KUKA. For relevant software, the documents should be named something

along the lines of "KUKA Sunrise.OS / KUKA Sunrise.Workbench",

"KUKA Sunrise.FRI".



### Backing up Existing Applications / Checking Compatibility



Before creating a new project, it is recommended to back up existing projects

from the controller. This is useful for backing up *and* ensuring that your

Sunrise Workbench is compatible with the Sunrise OS installed on the control

cabinet.



* (Optional) Switch to a new workspace: File -> Switch Workspace.

* File -> New -> Sunrise project

  * Select "Load project from controller"

  * Instructions from here should be straightforward.



### Creating the Java Application



TODO(sam.creasey) Can I just zip up a project/workspace?



  * File -> New -> SunriseProject

    * IP address of the controller can be left at 172.31.1.147

    * Create new project

    * Project Name: DrakeFRIDriver

    * Topology template: LBR iiwa 14 R820 (or the appropriate model)

    * Media Flange: Medien-Flansch Touch pneumatisch (or the appropriate model)

    * Uncheck "Create Sunrise application (starts another wizard)"

    * Source folder: whatever

    * Package: drake_fri

    * Name: DrakeFRIDriver



  * In "Package Explorer", select StationSetup.cat

    * Software

      * Leave anything that is already checked as-is

      * Check "Fast Robot Interface Extension"

    * Save (Ctrl-S)



  * In "Package Explorer", select SafetyConfiguration.sconf

    * Customer PSM

      * Uncheck row 1 "External EMERGENCY STOP"

      * Uncheck row 2 "Operator Protection",

      * Uncheck row 3 "Safety Stop"



  * Copy the Java source code for DrakeFRIPositionDriver and DrakeFRITorqueDriver.

    * In "Package Explorer", expand tree for your new project, navigate to `src`, right-click, and select New -> Package. Name this new package `drake_fri`.

    * Use code from `kuka-driver/sunrise_1.14`.

    * Copy DrakeFRIPositionDriver.java and DrakeFRITorqueDriver to DrakeFRIDriver/src/drake_fri. It may be easiest to drag and drop from a Windows Explorer window into the "Package Explorer" pane.  You can remove any exising DrakeFRIDriver files.



  * In "Package Explorer", select StationSetup.cat

    * Installation

      * Push "Install" (this will not actually install the application, but it will wipe the existing configuration of the KUKA cabinet and replace it with yours).  It will take a few minutes, and eventually will reboot the controller.



  * Press the "sync" button.  It's on the toolbar at the top, 5th from the right.  It looks a bit like a square with a couple of arrows over it (though it doesn't look much like this).  This will compile the Java source code and install the resulting applications.

    * Execute



### Enabling the Safety Configuration on the Robot



When you upload a new safety configuration to the robot it needs to be enabled. To do this go to `Safety-->Activation` on the pendant. Then click `Activation`. Use the default user, the password is `argus`. This should enable the new configuration.



## C++ driver



Once Sunrise Workbench is provisioned, you'll need to configure the

system which will communicate directly with the KONI interface.  This

system must be configured for the IP address 192.170.10.200 (netmask

/24, or 255.255.255.0) (this can be changed in the Java applications).

KUKA recommends directly attaching the computer to the KONI port

instead of using a switch.  Some network interfaces (particularly some

Intel models) have issues when cabled directly to the KONI port (problems

include link flapping up/down repeatedly).



On the SmartPad, turn the key switch, and choose the "AUT" mode, then

turn the key switch back. Choose either "DrakeFRITorqueDriver" or

"DrakeFRIPositionDriver" from "Application". Press the green "Play"

button on the left sidebar of the SmartPad.



### Compiling the driver



Next, build the driver program to communicate with the iiwa arm using

FRI, and with the controlling application using LCM.  Compiling this

project will output a single program in the build directory called

"kuka_driver".  Running it with no arguments will connect to the IIWA

at it's default address and port (192.170.10.2, port 30200), negotiate

LCM into the command state, and report the IIWA status via LCM.



An application wishing to control the arm should listen to LCM for

status updates and command the joints appropriately in response.



Before you begin, install the prerequisite:

```

sudo apt install libgflags-dev

```



The C++ driver can be build with either CMake or bazel.  There are two

external dependencies which need to be provided, FRI and drake.



This repository is configured with a private git submodule for the

KUKA FRI source code. To pull it:

```

git submodule init

git submodule update

```



If you do not have access to that repository, you will need to install

your own version of the FRI source (which can be found in your Sunrise

project in the directory FastRobotInterface_Client_Source).



```

cd kuka-fri

unzip /path/to/your/copy/of/FRI-Client-SDK_Cpp.zip

patch -p1 < ../fri_udp_connection_file_descriptor.diff

```



The patch above applies correctly to the FRI 1.7, 1.11, and 1.14 source.

Other versions have not been tested.



#### Building with bazel



When building with bazel, it will automatically fetch a copy of drake

to build against.  You should be able to run `bazel build //...` to

produce a working driver.



This is the easiest method for developers who are already working with

the drake source, since a working bazel build enviornment for drake

should be sufficient to build this package.



#### Building with CMake



When building with CMake, you'll need a binary copy of drake.  The

latest release can be found at

https://github.com/RobotLocomotion/drake/releases.  Uncompress the

binary tarfile, and add

`-DCMAKE_PREFIX_PATH=/drake/lib/cmake` to your cmake

command line.  For example:



```

mkdir build

cd build

cmake .. -DCMAKE_PREFIX_PATH=/tmp/drake/lib/cmake

make

```