Difference between revisions of "ElenaO-RV-proy1"
(→Desarrollo de un Portero) |
|||
| Line 259: | Line 259: | ||
== Desarrollo de un Portero == | == Desarrollo de un Portero == | ||
| + | |||
| + | La máquina de estados anterior, es una posible máquina de estados para un portero, pero no la que vamos a utilizar. Utilizaremos la siguiente: | ||
| + | |||
| + | [[Imagen:goalkeeper.jpg]] | ||
Revision as of 21:52, 8 February 2011
- Project Name:
- Authors: Elena Ortega Fernández
- Email Addres: elenaortega25@gmail.com
- Academic Year: 2010-2011
- Degree: undergraduate
- Tags: webots, naoqi, jmanager, player
- Technology: c, c++, naoqi, BICA
- State: Developing
Contents
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 vez 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 Modulos
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" );
Módulo 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).
ARQUITECTURA BICA
La arquitectura BICA (Behaviour Based Architecture For Robot Applications) se basa en la activación de los componentes mediante un árbol. Para ver cómo trabajar con ella, vamos a diseñar con Bica una posible 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 o las funciones auxiliares que hayamos creado nosotros
//BUILDER COMMENT. DO NOT REMOVE. auxcode begin //BUILDER COMMENT. DO NOT REMOVE. auxcode end
Pero cuidado, que la función step() la sobreescribe entera.
Desarrollo de un Portero
La máquina de estados anterior, es una posible máquina de estados para un portero, pero no la que vamos a utilizar. Utilizaremos la siguiente:
