Robot Operating System

El sistema está basado en un concepto modular, que en ROS denominan nodos. Los nodos son básicamente ejecutables, que utilizan “roscore” (otro ejecutable que es el núcleo del sistema) para comunicarse con otros nodos. Cada nodo lleva a cabo alguna actividad computacional, y entre ellos se comunican para intercambiar información de las tareas a realizar. Un robot puede albergar muchos nodos. Por ejemplo, un nodo puede controlar un laser medidor de distancias, otro nodo podría controlar los motores de la ruedas del robot, otro podría ser el módulo de localización, otro hacer la planificación de la trayectoria, otro proporcionar una vista gráfica de todo el sistema, y así cada nodo se encarga de una tarea e interactua con los demás.

ROS funciona por nodos que están empaquetados en stacks, cada uno de estos nodos tiene una funcionalidad básica asociada, la idea es poder compartir mensajes que nos dan una interconectividad que nos estanadariza los datos que pasan de un modulo a otro modulo y siempre que consigamos que los modulos compartan esos mensajes son capaces de entenderse idependientemente del hardware, o algoritmo que hay detrás. Hay gran cantidad de módulos disponibles, la función de los módulos es transmitir movimientos de alto contenido en ordenes muy básicas para el robot independientemente de cual sea el controlador

Según los diseñadores, esta estructura modular permite una buena tolerancia a fallos, ya que cada nodo funciona aislado de los demás. Por otro lado la complejidad se reduce en comparación con cualquier otro sistema monolítico(una sola capa donde se concentra todo el código del robot), y así los detalles de implementación se esconden hacia los demás módulos a los que solo se les dá una serie de parámetros básicos, que pueden ser proporcionados por un modulo escrito en cualquier otro lenguaje.

El sistema está pensado teniendo en cuenta otras plataformas software de desarrollo gratuitas o abiertas, que ya existen y que pueden aportar mucho también a ROS, como pueden ser OpenCV, Player/Stage, entre otras.

Comandos interesantes de ROS

1. rosmake compila los módulos
2. rospack nos permite extraer información de un paquete especificado
3. rostopic da información de los paquetes
4. roscore arranca la base de ros
5. roslaunch lanza varios nodos simultáneamente

Las instrucciones de instalación que se mostrarán a continuación están basadas en https://wiki.arcoslab.eie.ucr.ac.cr/doku.php?id=installing_ros_in_debian

En la documentación de ROS se tienen las instrucciones de instalación, donde se van instalando paquetes a lo largo de todo el proceso, por lo tanto para agilizar el proceso se instalan todos juntos, para así no tener problemas más de adelante de dependencias de paquetes, los paquetes requeridos son los siguientes:

  sudo apt-get install build-essential python-yaml cmake subversion wget python-setuptools mercurial git-core  python-yaml libapr1-dev libaprutil1-dev libbz2-dev python-dev libgtest-dev python-paramiko libboost-all-dev liblog4cxx10-dev pkg-config python-empy python-nose swig python-wxgtk2.8 python-gtk2 python-matplotlib libwxgtk2.8-dev python-imaging libqt4-dev graphviz qt4-qmake python-numpy bison++ autoconf libtinyxml-dev libxml2-dev nvidia-cg-dev libxt-dev libxaw7-dev nvidia-cg-toolkit libfreetype6-dev libxrandr-dev libfreeimage-dev libcurl-ocaml-dev libeigen3-dev libyaml-cpp-dev python-sip-dev python-sip python-qt4-dev python-qt4 python2.7-dev libglut3-dev libusb-1.0-0-dev openjdk-7-jdk doxygen lsb-release unzip libv4l-dev

Algunos paquetes son las dependencias de “bootstrap” (este término es utilizado para describir el arranque, o proceso de inicio de cualquier ordenador, suele referirse al programa que arranca un sistema operativo), las librerías base, y las librerías requeridas para usar las herramientas gráficas. Otros son necesarios para la instalación de las dependencias externas que se muestran más adelante.

Se debe incluir en este archivo las siguientes líneas:

• Para sobreescribir la detección de otra versión del OS

          export ROS_OS_OVERRIDE=debian:squeeze

• Para compilación en paralelo (depende de la cantidad de cores que tenga la computadora):

          export ROS_PARALLEL_JOBS=-j5

Ahora bien para realizar la instalación sin tocar el sistema principal se utilizará la herramienta xstow, el cual es un programa para manejar la instalación de paguetes de software, lo que hace es mantener los paquetes separados mientras que los hace parecer estar instalados en el mismo lugar, además se encarga de crear los enlaces simbólicos (tipo especial de archivo que contiene una referencia a otro directorio en forma de un camino absotulo o relativo) con los nombres de las rutas absolutas.

