AlvaroB-PFC-Drone02

From robotica.unileon.es
Revision as of 19:40, 10 July 2011 by Anonymous (talk) (→‎Parte 3)

Jump to: navigation, search
  • Project Name: Seguimiento de Color para el AR-Drone
  • Authors: Álvaro Botas Muñoz
  • Email Addres: infabm01@estudiantes.unileon.es
  • Academic Year: 2010-2011
  • Degree: PFC
  • Tags:
  • Technology: c, gtk, Api Ar.drone:sdk 1.5
  • State: Developing
  • Source License:
  • Document License:

Parte 1

Configurando la api de ArDrone (sdk 1.5) con el mando de la ps3 en Linux

Obtención del sdk

     tar zxvf archivo.tar.gz

Configuración de los ejemplos para Linux

sdk_demo

Se trata del ejemplo más sencillo, no dispone de interfaz gráfico pero contiene lo suficiente para controlar el ArDrone con un joystick y la creación de tuberías para la recepción de video asi como diferentes hilos Debemos modificar dos archivos para el correcto funcionamiento de nuestro mando de la ps3:

a) En primer lugar :

En el archivo ardrone_testing_tool.c (/’tu directorio’/ARDrone_SDK_1_5_V ersion_20101004/Examples/Linux/sdk_demo/Sources/ardrone_t esting_tool.c) , añadiéndole esta línea para añadir el mando: 

     ardrone_tool_input_add( &ps3pad );

Téngase en cuenta que este archivo es el que contiene el main de la aplicación, aquella que pone en funcionamiento todo.

b) En segundo lugar :

A continuación modificaremos el archivo gamepad.h (/’tu directorio’/ARDrone_SDK_1_5_V ersion_20101004/Examples/Linux/sdk_demo/Sources/UI), donde le asignaremos valores a los botones del mando: 

    #define GAMEPAD_PLAYSTATION3_ID 0x054C0268
        typedef enum
        {
           PS3BTN_SELECT=0,
           PS3BTN_L3=1,
           PS3BTN_R3=2,
           PS3BTN_START=3,
           PS3BTN_UP ARROW=4,
           PS3BTN_RIGHTARROW=5,
           PS3BTN_DOWNARROW=6,
           PS3BTN_LEFTARROW=7,
           PS3BTN_L2=8,
           PS3BTN_R2=9,
           PS3BTN_L1=10,
           PS3BTN_R1=11,
           PS3BTN_TRIANGLE=12,
           PS3BTN_CIRCLE=13,
           PS3BTN_CROSS=14,
           PS3BTN_SQUARE=15,
           PS3BTN_PS3=16,
        }PS3P AD_BUTTONS;

Navigation

Se trata de un ejemplo mas completo, en el que se puede observar un interfaz gráfico, con la inserción de las imágenes del video, entre muchas otras opciones adicionales.

Cómo compilar y ejecutar estos ejemplos

  • En primer lugar vamos a obtener algunas de las librerías necesarias para la compilación y posterios ejecución.
    $sudo apt-get install libsdl-dev libgtk2.0-dev libiw-dev
  • Debemos crear la biblioteca ArDroneLib usando el makefile dado.
    $cd SDK /ARDroneLib/Soft/Build
    $make
  • Compilar el ejemplo sdk_demo
    $cd SDK /Examples/Linux/sdk_demo/Build
    $make
  • Compilar el ejemplo Navigation
    $cd SDK /Examples/Linux/Navigation/Build
    $make

Ejecutar el ejemplo

Tras haber realizado estos pasos, deberíamos de tener 2 ejecutables en : /’tu directorio’/ARDrone_SDK_1_5_V ersion_20101004/Examples/Linux/Build/Release /. Conecta tu mando de la PS3 y ahora serás capaz de hacer volar tu ArDrone.

  • Para el ejemplo sdk_demo:
    ./linux_sdk_demo
  • Para el ejemplo Navigation:
    ./ardrone_navigation

