Object Manipulation Robot Simulator

Esto es un simulador para el robot TUM-Rosie. Simula los dos brazos y los dedos, además contiene sensores de fuerza y detección de torque. Es también un simulador de fricción con un objeto, mesa y el dedo del robot. El proyecto plantea poner en funcionamiento Object manipulation robot simulator, simulador de un robot Tum-Rosie, el cual cuenta con dos brazos y manos con sensores de fuerza y torque; además la continuación del proyecto va ser similar el comportamiento de un objeto dada una fuerza a una altura determinada. Actualmente la guía en línea de instalación propuesta en el wiki del arcos lab es muy general. El presente proyecto tiene el fin de analizar el tutorial, agregar las instrucciones necesarias y corregir posibles errores en la guía para mejorar el proceso de instalación. Así ponemos en funcionamiento el simulador de una manera más sencilla y con un manual informativo hacerlo de mayor accsesible para terceras personas interesadas en el proyecto.

• Describir cómo funcionan cada uno de los programas necesarios para incorporar el simulador.
• Buscar por errores en la guía de instalación en línea de Object Manipulation Robot Simulator del wiki.
• Explicar cómo interactúan entre si los programas a través de YARP mediante un mapa de conexión y realizar gráficas de dichas conexiones.
• Crear una simulación simple y exponer los beneficios de este simulador.
• Publicar los resultados en la página del wiki para facilitar su acceso a otras personas interesadas en realizarla.

Para este proyecto se aplicaron los siguientes pasos para tener el simulador instalado y corriendo:

• Instale debian en chroot siguiendo la guía Debian inestable en chroot. En este paso mejor utilizar este snapshot ya que es una versión que ha mostrado mejor funcionamiento.

$ debootstrap --arch amd64 sid /var/sid-amd64-chroot http://snapshot.debian.org/archive/debian/20130225T093150Z/

También es necesario agregar una línea al scrip que abre el chroot:

sudo mount proc -t proc $CHROOT_DIR/$CHROOT_NAME/proc
sudo mount -o bind /dev $CHROOT_DIR/$CHROOT_NAME/dev
sudo mount sys -t sysfs $CHROOT_DIR/$CHROOT_NAME/sys
sudo mount none -t devpts $CHROOT_DIR/$CHROOT_NAME/dev/pts
sudo mount -o bind / $CHROOT_DIR/$CHROOT_NAME/hostfs
**sudo mount -o bind /run/shm $CHROOT_DIR/$CHROOT_NAME/run/shm**

De ahora en adelante usted se va realizar los siguientes pasos como el usuario que usted creó en el paso anterior.

• Instale xstow. Es importante configurar el .bashrc para que funcione YARP en el siguiente paso.
• Instale YARP. También recuerde instalar el paquete python-dev ya que a veces se olvida instalarlo. Recuerde tambien en esta parte utilizar wget en una version estable de YARP y usar ese nuevo directorio de YARP para su instalación. Ejemplo:

wget http://downloads.sourceforge.net/yarp0/yarp-2.3.22.tar.gz

• Instale Orocos-KDL. Si en este paso se encuentra con errores al ejecutar el make install por falta de paquetes sip realice lo siguiente:

$ apt-get install sip4 python-sip4 python-sip4-dev

o lo siguiente si tiene una instalación de debian de amd64 si no le está funcionando puede descargarlos e instalarlos así:

wget http://ftp.us.debian.org/debian/pool/main/s/sip4/python-sip-dev_4.13.3-2_amd64.deb http://ftp.us.debian.org/debian/pool/main/s/sip4/python-sip_4.13.3-2_amd64.deb http://ftp.us.debian.org/debian/pool/main/s/sip4-qt3/python-sip4_4.10.2-1_all.deb http://ftp.us.debian.org/debian/pool/main/s/sip4-qt3/python-sip4-dev_4.10.2-1_all.deb http://ftp.us.debian.org/debian/pool/main/s/sip4-qt3/sip4_4.10.2-1_all.deb
$ dpkg –i python-sip_4.13.3-2_amd64.deb python-sip4_4.10.2-1_all.deb python-sip4-dev_4.10.2-1_all.deb python-sip-dev_4.13.3-2_amd64.deb sip4_4.10.2-1_all.deb

Despues de descargarlos utilize el comando: sudo dpkg -i <nombre de paquete> de los paquetes descargados.

Despues, ejecute:

$ apt-get install libeigen3-dev

Ahora sí, puede hacer el make install que se encuentra en el Orocos-KDL.

cd ~/local/src/orocos-kdl
make install-python

• Instale avispy:

cd ~local/src
git clone https://github.com/arcoslab/avispy.git
cd avispy
make xstow_install

• Instale roboview:

cd ~local/src
git clone https://github.com/arcoslab/roboview.git
cd roboview
make xstow_install