• Instalar xstow

   sudo apt-get install xstow

• Hacer la estructura de directorios básica

    mkdir -p local/src
    mkdir -p local/DIR

• Para dar los nuevos caminos (PATH) se modifica el archivo .bashrc (en /home/usuario)colocando las siguientes líneas en este, se utiliza este archivo ya que al abrir una consola se ejecuta, por lo que así nos evitamos tener que poner dichas líneas en consola cada vez que vamos a correr ROS.

    export PYTHON_VERSION=$(readlink $(which python))
    export PATH=${HOME}/local/bin:${HOME}/local/sbin:${HOME}/local/usr/bin:${PATH}
    export LD_LIBRARY_PATH=${HOME}/local/lib:${HOME}/local/usr/lib:${LD_LIBRARY_PATH}
    export LIBRARY_PATH=${LD_LIBRARY_PATH}:${LIBRARY_PATH}
    export CPATH=${HOME}/local/include:${HOME}/local/usr/include:${CPATH}
    export LDFLAGS="-L${HOME}/local/lib ${LDFLAGS}"
    export PKG_CONFIG_PATH=${HOME}/local/lib/pkgconfig
    export CMAKE_INCLUDE_PATH=${CPATH}
    export CMAKE_LIBRARY_PATH=${LIBRARY_PATH}
    export PYTHONPATH=${HOME}/local/lib/python/site-packages:${HOME}/local/lib/${PYTHON_VERSION}/site-packages:${PYTHONPATH}

• Se debe instalar una versión modificada de swig, este es una interfaz de compilador que conecta programas escritos en C y C++ con lenguajes como Perl, Python, Ruby y Tcl, lo que hace es tomar las declaraciones encontradas en los encabezados de los archivos C/C++ y genera el código necesario para que los lenguajes “script” accesen el código C/C++, vamos a instalarlo en una carpeta que creamos con el nombre ros-dependencies.

   cd ~/local/src/
   mkdir ros-dependencies
   cd ros-dependencies
   git clone https://github.com/ros/swig-wx.git   #aquí lo que hacemos es copiar swig-wx del repositorio

• Correr ./autogen.sh, esto lo que hace es dar automaticamente una preparación para la generación del sistema.

   cd swig-wx
   ./autogen.sh

• Usar ./configure, es una forma automática de crear los makefiles.

   ./configure --prefix=${HOME}/local/DIR/swig-wx
   make -j10
   export datarootdir=${HOME}/local/DIR/swig-wx/        #Esto se hace porque hay un error en autoconf de swig-wx
   make install
   cd ~/local/DIR

• Generamos los links simbólicos

   xstow swig-wx  

• Al terminar este proceso se observa en terminal lo siguiente:

• Se debe colocar una línea en el archivo .bashrc

   export SWIG_LIB=${HOME}/local/swig/1.3.29/

• Finalmente se realiza un “source” a dicho archivo, este comando lo que hace es tomar el contenido del archivo y lo pasa a un interpretador de Tcl como un texto script.

   source .bashrc

Es una herramienta que revisa el codigo fuente de distintos repositorios de control de versión y los actualiza.

• Primero se debe instalar python-pip, que es una herramienta de software usada para instalar y manejar paquetes de software escritos en Python.

    sudo apt-get install python-pip

• Configuramos el directorio para dicha instalación

    export PYTHONUSERBASE=${HOME}/local/DIR/rosinstall-fuerte

• Instalamos rosintall, y creamos los links simbólicos para su funcionamiento

    pip install --user -U rosinstall vcstools rospkg rosdep
    cd ~/local/DIR
    xstow rosinstall-fuerte

• Una vez que se instalaron los paquetes se observa lo siguiente:

En ésta sección se instalan tres dependencias: libflann, OpenCV2 y OpenNI .

Flann es una biblioteca para realizar rápidas búsquedas en espacios de alta dimensión. Contiene un sistema para elegir automáticamente el mejor algoritmo y los parámetros óptimos en función del conjunto de datos.

• Nos colocamos en la carpeta de dependencias de ROS

  cd ~/local/src/ros-dependencies

• Obtenemos el código fuente

 git clone https://github.com/wg-debs/flann