Parte 2

Creación de nuestra propia aplicación: Un tele-operador para el control del ArDrone

Se trata de crear un pequeño interfaz gráfico con las opciones básicas para el manejo del ArDrone, con la visualización del vídeo de la cámara del ArDrone. Está realizada en gtk y como base el ejemplo sdk_demo sobre el cual eliminaremos todo lo que necesitamos y ampliaremos las funciones necesarias.

Primeros pasos con GTK

Gtk es un conjunto de librerías cuya función es la de pintar ventanas Para su utilización debemos tener en cuenta que debemos incluir en nuestro proyecto las siguientes librerías: 

     #include <gtk/gtk.h>

Aquí tenemos un pequeño ejemplo de una ventana muy básica: 

    int main (int argc, char *argv[]){
       GtkWidget *window;
       gtk_init (&argc, &argv);
       window = create_window ();
       gtk_widget_show_all (window);
       gtk_main ();
       return 0;
    }

Podemos observar un pequeño tutorial aquí con algunas de las funciones básicas que nos ofrece gtk: http://www.linuxlots.com/~barreiro/spanish/gtk/tutorial/gtk_tut.es.html

Y la api: http://developer.gnome.org/gtk/2.24/

Se ha desarrollado con la version de GTK 2 ya que en el momento del comienzo del proyecto aun no había salido la version oficial de GTK 3.

Funciones de mi aplicación

Aquí se muestran las funciones que utilizo para la creación del entorno gráfico de la aplicación: 

   void delete_event (GtkWidget *widget, GdkEvent *event, gpointer data) 
   void escribeCuadro (char* data) void cbdespegar (GtkWidget *widget, gpointer data) 
   void cbaterrizar (GtkWidget *widget, gpointer data)
   void cbTurnLeft (GtkWidget *widget, gpointer data) 
   void cbForward (GtkWidget *widget, gpointer data) 
   void cbTurnRight (GtkWidget *widget, gpointer data) 
   void cbLeft (GtkWidget *widget, gpointer data)
   void cbBackward (GtkWidget *widget, gpointer data) 
   void cbRight (GtkWidget *widget, gpointer data) 
   void cbUp (GtkWidget *widget, gpointer data) 
   void cbDown (GtkWidget *widget, gpointer data) 
   void cbcontrol(GtkWidget *widget, gpointer data) 
   void cbShowControl(GtkWidget *widget, gpointer data) 
   void cbSave (GtkWidget *widget, gpointer data)
   void cbSaveStop (GtkWidget *widget, gpointer data) 
   void cbDetails (GtkWidget *widget, gpointer data) 
   void cbReset (GtkWidget *widget, gpointer data) 
   void cbChangCam (GtkWidget *widget, gpointer data) 
   GtkWidget *new_windowControl()
   GtkWidget *new_window () 
   gboolean update_display(gpointer pData) 
   int crea_ventana() GtkWidget *new_zoneVideo() 
   GtkWidget *new_zoneStadistics(GtkWidget *data) 
   GtkWidget *new_zoneButton() 
   GtkWidget *new_TextZone() 
   void create_tags (GtkTextBuffer * buffer)

Comandos que se envían al ArDrone

Aquí se listan los comandos que enviamos al ardrone para la realización de las diferentes funciones o movimientos que deseamos que realice:

a) Despegar 

   ardrone_tool_set_ui_pad_start(1);

b) Aterrizar: 

  ardrone_tool_set_ui_pad_start(1);

c) Mover hacia adelante: 

   ardrone_at_set_progress_cmd(1,0,-0.3,0,0);

d) Mover hacia atrás: 

   ardrone_at_set_progress_cmd(1, 0, 0.3, 0, 0);

e) Mover hacia arriba: 

   ardrone_at_set_progress_cmd(1, 0.3, 0, 0.5, 0);

