wiki:Robotino
Last modified 4 years ago Last modified on 03.02.2015 13:48:38

Robotino

Robotino 2.0 The Robotino is an educational robot platform manufactured and sold by Festo Didactic. It is used in the RoboCup Logistics League Sponsored by Festo.

Hardware

(additional hardware on Carologistics Robotino)

IO Port Layout

Fawkes on the Robotino

This page describes how to get Fawkes running on your Robotino. Note that this page describes deep modifications/updates of the operating system. It works nicely for us, your mileage may vary.

This page is work-in-progress.

Wifi Setup

To access the wifi setup to configure custom SSIDs or setup WPA2 encryption you must access the internal access point's web interface. The easiest way is to use SSH port forwarding. Assuming you have SSH access, do the following:

ssh -L 1234:172.26.101.1:80 robotino@ROBOTINO-IP

After logging in, point your web browser to http://localhost:1234 to reach the web interface. According to this forum post the username is admin and the password is apap6. It worked on the Robotinos we encountered. The web interface should be self explanatory to configure the access point. Do NOT change the IP address though, that'll just cause confusion.

Note: for the best experience you should turn off the secondary IP address used to communicate with the access point by default and enable it only when needed. When enabled, the IP is published via mDNS-SD/Bonjour, causing services to not properly show up on network tools and names like robotino.local cannot be resolved properly. To do this execute

for f in /etc/network/interfaces*; do \
  sudo sed -i -e 's/auto eth0:1/#auto eth0:1/' $f; \
done

Afterwards the interface is no longer automatically setup on startup. Use ifup eth0:1 to start it manually if needed. Remember to close it using ifdown eth0:1.

Packages and Requirements

First, we modify the apt configuration to be able to download updates for the installed base system (Ubuntu 9.04 "Jaunty Jackalope") and include our custom apt repository with backports and custom packages. We also add entries to be able to download packages and updates from Ubuntu 10.04 ("Lucid Lynx"). This is required to accommodate some of the requirements, and use some of the advanced features like PCL. Make a copy of /etc/apt/sources.list and replace it with our sources.list. We recommend not to upgrade the whole system, but only step by step what is needed. The memory that is available to apt is too small by default, you need to edit /etc/apt/apt.conf.d/01ubuntu so that it reads:

APT
{
  Cache-limit "67108864";
};

After updating the files, execute

sudo apt-get update

This will download the available package lists. Do not upgrade all the packages! We will now remove all Java bits (to conserve space on the flash disk) and uninstall GCC 4.3, and afterwards install GCC 4.4. By not simply upgrading it, we get Ubuntu to properly setup the symbolic links (e.g. gcc to gcc-4.4). We then install the dependencies, as is also described in the FawkesOnUbuntu instructions. Additionally we install distcc, as this can be tremendously useful to get reasonable compilation times (see below).

Note: we provide several packages rebuilt for the Robotino, specifically to omit dependencies on Java where possible. Therefore you might be asked to install packages which cannot be authenticated.

sudo apt-get remove '.*java.*' '.*gcj.*'
sudo apt-get install libboost1.40-all-dev
# The following removes GCC 4.3
sudo apt-get remove gcc
# The following install GCC 4.4 from Lucid Lynx repositories
sudo apt-get install gcc g++ libboost1.40-all-dev
sudo apt-get install git-core vim libmagic-dev libssl-dev libavahi-client-dev libsqlite3-dev \
  libxml++2.6-2 libxml++2.6-dev libdaemon-dev libmicrohttpd-dev  liblua5.1-0-dev libtolua++5.1-dev \
  libpng12-dev libjpeg62-dev libcv-dev libcvaux-dev librrd-dev libbullet0 libbullet-dev cmake \
  graphviz-dev libeigen3-dev libgtest-dev libqhull-dev libtinyxml-dev liburg0-dev \
  libv4l-dev v4l-utils yaml-cpp-dev distcc

If you intend to use PCL also execute

sudo apt-get install libpcl-1.3-all-dev

Disabling laserd

