Introduction

This tutorial explains how to do a position-based visual-servoing with the Panda 7-dof robot from Franka Emika equipped with an Intel Realsense D435 camera.

The following video shows the resulting robot trajectory when the robot is achieving a position-based visual servoing over an Apriltag target.

Prerequisites

Hardware

We suppose here that you have:

a Panda robot in its research version from Franka Emika that will be controlled throw vpRobotFranka class.
an Intel Realsense D345 camera attached to the robot end-effector. Note that this tutorial should also work with any other Intel Realsense camera.

Setting up a real-time kernel

In order to control your robot using libfranka, the controller program on the workstation PC must run with real-time priority under a PREEMPT_RT kernel. This tutorial shows how to proceed to install a real-time kernel.

In our case, we are using Ubuntu 20.04.5 LTS with the real-time kernel version 5.15.70-rt50 x86_64. The following instructions are to install 5.15.70-rt50.

Identify your kernel version

From here we suppose that you were able to install Ubuntu 20/04/5 LTS amd64 that comes with 5.15.0 kernel:
```
$ uname -mrs
Linux 5.15.0-48-generic x86_64
```

Choose and download a kernel version and the real-time patch

You have to decide which kernel version to use. We recommend to choose a version as close as possible from the generic kernel corresponding to your Ubuntu version. At the time it was written, in https://mirrors.edge.kernel.org/pub/linux/kernel/projects/rt/5.15/ the last 5.15.x-rt kernel is in patch-5.15.70-rt50.patch.gz. If you choose a different version, simply substitute the numbers. Having decided on a version, use curl to download the source files:
```
$ mkdir $VISP_WS/3rdparty
$ cd $VISP_WS/3rdparty
$ mkdir rt-linux; cd rt-linux
$ $ curl -SLO https://www.kernel.org/pub/linux/kernel/v5.x/linux-5.15.70.tar.gz
$ curl -SLO https://www.kernel.org/pub/linux/kernel/projects/rt/5.15/patch-5.15.70-rt50.patch.gz
```

Decompress them with:

$ tar xvzf linux-5.15.70.tar.gz
$ gunzip patch-5.15.70-rt50.patch.gz

Extract the source code and apply the patch:

$ cd linux-5.15.70
$ patch -p1 < ../patch-5.15.70-rt50.patch

Configure and build the kernel

First, install the necessary dependencies:

$ sudo apt-get install build-essential bc curl ca-certificates fakeroot gnupg2 libssl-dev lsb-release libelf-dev bison flex

The next step is to configure your kernel:
```
$ make oldconfig
```

This opens a text-based configuration menu. When asked for the Preemption Model, choose the Fully Preemptible Kernel:

Preemption Model
  1. No Forced Preemption (Server) (PREEMPT_NONE)
  2. Voluntary Kernel Preemption (Desktop) (PREEMPT_VOLUNTARY)
  3. Preemptible Kernel (Low-Latency Desktop) (PREEMPT)
> 4. Fully Preemptible Kernel (Real-Time) (PREEMPT_RT) (NEW)

We recommend keeping all options at their default values.

Afterwards, you are ready to compile the kernel. As this is a lengthy process, set the multi threading option -j to the number of your CPU cores:

$ fakeroot make -j4 deb-pkg

Note

If you get the following error:

make[4]: *** No rule to make target 'debian/canonical-certs.pem', needed by 'certs/x509_certificate_list'.  Stop.

The solution is to modify .config replacing the line

CONFIG_SYSTEM_TRUSTED_KEYS="debian/canonical-certs.pem"
CONFIG_SYSTEM_REVOCATION_KEYS="debian/canonical-revoked-certs.pem"
CONFIG_DEBUG_INFO_BTF=y

with

CONFIG_SYSTEM_TRUSTED_KEYS=""
CONFIG_SYSTEM_REVOCATION_KEYS=""
CONFIG_DEBUG_INFO_BTF=n

and then try a new build

$ fakeroot make -j4 deb-pkg

Finally, you are ready to install the newly created package. The exact names depend on your environment, but you are looking for headers and images packages without the dbg suffix. To install:
```
$ sudo dpkg -i ../linux-headers-5.15.70-rt50*.deb ../linux-image-5.15.70-rt50*.deb
```
Reboot the computer
```
$ sudo reboot
```
The version of the kernel is now 5.15.70-rt50
```
$ uname -msr
Linux 5.15.70-rt50 x86_64
```

Allow a user to set real-time permissions for its processes

After the PREEMPT_RT kernel is installed and running, add a group named realtime and add the user controlling your robot to this group:
```
$ sudo addgroup realtime
$ sudo usermod -a -G realtime $(whoami)
```

Afterwards, add the following limits to the realtime group in /etc/security/limits.conf:

@realtime soft rtprio 99
@realtime soft priority 99
@realtime soft memlock 102400
@realtime hard rtprio 99
@realtime hard priority 99
@realtime hard memlock 102400

The limits will be applied after you log out and in again.

Install Franka library

As described here, to install the Franka library, follow the steps:

$ sudo apt install build-essential cmake git libpoco-dev libeigen3-dev
$ cd $VISP_WS/3rdparty
$ git clone --recursive https://github.com/frankaemika/libfranka
$ cd libfranka
$ mkdir build
$ cd build
$ cmake .. -DCMAKE_BUILD_TYPE=Release
$ make -j4
$ sudo make install

Install Realsense library

Following the tutorial, we recall the main steps here:

Note: Since our kernel is 4.12+ streaming Depth/IR/Color is supported and is provided out of the box. This means that the patches are not needed.

Unplug any connected Intel RealSense camera.

Install the packages required for librealsense build:

$ sudo apt-get install git libssl-dev libusb-1.0-0-dev pkg-config libgtk-3-dev cmake-curses-gui
$ sudo apt-get install libglfw3-dev libgl1-mesa-dev libglu1-mesa-dev

Get librealsense from github:

$ cd $VISP_WS/3rdparty
$ git clone https://github.com/IntelRealSense/librealsense.git
$ cd librealsense

Run Intel Realsense permissions script located in librealsense root directory:
```
$ sudo ./scripts/setup_udev_rules.sh
```

Build and install librealsense

$ mkdir build
$ cd build
$ cmake .. -DBUILD_EXAMPLES=ON -DCMAKE_BUILD_TYPE=Release
$ make -j4
$ sudo make install

Connect your Realsense camera (we are using a D435) and check if you are able to acquire images running:
```
$ ./examples/capture/rs-capture
```

If you are able to visualize the images, it means that you succeed in librealsense installation.

Print an Apriltag target

We provide a ready to print 36h11 tag that is 12 by 12 cm square [download] that you may print.

If you are interested to get other tags, follow the steps described in Print an AprilTag marker.

Calibrate extrinsic camera parameters

Follow the steps described in Tutorial: Camera eye-to-hand extrinsic calibration in order to estimate the end-effector to camera transformation. This step is mandatory to control the robot in cartesian in the camera frame.

Configure and build ViSP

Since you installed new libfranka and librealsense 3rd parties, you need to configure again ViSP with cmake in order that ViSP is able to use these libraries. To this end follow Configure ViSP from source. At this step you should see new USE_FRANKA and USE_LIBREALSENSE2 cmake vars appearing in the CMake GUI.

Now follow the instructions for Build ViSP libraries.

Configure Ethernet

Our robot controller has by default IP 192.168.1.1. Here we show how to configure a laptop that is connected with an Ethernet cable to the robot controller.

Edit Ethernet connections:

Add a new connexion using "Add" button. Choose the default Ethernet connection type:

Click "Create" button in order to create a new Franka controller connection that has a static IPv4 like 192.168.1.10 and netmask 255.255.255.0:

Click "Save" button.

Connect to Franka desk

Select the new Ethernet Networks connection named "Franka controller". When the connection is established open a web browser like Firefox or Chromium and enter the address https://192.168.1.1/desk. The first time you will be warned that the connection is not secure. Click "Advanced" and "Add Exception":

Then confirm security exception

When connected, you may release the user-stop button and open brakes:

Position-based visual servoing

An example of position-based visual servoing using Panda robot equipped with a Realsense camera is available in servoFrankaPBVS.cpp.

Attach your Realsense camera to the robot end-effector
Put an Apriltag in the camera field of view
If not already done, follow Tutorial: Camera eye-to-hand extrinsic calibration to estimate $^e{\bf M}_c$ the homogeneous transformation between robot end-effector and camera frame. We suppose here that the file is located in apps/calibration/eMc.yaml.

