Reporte Nao

1

Reporte de Actividades

PROGRAMACIÓN Y DESARROLLO DE APLICACIONES DEL ROBOT

HUMANOIDE NAO.

CAMACHO TIRADO JUAN BERNARDO

DUARTE VALDEZ JORGE

GIL BAYARDO RAÚL

LÓPEZ PEINADO CHRISTIAN JAVIER

RÍOS LÓPEZ LUIS JAVIER

ESTANCÍA II DE

INGENIERÍA EN MECATRÓNICA

ASESOR ACADÉMICO

DR. PIERO ESPINO ROMÁN ASESOR EXTERNO

DR. JOSÉ VICTOR NUÑEZ NALDA ORGANISMO RECEPTOR

UNIVERSIDAD POLITÉCNICA DE SINALOA.

Mazatlán, Sin. 08 de Diciembre del 2014

2

Índice

ÍNDICE DE FIGURAS .......................................................................................................................................... 3

ÍNDICE DE TABLAS ............................................................................................................................................ 4

INTRODUCCIÓN .................................................................................................................................................. 5

ROBOT HUMANOIDE NAO ............................................................................................................................... 6

I. DIMENSIONES ............................................................................................................................................. 6

II. EJES DE COORDENADAS. ............................................................................................................................. 7

III. MOTORES DEL ROBOT. ................................................................................................................................ 8

PYTHON EN WINDOWS ................................................................................................................................... 13

I. INSTALANDO PYTHON EN WINDOWS. ....................................................................................................... 13

II. INSTALANDO SDK PARA PYTHON. ............................................................................................................ 15

PROGRAMANDO EN PYTHON. ...................................................................................................................... 17

I. EXPLICACION DEL CODIGO FUNCIONHABLAR.PY ............................................................................. 17

II. EXPLICACION DEL CODIGO FUNCIONPOSCIONINICIAL.PY ................................................................. 18

TAREAS REALIZADAS. .................................................................................................................................... 20

I. TAREA 1 MOVER EL BRAZO DE MANERA HORIZONTAL EN LÍNEA RECTA. .................................................. 20

II. TAREA 2 MOVER LA CADERA DE FORMA HORIZONTAL EN FORMA RECTA. ................................................ 24

III. TAREA 3 MOVER LA CADERA DE FORMA HORIZONTAL Y LEVANTAR PIE. .................................................. 27

ROBOT NAO Y UBUNTU LINUX .................................................................................................................... 31

I. CONOCIENDO LAS HERRAMIENTAS. .......................................................................................................... 31

II. TOOLCHAIN Y PREPARANDO EL SISTEMA. ................................................................................................. 31

III. CREACIÓN DEL PRIMER PROYECTO ............................................................................................................ 33

INTERFAZ GRÁFICA PARA CONTROLAR ROBOT NAO ........................................................................ 33

USANDO CHOREGRAPHE............................................................................................................................... 35

SIMULACIÓN EN WEBOTS. ............................................................................................................................ 36

I. WEBOTS PARA NAO. ................................................................................................................................. 37

II. CONEXIÓN CHOREGRAPHE - WEBOTS. ...................................................................................................... 37

CONCLUSIONES. ............................................................................................................................................... 40

3

BIBLIOGRAFIAS ................................................................................................................................................ 41

ÍNDICE DE FIGURAS

ILUSTRACIÓN 1 DIMENSIONES DEL ROBOT NAO (MM). ............................................................................................. 6

ILUSTRACIÓN 2 EJES DE COORDENADAS DE NAO. .................................................................................................... 7

ILUSTRACIÓN 3 FRAME_TORSO Y FRAME_ROBOT. ................................................................................................... 7

ILUSTRACIÓN 4 FRAME_WORLD. .............................................................................................................................. 8

ILUSTRACIÓN 5 MOTORES DEL ROBOT NAO. ............................................................................................................ 9

ILUSTRACIÓN 6 MOTORES DE LA CABEZA. ................................................................................................................ 9

ILUSTRACIÓN 7 MOTORES DEL BRAZO IZQUIERDO. ................................................................................................. 10

ILUSTRACIÓN 8 MOTORES DE LA CADERA. .............................................................................................................. 11

ILUSTRACIÓN 9 MOTORES DE LA PIERNA IZQUIERDA............................................................................................... 12

ILUSTRACIÓN 10 PYTHON.EXE ................................................................................................................................. 13

ILUSTRACIÓN 11 PASO 1. ........................................................................................................................................ 14

ILUSTRACIÓN 12 LIBRERÍAS. ................................................................................................................................... 14

ILUSTRACIÓN 13 INSTALACIÓN EN EJECUCIÓN. ....................................................................................................... 15

ILUSTRACIÓN 14 PYNAOQI. ..................................................................................................................................... 16

ILUSTRACIÓN 15 LIBRERIAS ESPECIALES. ................................................................................................................ 16

ILUSTRACIÓN 16 FINALIZAR INSTALACIÓN. ............................................................................................................ 17

ILUSTRACIÓN 17 CODIGO PARA HABLAR. ................................................................................................................ 17

ILUSTRACIÓN 18 CODIGO POSICIÓN INICIAL. ........................................................................................................... 19

ILUSTRACIÓN 19 CÓDIGO BRAZO. ........................................................................................................................... 20

ILUSTRACIÓN 20 CÓDIGO PARA OBTENER RESULTADOS. ......................................................................................... 22

ILUSTRACIÓN 21 PUNTOS DE MOVIMIENTO. ............................................................................................................ 23

ILUSTRACIÓN 22 SENSADO. ..................................................................................................................................... 25

ILUSTRACIÓN 23 CÓDIGO TORSO. ............................................................................................................................ 26

ILUSTRACIÓN 24 CÓDIGO TORSO-PIERNA DERECHA. ............................................................................................... 28

ILUSTRACIÓN 25 CÓDIGO TORSO-PIERNA IZQUIERDA. ............................................................................................. 29

ILUSTRACIÓN 26 INTERFAZ GRÁFICA. ..................................................................................................................... 34

ILUSTRACIÓN 27 ENTORNO DE DESARROLLO. ......................................................................................................... 34

ILUSTRACIÓN 28 MÓDULOS. ................................................................................................................................... 35

ILUSTRACIÓN 29 INTERFAZ CHOREGRAPHE. ............................................................................................................ 36

ILUSTRACIÓN 30 MOVIMIENTO. .............................................................................................................................. 36

ILUSTRACIÓN 31 WEBOTS FOR NAO. ...................................................................................................................... 37

