ICub machines configuration

In this page we describe the setup of the computers connected to the iCub robot, which all share a common network disk and configuration.

See iCub machines configuration/Archive for obsolete information.

Operating system installation

Ubuntu LTS, default settings and partitioning. The first user to be created must be called icub, to make the distributed setup possible: for NFS network mount, this user has to have uid 1000 and guid 1000.

In order to add a user:

• either use the Ubuntu graphical frontends
• or use a Terminal:

sudo adduser icub
sudo usermod -aG sudo icub  # gives sudo privileges

Other operations

Network configuration

See also: VisLab network, ISR computing resources.

Configure a static IP as explained in one of the following subsections, depending if the machine is a desktop or a server one.

Also, it is recommended to set up the /etc/hosts file as follows:

10.10.1.41 icubbrain1
10.10.1.42 icubbrain2
10.10.1.50 pc104
10.10.1.51 icub-cuda
10.10.1.53 icub-laptop

You should be able to do ping icubbrain1

Desktop machines

With the graphical Network Manager (https://help.ubuntu.com/14.04/ubuntu-help/net-fixed-ip-address.html), configure the connection "Auto eth0" IPv4 as follows:

Address	Netmask	Gateway	DNS Servers	notes
10.10.1.x	255.255.255.0	10.10.1.254	10.0.0.1, 10.0.0.2	visnet (iCub machines)
10.0.x.y	255.255.0.0	10.0.0.254	10.0.0.1, 10.0.0.2	isrnet (rest of ISR)

Servers

Edit /etc/network/interfaces like this:

auto lo
iface lo inet loopback
  
auto eth0
iface eth0 inet static
address 10.x.y.z # put your IP here, see above table
netmask 255.255.x.y # see above table
network 10.10.1.0
broadcast 10.10.1.255
gateway 10.10.1.254
dns-nameservers 10.0.0.1 10.0.0.2

In some versions of Ubuntu, to configure DNS you also need to edit /etc/resolvconf/resolv.conf.d/head like this:

nameserver 10.0.0.1
nameserver 10.0.0.2

then run:

sudo resolvconf -u

Dependencies

Installing the icub-common metapackage is sufficient. It is a bundle of the following packages (for more details see here and here):

sudo apt-get install build-essential libace-dev libedit-dev libgsl0-dev libncurses5-dev gfortran libtinyxml-dev
sudo apt-get install git-core ssh gcc g++ make cmake-curses-gui freeglut3-dev libxmu-dev libswscale-dev libavformat-dev
sudo apt-get install qttools5-dev qtdeclarative5-dev qtdeclarative5-controls-plugin qtdeclarative5-dialogs-plugin qtmultimedia5-dev qtdeclarative5-qtmultimedia-plugin qtquick1-5-dev libqt5svg5 libqt5opengl5-dev

iCub Simulator dependencies: SDL and ODE.

GTK graphical programs are obsolete and replaced by their Qt equivalents. If you still want the old GTK programs, install libgtkmm-2.4-dev

Environment variables

• Create a file called ~/.bashrc_iCub like this one. Usually you do not need all of the following variables and settings, just a subset.

# /usr/local/src/robot directory can be mounted from NFS, or created manually with permissions:  sudo chown icub.icub /usr/local/src/robot -R
export ROBOT_CODE=/usr/local/src/robot
export ICUBcontrib_DIR=$ROBOT_CODE/icub-contrib-common/build
export YARP_ROOT=$ROBOT_CODE/yarp
export YARP_DIR=$YARP_ROOT/build
export ICUB_ROOT=${ROBOT_CODE}/icub-main
export ICUB_DIR=${ICUB_ROOT}/build
export icub_firmware_shared_DIR=${ROBOT_CODE}/icub-firmware-shared/build
export YARP_DATA_DIRS=${YARP_DIR}/share/yarp:${ICUB_DIR}/share/iCub:${ICUBcontrib_DIR}/share/ICUBcontrib
export FIRMWARE_BIN=${ROBOT_CODE}/icub-firmware/build
export IPOPT_DIR=$ROBOT_CODE/Ipopt-3.11.9
export OpenCV_DIR=$ROBOT_CODE/opencv-2.4.9/build
#export OpenCV_DIR=$ROBOT_CODE/opencv-2.4.9/build-cuda # for opencv_gpu

# if your modules rely on icub-contrib-common (such as POETICON++), set the following:
export ICUBcontrib_DIR=$code/icub-contrib-common/build
export PATH=$PATH:$YARP_DIR/bin:$ICUB_DIR/bin:$ICUBcontrib_DIR/bin
export YARP_DATA_DIRS=$YARP_DIR/share/yarp:$ICUB_DIR/share/iCub:$ICUBcontrib_DIR/share/ICUBcontrib

# himrep, IOL, stereo-vision, SiftGPU, Lua
export SIFTGPU_DIR=~/SiftGPU    # note: SiftGPU installed outside NFS
export LIBSVMLIN_DIR=${ROBOT_CODE}/himrep/liblinear-1.91
### DO NOT REMOVE ';;;' ###
export LUA_PATH=";;;${ROBOT_CODE}/rFSM/?.lua;${ICUBcontrib_DIR}/share/ICUBcontrib/contexts/interactiveObjectsLearning/LUA/?.lua"
export LUA_CPATH=";;;$YARP_ROOT/bindings/build-lua/?.so"

export PATH=$PATH:$ICUB_DIR/bin:$YARP_DIR/bin:$ICUBcontrib_DIR/bin
export PATH=$PATH:${ROBOT_CODE}/rFSM/tools:${ICUBcontrib_DIR}/share/ICUBcontrib/contexts/interactiveObjectsLearning/LUA
export PATH=$PATH:${YARP_ROOT}/bindings/build-lua
# CUDA
export PATH=$PATH:/usr/local/cuda-6.5/bin
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/cuda-6.5/lib64

export YARP_ROBOT_NAME=iCubLisboa01

# To enable tab completion on yarp port names
if [ -f $YARP_ROOT/scripts/yarp_completion ]; then
  source $YARP_ROOT/scripts/yarp_completion
fi

• Then, before the following line of /etc/bash.bashrc

[ -z "$PS1" ] && return

add this:

# per-user environment variables (non-interactive and interactive mode)
source $HOME/.bashrc_iCub

The reason why we use the above custom file (as opposed to the standard ~/.bashrc) is that we want to enforce the variables both during interactive and non-interactive sessions, such as commands launched via yarprun from another machine.

See also https://gitlab.robotology.eu/matteo.brunettini/icub-environment for the variables and scripts employed at IIT.

Additional software

OpenCV

Ubuntu packages

• this is the easiest way to install OpenCV, however the Ubuntu packages might be too old and/or missing some specific features (in that case proceed with a manual installation, see below)

 sudo apt-get install libcv-dev libhighgui-dev libcvaux-dev libopencv-gpu-dev

Manual compilation

• on most machines: download OpenCV, create a build directory, CMake, set WITH_CUDA=OFF, compile, set OpenCV_DIR to the path of OpenCV-x.y.z/build, for example:

export OpenCV_DIR=$code/OpenCV-x.y.z/build

• on CUDA machines, in order to compile CUDA-enabled modules: create a build-cuda directory, CMake, set WITH_CUDA=ON, compile, set OpenCV_DIR to the path of OpenCV-x.y.z/build-cuda

YARP and iCub

• In general, when compiling this software, do not use sudo make install but simply make (and configure the PATH variable in such a way that it finds the binaries from the build directory).

• If you work with the robot, use the volume shares exported from the NFS server.

• In other cases, follow the instructions on the iCub software article.

• yarp CMake configuration

CMAKE_BUILD_TYPE Release
CREATE_GUIS
CREATE_LIB_MATH

// to enable 640x480@30Hz images with Bayer encoding
// install libraw1394-dev libdc1394-22-dev then enable
CREATE_OPTIONAL_CARRIERS
ENABLE_yarpcar_bayer_carrier

• icub-main CMake configuration

CMAKE_BUILD_TYPE Release
// on servers, do http://wiki.icub.org/wiki/Installing_IPOPT then enable
ENABLE_icubmod_cartesiancontrollerclient ON
ENABLE_icubmod_cartesiancontrollerserver ON
ENABLE_icubmod_gazecontrollerclient ON

• final configuration

1. yarp namespace /icub
2. yarp conf 10.10.1.53 10000 (yarpserver runs on iCub laptop)

• special machines such as pc104 need different flags

CUDA

Prerequisites

sudo apt-get install freeglut3-dev libdevil-dev libglew-dev
sudo apt-get purge libcudart*  // because we will manually install it

Troubleshooting: http://askubuntu.com/questions/410604/installing-nvidia-drivers-with-pkg1-run-ends-with-no-version-h-found

CUDA Toolkit, SDK and Examples

• stop X servers: sudo service lightdm stop (or gdm stop depending on configuration)
• download and install NVIDIA CUDA Toolkit from http://docs.nvidia.com/cuda (not from Ubuntu packages)
• if you obtain the error "Toolkit: Installation Failed. Using unsupported Compiler.", use the override option, e.g., ./cuda_6.0.37_linux_64.run --override
• if you obtain the error "The driver installation is unable to locate the kernel source. Please make sure that the kernel source packages are installed and set up correctly":
  • read the CUDA log in /tmp and verify that the graphics card is currently supported -- if not, you might need to install a legacy NVIDIA driver. For example, the Quadro FX 580 card needs NVIDIA legacy drivers 340.xx: install them and then answer no when CUDA Toolkit installer asks "Install NVIDIA Accelerated Graphics Driver for Linux-x86_64 346.46?"
  • sudo apt-get install linux-generic linux-headers-$(uname -r) linux-headers-generic-lts-trusty (or other Ubuntu version codename)
  • call the installer specifying the kernel source path, e.g., ./cuda_7.0.28_linux.run --kernel-source-path=/usr/src/linux-headers-3.13.0-52-generic/
• output of successful installation:

Driver:   Installed
Toolkit:  Installed in /usr/local/cuda-7.0
Samples:  Not Selected
Please make sure that
-   PATH includes /usr/local/cuda-7.0/bin
-   LD_LIBRARY_PATH includes /usr/local/cuda-7.0/lib64, or, add /usr/local/cuda-7.0/lib64 to /etc/ld.so.conf and run ldconfig as root
To uninstall the CUDA Toolkit, run the uninstall script in /usr/local/cuda-7.0/bin
To uninstall the NVIDIA Driver, run nvidia-uninstall

• troubleshooting:
  • http://askubuntu.com/questions/451672/installing-and-testing-cuda-in-ubuntu-14-04
  • http://troylee2008.blogspot.pt/2012/05/linking-error-while-compiling-cuda-sdk.html
  • https://devtalk.nvidia.com/default/topic/617414/-solved-cuda-driver-version-is-insufficient-for-cuda-runtime-version-fedora-18-rpmfusion-driver/

SiftGPU

• download it from http://cs.unc.edu/~ccwu/siftgpu/
• unzip it - typically in your home directory, not in the NFS shared folder
• compile with make
• if you obtain "unspecified launch failure" and 0 sift features/matches, check that the X server is running: sudo service lightdm start
• if you obtain the error "/usr/local/cuda/bin/nvcc: Command not found", this can help: sudo ln -s /usr/lib/nvidia-cuda-toolkit /usr/local/cuda. See also http://askubuntu.com/questions/231503/nvcc-compiler-setup-ubuntu-12-04
• run the test program SimpleSIFT - it should work via ssh, as well as in a local session
• example of successful execution:

$ ./SimpleSIFT 
Unable to create OpenGL Context!
For nVidia cards, you can try change to CUDA mode in this case
NOTE: changing maximum texture dimension to 32768
[SiftGPU Language]:	CUDA
Image size :	800x600
Image loaded :	../data/800-1.jpg
#Features:	3347
#Features MO:	3910
[RUN SIFT]:	0.339
Image size :	640x480
Image loaded :	../data/640-1.jpg
#Features:	2372
#Features MO:	2767
[RUN SIFT]:	0.208
NOTE: changing maximum texture dimension to 32768
[SiftMatchGPU]: CUDA
2247 sift matches were found;

• define export SIFTGPU_DIR=~/SiftGPU or similar in your iCub bashrc file, so that libsiftgpu.so is found by IOL modules

himrep

Clone https://github.com/robotology/himrep, follow the instructions to compile liblinear, CMake, make install

To use the deep neural network object recognition, based on Caffe, follow the instructions at README_Caffe.md. If you get "error: kernel launches from templates are not allowed in system files", use an older GCC version like 4.6 (see also https://github.com/BVLC/caffe/issues/337). If you get "ImportError: No module named 'yaml'", do sudo apt-get install python-yaml.

IOL

• sudo apt-get install lua5.1 liblua5.1-dev
• clone rFSM (no need to compile anything here)

Clone https://github.com/robotology/iol, CMake, make install

stereo-vision

Clone https://github.com/robotology/stereo-vision, CMake with USE_SIFT_GPU=ON, make install

Best practices

Below are some tips and tricks taken from:

• http://wiki.icub.org/wiki/Yarp-config
• http://www.yarp.it/yarp-config.html
• IIT - How to setup and start the iCub from scratch

XML files

Edit XML files locally, in /home/icub/.local/share/yarp

To install robot-specific XML files, compile icub-main (just make) then use commands like yarp-config robot --import-all (installs all files) or yarp-config robot --import iCubLisboa01 affordancesExploration.xml (installs specific files)

ini files

To install application conf/*.ini files, compile a project (e.g., icub-main, poeticon, iol) then use commands like yarp-config context --import-all (installs all files) or yarp-config context --import actionsRenderingEngine (installs the files of specific applications)

Disabling some robot parts

If the robot is not complete (or some parts need to be disabled):

• On the pc104, type yarp-config robot --list to look for the .ini files from where the configuration values are launched.
• Go to INSTALLED DATA directory path and then within the corresponding robot folder (eg. icubGenova04) and look for the file robotInterface.ini, which points to a .xml file which contains the configuration paths for all the robot parts (eg. icub_all.xml).
• If the local config file does not exist, there is only the canonical in the build path, then create a local one using yarp-config --import.
• Copy the .xml file with a descriptive name (eg icub_no_legs.xml) and on the copied file, comment or remove all lines that refer to .ini files of the part(s) that have to be disabled.
• Change robotInterface.ini too, so that it will point to the new .xml file where the parts have been commented.
• On the robot/icub Startup application, modify the way that gravityCompensator and wholeBodyDynamics are launched, so that they don’t look for leg configuration files. For the legs case, add --no_legs to the argument list.

See also

• http://wiki.icub.org/wiki/Generic_iCub_machine_installation_instructions