• La instrucción anterior crea una carpeta llamada flann dentro de ros-dependencies, donde queda el código fuente, ahí creamos una carpeta “build” para compilar flann

 cd flann
 mkdir build
 cd build
 ccmake ../ # Es importante cambiar CMAKE_INSTALL_PREFIX to /home/user/local/DIR/flann 

Cmake es usado para controlar el proceso de compilación de software, al realizar la ultima instrucción se observa lo siguiente:

• Seguidamente presionamos “c” para configurar y luego “g” para generar los makefiles y salir, finalmente compilamos, instalamos y creamos los “links simbólicos”

 make -j5
 make install

Luego de realizar el make install se ve el siguiente error: “could not create '/usr/lib/python2.7/site-packages': Permission denied”. Como se observa en la siguiente imagen, este error no afecta la instalación.

Se deja así y se sigue con la instalación:

 cd ~/local/DIR
 xstow flann

OpenCV (Open Source Computer Vision) es una librería de funciones de programación para visión por computadora en tiempo real.

• Para ROS se requiere una versión distinta de opencv, la compilación e instalación de opencv2 lleva los mismos pasos que libflann por lo que no se explicarán.

  cd ~/local/src/ros-dependencies
  git clone https://github.com/wg-debs/opencv2-release.git 
  cd opencv2-release
  mkdir build
  cd build
  ccmake ../ # Configure INSTALL_PREFIX to  /home/usuario/local/DIR/opencv2
  make -j5   #Compilamos
  make install
  cd ~/local/DIR
  xstow opencv2  # Crea los links simbólicos de las carpetas en ~/local/DIR/opencv2

Nota: En caso de tener problemas con github dirigirse a https://wiki.arcoslab.eie.ucr.ac.cr/doku.php?id=installing_ros_in_debian, para descargar una carpeta comprimida de opencv2, ya que al parecer no está disponible por el momento.

OpenNI es una interfaz estándar para procesamiento de algoritmos de sensores 3D, su propósito es definir tipos de datos (depth map, color map, user pose, etc.)y una interfaz a un módulo que los pueda generar para otros desarrolladores.

• Nos colocamos en la carpeta ros-dependencies y obtenemos el código fuente

  cd ~/local/src/ros-dependencies/
  mkdir openni
  hg clone https://kforge.ros.org/openni/drivers openni
  cd openni

• Se actualiza a una versión que funciona con el kinect y xtion

  hg update -r 299  

• Antes de compilar e instalar se debe modificar el archivo MakeFile ya que da un error en caso de no tener una configuración de 64bits

  nano ~/local/src/ros-dependencies/openni/Makefile

Se observa lo siguiente:

      ARCH=i386
      OPENNI_ARCH=xx

Se debe cambiar por:

      ARCH=i386
      OPENNI_ARCH=x86

En la siguiente figura se observa el archivo corregido

• Ahora se hacen los paquetes .deb y se instalan

      make -j5 debian

Si se hizo correctamente el make, dentro de la carpeta openni se observan archivos .deb como se observa en la siguiente imagen:

En mi caso son paquetes de arquitectura de 64 bits, pero de no ser así se tendrán los paquetes correspondientes.

• Finalmente se instalan los paquetes .deb

    sudo dpkg -i *.deb

ROS core es una colección de nodos y programas que son prerequisitos para un sistema basado en ROS, es necesario tener roscore corriendo para que los nodos se puedan comunicar.

• Obtenemos el código fuente y lo compilamos

  rosinstall --catkin ~/local/src/ros-underlay-fuerte http://ros.org/rosinstalls/fuerte-ros-full.rosinstall
  cd ~/local/src/ros-underlay-fuerte/
  mkdir build
  cd build
  ccmke .. -DCMAKE_INSTALL_PREFIX=${HOME}/local/DIR/ros-underlay-fuerte #Se cambia la dirección de instalación

• Sí se encuentra un error al ejecutar el comando rosinstall

Al día de hoy (04-dic-2012), el comando rosinstall anterior no está funcionando, se encuentra un error al tratar de acceder el repositorio git del actionLib, una posible solución es la siguiente.

  wget http://ros.org/rosinstalls/fuerte-ros-full.rosinstall #Descargar el archivo rosintall

Se edita el arhivo descargado reemplazando la descarga del git de actionLib por el siguiente repositorio hg:

  hg:
      local-name: actionlib
      uri: https://kforge.ros.org/common/actionlib
      version: fuerte-devel

Se guarda y se ejecuta el comando de rosintall, utilizando el archivo modificado.

  rosinstall --catkin ~/local/src/ros-underlay-fuerte fuerte-ros-full.rosinstall 

• El ejecutar ccmake se requiere que la versión de librería de python sea 2.7, sino se darán problemas de compatibilidad, para ello durante la configuración se presiona “t” para obtener más opciones y cambiar la librería python, si es 2.7 entonces no se debe realizar cambio.

  PYTHON_LIBRARY=/usr/lib/python2.7/config/libpython2.7.so 

• Una vez configurado se procede a compilar, instalar.

  make -j5
  make install

Al finalizar la instalación se tiene en terminal:

• Finalmente obtener los links simbólicos.

  cd ~/local/DIR
  xstow ros-underlay-fuerte
   . ~/local/setup.bash

• Se debe descargar el archivo: “http://packages.ros.org/cgi-bin/gen_rosinstall.py?rosdistro=fuerte&variant=desktop-full&overlay=no”, para ello se puede hacer:

     wget “http://packages.ros.org/cgi-bin/gen_rosinstall.py?rosdistro=fuerte&variant=desktop-full&overlay=no”

Con el editor de su preferencia a dicho archivo se le debe cambiar /opt/ros/fuerte por /home/your-user/local/DIR/ros-underlay-fuerte cada vez que aparezca, con esto nos garantizamos de no ensuciar nuestro sistema base.

• Seguidamente queremos agregar a nuestra instalación de ros-fuerte las configuraciones del archivo que recién bajamos, para ello utilizamos rosinstall, el comando de rosinstall es el siguiente:

    rosinstall <path> <paths...> 

El primer <path> es la dirección donde queremos que se descargue el código fuente, los otros <paths…> son tratados como locaciones de donde obtener el archivo de configuraciones adicionales de rosinstall, en este caso sería gen_rosintall.py, luego de la instalación, rosinstall escribe un arhivo bash de configuración en <path>, llamado setup.bash, por lo que es importante realizar un source a dicho archivo para configurar las variables de entorno.

  rosinstall ~/local/src/ros-fuerte gen_rosinstall.py
  source ~/local/src/ros-fuerte/setup.bash

• Luego se añade en el archivo ~/.bashrc la siguiente línea

   alias env_ros_fuerte='source ~/local/src/ros-fuerte/setup.bash'

La idea de dicha línea es que cada vez que escribamos en consola env_ros_fuerte, se configuran las variables de entorno de ROS, si se quisiera también se podría poner directo, pero es mejor no tener ROS siempre activo, al menos que se vaya a utilizar.

• Luego se debe cambiar en /home/your-user/local/lib/python2.7/site-packages/rosdep2/sources_list.py la línea:

   etc_ros = '/etc/ros'

con:

  etc_ros = '/home/yourusername/local/etc/ros'

Lo anterior se debe hacer ya que no podemos usar etc/ros porque las configuraciones de entorno no se llevan a cabo bajo sudo, y si dejamos dicha dirección nos daría problemas de permisos.

• Ahora corremos rosdep, el comando rosdep ayuda a instalar las dependencias externas en un OS independiente

   rosdep init
   rosdep update

• La siguiente línea se encarga de instalar todos los paquetes ROS

   rosdep install -a

• Para compilar rviz se requieren unos paquetes que ya no son debian, estos se pueden descargar en http://snapshot.debian.org, la búsqueda se debe hacer con el nombre completo del paquete.

Para 64 bits:

   sudo dpkg -i libassimp2_2.0.863+dfsg-2+b1_amd64.deb libassimp-dev_2.0.863+dfsg-2+b1_amd64.deb

Para 32 bits:

   sudo dpkg -i libassimp2_2.0.863+dfsg-2_i386.deb libassimp-dev_2.0.863+dfsg-2_i386.deb

• Además se deben arreglar ciertos archivosdel código de rviz, agregarle una línea, los archivos a arreglar son los siguientes:

    ${HOME}/local/src/ros-fuerte/visualization/rviz/src/rviz/CMakeLists.txt
    ${HOME}/local/src/ros-fuerte/visualization/rviz/src/rviz/default_plugin/CMakeLists.txt
    ${HOME}/local/src/ros-fuerte/visualization/rviz/src/test/CMakeLists.txt
    ${HOME}/local/src/ros-fuerte/visualization/rviz/src/image_view/CMakeLists.txt

• Cada vez que aparezca la línea “qt4_wrap_cpp(” se debe agregar lo siguiente antes del cierre de paréntesis

    OPTIONS -DBOOST_TT_HAS_OPERATOR_HPP_INCLUDED

• Finalmente compilamos rviz

    rosmake rviz

ÍNDICE