Compilación Cruzada e Instalación de ROS para el NAO V4

Description: This tutorial is a step by step guide to build, install and run ROS natively onto the Intel Atom CPU of the latest NAO robot.

ENGLISH VERSION OF THIS TUTORIAL

Descripción: Este tutorial es una guía paso a paso para compilar, instalar y correr ROS de forma nativa en la CPU Intel Atom de la última versión del robot NAO.

Equipo de fútbol robótico de la Universidad de Chile
Standar League Platform - Robocup SPL

Keywords: Nao, ROS, Cross-compile.

Nivel del Tutorial: INTERMEDIO

NOTA:
Este tutorial asume el uso de ROS fuerte, UBUNTU 10.04, la nueva versión del Robot NAO (V4, Intel Atom CPU) con Naoqi > 1.12.xx.

1. Introducción

Este tutorial presenta una guía paso a paso para compilar, instalar y correr la más reciente versión de ROS (Fuerte) de forma embebida en el nuevo robot NAO V4, que posee una CPU Intel Atom. Se realiza una compilación cruzada haciendo uso del toolchain suministrado por Aldebaran. Este procedimiento se ha testeado en versiones de naoqi > 1.12.xx y solo se ha hecho funcionar con ubuntu 10.04. y si bien ha sido probado en varios robots NAO y en diferentes computadoras, usando maquina virtual (vmware) y linux nativo, aún así consideramos que debe ser probado en más maquinas y otros robots.
La instalación de ROS es realizada dentro del directorio /home/nao. Posteriormente se copia al mismo path dentro del robot NAO para mantener los links y rutas de acceso para las variables de entorno de ROS. La instalación se realiza en ese path con el fin de evitar usar permisos de usuario root y teniendo en cuenta que el robot tiene por defecto esta ruta como la carpeta de usuario.
Este tutorial está basado en [http://www.ros.org/wiki/nao/Tutorials/Cross-Compiling]

2. Requerimientos

  • Descargar y descomprimir la versión correspondiente de toolchain correspondiente al Naoqi que esté usando su NAO de la pagina de Aldebaran Robotics. Se recomienda descomprimirla en /home/nao/
$ sudo apt-get install python-rosinstall
$ rosinstall --catkin ~/ros-underlay http://ros.org/rosinstalls/fuerte-ros-base.rosinstall
  • Descargue aquí el scrip de setup de rutas, variables de entorno y directorios para la instalación o cree un archivo de texto con el contenido mostrado a continuación y guárdelo como un script .sh. Por ejemplo ¨paths-nao-ctc.sh¨. Si es necesario, modifique los paths o nombres de directorios que desee.
#!/bin/sh 
# set some environment variables and generates directories 
export TARGETDIR=/home/nao/ros-nao #ROS-NAO root path 
export ROS_FUERTE_DIR=$TARGETDIR/ros/fuerte #ROS fuerte installation path 
export ROS_STACKS_DIR=$ROS_FUERTE_DIR/stacks #ROS fuerte stacks installation path 
export CTC_DIR=/home/nao/nao-atom-cross-toolchain-1.12.5.3_2012-06-03 # Directory where Aldebaran's cross-compilation toolchain (CTC) was uncompressed 
export CTC_USR_DIR=$CTC_DIR/sysroot/usr # Set here your CTC user path 
export ROS_BOOST_ROOT="${CTC_DIR}/sysroot/usr"  # Set here your CTC boost root path 
export ROS_BOOST_VERSION="1.45.0"      # Set here your CTC boost version 
export BOOST_ROOT="${CTC_DIR}/sysroot/usr"   # Global boost root path 
export LD_LIBRARY_PATH= # To clear this ROS environment variable 
mkdir -p $TARGETDIR 
mkdir  -p $ROS_FUERTE_DIR 
mkdir  -p $ROS_STACKS_DIR 
mkdir -p $TARGETDIR/lib 
mkdir -p $TARGETDIR/python 
echo Paths and Directories generated ...

3. Pasos previos y recomendaciones

Incluir el toolchain del NAO dentro del toolchain de ROS build:

$ echo "include(\"$CTC_DIR/toolchain-atom.cmake\")" >>  ~/ros-underlay/ros/core/rosbuild/rostoolchain.cmake

Esto es equivalente a abrir el archivo ~/ros-underlay/ros/core/rosbuild/rostoolchain.cmake e incluir al final del archivo el path del toolchain del NAO.

Realizar el parche del punto 4.5 que se encuentra en este tutorial. Para ello se abre el archivo ~/ros-underlay/ros/core/rosbuild/private.cmake y buscar las lineas 181 y 221 que dicen:

find_file(_file_name ${file} ${PROJECT_SOURCE_DIR} /)

Reemplazándolas por esto:
find_file(_file_name ${file} ${PROJECT_SOURCE_DIR} / NO_CMAKE_FIND_ROOT_PATH)

Dado que en el toolchain del NAO no se encuentran las librerías log4cxx.so ni las aprutil*.so, estas deben ser copiadas:

$ cp /usr/lib/liblog4cxx*.so* $CTC_USR_DIR/lib/
$ cp -r /usr/include/log4cxx $CTC_USR_DIR/include/
$ cp /usr/lib/libapr*.so* /$CTC_USR_DIR/lib/

4. Compilando ROS Base from source

Generar el proyecto usando cmake:

$ cd ~/ros-underlay
$ mkdir build
$ cd build
$ cmake .. -DCMAKE_INSTALL_PREFIX=$ROS_FUERTE_DIR
$ make -j8
$ make install

Si se presentan errores de linking (típicamente con boost), abrir el proyecto usando cmake-gui, borrar cache, y al configurar seleccionar manualmente el toolchain de ros contenido en ~/ros-underlay/ros/core/rosbuild/rostoolchain.cmake. Despues, antes de hacer el generate NO OLVIDE setear el path de instalación en la pestaña CMAKE-INTSALL-PREFIX = /home/nao/ros-nao/ros/fuerteo o su path de instalación preferido.
Si el procedimiento anterior no funciona, reemplazar el include del tolchain del nao realizado en el paso 3.1, por este:

include(\"$CTC_DIR/cross-config.cmake\")

Para probar que la instalación se ha realizado correctamente ejecutar:

$ cd $ROS_FUERTE_DIR
$ . setup.sh
$ which roscore

La consola debería indicar el path en donde se encuentra el ejecutable de roscore.
ROS_FUERTE_DIR/bin/roscore

Para descargar, compilar o generar packages posteriormente, es necesario habilitar, descargar e instalar algunos paquetes y herramientas. Esto se indica en este tutorial desde el paso 1.3 (Build Higher-level/tools) hasta el 1.7.ii (Install core library dependencies).

5. Generando el directorio de trabajo

Es útil crear un workspace, ros fuerte incluye una herramienta para facilitar esta labor (basado en este tutorial).

$ rosws init $TARGETDIR/workspace_nao $ROS_FUERTE_DIR 
$ mkdir $TARGETDIR/workspace_nao/sandbox 
$ source $TARGETDIR/workspace_nao/setup.bash
$ rosws set $TARGETDIR/workspace_nao/sandbox

Es conveniente especificar un path para descargar e instalar stacks, para esto:

$ rosws set $ROS_STACKS_DIR
$ source $TARGETDIR/workspace_nao/setup.bash

Si este path ya ha sido agregado por defecto durante la instalación de ROS, indicará un error del tipo "already exists" lo cual indica que ya está listo. Si presenta un error con el archivo ".rosintall", simplemente hay que borrarlo e intentar nuevamente.
$ rm $ROS_STACKS_DIR/.rosinstall

Verificar los paths ejecutando el comando
$ roscd

Debe aparecer la ruta:
TARGETDIR/workspace_nao

Además, al visualizar la variable de entorno de packages de ros, debería aparecer cada directorio agregado con rosws set además de los directorios /share por defecto, algo así:

echo $ROS_PACKAGE_PATH
/home/nao/ros-nao/workspace_nao/sandbox:/home/nao/ros-nao/ros/fuerte/stacks:/home/nao/ros-nao/ros/fuerte/share:/home/nao/ros-nao/ros/fuerte/share/ros

Para no tener que ejecutar el comando source cada vez que se abra un nuevo terminal, es posible agregar ese comando al bash de la consola ejecutando lo siguiente:

$ echo "source /home/nao/ros-nao/workspace_nao/setup.bash" >> ~/.bashrc
$ . ~/.bashrc

Si ha cambiado el path de instalación o el nombre del workspace, debe modificar esta linea según corresponda.

6. Copiando archivos, scripts y librerías faltantes

Es necesario copiar dentro del directorio de instalación algunos archivos, scripts y librerías necesarias para correr ROS que no se encuentran dentro del toolchain y obviamente tampoco del robot NAO.

$ cp -r /usr/lib/python2.6/dist-packages/yaml $TARGETDIR/python/
$ cp -L /usr/lib/python2.6/dist-packages/pkg_resources.py $TARGETDIR/python/ 
$ cp -r -L /usr/lib/pymodules/python2.6/rospkg* $TARGETDIR/python/
$ cp /usr/lib/liblog4cxx*.so* $TARGETDIR/lib/
$ cp /usr/lib/libapr*.so* $TARGETDIR/lib/
$ cp -r $CTC_USR_DIR/lib/libboost* $TARGETDIR/lib/

7. Configurando variables de entorno

Se le debe indicar a ROS el path donde se encuentran los archivos, scripts y librerías agregados en el paso anterior. Para ello deben exportarse las variables de entorno mostradas a continuación, o ejecutar éste script, modificando las rutas según corresponda con su instalación.

export LD_LIBRARY_PATH=/home/nao/ros-nao/lib:$LD_LIBRARY_PATH 
export PYTHONPATH=$PYTHONPATH:/home/nao/ros-nao/python
source /home/nao/ros-nao/workspace_nao/setup.bash

Estos comandos o el script, deben ejecutarse en cada terminal en la que se requiera ejecutar algún proceso de ROS. Se recomienda agregar los comandos al ~/.bashrc para facilitar la inicialización de ROS cuando se trabaja desde el ordenador.

8. Instalando y corriendo ROS dentro de la CPU del NAO

Para instalar ROS dentro del NAO, basta con copiar la carpeta raíz de instalación al robot por medio de ssh:

$ export NAOIP=192.168.xx.xxx
$ rsync -rv $TARGETDIR nao@$NAOIP:/home/nao

En NAOIP=192.168.xx.xxx, indique la IP de su robot. Recuerde que $TARGETDIR forzosamente debe coincidir con la ruta de instalación que se indique dentro del robot ( /home/nao en este caso ).

Para probar la instalación ingresar al robot por ssh:

$ ssh nao@NAOIP
$ cd $TARGETDIR
$ . ./setupPaths_NaoROS.sh
$ roscore

Reemplazar $TARGETDIR por el path en donde guardó el script setupPaths_NaoROS.sh.

9. Consideraciones finales y trabajo futuro

Para facilitar la instalación de librerías y herramientas básicas requeridas por ROS en aquellos casos en que este tutorial se realice en una computadora recién formateada por ejemplo. Se recomienda realizar la instalación básica de ROS-Comm (Bare Bones) tal como se indica en este tutorial , siguiéndolo nada más que hasta el paso 1.4. Esto instalará librerías, software y herramientas requeridas por ROS tales como python, git, cmake, entre otras.

El robot Nao usa python 2.6, versión que se encuentra por defecto en Ubuntu 10.04. Para realizar este tutorial sobre versiones posteriores de Ubuntu, podría instalarse python 2.6 (sudo apt-get install python2.6) e indicarle a cmake que use tal versión. Este procedimiento no ha sido testeado correctamente, si alguien lo lleva a cabo sería ideal compartirlo para complementar esta pagina. Además si tienen otro tipo de aportes o comentarios que puedan enriquecer este tutorial, son bienvenidos.

En el laboratorio de robótica de la universidad de Chile, actualmente estamos usando esta instalación de ROS en el robot NAO dentro de las actividades del equipo de fútbol robótico que participa en la SPL de la robocup. Hasta el momento hemos integrado la caminata de Aldebaran propia del NAO y la caminata del equipo B-Human. Nos encontramos en proceso de incluir diferentes módulos de visión, localización y cognición en general tanto desarrollados por nosotros como por otros laboratorios dentro de nuestro stack de ROS, usando algunas de sus herramientas de integración, compilación, debugg y comunicaciones entre procesos. Pensamos en un tiempo cercano, compartir a la comunidad de ROS una versión de nuestro sack, una vez obtenidos los permisos pertinentes y realizadas adecuadas pruebas de estabilidad del código.

Equipo de fútbol robótico de la Universidad de Chile
Autor: Leonardo Leottau Forero
e-mail: lc.elihcu.gni|uattoeld#lc.elihcu.gni|uattoeld

Unless otherwise stated, the content of this page is licensed under Creative Commons Attribution-ShareAlike 3.0 License