ILUSTRACIÓN 32 RUTINA EN CHOREGRAPHE. .......................................................................................................... 38

4

ILUSTRACIÓN 33 RUTINA EN WEBOTS. .................................................................................................................... 38

ILUSTRACIÓN 34 COLOCANDO OBJETOS. ................................................................................................................. 39

ÍNDICE DE TABLAS

TABLA 1 ÁNGULOS MÁXIMOS Y MINIMOS DE LA CABEZA DEL ROBOT. .................................................................... 10

TABLA 2 ÁNGULOS MÁXIMOS Y MÍNIMOS DEL BRAZO DEL ROBOT. ......................................................................... 11

TABLA 3 ÁNGULOS MÁXIMOS Y MÍNIMOS DE LA PIERNA IZQUIERDA. ...................................................................... 12

5

INTRODUCCIÓN

Nao es un robot humanoide programable y autónomo, desarrollado por Aldebaran Robotics, una

compañía de robótica francesa con sede en París. El desarrollo del robot comenzó con el

lanzamiento del Proyecto Nao en 2004. En el 15 de agosto de 2007, Nao sustituye al perro

robot Aibo de Sony como la plataforma estándar para la Robocup ("Robot Soccer World Cup"),

un concurso internacional de robótica. Nao se utilizó en RoboCup 2008 y 2009, y el NaoV3R

fue elegido como la plataforma para el SPL en RoboCup 2010.

La Edición Académica de Nao fue desarrollada para las universidades y laboratorios con fines

de investigación y educación. Fue lanzado a las instituciones en 2008, y se puso a disposición

del público antes de 2011. El robot ha entrado ya su uso en numerosas instituciones académicas

de todo el mundo, incluyendo la Universidad de Tokio, el IIT Kanpur de la India y la

Universidad del Rey Fahd de Petróleo y Minerales de Arabia Saudita. En diciembre de 2011,

Aldebaran Robotics lanzó la Nao Next Gen, con software mejorado, una CPU más potente y

cámaras de alta definición.

Python es un lenguaje de programación interpretado cuya filosofía hace hincapié en una sintaxis

que favorezca un código legible.

Se trata de un lenguaje de programación multiparadigma, ya que soporta orientación a

objetos, programación imperativa y, en menor medida, programación funcional. Es un lenguaje

interpretado, usa tipado dinámico y es multiplataforma.

Es administrado por la Python Software Foundation. Posee una licencia de código abierto,

denominada Python Software Foundation License,1 que es compatible con la Licencia pública

general de GNU a partir de la versión 2.1.1, e incompatible en ciertas versiones anteriores.

6

ROBOT HUMANOIDE NAO

NAO es un robot humanoide que es completamente programable, este tiene una altura de 57.3

cm, fue diseñado para ser un robot sociable y amigable para que pudiera interactuar con las

personas, este robot es una plataforma muy completa ya que nos ofrece varias características

que permiten en este caso se usó el robot NAO H25, el cual tiene las siguientes características:

I. Dimensiones

Ilustración 1 Dimensiones del robot NAO (mm).

El robot NAO posee las dimensiones mostradas en la imagen anterior, en la cual podemos

apreciar que tiene unas medidas que lo hacen grande en comparación con otros robots

comerciales que se venden hoy en día.

7

II. Ejes de coordenadas.

Ilustración 2 Ejes de coordenadas de NAO.

En la imagen anterior se puede ver cómo están dispuestos los ejes de coordenadas en el robot,

siendo X el movimiento hacia adelante cuando este es positivo y hacia la izquierda del robot

esta Y al cual cuando se le de valores positivos tomará esta dirección, si el valor es negativo

se irá al otro lado. El robot tiene otros marcos de referencias que ya están preestablecidos y se

pueden usar para referir una posición con respecto al marco de referencia que se ha escogido,

en la siguiente imagen se puede ver cómo están distribuidos estos marcos a lo largo del robot.

Ilustración 3 Frame_Torso y Frame_Robot.

8

Estos 2 primeros marcos siempre están en una posición constante con respecto al robot, ya que

son fijos y nunca cambian las dimensiones con respecto a este, pero hay un tercer marco de

referencia que si cambia, ya que este se genera cuando el robot inicia a caminar y se queda

en esa posición que inicio, conforme el robot se vaya moviendo la magnitud de la distancia de

este con respecto al robot irá cambiando, se puede apreciar esto en la siguiente imagen:

Ilustración 4 Frame_World.

Así pues se puede definir con respecto a que marco se va a medir las distancias del robot, estas

son usadas principalmente en las funciones cartesianas en las cuales se usa cinemática inversa

para alcanzar alguna posición que se le da al robot, es por ello que hay que prestar atención

cuando se usen estas, ya que si se escoge alguna incorrecta el robot va a intentar alcanzarla

y lo podríamos hacer caer o simplemente que realice algún movimiento no deseado.

III. Motores del robot.

Otra de las cosas importantes que tenemos que conocer del robot NAO son los motores con

los que cuenta, en nuestro caso tenemos el H25 que cuenta con 25 grados de libertad, cada

uno de estos motores están dispuestos de la manera que se muestra en la imagen a

continuación:

9

Ilustración 5 Motores del robot NAO.

Ahora pasaremos a revisar más a fondo cada una de las extremidades del robot, en las

cuales podremos observar los limites angulares que tiene cada una de estas, primeramente

empezamos a revisar la cabeza del robot, la cual consta de 2 grados de libertad, que están

dispuestos de la siguiente manera:

Ilustración 6 Motores de la cabeza.

10

Tabla 1 Ángulos máximos y minimos de la cabeza del robot.

Joint name Motion Range (degrees) Range (radians)

HeadYaw Head joint twist (Z) -119.5 to 119.5 -2.0857 to 2.0857

HeadPitch Head joint front and back (Y) -38.5 to 29.5 -0.6720 to 0.5149

Siguiendo con la descripción de las articulaciones del robot, pasaremos ahora a revisar uno

de los brazos del robot que como se ve en la figura 2.5 hay cuatro motores en cada brazo del

NAO, en el caso de la versión H21, ya que en la versión H25 se tienen dos motores más los

cuales nos permiten tener un grado de libertad para la orientación del efector final y además

otro con el cual podemos abrir y cerrar el efector final (mano del robot), los motores de este

robot están dispuestos de la siguiente manera y tienen un nombre ya definido con el cual

podremos referirnos a cada uno cuando estemos controlando sus articulaciones.

Ilustración 7 Motores del brazo izquierdo.

Para el brazo derecho tenemos las mismas características que en este, la única diferencia es el