• Instale cmoc:

cd ~local/src
git clone https://github.com/arcoslab/cmoc.git
cd cmoc
make xstow_install

• Instale pyrovito:

cd ~local/src
git clone https://github.com/arcoslab/pyrovito.git
cd pyrovito
make xstow_install

• Instale vfl:

cd ~local/src
git clone https://github.com/arcoslab/vfl.git
cd vfl
make xstow_install

• Instale vfclik:

cd ~local/src
git clone https://github.com/arcoslab/vfclik.git
cd vfclik
make xstow_install

• Instale kbd-cart-cmd

cd ~local/src
git clone https://github.com/arcoslab/kbd-cart-cmd.git
cd kbd-cart-cmd
make xstow_install

• Instale arcospyu

cd ~local/src
git clone https://github.com/arcoslab/arcospyu.git
cd arcospyu
make xstow_install

• Descargue robot_descriptions:

cd ~local/src
git clone https://github.com/arcoslab/robot_descriptions.git

• Ahora solo falta algunos paquetes más para que las simulaciones funcionen:

$ apt-get install python-qt4 python-pygame python-numpy python-scipy python-matplotlib ipython ipython-notebook python-pandas python-sympy python-nose python-vtk libcanberra-gtk3-module libcanberra-gtk-module python-gtkglext1 python-pygame rlwrap

• Ejecute vfclik para el brazo derecho:

cd ~/local/src
vfclik -i lwr -i right -d robot_descriptions/tum-rosie/kinematics/lwr/ -s

• En otra consola ejecute vfclik para el brazo izquierdo:

cd ~/local/src
vfclik -i lwr -i left -d robot_descriptions/tum-rosie/kinematics/lwr/ -s

• En otra consola ejecute el simulador de manos:

cd ~/local/src
sahand_yarp_sim -s -d -n -f robot_descriptions/tum-rosie/kinematics/sahand/hands_kin.py

• En otra consola ejecute visualizador oboviewer:

cd ~/local/src
pyrovito -r lwr --arm_right --arm_left --hand_right --hand_left -a robot_descriptions/tum-rosie/kinematics/lwr/ -d robot_descriptions/tum-rosie/kinematics/sahand/

• En otra consola ejecute simulador de torque:

cd ~/local/src
torque_sim -s -a robot_descriptions/tum-rosie/kinematics/lwr/ -c robot_descriptions/tum-rosie/kinematics/sahand/calibration_data/finger_calibration_data.py -f robot_descriptions/tum-rosie/kinematics/sahand/hands_kin.py

Sí desea controlar la simulación se puede ejecutar los siguientes comandos en dos consolas diferentes:

cd ~/local/src	  
run_left.sh

y

cd ~/local/src
run_right.sh

También para controlar los vectores se puede hacer lo siguiente para controlar la posición.

rlwrap yarp write … /torque_sim/force_in
(2 0 2 0)

Es una librería que permite construir campos vectoriales complejos a partir de varios campos vectoriales más simples, una vez calculado el campo vectorial final se puede obtener el vector determinado para una posición determinada.

Dentro del directorio vfl se encuentra el archivo vectorFieldsClass.py, con el cual se pueden crear campos vectoriales y campos escalares mediante las clases VectorField y Scalar Field, además define las funciones attractor, con las que se genera un campo de vectorial de atracción hacia un punto. Las funciones atractor describe la la posición de inicio, el punto de atracción y la posición actual). VectorFieldsClass.py utiliza las funciones sqrt y sin (importadas desde la librería math) e inner y array (importadas desde numpy).

El ejecutable vfl importa vectorFileldsClass entre algunas funciones de la librería math (sqrt, sin, pow, exp) y numpy (dot, array, matrix, inner, concotenate) así como PyKDL. Y define las clases: VectorFieldLibrary, nullAtracttor, pointAttractor, planeAttractor, hemisphereAttractor y funnelAttractor. Cabe destacar que la clase VectorFieldLibrary registrar los tipos de campos vectoriales mediante las clases restantes.

Asimismo, define las funciones goalObstacleVField2, trapesoidWeight, simpleAttractor2, simpleRepeller1, simpleRepeller1a, simpleRepeller2, simpleRepeller3, simpleRepeller4, lateralRepeller1, XyplanarRepeller, attractor1, attractor2, attractor3, atttractorSinHib, vectorF_hperbola, bellshape, hyperbola, hiperbolaDisplacedRotated, hyperbolaInside.

Es un controllador que mueve un manipulador hacia una meta incluso evadiendo obstaculos utilizando aproximación por campos vectoriales. Corre en tiempo real y la velocidad actual dada al robot es calculada en cada ciclo de control y se basa en la posición actual del extremo del robot, la posición del obstaculo y la posición meta.