f) Mover hacia abajo: 

   ardrone_at_set_progress_cmd(1, 0.3, 0, 0.5, 0);

d) Mover hacia la derecha: 

   ardrone_at_set_progress_cmd (1, 0.3, 0, 0,0);

e) Mover hacia la izquierda: 

   ardrone_at_set_progress_cmd (1, -0.3, 0, 0,0);

f) Girar hacia la derecha: 

   ardrone_at_set_progress_cmd(1, 0.3, 0, 0,0);

g) Girar hacia la izquierda: 

   ardrone_at_set_progress_cmd(1, 0, 0, 0, -0.3);

h) Enviar un reset: 

   ardrone_tool_set_ui_pad_select(1);

i) Cambiar la camara que estamos viendo: 

   ardrone_at_zap //Revisar

j) Señal de que el ardrone esta en una superficie horizontal para un vuelo estable: 

   ardrone_at_set_flat_trim

Creación de ficheros de log

En “directorio”/Version1.0/basico/File disponemos de 2 ficheros que se encargan de la gestion de guardar en un fichero de log (en “directorio”/Version1.0/Build/Debug) con el instante y el mensaje de la acción realizada. En el fichero save_file.h se declaran las funciones y en save_file.c se implementan. En la función InsertaDatos se usa la funcion fopen(ruta, “a”) siendo ruta el directorio donde lo guardamos y “a” el mensaje y se encarga de crear un fichero si este no existe o añadir mensajes si ya existia.

Uso de Subversion

Se trata de un sistema de control de versiones que viene a sustituir al antiguo cvs. Alguna de las operaciones realizadas para subir archivos y gestionarlos:

  • Creación de una nueva rama para nuestro proyecto:
   $ svn copy http://robotica.unileon.es/svn/Projects/PFC/ardrone \
   http://robotica.unileon.es/svn/Projects/PFC/ardrone/branches/Version1_albo_08062011 \
   -m "Creating a new branch Version1_albo_08062011."
  • Subida de nuestro proyecto
   $svn import /(YOUR PROJECT DIR)
   http://robotica.unileon.es/svn/Projects/PFC/ardrone/branches/Version1_albo_08062011 -m
   "Version1 import"
  • Descarga de nuestro proyecto
   $svn checkout
   http://robotica.unileon.es/svn/Projects/PFC/ardrone/branches/Version1_albo_08062011
  • Eliminación de un directorio de svn
   $svn delete http://(URL DIRECTORY) -m "DIRECTORY DELETED"

Creación del Makefile para la compilación de nuestro proyecto

Vamos a partir del Makefile que viene por defecto con el ejemplo en el sdk_demo pero modificandolo para nuestro proyecto. Debemos añadir los fuentes de nuestro proyecto de esta forma : 

   GENERIC_BINARIES_COMMON_SOURCE_FILES+=	\ 
   Navdata/navdata.c \
   Ihm/Principal.c \
   Ihm/Principal_o_gtk.c \
   File/save_file.c

Debemos añadir las librerías que necesitemos, en este caso las de gtk de esta manera: 

   GENERIC_LIBS=-lpc_ardrone -lgtk-x11-2.0 -lrt

Parte 3

Instalación OpenCV

Código desde el svn

Para la instalación desde Ubuntu podemos realizarlo de la siguiente forma, desde la línea de comandos: 

   cd ~/<my_working_directory>
   svn co https://code.ros.org/svn/opencv/trunk

Instalación de librerías requeridas y herramientas

  • Compilador C/C++
  • CMake 2.6 o superior
  • (Opcional) svn
  • (Opcional) Python 2.6.x or 2.7.x
  • (Opcional) Intel TBB para permitir el código paralelo en OpenCV.
  • (Opcional) Qt 4.6 o posterior.
  • (Opcional) IPP 5.1 o 6.1 (no 7).
  • (Opcional) Distribución LiveTeX para construir el manual de referencia. actualizado de OpenCV en pdf.
  • (Opcional) El último kit de herramientas CUDA para construir con soporte GPU.