nombre que se le da a cada articulación, en los cuales nada más cambia la letra inicial, en lugar

de iniciar con la L (Left) estos inician con la letra R (Ritgh).

11

Tabla 2 Ángulos máximos y mínimos del brazo del robot.

Joint name Motion Range (degrees) Range (radians)

LShoulderPitch Left shoulder joint front and back (Y) -119.5 to 119.5 -2.0857 to 2.0857

LShoulderRoll Left shoulder joint right and left (Z) -18 to 76 -0.3142 to 1.3265

LElbowYaw Left shoulder joint twist (X) -119.5 to 119.5 -2.0857 to 2.0857

LElbowRoll Left elbow joint (Z) -88.5 to -2 1.5446 to 0.0349

En la cadera tenemos las siguientes articulaciones, que se muestran a continuación:

Ilustración 8 Motores de la cadera.

Finalmente llegamos a las piernas del robot, estas tienen 5 grados de libertad cada una,

los cuales están dispuestos como se muestra a continuación:

12

Ilustración 9 Motores de la pierna izquierda.

En la siguiente tabla se muestran los valores mínimos y máximos que puede moverse cada

motor, además viene el valor en radianes, ya que a la hora de enviarle el dato de la posición

del motor, este tiene que estar dado en radianes, como se mostrará más adelante en los

ejemplos.

Tabla 3 Ángulos máximos y mínimos de la pierna izquierda.

Joint name Motion Range (degrees) Range (radians)

LHipRoll Left hip joint right and left (X) -21.74 to 45.29 -0.379472 to 0.790477

LHipPitch Left hip joint front and back (Y) -88.00 to 27.73 -1.535889 to 0.484090

LKneePitch Left knee joint (Y) -5.29 to 121.04 -0.092346 to 2.112528

LAnklePitch Left ankle joint front and back (Y) -68.15 to 52.86 -1.189516 to 0.922747

LAnkleRoll Left ankle joint right and left (X) -22.79 to 44.06 -0.397880 to 0.769001

13

PYTHON EN WINDOWS

I. Instalando Python en Windows.

El procedimiento para instalar Python ya sea en Windows XP, Windows Vista o Windows 7

son muy similares ya que todos se basan en una bonita interfaz gráfica, que te guía durante todo

el proceso de instalación.

Lo primero que tienes que hacer es bajar la última versión de Python directo de su página.

Como ya hemos mencionado esta guía se concentrara en el uso de Python 2.7.

Ilustración 10 python.exe

Al terminar de bajar el archivo puedes ejecutarlo e iniciar con el proceso de instalación.

Probablemente te pida permisos de administrador.

14

Ilustración 11 Paso 1.

El asistente te preguntara si lo quieres instalar para todos los usuarios o solo para el usuario que

está ejecutando el instalador, en este caso elegimos para todos los usuarios.

Selecciona la ruta donde se va a instalar, regularmente la ruta por defecto es

"C:\Python[Version]" claro que puedes cambiar la ruta de instalación.

Ilustración 12 Librerías.

15

Después empieza la instalación.

La instalación de Python puede tomar algunos minutos por lo cual es importante mantener el

equipo conectado a la corriente para evitar un mal funcionamiento.

Ilustración 13 Instalación en ejecución.

Puede tardar uno o dos minutos.

Cuando termine la instalación nos mostrara una pantalla que todo se ha instalado correctamente.

Este instalador no solo instala el intérprete de Python, si no también te instala un bonito y

funcional IDE.

II. Instalando SDK para Python.

Una vez finalizada la instalación de Python 2.7, se puede proceder a descargar el SDK para

Python, este lo podremos encontrar como NAOqi.

Podemos encontrar la última versión de NAOqi en el sitio web oficial de Aldebarán o

igualmente se puede descargar desde el siguiente enlace.

Al hacer doble clic en el archivo NAOqi ejecutable, se mostrara la siguiente ventana de

instalación.

16

Ilustración 14 Pynaoqi.

Después el instalador solicitara permiso para poder agregar nuevas librerías.

Ilustración 15 Librerias especiales.

17

Una vez que colocado la ruta deseada para guardar las librerías, presionamos siguiente, lo cual

será un proceso de unos minutos para instalar las librerías, después clic en finalizar y listo.

Ilustración 16 Finalizar instalación.

PROGRAMANDO EN PYTHON.

I. EXPLICACION DEL CODIGO funcionhablar.py

Ilustración 17 Codigo para hablar.

18

Este código es una modificación del que se muestra de ejemplo en la página de documentación

de Aldebarán, la razón de la modificación es hacerlo más amigable para comprenderlo, además

de convertirlo en una función para de este modo cuando sea requerido en otro programa solo

mandarlo llamar.

En la primera línea se manda llamar la librería requerida.

En la segunda línea se optó por hacer una variable global llamada robotIP para solo tener que

cambiarla una vez cuando sean programas más extensos.

A partir de la tercera línea se crea la función que en este caso es para hacer al robot hablar, para

crear una función en Python se pone la palabra reservada “def” después se escribe el nombre de

la función y seguido a esto entre paréntesis se escribe el parámetro que requiere la función.

Acto seguido se escribe el cuerpo de la función, en este punto se realizó otra pequeña

modificación al código original. Se establecieron 3 variables locales una llamada idioma en el

que se escribe el idioma en el que se quiere que el robot hable, la otra variable es discurso en la

que se escribe lo que se quiere que diga el robot y la tercera y última es tts esta es igual al módulo

requerido para hacer hablar al robot (ALTextToSpeech) que a su vez está alojado en ALProxy

(la sintaxis para escribirlo se puede observar en la 6ta línea de la imagen anterior). ALProxy

requiere 3 parámetros que se escriben entre paréntesis, estos parámetros son: modulo requerido

para hacer hablar al robot (ALTextToSpeech), IP del robot y puerto de comunicación con el

robot. En la siguiente línea se manda llamar la tarea .setLanguage de la variable creada

anteriormente alojada en ALTextToSpeech que te pide de parámetro el lenguaje en el que se

quiere que el robot hable. Para finalizar el cuerpo de la función se llama la tarea .say alojada

igualmente en ALTextToSpeech cuyo parámetro esta vez será lo que se quiere que diga el robot.

Para finalizar el código simplemente se manda llamar la función creada anteriormente.

II. EXPLICACION DEL CODIGO funcionposcioninicial.py

19

Ilustración 18 Codigo posición inicial.

En la primera línea se manda llamar la librería requerida.

En la segunda línea se optó por hacer una variable global llamada robotIP para solo tener que

cambiarla una vez cuando sean programas más extensos.

Para realizar cualquier movimiento se necesita antes poner los motores del robot con cierta

rigidez, para esto creamos una función llamada rigidez

A partir de la tercera línea se crea la función rigidez que en este caso es para hacer al robot

presente rigidez en los motores, para crear una función en python se pone la palabra reservada

“def” después se escribe el nombre de la función y seguido a esto entre paréntesis se escribe el

parámetro que requiere la función.

Para el cuerpo de la función se crearon 2 variables, la primera variable se llama junta, en esta se

establecen los motores a los que les quieres poner rigidez (su utiliza “Body” para todos los

motores). La segunda variable (motion) es igual al módulo requerido para establecer la rigidez

del robot (ALMotion) que a su vez está alojado en ALProxy (la sintaxis para escribirlo se puede

observar en la imagen anterior). ALProxy requiere 3 parámetros que se escriben entre paréntesis,

estos parámetros son: modulo requerido para la rigidez del robot (ALMotion), IP del robot y

puerto de comunicación con el robot. En la siguiente línea se manda llamar la tarea

.setStiffnesses de la variable creada anteriormente alojada en ALMotion que te pide 3

20

parámetros: las juntas a las que se quiere poner rigidez, el porcentaje que rigidez que se quiere

(siendo 1 el 100% y 0 el 0%).

La siguiente función (posicionInicial) que en este caso es para hacer al robot se pare y se ponga

en posición inicial, se crea de igual manera como ya fue explicado.

Para el cuerpo de la función se utilizó una variable llamada postureProxy igualada al módulo

requerido para hacer que el robot se ponga en posición inicial (ALRobotPosture) que a su vez

está alojado en ALProxy (la sintaxis para escribirlo se puede observar en la imagen anterior).

ALProxy requiere 3 parámetros que se escriben entre paréntesis, estos parámetros son: modulo

requerido para hacer que el robot se ponga en posición inicial (ALRobotPosture), IP del robot

y puerto de comunicación con el robot. En la línea siguiente se manda llamar la función rigidez

pues antes de realizar cualquier movimiento se le tiene que asignar rigidez al robot. Por último

se manda llamar la tarea .goToPosture de la variable creada anteriormente alojada en

ALRobotPosture que te pide 2 parámetros: la posición requerida y la velocidad con la que se

quiere que realice el movimiento (siendo 1 lo más rápido posible).

Para finalizar el código simplemente se manda llamar la función creada anteriormente.

TAREAS REALIZADAS.

I. Tarea 1 Mover el brazo de manera horizontal en línea recta.

Para realizar esta tarea se toma de base el código anterior mente explicado al cual se le agregaran

3 funciones más para realizar la tarea asignada.

Ilustración 19 Código brazo.

21

Lo primero es crear la función brazoPos de la misma manera como se ha explicado en los

ejemplos anteriores, esta será la referencia y el punto donde todas las coordenadas serán 0.

Lo primero es llamar la función posicionInicial que ya fue explicada anteriormente. Después

serán necesarias una serie de variables, por ende es necesario crearlas la primera será

motionProxy es igual al módulo requerido para establecer movimiento en el robot (ALMotion)

que a su vez está alojado en ALProxy (la sintaxis para escribirlo se puede observar en la imagen

anterior). ALProxy requiere 3 parámetros que se escriben entre paréntesis, estos parámetros son:

modulo requerido para el movimiento del robot (ALMotion), IP del robot y puerto de

comunicación con el robot. La siguiente variable será juntas, la cual se iguala a una matriz

renglón en la que se especifican las juntas a mover. Lo siguiente es una variable x igualada a la

proporción que se desea a la hora de cambiar los ángulos en grados a radianes más abajo en el

código (como en este caso no queremos que cambie la proporción se le da el valor de 1). La

siguiente variable es Arm1 que es igualada a una matriz renglón con los ángulos en grados de

las juntas antes especificadas para que el brazo este en la posición deseada. El lenguaje python

permite reasignar valores a las variables y eso es lo que se hace en la siguiente línea, se reasigna

cada uno de los ángulos esta vez en radianes, para ello se utiliza la función motion.TO_RAD (la

sintaxis e muestra en la imagen anterior). NOTA: para utilizar la función anterior es necesario

agregar una librería llamada motion. A continuación se asigna una variable tiempo en la que se

establece la velocidad con la que se quiere que se realice el movimiento (siendo 1 la máxima

velocidad). Por último se manda llamar la tarea .angleInterpolationWithSpeed de la variable

creada en un principio alojada en ALMotion que te pide 3 parámetros: las juntas a mover, los

ángulos de cada junta en radianes y la velocidad con la que se quiere que se muevan.

22

Ilustración 20 Código para obtener resultados.

Para futuras investigaciones fue requerido censar el peso que registra cada uno de los 4 sensores

por pie que tiene el robot para esto se creó la función sensarpies de la misma manera como se

ha explicado en los ejemplos anteriores. Lo siguiente será crear una serie de variables, una por

cada sensor como son 8 sensores se necesitan 8 variables más 1 en la que se accederá a la

memoria. La primera será memoryProxy es igual al módulo requerido para establecer

movimiento en el robot (ALMemory) que a su vez está alojado en ALProxy (la sintaxis para

escribirlo se puede observar en la imagen anterior). ALProxy requiere 3 parámetros que se

escriben entre paréntesis, estos parámetros son: modulo requerido para acceder a la memoria

del robot (ALMemory), IP del robot y puerto de comunicación con el robot. Después se crean

las 8 variables de los sensores cada una es igualada a la variable anterior más las tarea .getData

(la sintaxis para escribirlo se puede observar en la imagen anterior) que requiere de parametro

la dirección en la memoria a la que se quiere acceder, la dirección es la siguiente:

"Device/SubDeviceList/LFoot/FSR/FrontLeft/Sensor/Value" variando LFoot por RFoot si se

quiere el del pie derecho y FrontLeft por RearLeft o RearRight según el sensor deseado.

Por último se mandan imprimir los 8 datos obtenidos.

23

Ilustración 21 Puntos de movimiento.

Para finalizar el código creamos una función brazo en la que estableceremos los puntos a los

que queremos que la mano del robot llegue. Para esto necesitamos una serie de variables.

La primer variable será motionProxy es igual al módulo requerido para establecer movimiento

en el robot (ALMotion) que a su vez está alojado en ALProxy (la sintaxis para escribirlo se

puede observar en la imagen anterior). ALProxy requiere 3 parámetros que se escriben entre

paréntesis, estos parámetros son: modulo requerido para el movimiento del robot (ALMotion),