Kbd-cart-cmd (Keyboard Cartesian Commander) Keyboad Cartesian Commander. A partir de comandos del teclado envia una nueva posición final para el extremo del brazo a vfclik (vector field closed loop inverse kinematics). El envío de instrucciones se hace mediante yarpserver.

Contiene vaias librerias con utilidades de python, entre las que se pueden mencionar:

• computer_graphics
• config_parser
• control
• dprint
• kdl_helpers
• myopen
• numeric
• pmanager
• print_colors
• rawkey
• robot_tools
• signal_proc
• yarp_tools

Contiene la librería de robot kinematics para el robot TUM-rosie. Específicamente contiene las librerías lwr ( la terminología lwr se refiere al brazo del robot) de configuración para ambos brazos y sahand para configuración de las manos (y dedos).

Es una herramienta de visualización de un robot para python, utiliza numpy y pygame para construir las visualizaciones. Entre sus directorios se encuentra el archivo ejecutable engine.py, con el cual se pueden crear objetos genéricos, además de especificaciones de color, luz, dimensiones y ubicación inicial para el objeto en el ambiente de simulación; por otra parte engine.py contiene las funciones de control para la cámara (rotación, altura, zoom ).

También contiene la librería objects_lib.py la cual permite crear objetos particulares para la simulación. Entre los objetos que permite crear se pueden mencionar: círculos, cilindros, discos, conos, flechas, esferas y barras. Con estos objetos y clases importadas desde engine.py se crean objetos más complejos como los joints (a partir de cilindros) y las barras que luego forman el brazo y estructura del robot del robot (Clases Frame, Segment y Articulated, Articulated_tree).

Es un visualizador de kinematic basado en la librería de Orocos KDL, con Roboview se pueden desplegar cadenas cinemáticas y pruebas utilizando cinemática invesa utilizando KDL.

USER INPUT
Left-button drag on background —>rotate camera
Middle-button drag on background —>move camera
Button drag on joint —>change joint value
Left-button drag on end effector —>rotate end effector (tries to inverse kinematics)
Middle-button drag on end effector—>translate end effector (tries to do inverse kinematics)
Key R —>reset camera
Key Q —>quit

Contiene modelos de control para objetos. Entre los directorios objects y sliding se pueden encontrar los archivos: box.py, box_contol.py, robot_params, webcam_calibration_values.py; así como los scripts de de planar_sliding, planar_sliding_simple, slider_control y slider_control_simple.

Por otra parte el directorio robot posee hand_sim_handler.py, joint_controller.py, sahand.py, sim_handlers.py y los ejecutables: joint_sim, sahand_yarp_sim y torque_sim.

Es una herramienta de visualización para robots a apartir de python y yarp. Este módulo crea un visor de cinemática además de objetos, utiliza los archivos de configuración de los brazos y la descripción cinemática del han_catesian para crear una representación visual. Además, utiliza el módulo de la mano de hand_catesian para conseguir los datos de la mano y los dedos, y el arm_helper para obtener los datos del brazo. Los objetos se pueden agregar de manera simple y luego cambiarles las propiedades como color y posición.

Los programas que se ejecutaron anteriormente utilizan YARP para transferir datos y variables entre ellos. Hay muchos puertos de YARP que se abren y se asignan dentro de la misma ejecución y que las otras ejecuciones no necesitan. Estas conexiones internas se utilizan para transferir datos.
Hay algunos puertos de YARP que se abren y quedan abiertos hasta que se ejecuta algunos de los pasos finales de la simulación en el cual se conectan los puertos necesarios. Estos puertos nos permiten ver como interactúan entre sí los programas ejecutados. Los puertos son los siguientes:

Vfclik –right
/lwr/right/bridge/encoders —→ /lwr/roboviewer/r_arm_qin
/lwr/right/bridge/encoders —→ /lwr/right/torque_sim/arm_joints/qin
/torque_sim/right/joint_sim_client/torque_out —→ /lwr/right/joint_sim/torque_in

Vfclik –left
/lwr/left/bridge/encoders —→ /lwr/roboviewer/l_arm_qin
/lwr/left/bridge/encoders —→ /lwr/left/torque_sim/arm_joints/qin
/torque_sim/left/joint_sim_client/torque_out —→ /lwr/left/joint_sim/torque_in

Sahand
/sahand0/out —→ /roboviewer_right_hand/hand_client0
/roboviewer_right_hand/hand_client0 —→ /sahand0/in
/sahand1/out —→ /roboviewer_left_hand/hand_client1

Expandimos levemente la guía para que personas más principiantes pudieran realizar la simulación y solucionar los errores con mayor facilidad.

Arcos- lab wiki
https://wiki.arcoslab.eie.ucr.ac.cr/doku.php
Yarp documentation
http://wiki.icub.org/yarpdoc/index.html
Python documentation
http://www.python.org/doc/