Revision as of 12:14, 21 December 2010

INTRODUCCIÓN AL ENTORNO NAOQI

HOLA MUNDO (Versión 2.6)

El entorno de NaoQi es un framework distribuido y consta de 2 entidades principales: Módulos y proxies. Los módulos son objetos, que normalmente residirán en el robot y tienen asociados métodos que implementan determinada funcionalidad. De serie tenemos el módulo ALMotion que implementa multitud de movimientos en el robot, el módulo ALMemory que permite leer los sensores, el módulo ALTextToSpeech que nos permite usar el sintetizador de voz, etc.

Un módulo siempre forma parte de un broker o servidor que escucha en una determinada dirección IP y puerto (normalmente en la dirección IP del robot y puerto 9559).

La segunda entidad es el proxy. Un proxy es un cliente que se conecta a un determinado broker y ejecuta un método de uno de sus módulos. Los proxies o clientes normalmente se encuentran fuera del robot. Todos los ejemplos que hemos utilizado para probar el robot (dentro de la carpeta $AL_DIR/modules/src/examples/ son proxies, puesto que son clientes que se conectan al main broker o broker principal del NAO y ejecutan métodos de algunos de sus módulos (en concreto del módulo ALMotion).

También es habitual que alguno de los métodos que implementa un módulo haga de proxy. Es decir, que solicite la ejecución de un método de otro módulo.

En el directorio ruta/aldebaran-sdk-v1.6.0-linux/modules/src/examples/ tenemos el ejemplo del hola mundo.

Antes de probar el ejemplo tenemos que establecer las variables de entorno de NaoQi

               $ export AL_DIR=<ruta>/aldebaran-sdk-v1.6.0-linux
               $ export LD_LIBRARY_PATH=$AL_DIR/lib
               $ export PATH=$AL_DIR/bin:$PATH
               $ export PYTHONHOME=$AL_DIR
               $ export PYTHONPATH=.:$AL_DIR/lib:$PYTHONPATH

Una veq que las tengamos, crearemos el build del proyecto

               $ mkdir build
               $ cd build
               $ cmake -DCMAKE_TOOLCHAIN_FILE=$AL_DIR/ctc/toolchain-geode.cmake ..
               $ ccmake . (opcional)
               $ make

Copia la biblioteca dinámica al robot. En concreto deberás copiarla al directorio /home/nao/naoqi/lib/naoqi

               $ cd $AL_DIR/modules/src/examples/build/src/
               $ scp libtestbroker.so root@192.168.1.111:/home/nao/naoqi/lib/naoqi

Nuestro objetivo es que el robot, en el momento de arrancar, cargue nuestro módulo de manera automática de la misma manera que carga los módulos de Aldebarán. Para ello tendremos que editar el fichero /home/nao/naoqi/preferences/autoload.ini y añadir la siguiente línea:

               allhelloworld

Para ello deberemos conectarnos al robot

               ssh -l nao dir_ip

Ahora deberás reiniciar naoqi

               nao restart

Ahora, solo queda ejecutar el proxy

               python test_alhelloword.py

Nota: test_allhelloword.py se encuentra en $AL_DIR/modules/src/examples. Y debemos modificar la dirección IP, por la de nuestro nao.

CREACIÓN DE MÓDULOS

Instalación de Paquetes

Primero tenemos que instalar los módulos de Python: Cheetah y PyQt4. Para ello debemos instalar los paquetes:

                libqtgui4
                python qt4
                libgnuradio-qtgui0
                libgnuradio-qtgui0-dev(**)
                python-cheetah
                python-mako
        
                cmake-curses-gui

Una vez que tengamos los paquetes instalados, si estan establecidas las variables de entorno de NaoQi, va a haber conflicto entre éstas y las de python. Para solucionar este conflicto deberemos comentar la AL_DIR, y eliminar las de python (PYTHONPATH, PYTHONHOME). Y establecer la PYTHONHOME:

                $ export PYTHONHOME=/usr/bin/python/:/usr/lib/python2.6/:/usr/lib/pymodules/python2.6/:

Ejecución del Generador de Módulos

Vamos al directorio de $AL_DIR/modules/src y desde allí lanzamos el generador

                $ python module_generator.py

Se podría hacer por consola de la siguiente forma

                $ python module_generator.py -p "nombre_proyecto" -a "autor" modulo1 modulo2...

Nota: Una vez que esté el módulo creado, habría que volver a cambiarlas para compilar.

HOLA MUNDO (Versión 2.6 con los módulos ALTextToSpeech y ALLogger)

Creación de los módulos

El módulo ALTextToSpeech que nos permite usar el sintetizador de voz, mientras que el ALLogger nos permite crear mensajes Log.

Vamos a crear un módulo propio que encapsulará la funcionalidad del método Say en nuestro propio método. De esta manera crearemos tanto un módulo como un proxy.

Para la creación del módulo nos vamos a ayudar de la herramienta modulegenerator, que ya hemos visto, con la que generaremos un proyecto con un único módulo.

En el archivo modulo.cpp tenemos que definir la directiva ROBOT, de la siguiente forma:

                #define ROBOT

Además, al constructor le tenemos que añadir la descripción de nuestro módulo:

                functionName( "helloWorld", "testModule",  "Say the message Hello World" );
                BIND_METHOD (modulo::helloWorld);

Una vez que tengamos ésto, añadimos la función init, que va a ser la encargada de crear tanto el proxy del ALLogger como el de ALTextToSpeech

                void modulo::init() {
                  // Create a proxy to the logger module.
                  // If this fails, we throw an exception and the module will not be registered.
                  try {    
                	pLog = getParentBroker()->getLoggerProxy();
                  } catch (const AL::ALError& e) {
                    throw AL::ALError(getName(), "module()", "Fail to create a proxy to ALLogger "
                      "module. Msg " + e.toString() + "\nModule will abort.");
                  }
                #ifdef ROBOT
                  try {
                	this->pAudio = AL::ALPtr<AL::ALTextToSpeechProxy>(new AL::ALTextToSpeechProxy(getParentBroker()));
                  } catch (const AL::ALError& e) {
                    throw AL::ALError(getName(), "Module()", "Could not create a proxy to ALTextToSpeechProxy " +
                      e.toString());
                  }
                #endif 
                this->pLog->info(getName(),"Todo ha salido OK *********************************");
                }

Y por último (en el archivo modulo.cpp) añadimos nuestra función

                void modulo::helloWorld(){
                	std::string pmsg="Hello World";
                	#ifdef ROBOT
                		this->pAudio->callVoid("say", pmsg);
                	#endif	
                	this->pLog->info(getName(),"Hello World");
                }

Ahora, nos vamos al archivo de cabecera (modulo.h) e incluimos en él las dos nuevas funciones dentro del constructor:

                void helloWorld();
                void init();

Definimos e inicializamos como privados dos variables, una del tipo ALTextToSpeech y otra del tipo ALLogger, que van a realizar la función de proxy

                private:
                  AL::ALPtr<AL::ALTextToSpeechProxy> pAudio;
                  AL::ALPtr<AL::ALLoggerProxy> pLog;

Compilación de los modulos y carga en el Nao

La compilación y carga del módulo ya se ha explicado anteriormente y va a ser de la misma forma. Pero hay que asegurarse de que en el autoload.ini estén las bibliotecas necesarias para su ejecución, estas son:

                audiodevice
                audioout

que tienen que ir en la etiqueta [core]

Además, en [extra] no tenemos que olvidarnos de añadir nuestro módulo.

Creación de un Proxy Genérico

También podemos utilizar los módulos de forma genérica, en vez de definir un proxy de un tipo concreto de módulo, lo definimos como un proxy genérico. Es decir, en lugar de definir un proxy de tipo ALTextToSpeech

                AL::ALPtr<AL::ALTextToSpeechProxy> pAudio;

lo definimos como ALProxy

                AL::ALPtr<AL::ALProxy> pAudio;

Por lo tanto, a la hora de crear el proxy, en vez de inicializarlo así

                this->pAudio = AL::ALPtr<AL::ALTextToSpeechProxy>(new AL::ALTextToSpeechProxy(getParentBroker()));

Lo inicializaremos de la siguiente forma

                pAudio = getParentBroker()->getProxy( "ALTextToSpeech" );

MODULO ALMOTION

ALMotion es el módulo que proporciona a Nao los métodos necesarios para que éste se mueva.

Como con cualquier otro módulo, lo primero que tenemos que hacer a la hora de trabajar con él es crear un proxy de ALMotion.

                pMotion = getParentBroker()->getMotionProxy();

Una vez creado el proxy, podemos mandar cualquier comando a los motores de nao, pero éstos no se moveran, porque inicialmente la potencia en ellos es 0 (Stiffness). Por lo tanto, el siguiente paso necesario a la hora de trabajar con este módulo es establecer stiffness en el motor al que queramos dar potencia. Por ejemplo, si lo que queremos es que Nao ande, deberemos establecer Stiffness en ambas piernas

                pMotion->setStiffnesses ("RLeg",1.0);
                pMotion->setStiffnesses ("LLeg",1.0);

Y a continuación ya podríamos mandarle el comando para andar

                pMotion->walkTo(0.2, 0.2, 1.5709)

El primer parámetro que le pasamos es x (distancia a lo largo del eje x en metros), el segundo y (distancia a lo largo del eje y en metros), y el tercero un ángulo (rotación sobre el eje z en radianes).

Si en vez de andar, quisiesemos que diese un sólo paso, se utilizaría el comando stepTo (que funciona de forma similar) con la diferencia que con este comando sólo da un paso. Por eso, si queremos que de dos pasos seguidos, deberemos indicarle que espere a que termine uno para empezar el otro con el comando wait, ya que sino, intentará hacerlo a la vez. Por ejemplo, en un movimiento de la cabeza, sería una interpolación de ambos movimientos (si intentamos moverlo de un punto x a un punto y, y de un punto y a un punto z, el resultado será un movimiento del punto x inicial al z final).

CÓMO TRABAJAR CON BICA

Vamos a diseñar con Bica la siguiente máquina de estados de un portero:

Imagen:GoalKeeper.png Imagen:iconos.png

Antes de empezar a trabajar con VICODE, debemos saber:

   - Los iconos naranjas son para crear o borrar un estado.                                   
   - Los azules pequeños y con línea continua para crear una nueva transición entre estados.                                      
   - Los azules grandes con línea discontinua para crear una dependencia de clases de un estado.
   - Las flechas para unir o borrar las dependencias de los estados.

Además, para unir los estados con transiciones o las dependencias con estados debemos seleccionar la opción y hacer click en el estado de inicio y en el de fin.

Una vez que sepamos esto, ya podemos diseñar la máquina de estados.

Cuando guardamos la máquina de estados (archivo .xml) automáticamente se nos genera dos archivo de c++, uno con el código fuente y otro de cabecera. En el archivo fuente, Bica nos genera las funciones de los estados y de las transiciones, y una función step, para cambiar de un estado a otro. Además de instanciar las clases necesarias en cada estado (de ahí las dependencias de clases que creamos).

Las funciones de las transiciones son funciones booleanas, cuya condición es aquella para pasar de un estado a otro. En nuestro ejemplo la condición de transición del estado inicial al estado SearchingBall es que no se haya visto la pelota, por eso, la función Initial2SearchingBall0 debería quedar así:

   bool GoalKeeper::Initial2SearchingBall0_transition_code(void)
   {
      return !_BallDetector->seen();
   }

Nosotros sólo hemos añadido el return statement.

NOTA IMPORTANTE: Si realizamos algún tipo de modificación desde VICODE se sobreescriben los ficheros .cpp y .h, a excepción del código que esté entre los comentarios de código auxiliar

   //BUILDER COMMENT. DO NOT REMOVE. auxcode begin
   //BUILDER COMMENT. DO NOT REMOVE. auxcode end

Pero cuidado, que la función step() la sobreescribe entera.