IP del robot y puerto de comunicación con el robot. La segunda es effector esta se iguala a la

cadena amover (brazo, pierna, torso o cabeza). Después viene la variable space que se iguala a

la función motoin.FRAME_TORSO que hace que el marco de referencia a usar sea el torso,

NOTA: para utilizar la función anterior es necesario agregar una librería llamada motion. La

siguiente variable es amp que es la amplitud en metros que se moverá la mano. Después viene

tiempo que será el tiempo en segundos que durara en llegar de un punto a otro. Seguido viene

veces que será igual al número de veces que se quiere que se repita el ciclo. Luego viene valor

este se iguala a una relación que involucra el tiempo para saber cuántas muestras tomara a la ora

de censar por cada movimiento. Después se convierte a valor en un entero y se guarda en valor1.

24

Lo siguiente es establecer en cuál de los 6 grados de libertad que tiene un cuerpo en el espacio

queremos movernos, como en este caso el movimiento es solo horizontal la variable amp solo

se iguala a “y” y los demás parámetros se dejan en 0, basándose en lo comentado se establecen

3 posiciones objetivo que son reposo, posicionObjetivo y posicionObjetivo1. La variable

siguiente path es una matriz renglón en la que se ponen los 3 movimientos a realizar. axisMask

se iguala a 7 lo que representa que los parámetros dados son solo posiciones. lo siguiente es

times que es una matriz renglón en la que se especifica el tiempo en segundos de cada uno de

los movimientos. La ultima variable es isAbsolute se deshabilita esto hace que el marco de

referencia establecido anteriormente sea relativo a la posición de la cadena usada. Finalmente

se llama a la variable motionProxy a la que se le asigna las tareas .post (que es esperar a la

siguiente tarea para ejecutarse de manera simultánea) y .positionInterpolation que requiere 6

parámetros (effector, space, path, axisMask, times, isAbsolute) todas variables creadas

anteriormente, esto se pone dentro de un bucle for, con un rango igual a la variable veces, para

así repetir el ciclo las veces deseadas. A su vez dentro del for anterior se incluye un nuevo bucle

con rango igual a la variable valor1 en el que se ejecutara la función sensarpies de manera

simultánea con el movimiento del robot.

Al final solo se mandan llamar las funciones en el siguiente orden:

brazoPos(robotIP)

brazo(robotIP).

II. Tarea 2 Mover la cadera de forma horizontal en forma recta.

Para realizar esta tarea se toma de base el código anterior mente explicado

(funcionposcioninicial.py) al cual se le agregaran 2 funciones más para realizar la tarea

asignada.

25

Ilustración 22 Sensado.

Lo primero en agregarse es la función sensarpies que ya fue explicada en el ejemplo anterior.

Aquí de nuevo su explicación:

Para futuras investigaciones fue requerido censar el peso que registra cada uno de los 4 sensores

por pie que tiene el robot para esto se creó la función sensarpies de la misma manera como se

ha explicado en los ejemplos anteriores. Lo siguiente será crear una serie de variables, una por

cada sensor como son 8 sensores se necesitan 8 variables más 1 en la que se accederá a la

memoria. La primera será memoryProxy es igual al módulo requerido para establecer

movimiento en el robot (ALMemory) que a su vez está alojado en ALProxy (la sintaxis para

escribirlo se puede observar en la imagen anterior). ALProxy requiere 3 parámetros que se

escriben entre paréntesis, estos parámetros son: modulo requerido para acceder a la memoria

del robot (ALMemory), IP del robot y puerto de comunicación con el robot. Después se crean

las 8 variables de los sensores cada una es igualada a la variable anterior más las tarea .getData

(la sintaxis para escribirlo se puede observar en la imagen anterior) que requiere de parametro

la dirección en la memoria a la que se quiere acceder, la dirección es la siguiente:

"Device/SubDeviceList/LFoot/FSR/FrontLeft/Sensor/Value" variando LFoot por RFoot si se

quiere el del pie derecho y FrontLeft por RearLeft o RearRight según el sensor deseado.

Por último se mandan imprimir los 8 datos obtenidos.

26

Ilustración 23 Código torso.

La función torso será la encargada de crear el movimiento horizontal de la parte ya mencionada.

Esta función es muy similar a la función brazo utilizado anteriormente con la única diferencia

de la variable isAbsolute que esta vez esta activada, lo que representa que el centro del torso es

la posición donde todos los parámetros son 0. Aclarando esta única diferencia aquí se vuelve a

explicar cada una de las variables involucradas:

La primer variable será motionProxy es igual al módulo requerido para establecer movimiento

en el robot (ALMotion) que a su vez está alojado en ALProxy (la sintaxis para escribirlo se

puede observar en la imagen anterior). ALProxy requiere 3 parámetros que se escriben entre

paréntesis, estos parámetros son: modulo requerido para el movimiento del robot (ALMotion),

IP del robot y puerto de comunicación con el robot. La segunda es effector esta se iguala a la

27

cadena amover (brazo, pierna, torso o cabeza). Después viene la variable space que se iguala a

la función motoin.FRAME_TORSO que hace que el marco de referencia a usar sea el torso,

NOTA: para utilizar la función anterior es necesario agregar una librería llamada motion. La

siguiente variable es amp que es la amplitud en metros que se moverá la mano. Después viene

tiempo que será el tiempo en segundos que durara en llegar de un punto a otro. Seguido viene

veces que será igual al número de veces que se quiere que se repita el ciclo. Luego viene valor

este se iguala a una relación que involucra el tiempo para saber cuántas muestras tomara a la

hora de censar por cada movimiento. Después se convierte a valor en un entero y se guarda en

valor1. Lo siguiente es establecer en cuál de los 6 grados de libertad que tiene un cuerpo en el

espacio queremos movernos, como en este caso el movimiento es solo horizontal la variable

amp solo se iguala a “y” y los demás parámetros se dejan en 0, basándose en lo comentado se

establecen 3 posiciones objetivo que son reposo, posicionObjetivo y posicionObjetivo1. La

variable siguiente path es una matriz renglón en la que se ponen los 3 movimientos a realizar.

axisMask se iguala a 7 lo que representa que los parámetros dados son solo posiciones. Lo

siguiente es times que es una matriz renglón en la que se especifica el tiempo en segundos de

cada uno de los movimientos. La ultima variable es isAbsolute se deshabilita esto hace que el

marco de referencia establecido anteriormente sea relativo a la posición de la cadena usada.

Finalmente se llama a la variable motionProxy a la que se le asigna las tareas .post (que es

esperar a la siguiente tarea para ejecutarse de manera simultánea) y .positionInterpolation que

requiere 6 parámetros (effector, space, path, axisMask, times, isAbsolute) todas variables

creadas anteriormente, esto se pone dentro de un bucle for, con un rango igual a la variable

veces, para así repetir el ciclo las veces deseadas. A su vez dentro del for anterior se incluye un

nuevo bucle con rango igual a la variable valor1 en el que se ejecutara la función sensarpies de

manera simultánea con el movimiento del robot.

Al final solo se mandan llamar la función torso.

III. Tarea 3 Mover la cadera de forma horizontal y levantar pie.

Para realizar esta tarea se toma de base el código anterior mente explicado al cual se le agregaran

2 funciones más para realizar la tarea asignada.

28

Ilustración 24 Código torso-pierna derecha.

La estructura de esta función es bastante parecida a la de la función brazoPos.

Lo primero es crear la función alzarPiernaDer de la misma manera como se ha explicado en los

ejemplos anteriores.

Después serán necesarias una serie de variables, por ende es necesario crearlas la primera será

motionProxy es igual al módulo requerido para establecer movimiento en el robot (ALMotion)

que a su vez está alojado en ALProxy (la sintaxis para escribirlo se puede observar en la imagen

anterior). ALProxy requiere 3 parámetros que se escriben entre paréntesis, estos parámetros son:

modulo requerido para el movimiento del robot (ALMotion), IP del robot y puerto de

comunicación con el robot. Lo siguiente es una variable x igualada a la proporción que se desea

a la hora de cambiar los ángulos en grados a radianes más abajo en el código (como en este caso

no queremos que cambie la proporción se le da el valor de 1). La siguiente variable será juntas2,

la cual se iguala a una matriz renglón en la que se especifican las juntas a mover. La siguiente

variable es legs que es igualada a una matriz renglón con los ángulos en grados de las juntas

antes especificadas para que la cadera y las piernas estén en la posición deseada. El lenguaje

Python permite reasignar valores a las variables y eso es lo que se hace en la siguiente línea, se

reasigna cada uno de los ángulos esta vez en radianes, para ello se utiliza la función

motion.TO_RAD (la sintaxis e muestra en la imagen anterior). NOTA: para utilizar la función

anterior es necesario agregar una librería llamada motion. La siguiente variable es legs1 que es

igualada a una matriz renglón con los ángulos en grados de las juntas antes especificadas para

que la cadera y las piernas estén en la segunda posición deseada (pierna derecha arriba). El

29

lenguaje Python permite reasignar valores a las variables y eso es lo que se hace en la siguiente

línea, se reasigna cada uno de los ángulos esta vez en radianes, para ello se utiliza la función

motion.TO_RAD (la sintaxis e muestra en la imagen anterior). NOTA: para utilizar la función

anterior es necesario agregar una librería llamada motion. A continuación se asigna una variable

tiempo en la que se establece la velocidad con la que se quiere que se realice el movimiento

(siendo 1 la máxima velocidad) esta será igualada a una variable global llamada vel. Por último

se manda llamar la tarea .angleInterpolationWithSpeed de la variable creada en un principio

alojada en ALMotion que te pide 3 parámetros: las juntas a mover, los ángulos de cada junta en

radianes y la velocidad con la que se quiere que se muevan (esta tarea se lleva acabo 3 veces,

ambos pies abajo, pie derecho arriba y ambos pies abajo de nuevo).

Ilustración 25 Código torso-pierna izquierda.

La otra función agregada es similar a la anterior la diferencia además del nombre es que la

cadera se mueve hacia el otro lado y se levanta la pierna opuesta. Aclarando estas únicas

diferencia aquí se vuelve a explicar cada una de las variables involucradas:

Serán necesarias una serie de variables, por ende es necesario crearlas la primera será

motionProxy es igual al módulo requerido para establecer movimiento en el robot (ALMotion)

que a su vez está alojado en ALProxy (la sintaxis para escribirlo se puede observar en la imagen

anterior). ALProxy requiere 3 parámetros que se escriben entre paréntesis, estos parámetros son:

modulo requerido para el movimiento del robot (ALMotion), IP del robot y puerto de

30

comunicación con el robot. Lo siguiente es una variable x igualada a la proporción que se desea

a la hora de cambiar los ángulos en grados a radianes más abajo en el código (como en este caso

no queremos que cambie la proporción se le da el valor de 1). La siguiente variable será juntas2,

la cual se iguala a una matriz renglón en la que se especifican las juntas a mover. La siguiente

variable es legs que es igualada a una matriz renglón con los ángulos en grados de las juntas

antes especificadas para que la cadera y las piernas estén en la posición deseada. El lenguaje

Python permite reasignar valores a las variables y eso es lo que se hace en la siguiente línea, se

reasigna cada uno de los ángulos esta vez en radianes, para ello se utiliza la función

motion.TO_RAD (la sintaxis e muestra en la imagen anterior). NOTA: para utilizar la función

anterior es necesario agregar una librería llamada motion. La siguiente variable es legs1 que es

igualada a una matriz renglón con los ángulos en grados de las juntas antes especificadas para

que la cadera y las piernas estén en la segunda posición deseada (pierna izquierda arriba). El

lenguaje Python permite reasignar valores a las variables y eso es lo que se hace en la siguiente

línea, se reasigna cada uno de los ángulos esta vez en radianes, para ello se utiliza la función

motion.TO_RAD (la sintaxis e muestra en la imagen anterior). NOTA: para utilizar la función

anterior es necesario agregar una librería llamada motion. A continuación se asigna una variable

tiempo en la que se establece la velocidad con la que se quiere que se realice el movimiento

(siendo 1 la máxima velocidad) esta será igualada a una variable global llamada vel. Por último

se manda llamar la tarea .angleInterpolationWithSpeed de la variable creada en un principio

alojada en ALMotion que te pide 3 parámetros: las juntas a mover, los ángulos de cada junta en

radianes y la velocidad con la que se quiere que se muevan (esta tarea se lleva acabo 3 veces,

ambos pies abajo, pie izquierdo arriba y ambos pies debajo de nuevo).

Al principio del código se pueden observar 2 variables globales que no han sido explicadas.

Veces representara el número de repeticiones del ciclo que se quieran realizar, y vel será la

velocidad con la que se quiera realizar los movimientos (siendo 1 la máxima velocidad).

Para terminar el código se escribe lo siguiente:

posicionInicial(robotIP)

for i in range(veces):

alzarPiernaDer(robotIP)

alzarPiernaIzq(robotIP)