Prerequisitos extra

  • pkg-config.
  • (Opcional) gtk+ 2.x y paquetes relacionados(glib, gthread, etc.).
  • (Opcional) libjpeg, libtiff, libjasper, libpng y zlib, openexr.
  • (Opcional) ffmpeg, libgstreamer, libxine, unicap, libdc1394 2.x.

Construir la librería OpenCv desde el código usando CMake y tu compilador C++

Dirigete al directorio donde descargaste los paquetes del svn de OpenCV, si por ejemplo este fuera ~/projects/opencv podrías realizar las siguientes operaciones: 

   cd ~/projects/opencv # el directorio que contiene el INSTALL, CMakeLists.txt etc.
   mkdir release
   cd release
   cmake -D CMAKE_BUILD_TYPE=RELEASE -D CMAKE_INSTALL_PREFIX=/usr/local -D BUILD_PYTHON_SUPPORT=ON ..

Compilar usando GCC

Una vez realizado el paso previo, debería haberse creado una serie de librerías que previamente no existían junto con un makefile. Procederemos a la instalación mediante estas operaciones: 

   make
   sudo make install

Deberías añadir ~/projects/opencv/lib/[debug/] a /etc/ld.so.conf o a LD_LIBRARY_PATH de esta manera: 

   export LD_LIBRARY_PATH=~/projects/opencv/release/lib:$LD_LIBRARY_PATH
   sudo ldconfig

Compilar archivos C

Debes configurar la variable PKG_CONFIG_PATH: 

   cd /where/you/have/the/source/code
   PKG_CONFIG_PATH=~/projects/opencv/lib/pkgconfig:${PKG_CONFIG_PATH} 
   export PKG_CONFIG_PATH

Puedes comprobar que la variable está correcta de este modo: 

   pkg-config --cflags opencv
   pkg-config --libs opencv

De manera que deberías tener algo como: 

   $ pkg-config --cflags opencv -I~/projects/opencv/include/opencv
   $ pkg-config --libs opencv -L~/projects/opencv/lib -lcxcore -lcv -lhighgui -lcvaux

Después compila de esta forma: 

   gcc `pkg-config --cflags --libs opencv` -o my-opencv-prgm my-opencv-prgm.c

Desarrollo de nuestra aplicación para implementar la visión artificial en el ArDrone

Ayudas

http://www.amazon.com/Learning-OpenCV-Computer-Vision-Library/dp/0596516134 http://opencv.willowgarage.com/wiki/FullOpenCVWiki http://opencv.willowgarage.com/documentation/index.html http://www.cs.iit.edu/~agam/cs512/lect-notes/opencv-intro/index.html http://web.archive.org/web/20060715011915/http://www.cs.bham.ac.uk/resources/courses/robotics/doc/opencvdocs/ref/OpenCVRef_ImageProcessing.htm http://www.softintegration.com/products/thirdparty/opencv/demos/ http://opencv.willowgarage.com/documentation/c/index.html

Añadir librerías al Makefile de nuestra aplicación

Directorio de OpenCV

En primer lugar debemos añadir el directorio donde tenemos instalado opencv para que sepa añadir las librerías correspondientes al compilar: 

   USR_PATH:=$(shell $HOME)/../../usr 
   GENERIC_INCLUDES+=
   $(USR_PATH)/local/include/opencv

Librerías a añadir

En segundo lugar debemos añadir las librerías siguientes: 

   GENERIC_LIBS=-lopencv_core -lopencv_imgproc -lopencv_calib3d -lopencv_video -
   lopencv_features2d -lopencv_ml -lopencv_highgui -lopencv_objdetect -lopencv_contrib -
   lopencv_legacy
Retrieved from "https://robotica.unileon.es/index.php?title=AlvaroB-PFC-Drone02&oldid=699"