OpenRobotino is setup in such a way to run its laserd as soon as a Hokuyo URG laser is connected. Since we will use Fawkes' laser plugin to get data we need to disable this behavior. To do this execute the following command:

sudo sed -e 's/^\(.\)/#\1/' -i /etc/udev/rules.d/99-rangefinder.rules

Getting Fawkes

Afterwards you can continue with the Getting Started Guide to start Fawkes. The ultimate quickstart to clone the repository is:

git clone git://git.fawkesrobotics.org/fawkes.git 

(Note: if git is blocked on your network, use http://git.fawkesrobotics.org/fawkes.git instead.)

To use the private repository for the Carologistics RoboCup team use (please note that this requires Git 1.7.7 or higher to work and you must have provided your SSH public key to the repository admin).

git clone --recursive git@git.fawkesrobotics.org:fawkes-robotino.git

Then enable compiler optimization and start building Fawkes.

cd fawkes
# The following adds optimizer flags, older Robotinos need c3 instead of geode
sed -i -e 's/-g/-g -O3 -march=geode/' etc/buildsys/btypes/config_fawkes.mk
make

To run Robotino from the LCD keypad you need to add an entry to the lcdd menu file and setup the plugins to load by default. First, run Fawkes and on a second terminal execute the following:

ffconfig set /fawkes/meta_plugin/default robotino_default string

This will cause the robotino integration plugins to be loaded by default. This also includes webview and joystick control (if a joystick has been plugged in). Afterwards add the following to /etc/robotino/lcdd.xml:

      <title>
        <text>Hauptmenu</text>
      </title>
      <entry>
        <text>Fawkes</text>
        <action name="execute">
          <message>
            <text>Running Fawkes...</text>
          </message>
          <file>/home/robotino/fawkes/bin/fawkes</file>
          <param></param>
        </action>
      </entry>

The "Hauptmenu" text will already exist. Just add the following <entry> block.

Compiling using distcc

We recommend using a virtual machine for compilation as described in Creating a Virtual Machine of a Robotino 2.0 Base.

To speed up compilation you might want to use distcc. If you intent to use ROS alongside Fawkes and want to build this on your own you even need this, as the RAM on the Robotino of 128MB is insufficient and swapping is disabled for reasons of real-time capabilities.

First, setup a virtual machine using Ubuntu Jaunty (32bit, i386). You can get the ISO image from http://old-releases.ubuntu.com/releases/jaunty/. You might also be able to use a more recent version, but we did not try this. We recommend using KVM with a machine capable of hardware virtualization. Make sure that virtualization support is enabled in the BIOS. When using libvirt and virt-manager to setup the VM and you can only select qemu this is not the case. After the installation has completed, perform the same steps mentioned above in Basic Setup. For now we assume the host is Fedora 16 using KVM with the default NAT networking setup.

Then install distcc on both, the Robotino and the VM using

apt-get install distcc

In the VM, edit /etc/default/distcc and set STARTDISTCC="true" and add your robot to ALLOWEDNETS. Comment out the LISTENER line so that the socket is bound open. Start distcc on the server using /etc/init.d/distcc start.

On the host you need to allow flowing distcc traffic and enable port forwarding from the host to the VM. To achieve this execute the following as root replacing VM-IP with the actual IP address of the virtual machine (use ifconfig to find out).

iptables -I FORWARD -m tcp -p tcp --dport 3632 -j ACCEPT
iptables -t nat -A PREROUTING -m tcp -p tcp --dport 3632 -j DNAT --to-destination VM-IP
sysctl net.ipv4.conf.all.forwarding=1

Note that this is only enabled temporary and must be executed again on a reboot.

The configuration of /etc/sysconfig/iptables on the lenovo-notebook should look like this:

# Firewall configuration written by system-config-firewall
# Manual customization of this file is not recommended.
*filter
:INPUT ACCEPT [0:0]
:FORWARD ACCEPT [0:0]
:OUTPUT ACCEPT [0:0]
-A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
-A INPUT -p icmp -j ACCEPT
-A INPUT -i lo -j ACCEPT
-A INPUT -m state --state NEW -m udp -p udp --dport 5353 -d 224.0.0.251 -j ACCEPT
-A INPUT -m state --state NEW -m udp -p udp --dport 631 -j ACCEPT
-A INPUT -m state --state NEW -m udp -p udp --dport 137 -j ACCEPT
-A INPUT -m state --state NEW -m udp -p udp --dport 138 -j ACCEPT
-A INPUT -m state --state NEW -m tcp -p tcp --dport 22 -j ACCEPT
-A INPUT -m state --state NEW -m tcp -p tcp --dport 3632 -j ACCEPT
-A FORWARD -m tcp -p tcp --dport 3632 -j ACCEPT
-I FORWARD -s 172.16.35.0/24 -d 192.168.122.0/24 -j ACCEPT
-I FORWARD -d 172.16.35.0/24 -s 192.168.122.0/24 -j ACCEPT
-A INPUT -j REJECT --reject-with icmp-host-prohibited
-A FORWARD -j REJECT --reject-with icmp-host-prohibited
COMMIT
*nat
-A PREROUTING -m tcp -p tcp --dport 3632 -j DNAT --to-destination 192.168.122.128
COMMIT

Finally, to compile using distcc on the robotino, run the following command which changes the PATH search order so distcc is used instead of gcc:

source /home/robotino/bin/use-distcc

Test Run: Moving the Robotino with a xbox controller

Make sure that xbox drivers have been installed Now start Fawkes:

robotino@robotino:~/fawkes/bin$./fawkes

In a new terminal load the necessary plugins robotino, joystick and robotino-joystick in the given order:

robotino@robotino:~/fawkes/bin$ ./ffplugin -l robotino
Requesting loading of plugin robotino
Loading of robotino succeeded
robotino@robotino:~/fawkes/bin$ ./ffplugin -l joystick
Requesting loading of plugin joystick
Loading of joystick succeeded
robotino@robotino:~/fawkes/bin$ ./ffplugin -l robotino-joystick
Requesting loading of plugin robotino-joystick
Loading of robotino-joystick succeeded

The robot should now be movable using the xbox controller.

ROS Compatibility Setup

If you want to use ROS in combination with Fawkes, you need to install at least a basic ROS environment (BEWARE, we have seen issues with ROS Groovy, so stay with Fuerte if possible). This is tricky compared to Fawkes as it has more requirements on recent version of the compiler, boost, as well as on RAM. To build from source we strongly recommend using distcc to finish in acceptable time (we have used the desktop install target). However, a much faster installation is possible using pre-built packages. We will now sketch installation from the Lucid apt repository as described in more detail in the ROS Installation Instructions.

sudo sh -c 'echo "deb http://packages.ros.org/ros/ubuntu lucid main" > /etc/apt/sources.list.d/ros-latest.list'
wget http://packages.ros.org/ros.key -O - | sudo apt-key add -
sudo apt-get update

# ROS comes with its own OpenCV version (that Fawkes can use)
sudo apt-get remove libcv-dev libcvaux-dev libopencv-calib3d-dev libopencv-calib3d2.3 \
  libopencv-core-dev libopencv-core2.3 libopencv-features2d-dev libopencv-features2d2.3 \
  libopencv-flann-dev libopencv-flann2.3 libopencv-gpu2.3 libopencv-highgui-dev libopencv-highgui2.3 \
  libopencv-imgproc-dev libopencv-imgproc2.3 libopencv-legacy2.3 libopencv-ml-dev libopencv-ml2.3 \
  libopencv-objdetect-dev libopencv-objdetect2.3 libopencv-video2.3

sudo apt-get install ros-fuerte-ros-comm ros-fuerte-common-msgs ros-fuerte-geometry \
  ros-fuerte-robot-model ros-fuerte-image-common ros-fuerte-image-transport-plugins \
  libeigen3-dev=3.0.1-1+ros4~lucid

This will install the basic required packages (especially the stacks required to gain the relevant Fawkes-ROS integration support). Note that this will also downgrade the Eigen package to the version required by ROS and install a different OpenCV (minor) version. After installation you should clean and rebuild your Fawkes working copy.

Attachments