31

Aquí se están mandando, llamar las funciones a realizar posicionInicial, luego un bucle for en

el que se llaman las 2 funciones antes explicadas donde el rango es igual a la variable global

veces que hará que esto se repita el número de veces que ingresamos en la variable.

ROBOT NAO Y UBUNTU LINUX

Debido a que el sistema operativo del robot Nao (NAOqi) se encuentra desarrollado en Linux,

resulta necesario el uso de las herramientas proporcionadas por Aldebaran Robotics para el

desarrollo del robot Nao en el entorno Linux para este caso se utilizaron las herramientas para

el desarrollo en C++ y el sistema operativo Ubuntu que corresponde a una de las distribuciones

más usadas de Linux.

I. Conociendo las Herramientas.

NAOqi es el sistema operativo que corre en el robot (también corre en la computadora y se

comunica con el NAOqi del robot). NAOqi se encarga de controlar los diferentes módulos y

protocolos de comunicación que son usados para manejar el robot.

qiBuild es el programa que corre sobre la computadora en la cual se desarrolla el software. Es

la más importante herramienta para compilar software que usan los desarrolladores del Nao. Se

usa para configurar, compilar e instalar el programa en el robot Nao.

Qt Creator es un entorno de desarrollo integrado (IDE por sus siglas en inglés) creado por

Trolltech para el desarrollo de aplicaciones con las bibliotecas Qt.

Sublime Text 3 es un editor de texto y editor de código está escrito en C++ y Python. Se

distribuye de forma gratuita.

II. Toolchain y preparando el sistema.

Para comenzar a desarrollar aplicaciones para el robot nao desde Ubuntu es necesario instalar

varias cosas para preparar el sistema, por lo que a continuación se abordara paso por paso la

instalación es las herramientas necesarias para comenzar a desarrollar en el robot Nao desde

Ubuntu utilizando C++.

32

Primero es necesario instalar GCC Cmake y Python 2 para esto vamos a la terminar de Ubuntu

Ctrl+Alt+T y ejecutamos los siguientes comandos.

$sudo apt-get install gcc cmake

$sudo apt-get install Python

Una vez instalados en necesario instalar Qt Creator y Sublime Text para esto es necesario ir a

sus respectivas páginas web y descargar el instalador para Ubuntu.

Después es necesario descargar los siguientes archivos desde la página de Aldebaran Robotics:

NAOQI C++ SDK 1.14.5

NAOQI C++ Cross Toolchain 1.14.5 Linux 64 bits (32 bits según las

arquitectura de tu sistema).

QiBuild

Después se deben extraer esos archivos en el directorio que se creara a continuación. En la

terminal ejecutar el comando:

$mkdir -p ~/nao/{devtools,workspace}

El cual creara una carpeta con 2 subdirectorios nosotros iremos al subdirectorio devtools en el

cual se extraerán los archivos anteriormente descargados. Una vez descargados navegaremos

hasta la carpeta donde se extrajo qiBuild desde la terminal para ejecutar el instalador de qiBuild

por lo cual ejecutamos desde la terminar los siguientes comandos:

$cd ~/nao/devtools/qibuild (siendo qibuild el nombre de la carpeta donde se extrajo)

$./install-qibuild.sh

Después configuraremos qiBuild por lo cual ejecutamos desde terminal.

$cd ..

$qibuild config --wizard

Se deben elegir las opciones Unix Makefiles y Qt Creator (en caso de que se solicite la dirección

donde se encuentra instalado Qt Creator proporcionarla).

33

qiBuild toolchain y preparación del espacio de trabajo

Ahora crearemos un toolchain para compilar desde C++.

$qitoolchain create naoqi ~/nao/devtools/naoqi-sdk/toolchain.xml (siendo naoqi-sdk la

carpeta donde se extrajo y naoqi el nombre que se le dara al toolchain)

Desde la terminal vamos hacia la carpeta workspace y la configuramos como un espacio de

trabajo.

$cd; cd ~/nao/devtools/workspace

$qibuild init

El ultimo comando crear una carpeta llamada “.qi” la cual se encuentra oculta por el sistema

para verla presionamos Ctrl+H en el directorio workspace.

III. Creación del primer proyecto

Desde la terminar y en el directorio de workspace ejecutar:

$qibuild create project (siendo project el nombre del proyecto)

$cd project

Ahora configuramos y compilamos el proyecto.

$qibuild configure -c naoqi

$qibuild make -c naoqi

Si durante estos 2 últimos comandos no se encontró ningún error “Felicitaciones ahora puedes

desarrollar aplicaciones para el robot nao usando C++ desde Ubuntu Linux”. En caso de algún

error favor de verificar los pasos otra vez. Como información adicional se puede consultar

información el manual de referencias de Aldebaran Robotics en la página oficial.

INTERFAZ GRÁFICA PARA CONTROLAR ROBOT NAO

Se realizó una interfaz gráfica para el control del robot nao la cual está programada en C++ y

usa las librerías Qt del entorno de desarrollo integrado Qt Creator. A continuación presentamos

la interfaz gráfica:

34

Ilustración 26 Interfaz gráfica.

La interfaz hace uso de las librerías Qt para generar un archivo con extensión .xml el cual se

interpreta por el código C++ y se usa para desplegar la misma de forma gráfica y sencilla a la

vista.

La interfaz gráfica se creo con el objetivo de facilitar el manejo del robot Nao mediante el uso

de las librerías de Aldebaran C++ SDK las cuales contienen diferentes módulos que se

encuentras ubicados dentro de una súper clase a la cual llamamos Alproxy.

Haciendo uso de estos módulos se puede entablar comunicación directa por medio de la red Wi-

Fi y controlar el robot mediante la interfaz gráfica creada.

En primer lugar se utilizó Qt Creator para crear una interfaz tanto visiblemente agradable

como sencilla en uso. A continuación se presenta el entorno de desarrollo integrado Qt Creator.

Ilustración 27 Entorno de desarrollo.

35

Una vez creada la interfaz se continuó con el desarrollo de los diversos eventos (ejemplo.

Presión botón, movimiento slider, accionamiento de radio buttom, etc.) Los cuales controlaran

el comportamiento de la interfaz al momento de controlar el robot Nao. Después se tomaron los

archivos creados por la interfaz y se agregaron a un proyecto nuevo creado por el compilador

qiBuild el cual es absolutamente necesario para utilizar los módulos de programación del robot

Nao. Debido a la naturaleza del compilador qiBuild se usó el editor de texto y código Sublime

Text 3 para incluir los módulos de la librería Aldebaran SDK C++ para darle el comportamiento