Now enter in example/servo-franka folder and run servoFrankaPBVS binary using --eMc to locate the file containing the $^e{\bf M}_c$ transformation. Other options are available. Using --help show them:

$ cd example/servo-franka
$ ./servoFrankaPBVS --help
./servoFrankaPBVS [--ip <default 192.168.1.1>] [--tag_size <marker size in meter; default 0.12>] [--eMc <eMc extrinsic file>] [--quad_decimate <decimation; default 2>] [--adaptive_gain] [--plot] [--task_sequencing] [--no-convergence-threshold] [--verbose] [--help] [-h]

Run the binary activating the plot and using a constant gain:

$ ./servoFrankaPBVS --eMc ../../apps/calibration/eMc.yaml --plot

Note

If you encounter the following error message:

$ ./servoFrankaPBVS
Franka network exception: libfranka: Connection to FCI refused. Please install FCI feature or enable FCI mode in Desk.

you need to use your navigator to activate FCI. This new security feature was introduced in Franka system between version 4.0.2 and 4.2.2. See known issue: libfranka: Connection to FCI refused.

Now you should see new window that shows the image from the camera like in the next image. In this window, use the left mouse click to enable the robot controller, and the right click to quit the binary.

Legend: Example of initial position. The goal is here to bring the RGB frame attached to the tag over the yellow frame corresponding to the desired position of the tag in the camera frame.

Legend: Example of final position reached after position-based visual servoing. In green, you can see the trajectories in the image of the tag corners and tag cog. The latest correspond to the trajectory of the projection in the image of the tag frame origin. The 3D trajectory of this frame is a straight line when the camera extrinsic parameters are well calibrated.

Legend: Corresponding visual-features (translation and orientation of the cdMc homogeneous matrix corresponding to the transformation between the desired camera pose and the current one) and velocities applied to the robot in the camera frame. You can observe an exponential decrease of the visual features.

You can also activate an adaptive gain that will make the convergence faster:

$ ./servoFrankaPBVS --eMc ../../apps/calibration/eMc.yaml --plot --adaptive_gain

You can also start the robot with a zero velocity at the beginning introducing task sequencing option:

$ ./servoFrankaPBVS --eMc ../../apps/calibration/eMc.yaml --plot --task_sequencing

And finally you can activate the adaptive gain and task sequencing:

$ ./servoFrankaPBVS --eMc ../../apps/calibration/eMc.yaml --plot --adaptive_gain --task_sequencing

To learn more about adaptive gain and task sequencing see Tutorial: How to boost your visual servo control law.

Known issues

libfranka: Connection to FCI refused

When executing one of the binaries that use libfranka you may encounter the following error like:

$ ./servoFrankaIBVS --ip 192.168.100.2
Franka network exception: libfranka: Connection to FCI refused. Please install FCI feature or enable FCI mode in Desk.
Check if you are connected to the Franka robot or if you specified the right IP using --ip command line option set by default to 192.168.1.1.

This error occurred with our robot after upgrading the Franka system from 4.0.2 to 4.2.2 version.

The Dashboard shows that after a synchonization using Franka World, our System version is 4.2.2.

To overcome this error, you need:

First check if FCI is installed:

When FCI is installed, in Desk you should see this image.
Secondly activate FCI. For that, as shown in the next image click on "Activate FCI" in the Desk right column (1). It will open the popup (2) that should remain present all the time you want to execute any binary that needs to communicate with the robot using libfranka.

Behavior when FCI (Franka Controller Interface) is activated.

Next tutorial

You can continue with the Tutorial: IBVS with Panda 7-dof robot from Franka Emika that shows how to implement an image-based visual servoing scheme with the Franka robot or follow Tutorial: Image-based visual servo that will give some hints on image-based visual servoing in simulation with a free flying camera.

If you want to achieve a physical simulation of a Franka robot, with a model that has been accurately identified from a real Franka robot, like in the next video, we recommend to make a tour on Tutorial: FrankaSim a Panda 7-dof robot from Franka Emika simulator that is available in visp_ros. Here you will find a ROS package that allows to implement position, velocity and impedance control of a simulated Franka robot using ROS and CoppeliaSim.

Table of Contents