que tendría determinado componente de la interfaz. A continuación se muestra un fragmento de

la programación de los módulos del robot Nao desde Sublime Text 3.

USANDO CHOREGRAPHE.

Aldebarán la empresa desarrolladora de los robot Nao, crean un programa de su propio diseño

y desarrollo llamado choregraphe, es el software de programación que permite al usuario del

robot crear movimientos de edición y comportamientos interactivos con mucha facilidad. Su

intuitiva interfaz gráfica, la biblioteca de comportamientos estándar y funciones de

programación avanzadas nos introdujeron al robot Nao siendo unos inexpertos en la

manipulación de dicho robot.

Ilustración 28 Módulos.

36

.

Ilustración 29 Interfaz choregraphe.

Aunque el programa choregraphe es muy útil se necesitaba aprender a programar a Nao con

otros software que son más flexibles pues te permite cambiar la velocidad de acción de Nao y

hacer secuencias mucho más complejas, pero el programa choregraphe no deja de ser

irrelevante pues por medio del nao virtual que aparece al lado derecho de la página, se puede

saber los ángulos de cada parte del cuerpo solo con seleccionar la pieza, y es útil a la hora hacer

matrices de movimiento.

Ilustración 30 Movimiento.

SIMULACIÓN EN WEBOTS.

Webots es un entorno de desarrollo utilizado para modelar, programar y simular robots

móviles. Con Webots el usuario puede diseñar configuraciones robóticos complejos, con uno o

varios, similares o diferentes robots, en un entorno compartido. Las propiedades de cada objeto,

como la forma, el color, la textura, la masa, fricción, etc., son elegidos por el usuario. Una amplia

variedad de sensores y actuadores simulados está disponible para equipar cada robot. Los

controladores de robots se pueden programar con el IDE incorporado o con entornos de

37

desarrollo tercera parte. El comportamiento del robot se puede probar en mundos físicamente

realistas.

I. Webots para Nao.

En la estancia se realizan pruebas con los códigos de programación del robot Nao, pero antes de

probarlos con el robot Nao físico, se cuenta con un avanzado software de simulación en vivo

llamada webots, este es capaz correr el código para mover al robot Nao en un mundo virtual se

puede ver el comportamiento del robot. Webots aunque sirve para simulación de robots el

webots que se utilizó solo es compatible para Nao.

Ilustración 31 Webots for NAO.

II. Conexión choregraphe - Webots.

El webots se puede conectar directamente a choregraphe y se puede ver que ambos robots hacen

la misma rutina.

38

Ilustración 32 Rutina en choregraphe.

Ilustración 33 Rutina en Webots.

En el software Webots es posible crear un propio mundo virtual donde se pueden colocar

obstáculos y ciertos objetos para tratar de que la simulación se lo más cercano posible a la

realidad y así al momento de ejecutar un programa en el robot NAO físico la probabilidad de

que concuerde sea demasiada alta.

39

Ilustración 34 Colocando objetos.

40

CONCLUSIONES.

Para concluir con la investigación acerca del robot NAO y de la programación de ciertas

aplicaciones, uno de los aspectos que caben resaltar es que es importante tener un poco de lógica

y también un poco de conocimiento básico, porque aunque sea un lenguaje desconocido para

algunos, si se tiene conocimientos de lenguajes de programación similares, se pueden consultar

ejemplos en internet y poder entenderlos un poco para así poder crear uno propio. Algunos

problemas se presentaron al correr ciertos programas o al realizar ciertas funciones ya que se

requirieron algunas librerías extras. En lo que concierne al desarrollo de aplicaciones para el

robot nao desde el sistema operativo basado en la distribución Linux Ubuntu, se llegó a la

conclusión de que aperas de que se puede desarrollar aplicaciones desde los sistemas operativos

más usados Windows y Mac OS trabajar desde las las distribuciones Linux brinda más soporte

y versatilidad cuando se trabaja con el robot humanoide Nao es por esta razón que a pesar de

carecer de conocimientos previos sobre el uso de Linux se optó por continuar con el desarrollo

de la interfaz gráfica desde este. Además gracias a que los sistemas operativos basados en Linux

trabajan bajo las licencias publicas generales de GNU (GNU GPL por sus siglas en inglés) las

cuales proveen software de manera gratuita se pueden desarrollar diversas aplicaciones para el

robot nao ya sean escritas en código Python o C++ siendo este último uno de los más usados

debido a que por lo regular todos los lenguajes de alto nivel se encuentran basados en este.

Haciendo uso de las librerías de Aldebaran se logró profundizar en el los conocimientos de

programación así como adquisición de conocimiento del editor de texto y código denominado

Sublime Text 3 y sus diversas aplicaciones para generar diferentes soluciones, también se pudo

apreciar la versátil aplicación del entorno de desarrollo integrado Qt Creator para la creación de

interfaces gráficas tanto agradables a la vista como confiables y eficaz.

Por ultimo alguna de las ventajas con las que se cuenta es que no es necesario probar todas las

aplicaciones directo en el robot , ya que se cuenta con el software webots el cual permite

visualizar en tiempo real el programa en ejecución y así evitar ocasionar algún daño físico al

robot.

41

BIBLIOGRAFIAS

Python api. Aldebaran (2013). Recuperado en Noviembre de 2014 de:

http://doc.aldebaran.com/1-14/ref/python-api.html

Python. Aldebaran (2013). Recuperado en Noviembre de 2014 de: http://doc.aldebaran.com/1-

14/dev/python/index.html

Clases Alproxy. Aldebaran (2013). Recuperado en Noviembre de 2014 de:

http://doc.aldebaran.com/1-14/ref/libalcommon/classAL_1_1ALProxy.html#details

Programas simultaneos. Web del programador (2014). Recuperado en Noviembre de 2014 de:

http://www.lawebdelprogramador.com/foros/Python/1336195-

Como_ejecutar_programa_.py_dentro_de_otro_programa_.py_y_saber_cuando_termino.html

Funciones de movimientos. UCR (2014). Recuperado en Diciembre de 2014 de:

http://eie.ucr.ac.cr/uploads/file/proybach/pb0856t.pdf

Tutoriales para NAO. (2013). Recuperado en Diciembre de 2014 de:

http://www.cs.utexas.edu/~pstone/Courses/393Rfall13/resources/tutorial.html

Graficas. Librerias Matplotlib (2013). Recuperado en Diciembre de 2014 de:

http://grokbase.com/t/python/python-es/1389p48am8/ajuste-de-valores-en-el-eje-x-matplotlib