Proyecto robot aéreo tele operado por internet

Proyecto final de carrera Desarrollo y control de un vehículo aéreo no tripulado.

Título: Desarrollo y control de un vehículo aéreo no tripulado.

Titulación: Ingeniería Informática Autor: Richard Juan Barberán Director: Pascual Pérez Blasco

[Pick the date]

Índice Introducción ............................................................................................ 4 Antecedentes .......................................................................................... 6 Vehículo aéreo no tripulado (UAV)............................................................................ 6 Definición. .......................................................................................................................6 Aplicaciones. ...................................................................................................................7 Ventajas de los UAV .........................................................................................................8 Desventajas de los UAV....................................................................................................8 Clasificación. ....................................................................................................................9

UAV multi-rotores. ................................................................................................. 10 Definición. ..................................................................................................................... 11 Características. .............................................................................................................. 11 Sistemas comerciales. .................................................................................................... 12 Componentes de un multi-rotor. .................................................................................... 13 Motores y controladores de motor. .................................................................................................. 13 Motor Brushless. ........................................................................................................................... 13 Controlador de motor ................................................................................................................... 15 Servos. ............................................................................................................................................... 16 Alimentación. ..................................................................................................................................... 17

Sistema de control. ........................................................................................................ 19 Micro controlador. ............................................................................................................................. 19 Sensores. ............................................................................................................................................ 19 Sistema de comunicación. ................................................................................................................. 20

Análisis.................................................................................................. 21 Nuestro sistema: UAV Tricoptero. ........................................................................... 21 Dinámica. ...................................................................................................................... 21 Estabilidad y control del aparato. ................................................................................... 23 Hardware ...................................................................................................................... 23 Aduino. .............................................................................................................................................. 24 ARDUIMU FLAT V2. ............................................................................................................................ 25 El micro controlador ATMEGA328. ............................................................................................... 27 Acelerómetro ................................................................................................................................ 28 Giroscopio ..................................................................................................................................... 30 FezPanda II ......................................................................................................................................... 31

Algoritmo DCM. ............................................................................................................. 33 Visión general .................................................................................................................................... 33

Sistemas de referencia....................................................................................................................... 34 Matriz de cosenos directores ............................................................................................................ 36 Re normalización ............................................................................................................................... 37 Ángulos de vuelo ............................................................................................................................... 39 Corrección de deriva .......................................................................................................................... 40

Algoritmo de Control. .................................................................................................... 41 Control PID (Proporcional Integral Derivativo). ................................................................................. 42 Componente Proporcional. ........................................................................................................... 43 Componente Integral. ................................................................................................................... 43 Componente Derivativa. ............................................................................................................... 45 Aplicación del controlador PID en el t-coptero.................................................................................. 45

Comunicación con el UAV: un paso más allá. .................................................................. 46 Funcionalidad del prototipo ........................................................................................... 50

Diseño ................................................................................................... 51 Descripción............................................................................................................. 51 Estructura y soporte. .............................................................................................. 51 Motores y controladores......................................................................................... 57 Unidad de control. .................................................................................................. 60 Obteniendo los ángulos de vuelo.................................................................................... 60 Programación de la IMU .................................................................................................................... 60 Inicializaciones: setup() ................................................................................................................. 62 Implementación del algoritmo DCM: loop() ................................................................................. 63 Conexión e instalación de la IMU en la estructura ............................................................................ 63

Procesamiento y control del aparato .............................................................................. 65 Instalación de la FezPanda II en la estructura.................................................................................... 65 Cableado de los distintos dispositivos a la placa. .............................................................................. 66 Programando la FezPanda II .............................................................................................................. 67 Algoritmo de control ..................................................................................................................... 69

Alimentación. ......................................................................................................... 75

Sistema de comunicación ...................................................................... 77 Descripción............................................................................................................. 77 El servidor. ............................................................................................................. 79 Servidor Http Apache. .................................................................................................... 79 Comunicación basada en servidor de sockets. ................................................................. 79 PHP .................................................................................................................................................... 81 Implementación. ................................................................................................................................ 81 Primera implementación. .............................................................................................................. 82 Segunda Implementación. Utilizando WebSockets. ...................................................................... 83

Panel de control. .................................................................................................... 85

Interfaz de usuario. ........................................................................................................ 85 HTML + CSS + JavaScript .................................................................................................................... 87 Jquery / Jquery UI .............................................................................................................................. 89 AJAX. .................................................................................................................................................. 90 Implementación de la funcionalidad. ................................................................................................ 90

Comunicación desde el aparato. ............................................................................. 91 App android abordo. ...................................................................................................... 91 Conexión entre los sistemas de Comunicación y de Control. ............................................................ 95 Android Debug Bridge (ADB) ............................................................................................................. 96

Conclusión ............................................................................................ 97 Bibliografía ........................................................................................... 98

Introducción.

Los últimos años hemos podido apreciar un incremento considerable en los dispositivos autónomos y los dispositivos controlados a distancia. Desde una aspiradora, capaz de evitar obstáculos y escaleras hasta los más avanzados aviones militares, capaces de llevar a cabo misiones complejas. Todos ellos capaces de realizar ciertas tareas sin necesidad de ser controlados directamente por un humano para facilitar el trabajo de las personas o incluso evitar situaciones peligrosas. Un UAV es un vehículo aéreo no tripulado reutilizable capaz de mantener un nivel de vuelo controlado y sostenido, y propulsado por motor. Existe una amplia variedad de formas, tamaños, configuraciones y características en el diseño de los UAV. Históricamente los UAV eran simplemente aviones pilotados remotamente pero cada vez más se está empleando el control autónomo dentro de los UAV de forma que hay dos grandes variantes: los vehículos controlados desde una ubicación remota, y los que vuelan de forma autónoma sobre la base de planes de vuelo pre programados usando sistemas de control dinámico más complejos, si bien existen multitud de enfoques híbridos.

Figura 1: Ejemplo de UAV de uso militar Americano.

De manera paralela, la creciente mejora y modernización del hardware y de las comunicaciones móviles hace que cualquier dispositivo móvil personal (móviles y smartphones), se convierta en una interesante herramienta con potencia suficiente para realizar tareas que años atrás se creían imposibles. Éste documento trata el desarrollo de un dispositivo aéreo multi-rotor que podrá ser comandado a través de un panel de control utilizando la tecnología 3g móvil. No se pretende construir un UAV totalmente funcional, sino un sistema que sirva de base para futuros proyectos.

El objetivo del proyecto es construir un prototipo de un UAV de muy bajo coste y un sistema de comunicación a través de la web que demuestre las enormes posibilidades actuales que ofrecen las tecnologías que todos tenemos a nuestro alcance. Haciendo uso de un dispositivo android y la nueva tendencia de las aplicaciones web estableceremos una comunicación entre el prototipo y el usuario que aventaja en funcionalidad y capacidad a los típicos sistemas de comunicación por radiofrecuencia.

El desarrollo del proyecto comprende tres partes: Diseño y construcción de la estructura del prototipo, programación de la unidad de control del robot, tanto interna como externa y desarrollo de un sistema de comunicación avanzado por 3g. El proyecto se centrará principalmente en las dos últimas partes.

Durante el presente documento iremos describiendo como se han realizados las diferentes fases en las cuales podemos separar el proyecto. Como el tema principal se centra en la comunicación y control del dispositivo durante el proyecto nos centraremos en éstas partes, describiendo de forma más superficial la construcción de la estructura física del dispositivo. Las fases que iremos superando durante el desarrollo del proyecto las podemos ordenar de la siguiente manera:

1.

2.

3.

4.

Diseño y construcción de la estructura.

Obtención y análisis de la información captada por los sensores.

Diseño de los controladores para la estabilización del prototipo en todos sus ejes.

Control del aparato a través de una aplicación web.

Antecedentes.

Vehículo aéreo no tripulado (UAV).

Definición.

Un vehículo aéreo no tripulado, UAV por siglas en inglés (Unmanned Aerial Vehicle), o sistema aéreo no tripulado, UAS (Unmanned Aerial System), conocido en castellano por sus siglas como VANT, es una aeronave que vuela sin tripulación humana a bordo.

Son usados mayoritariamente en aplicaciones militares. Históricamente los UAVs eran simplemente aviones pilotados remotamente (en inglés: drones), pero cada vez más se está empleando el control autónomo de los UAV. En este sentido se han creado dos variantes: algunos son controlados desde una ubicación remota, y otros vuelan de forma autónoma sobre la base de planes de vuelo pre programados usando sistemas

más complejos de automatización dinámica. Si bien es cierto que en el dispositivo que hemos armado no hemos podido definir cualidades autónomas por falta de tiempo, éste servirá como base para un completo UAV pues tanto el hardware, como el sistema de comunicación 3g son lo suficientemente potentes para aplicaciones autónomas básicas.

El UAV más antiguo fue desarrollado después de la primera guerra mundial, y se emplearon durante la segunda guerra mundial para entrenar a los operarios de los cañones antiaéreos. Sin embargo, no es hasta poco más que a finales del siglo XX cuando operan los UAV mediante radio control con todas las características de autonomía. Los UAV han demostrado sobradamente en diferentes escenarios y, especialmente en la Guerra del Golfo y en la Guerra de Bosnia, el gran potencial que tienen.

Aplicaciones.

Actualmente los UAV no se limitan al uso militar sino que son cada vez más las áreas donde estos dispositivos están cobrando importancia en el mercado civil. Si bien es cierto que para aplicaciones militares la mayor parte de los UAV existentes son del tipo aeroplano, para aplicaciones civiles, la maniobrabilidad y la capacidad de vuelo estacionario de los helicópteros y multi-rotores han hecho que éstos sean el tipo de aeronave más frecuente para uso civil.

La tabla 2 recoge las aplicaciones más extendidas actualmente de los UAV. En muchas de éstas aplicaciones la distancia entre el vehículo y la estación base varia entre decenas y cientos de metros llegando incluso a varios kilómetros. Además es frecuente que en algunos casos se requiera vuelos a baja velocidad o incluso vuelo estacionario, lo que justifica el uso preferente de los helicópteros y sistemas multi-rotor.

Aplicación Inspección infraestructuras Inspección de obra civil Vigilancia de fronteras Supervisión de Tráfico Patrulla marítima Filmografía

Ejemplo de Líneas eléctricas Oleoductos y Gaseoductos Puentes, viaductos, presas Inmigración ilegal Contrabando Inmigración ilegal Contrabando Cine Reportaje fotográfico

Aeronave más frecuente Helicóptero

Helicóptero Aeroplano Helicóptero Aeroplano Helicóptero Aeroplano

Reconocimiento y toma de Huracanes datos en desastres naturales Riadas Volcanes Levantamiento de mapas Topografía Climatología Toma de muestras y monitorización de partículas en Aerosol Monitorización de contaminación atmosférica Agricultura Aplicación de fumigantes Análisis del estrés hídrico Agricultura de precisión Intervención en desastres no Radiactivos naturales Vertidos contaminantes Incendios forestales Enlace de comunicaciones Localización de recursos Pesca naturales Minería Transporte de paquetería Búsqueda y rescate Naufragios Accidentes en montaña o zonas de difícil acceso Tabla 2: Aplicaciones civiles de los UAV.

Helicóptero Aeroplano

Helicóptero Aeroplano Dirigible Helicóptero

Helicóptero Aeroplano Helicóptero Aeroplano Helicóptero Aeroplano Aeroplano Helicóptero

Ventajas de los UAV No es de extrañar que éstos sistemas robóticos tengan numerables ventajas, ya que a menudo escuchamos o leemos lo cuantiosas que son las inversiones realizadas en estos campos. Entre tantas ventajas podemos destacar que los UAV ofrecen la posibilidad de uso en áreas de riesgo o difícil acceso y no requieren la actuación de pilotos en las misiones llevadas a cabo por los UAV. Éste aspecto es muy importante pues, que un vehículo sea tripulado de manera remota o autónoma es una manera indiscutible de no poner en peligro vidas humanas.

Desventajas de los UAV Las desventajas de un UAV las podríamos clasificar de la siguiente manera: Técnicas, Éticas y Económicas.

Técnicas.







Intrusiones no permitidas (hackeos) en el sistema de comunicación entre la estación de control y el propio UAV para hacerse con el control del dispositivo o para el robo de información.

Tiempos de retardo que se producen entre la emisión de instrucciones y la recepción de éstas, que pueden ser un error técnico fatal y producir accidentes terribles.

Influencia en el correcto funcionamiento del sistema por los fenómenos físicos.

Éticas.  

En el caso de UAV militares, la posibilidad de que la inteligencia artificial pudiera crear por si misma objetivos de ataque.

Su comercialización no controlada, pudiendo ser adquiridos por personas o grupos de dudosa ética.

Económicas. 

El alto coste de su adquisición y mantenimiento dificulta enormemente su uso civil.

Clasificación.

A la hora de establecer una clasificación de los UAV es posible atender a diferentes criterios. Tal vez el más simple sea el que se basa en el tipo de aeronave. De acuerdo a éste pueden distinguirse a aquellas de despegue vertical, de las que no lo son, entando dentro de las primeras las de ala rotativa o hélice (helicóptero y multi-rotores entre otros), los de ala flexible y los auto-sustentados (dirigibles y globos). Dentro de los de despegue no vertical, se encuentran los de ala fija (aeroplanos). Veamos unos ejemplos de las aeronaves más comunes utilizadas en los UAV.

Figura 2: Aeroplano autónomo Predator del ejército americano.

Figura 3: Dirigible autónomo.

Figura 4: Helicóptero autónomo.

Figura 5: Multi-rotor policial de la empresa Dragonflyer.

Las aplicaciones para las que son destinadas las aeronaves varían mucho y dependen de sus prestaciones. Aunque podríamos extendernos en la descripción de las capacidades de vuelo de los UAV y exponer cómo se clasifican atendiendo a éstas características, no vamos a entrar en demasiados detalles por no extender demasiado el documento. La siguiente tabla recoge algunas características de las principales aeronaves utilizadas para UAV.

Característica

Helicóptero s vuelo ***

Aeroplano s

Dirigibles Multirotores **** ***

Capacidad de estacionario Velocidad de desplazamiento *** **** * Maniobrabilidad *** * * Autonomía de vuelo ** *** **** Resistencia a perturbaciones ** **** * externas (viento) Auto estabilidad * *** **** Capacidad de vuelos verticales **** * ** Capacidad de carga *** **** * Capacidad de vuelo en ** * *** interiores Techo de vuelo ** **** *** Tabla 1. Características de los principales tipos de aeronaves para UAV.

UAV multi-rotores.

** **** * ** ** **** ** **** *

Definición.

Una aeronave multi-rotor es un dispositivo que se eleva y desplaza por la fuerza de elevación de más de un motor. Los sistemas más comunes son los cruadricóptero (quadcopter en inglés) y los tricopteros, los que se caracterizan por 4 y 3 motores respectivamente, aunque existen muchas más configuraciones aunque algo menos comunes, de 6, 8, 16 motores, etc.

Figura 6: Multi-rotor de 3 motores o bien tricoptero en configuración T.

Características.

Los sistemas multi-rotores son por lo general aeronaves de pequeño tamaño, clasificadas según su tamaño como aeronaves de menos de 25 kg.

La característica principal que define cualquier sistema multi-rotor es la gran maniobrabilidad de vuelo que tienen. El poder desplazarse tan libremente, hace estos UAV idóneos para tareas de difícil acceso o vuelos en entornos interiores.

Otras de las cualidades de los multi-rotores son la capacidad de vuelo vertical e incluso el vuelo estacionario, sólo realizable en unas pocas aeronaves como helicópteros mayoritariamente.

No todo son ventajas frente a otros sistemas, pues un sistema multi-rotor precisa de un software de control más complejo para la estabilización del aparato en el aire, pues hay que estabilizar de manera independiente el aparato en todos sus ejes de libertad.

Si tuviéramos que numerar otra desventaja de éstos UAV’s, podríamos decir que la autonomía de vuelo es un aspecto a tener en cuenta cuando se piensa en elegir un multi-rotor para una determinada aplicación, pues a autonomía de vuelo de estas aeronaves en el presente es muy limitada. Esto es debido al estado actual de los sistemas de acumulación de energía (baterías), que si bien es cierto que está en continua mejora todavía tienen que mejorar en la relación capacidad (mAh)/peso.

Sistemas comerciales.

De entre varias empresas que se dedican a la venta y distribución de pequeñas aeronaves multi-rotores podríamos destacar Draganfly. Ésta empresa cuenta en su catálogo con varios modelos de UAV multi-rotores que van desde los 4 hasta los 8 motores montados en diferentes configuraciones.

Figura 7: Modelo comercial UAV multi-rotor Draganflyer X8 de la empresa Draganfly.

Los Draganflyer, nombre por el que se conocen sus UAV, con un peso menor a 2kg en todos sus modelos se alimentan con baterías de polímero de litio y se controlan mediante una emisora que la misma empresa proporciona. Ésta emisora permite el control y monitorización de la telemetría del aparato por radiofrecuencia, con un alcance de unos 200 metros en línea de visión.

El uso que se da a los draganflyer es variado, por ejemplo, se utilizan en el entorno educativo-investigación, pues es conocido que el MIT (Massachusetts Institute of

Technology) ha utilizado varios de éstos modelos en algunos de sus proyectos. En el sector de la fotografía también tienen un pequeño mercado estos aparatos pues Draganfly puede suministrar junto con el UAV una plataforma giro-estabilizada para montar una cámara sobre el aparato, utilidad que también lo hace válido para usos policiales de vigilancia y control de situaciones.

Por ejemplo, citemos las características más relevantes del Draganflyer X8.

-

Capacidad de mantener una posición dada asistido por GPS. Estructura resistente y ligera de fibra de carbono.

Información GPS mostrada: Latitud, Longitud, Altitud, error de posición, etc.

Emisora con pantalla para monitorizar datos de vuelo en tiempo real.

Diseño modular. Facilita el cambio de piezas en caso de accidente.

Sistema de estabilidad compuesto por 11 sensores: o 3 gyros. o 3 acelerometros. o 3 magnómetros. o 1 sensor barométrico. o 1 receptor GPS.

Componentes de un multi-rotor.

Motores y controladores de motor.

Los motores más utilizados en robótica son los motores DC y los motores brushless, aunque los primeros ya están quedando relegados a usos en robótica a pequeña escala por las características superiores de los motores brushless. Los motores Brushless son los más utilizados en los sistemas multi-rotores debido a la mayor potencia a igualdad de peso y a un mejor aprovechamiento de las baterías.

Motor Brushless.

Motores Brushless o motores sin escobillas son los motores que más se están usando en los proyectos robóticos en la actualidad. La causa de esto es que son muy superiores a los conocidos motores DC en cuanto a la relación potencia/peso y son mucho más eficientes, siendo mayor la cantidad de energía eléctrica transformada en energía mecánica.

Figura 8: Detalle de un motor brushless.

Los motores brushless, a diferencia de los motores DC carecen de colectores y escobillas, eliminando la fricción y aumentando el rendimiento.

Otra gran diferencia entre los motores brushless y los motores DC es que los motores brushless funcionan en corriente alterna, alimentándose con una señal trifásica. Esto hace sin embargo, que el control se complique necesitando un circuito de control para hacer funcionar un motor brushless.

Ventajas de los motores brushless frente a los motores DC:         

Mayor eficiencia (menos perdida por calor) Mayor rendimiento (mayor duración de las baterías para la misma potencia) Menor peso para la misma potencia Requieren menos mantenimiento al no tener escobillas Relación velocidad/par motor es casi una constante Mayor potencia para el mismo tamaño Mejor disipación de calor Rango de velocidad elevado al no tener limitación mecánica.

Menor ruido electrónico (menos interferencias en otros circuitos)

Desventajas frente a los motores DC:   

Mayor costo de construcción El control es mediante un circuito caro y complejo Siempre hace falta un control electrónico para que funcione, que a veces duplica el costo

Controlador de motor

Como ya se ha dicho, se han elegido motores sin escobillas para el proyecto, y como éstos se alimentan con una señal trifásica necesitamos unos instrumentos denominados ESC (electronic speed control) para controlar los motores. Un ESC es un circuito electrónico que tiene como objetivo variar la velocidad de los motores. Para ello transforman la corriente continua de las baterías o una fuente de alimentación en una tensión alterna trifásica y alimentan a los bobinados del motor en cierta secuencia dependiendo de la posición del rotor. Éste es el aspecto que tienen:

Figura 9: Detalle de un Controlador de motor ESC. Para el control del ESC se utiliza una señal modulada por ancho de pulso o PWM, que se puede mandar desde cualquier micro controlador o emisora radio control.

Dependiendo de la longitud del pulso PWM (usualmente entre 1 y 2 ms) variara la potencia de salida del controlador, obteniendo más o menos velocidad por parte del motor.

Figura 11: Detalle de diferentes señales PWM que resultan en diferentes tensiones promedio.

La señal PWM se utiliza como técnica para controlar circuitos analógicos. El periodo y la frecuencia del tren de pulsos pueden determinar la potencia entregada a dicho circuito. Si, por ejemplo, tenemos un voltaje de 9 V y lo modulamos con un ciclo de trabajo (duty cycle) del 10%, obtenemos 0.9 V de media. Para entenderlo mejor, realmente estamos alimentando el motor y apagándolo en períodos de tiempo del orden de milisegundos. Gracias a la inercia del propio motor estos cambios provocan que se mueva a una velocidad constante. Así pues, cuanto mayor sea el ancho del pulso, mayor velocidad obtendremos.

Servos.

Dependiendo el sistema multi-rotor diseñado para el control del aparato se puede precisar que uno o varios de sus motores sea capaz de cambiar el ángulo en el que ejercen la fuerza de elevación. Para esto es necesario el uso de un servo o servomotor.

Figura 11: Detalle de un servomotor.

Un servo es un dispositivo actuador que tiene la capacidad de ubicarse en cualquier posición dentro de su rango de operación, y de mantenerse estable en dicha posición.

Está formado por un motor de corriente continua, una caja reductora y un circuito de control, y su margen de funcionamiento generalmente es de menos de una vuelta completa.

Dependiendo del modelo del servo, la tensión de alimentación puede estar comprendida entre los 4 y 8 voltios. El control de un servo se reduce a indicar su posición mediante una señal cuadrada de voltaje: el ángulo de ubicación del motor depende de la duración del nivel alto de la señal.

Cada servo, dependiendo de la marca y modelo utilizado, tiene sus propios márgenes de operación. Por ejemplo, para algunos servos los valores de tiempo de la señal en alto están entre 1 y 2 ms, que posicionan al motor en ambos extremos de giro (0° y 180°, respectivamente). Los valores de tiempo de alto para ubicar el motor en otras posiciones se hallan mediante una relación completamente lineal: el valor 1,5 ms indica la posición central, y otros valores de duración del pulso dejarían al motor en la posición proporcional a dicha duración.

Alimentación.

La alimentación del sistema multi-rotor es un punto clave del que dependen directamente factores decisivos como la potencia y la autonomía de vuelo del aparato.

Obviamente no se puede utilizar un suministro de corriente por cableado a un sistema aéreo por lo que se hace necesario el uso de acumuladores o baterías en estos sistemas.

Actualmente hay diversos tipos de baterías pero las más conocidos son: Ni-Cd, Ni-MH, Li-ion, Li-Po . A continuación presentamos una tabla comparativa de los principales tipos de baterías actuales: Tipo

Energia/Peso

Tensión

Duración

Tiempo

de Auto-descarga

por celda (V) 1.25 V 1.25 V 3.16 V

Ni-Cd Ni-MH Li-ion

(NĂşm. recargas) 500 1000 4000

carga

por mes (% del total) 30% 20% 25%

48-80 Wh/kg 10-14h 60-120 Wh/kg 2-4h 110-160 2-4h Wh/kg Li-Po 100-130 3.7 V 5000 1-1,5h 10% Wh/kg Tabla 2: CaracterĂ­sticas de los diferentes tipos de baterĂ­as actuales.

Para un sistema multi-rotor los aspectos a considerar en la elección de una batería es la capacidad de almacenamiento de energía y la capacidad de descarga. La capacidad de la batería es la cantidad de energía que es capaz de acumular y se mide en mAh (miliamperios hora). Cuantos mås mAh tenga una batería mayor serå su capacidad de almacenamiento. La capacidad de descarga de la batería es la intensidad de corriente a la que es capaz de descargarse la batería. Éste es un aspecto muy importante en los multi-rotores, ya que la alimentación de todo el sistema, pero sobre todo los motores, requiere altas corrientes, con picos superiores a 10A en la mayoría de los casos.

No vamos a extendernos en las caracterĂ­sticas todos los tipos de baterĂ­as pues en aeromodelismo y sistemas robĂłticos aĂŠreos se utilizan en la inmensa mayorĂ­a baterĂ­as Li-Po por su ligereza y pequeĂąo tamaĂąo y su gran capacidad de descarga, haciĂŠndolas aptas para la alimentaciĂłn de los potentes motores brushless.

Las baterĂ­as Li-Po se caracterizan por el voltaje que proporcionan medido en celdas (1S, 2S, 3S, etc), que como observamos en la tabla son de 3.7V cada una. AdemĂĄs del voltaje a la hora de elegir una baterĂ­a de ĂŠste tipo un dato importante es la capacidad de descarga de la baterĂ­a. La capacidad de descarga de una baterĂ­a denotada como un valor numĂŠrico seguido por una “Câ€? (15C, 20C, 30C, etc) es la corriente mĂĄxima que es capaz de ofrecer la baterĂ­a. Se calcula a travĂŠs de una pequeĂąa fĂłrmula: đ??śđ?‘œđ?‘&#x;đ?‘&#x;đ?‘–đ?‘’đ?‘›đ?‘Ąđ?‘’ đ?‘€ĂĄđ?‘Ľ = đ??ś đ?‘Ľ đ??śđ?‘Žđ?‘?đ?‘Žđ?‘?đ?‘–đ?‘‘đ?‘Žđ?‘‘(đ?‘’đ?‘› đ??´â„Ž) Por ejemplo, para la baterĂ­a 3S de 4000 mAh y 30C que hemos utilizado para el UAV tenemos que sus valores caracterĂ­sticos son: Voltaje: 3 x 3.7 = 11.1V Capacidad: 4000 mAh Capacidad de descarga: 30 x 4Ah = 130 Ah

Sistema de control.

El sistema de control de un UAV es la parte más importante de la aeronave. Es constituido por un micro controlador, un grupo de sensores encargados de recolección de datos, y un sistema de comunicación entre la estación base y la aeronave.

Micro controlador.

El micro controlador es el circuito integrado encargado del procesado de la información en un sistema digital. Hoy día se encuentran en prácticamente cualquier dispositivo eléctrico, desde una batidora hasta en los más sofisticados aviones comerciales.

Difiere de una unidad de procesamiento normal en que es más fácil convertirla en una computadora en funcionamiento, con un mínimo de circuitos integrados externos de apoyo. La idea es que un micro controlador se coloque en un dispositivo enganchado a la fuente de alimentación y la información que necesite, y sea suficiente para su funcionamiento. En un microprocesador normal esto no es posible, puesto que espera que todas estas tareas sean manejadas por otros chips, agregándole módulos de entrada y salida y la memoria para el almacenamiento de la información.

En un sistema multi-rotor el micro controlador recibe la información los sensores y del sistema de comunicación a través de puertos UART, I2C, conversores ADC, entre otros, para ser procesada por el programa grabado en la ROM del micro y actuar sobre los otros elementos del sistema como motores, servos, cámaras, etc.

Sensores.

Un sensor es un dispositivo utilizado para medir algún tipo de energía del entorno en que se encuentra (temperatura, altitud, nivel sonoro, etc). Genera una señal medible que cambia de acuerdo a las condiciones del entorno percibido.

Un sistema multi-rotor requiere un complejo sistema de control que permita la navegación y mantenga el aparato estabilizado en todo momento durante el vuelo.

Para mantener la estabilidad en aire los multi-rotores los sensores más utilizados son los acelerómetros y giroscopios. De la misma manera, los sensores más utilizados para la navegación son los gps, sensores de proximidad, brújulas digitales y sensores de presión atmosférica.

En los siguientes capítulos se realizará una mejor descripción de los sensores utilizados en la construcción del UAV y entraremos en más detalles sobre su funcionamiento.

Sistema de comunicación.

El sistema de comunicación de un UAV es el sistema utilizador por el piloto para comunicarse con el aparato.

Desde sus orígenes la manera más utilizada de controlar un UAV ha sido la emisora radio control. Desde sus orígenes, los UAV se han controlado mayoritariamente por emisoras radio control debido en parte a la vinculación de los UAV con el aeromodelismo y a la simplicidad de la comunicación por radiofrecuencia.

Actualmente una gran limitación de las emisoras radio control es que la gran expansión del aeromodelismo hace que se produzcan problemas por el uso de la misma frecuencia por varios usuarios. Otro problema de las emisoras radio control es que son muy susceptibles a las interferencias provocadas por canales adyacentes, provocando errores en la transmisión. Actualmente las emisoras radio control no utilizan frecuencias de emisión fijas, sino que emiten en bandas más anchas permitiendo la negociación de canales en caso de interferencia con otras emisoras. Es el caso de las emisoras de 2,4ghz que casi no reciben interferencias. Las emisoras se siguen y seguirán usando por si simplicidad y su bajo coste pero es una tecnología obsoleta para muchos de los sistemas robóticos aéreos actuales que necesitan comunicaciones más complejas.

Actualmente los avances en las comunicaciones inalámbricas han hecho posibles sistemas de comunicación muy robustos y con tasas de transmisión elevadas. Algunas de estas tecnologías se están usando para controlar aeronaves autónomas, aumentando así la seguridad y rango de transmisión que las comunicaciones por emisoras radio control ofrecen, como es el caso de comunicaciones por satélite, capaces de comunicar dos nodos situados a miles de kilómetros de distancia.

En los sistemas multi-rotores, debido a que son aeronaves de corto alcance y de poca autonomía utilizan sistemas de comunicación de corto alcance variados, comunicaciones wifi, Zigbee, bluetooth o las actuales emisoras por radio frecuencia de 2,4ghz, entre otros.

Análisis

Nuestro sistema: UAV Tricoptero.

Un tricoptero es una aeronave multi-rotor de que obtiene la propulsión para su elevación y desplazamiento de tres motores.

Existen varias configuraciones estructurales pero las más usadas son las conocidas como configuraciones Y y T. La principal diferencia de estas dos configuraciones es que en la configuración Y el peso del aparato es repartido en partes iguales entre los tres motores, ejerciendo éstos la misma fuerza de propulsión, mientras que en la configuración T el peso es elevado en un 90% por los dos motores delantero quedando el motor trasero a cargo del control de dirección. Básicamente cambia el centro de gravedad del aparato, situado en el centro de los tres motores para la configuración Y y situado cerca del eje que forman los dos motores delanteros para la configuración T. Para el proyecto se ha construido una aeronave t-coptero, o dicho de otra manera, un tricoptero en configuración T.

Figura 12: Tricoptero en configuración Y.

Figura 13: Tricoptero en configuración T.

En los siguientes apartados vamos a explicar cuál es la dinámica de vuelo de éste aparato para entender cómo se eleva y desplaza en pleno vuelo. Cómo para cada configuración utilizada en el diseño de un multi-rotor la dinámica de vuelo cambia, vamos a centrarnos en las características dinámicas del diseño elegido para nuestro proyecto, un t-coptero.

Dinámica.

El multi-rotor está caracterizado en 3 motores dispuestos en forma de T y cada uno de ellos incorpora una hélice de ángulo fijo. Mientras que los dos motores delanteros

están fijos a la estructura y ejercen sobre el 90% de la fuerza de elevación del aparato, el motor trasero es basculante, ejerciendo de timón en el vuelo. x

z

y

Figura 14: Disposición del multi-rotor en T. Para mantener un vuelo estático y mantener el aparato estable los dos motores delanteros ejercerán la misma potencia y al mismo tiempo el motor trasero mantendrá el aparato en una inclinación de 0 grados.

Para hacer avanzar el aparato el motor trasero aumenta la potencia inclinando el cuerpo de la aeronave hacia adelante produciendo el avance. De la misma manera para ir en sentido contrario, el motor de cola disminuiría la potencia y la inclinación sería negativa hacia atrás del aparato propiciando el movimiento. z

z

z

y

y x

y

x

g

g

vuelo estacionario

avance

g

retroceso

Figura 15: Detalle de la dinámica de vuelo de un t-coptero.

Si lo que queremos es un movimiento en una dirección el servo de cola inclina el motor de cola produciendo que parte del empuje del motor trasero haga rotar el aparato. De la misma manera el motor de cola servirá para mantener orientado en todo momento el UAV.

x

x

x

x

y

z

y

z

z y

z

z

z

y

x

y

x

x y

g

orientación estable

g

giro a derechas

g

giro a izquierdas

Figura 16: Detalle del funcionamiento del motor de cola como timón del UAV. Éste aspecto del control del aparato se explicará con más detalle en capítulos siguientes.

Estabilidad y control del aparato.

Para poder mantener el aparato estable en el aire necesitamos una serie de sensores para conocer el plano en el que se encuentra nuestro UAV y un micro controlador que analice los datos obtenidos por éstos sensores y actúe sobre los motores para rectificar la posición, inclinación u orientación del aparato.

La inclinación y orientación respecto al plano horizontal es lo que determinará la dirección del movimiento del aparato y serán necesarias para el control de estabilidad.

Los sensores que nos van a permitir conocer la inclinación respecto al plano horizontal son los acelerómetros y los giroscopios. Si bien su forma de funcionamiento es muy diferente, el uso de los dos sensores de forma conjunta nos permitirá obtener medidas más fiables. En el apartado de diseño explicaremos con más detenimiento el uso que se les ha dado a éstos dos sensores.

Hardware Para nuestro proyecto hemos utilizado una IMU (Unidad de Medición Inercial) que integra un acelerómetro de tres ejes y dos giroscopios de 2 y 1 ejes respectivamente

junto a un micro procesador Atmega328 funcionando a 16MHz. La función de la IMU será la obtención de los ángulos en los que se encuentra el aparato en todo momento y pasarlos a la unidad procesamiento principal. Dicha unidad de procesamiento con la que contamos para el UAV es una placa de desarrollo modelo FezPanda II. A continuación mostraremos las características de de éstas dos placas que conforman la unidad de medida y procesamiento del t-coptero que hemos fabricado pero antes cabría destacar que aunque son de marcas diferentes, tanto la ArduIMU como la FezPanda son dos placas basadas en el concepto Arduino. Más concretamente la ArduIMU pertenece al conjunto de placas Arduino y la FezPanda la alternativa .NET a Arduino proporcionada por Microsoft. Pero, ¿Qué es Arduino?

Aduino.

Arduino es una plataforma de hardware libre basada en una sencilla placa con un micro controlador y un entorno de desarrollo libre. Arduino es usado por ingenieros y aficionados a la robótica y electrónica para desarrollar objetos interactivos autónomos o para aplicaciones en que el módulo se conecta a un software del ordenador, entre otros muchos proyectos. Hay que destacar que el entorno de desarrollo integrado es libre y se puede descargar gratuitamente.

Las plataformas Arduino están basadas en los micro controladores Atmega y otros similares, chips sencillos y de bajo coste que permiten el desarrollo de múltiples diseños.

Al ser open-hardware, tanto su diseño como su distribución son libres. Es decir, puede utilizarse libremente para el desarrollo de cualquier tipo de proyecto sin haber adquirido ninguna licencia.

Arduino está basado en C y soporta todas las funciones del estándar C y algunas de C++.

Para programar cualquier plataforma basada en Arduino se puede usar el entorno de desarrollo integrado libre que se puede descargar gratuitamente.

Figura 17: Entorno de desarrollo Arduino

ARDUIMU FLAT V2.

El ArduIMU v2 Flat es un modelo específico de Arduino pensado para aplicaciones de medición inercial (IMU). Consiste en una pequeña placa que incluye un acelerómetro de 3 ejes ADXL335, un regulador de tensión dual (3,3V y 5V), un puerto para conexión GPS y dos giroscopios (LPR530AL 2 ejes y LY530ALH de 1 eje). Como centro de control se encuentra un micro controlador Atmega328 funcionando a 16MHz y diodos LED indicadores.

Figura 18: Placa de medición inercial ArduIMU FLAT V2

Ésta placa es muy versátil y puede servir en aplicaciones de posicionamiento tridimensional tales como pequeños robots, robots voladores, geoposicionamiento, pilotos automáticos, etc. Éstas son sus características:

            

Acelerómetro 3 ejes ADXL335 Giroscópio 2 ejes LPR530AL Giroscópio 1 eje LY530ALH Compatible con Arduino IDE Código fuente y códigos de ejemplos Open Source LED de alimentación (verde) LEDs de estado: (Rojo, Azul, Amarillo) Puerto SPI Puerto I2C Dos salidas PWM (para servos) Puerto GPS (compatible con uBlox) Diodo de protección polaridad Salida puerto serie (UART)

Como ya se ha comentado, se trata de una placa de hardware-libre por lo que podemos encontrar tanto su esquema de diseño como el diagrama de la placa en las especificaciones del dispositivo. Ésta es la vista trasera de la placa, donde podemos apreciar los pines que dispone y la función que cumple cada uno de ellos.

Figura 19: Disposición y función de los pines en la placa ArduIMU

En rojo se ha marcado los pines que realmente hemos usado para el proyecto que estamos tratando. La conexión FTDI es la que nos permitirá, a través de un conversor

Serie-USB conectarnos con el pc para programar el micro y realizar la conexión con la otra placa (FezPanda II) a la que le pasaremos los valores recibidos de los sensores para que ésta realice los cálculos, además de alimentar todos los componentes de la placa. El conversor usado se trata de una simple placa conversora de serie a USB, en la cual no vamos a entrar en detalles. Se trata de esta placa:

Figura 20: Conversor serie-USB FTDI. Más adelante entraremos en más detalles sobre las salidas PWM, el micro controlador, el acelerómetro y los giroscopios que contiene la placa.

El micro controlador ATMEGA328.

El micro controlador de la IMU será el cerebro en el cálculo de las inclinaciones, será el que se comunique con los sensores y haciendo los cálculos pertinentes con los datos obtenidos de éstos calcule y transmita a la otra placa los resultados. Nuestra placa de desarrollo Arduimu incorpora un micro controlador Atmega328P. No vamos a entrar en muchos detalles sobre éste, pues nos extenderíamos demasiado y ya incluimos el datasheet junto con la memoria, y vamos a recalcar sus propiedades más destacables.

Se trata de un micro que implementa una arquitectura RISC (reduced instruction set computer), con un juego de 131 instrucciones, 32x8 registros de uso general y que puede desarrollar una potencia de 20 MIPS corriendo a 20 MHz. En cuanto a la memoria decir que nuestro micro en cuestión, el Atmega328p dispone de 2KB de memoria RAM, 1KB de memoria persistente (EEPROM) y de 32KB de memoria flash para código.

Referente a los periféricos de que dispone, destacamos las siguientes características: – – – – – – –

Dos temporizadores/contadores de 8 bits.

Un temporizador/contador de 16 bits.

Un contador de tiempo real con cristal propio.

Seis salidas PWM 8 conversores analógico-digital (ADC) de 10 bits Un puerto programable Serial USART Puerto SPI maestro/esclavo

– –

Temporizador Watchdog con cristal propio.

Comparador analógico

Aquí podemos observar el esquema de configuración de pines:

Figura 21: Disposición de los pines en el Atmega328 No se trata de un micro especialmente potente comparado con otras opciones en la actualidad, pero es más que suficiente para comandar varios sensores y actuadores en un pequeño proyecto como es el que estamos tratando.

Acelerómetro

El acelerómetro es un sensor que mide aceleraciones y con unos cálculos no muy complejos nos permitirá medir el ángulo de inclinación de la plataforma en todo momento. En nuestro caso disponemos de un acelerómetro 3 ejes ADXL335 que para

cada eje devuelve la tensión proporcional a la aceleración, con lo que podemos interpretar éstas señales para el cálculo de inclinaciones. Más concretamente, este sensor es capaz de medir aceleraciones de +-3 g y cambios de aceleración de hasta 10.000 g. Según el fabricante, para un correcto funcionamiento del acelerómetro tenemos que añadir unos condensadores colocados en la salida (Cx, Cy, Cz) como se observa en el diagrama del acelerómetro:

Figura 22: Diagrama del acelerómetro ADXL335

Dependiendo del valor que escojamos para dichos condensadores obtendremos un valor diferente de ancho de banda. En éste caso no nos preocupa, ya que la circuitería ya está implementada en la placa ArduIMU, donde se encuentra ya ensamblado nuestro acelerómetro.

Para ver de manera resumida cuáles son las especificaciones del ADXL335 vamos a adjuntar ésta tabla extraída del datasheet del dispositivo:

En cuanto a la configuración de los pines de éste modelo, no vamos a entrar en detalles, pues al tener ya ensamblado el acelerómetro en la placa ArduIMU la electrónica y conexión de pines entre micro controlador y sensores es trabajo que ya tenemos hecho.

Más adelante explicaremos de qué manera se ha usado el acelerómetro, ya que también disponemos de otros sensores, como el giroscopio y de qué manera combinaremos ambos para implementar un correcto sistema de control.

Giroscopio

El uso del giroscopio proporciona una mejora considerable en la precisión y rendimiento del sistema. Los giroscopios son capaces de medir las velocidades angulares en sus ejes. En nuestro caso el giroscopio utilizado es el LPR530AL, un giroscopio de 2 ejes (x e y) capaz de detectar cambios en la velocidad angular de +-300

grados por segundo. Si bien toda la información necesaria sobre éste dispositivo está documentada en el datasheet que también se incluye con ésta memoria, las características funcionales del LPR530AL son las siguientes:

El fabricante pone a nuestra disposición en el datasheet el diagrama del dispositivo, que no mostraremos aquí para no extender demasiado el presente documento.

FezPanda II

A diferencia de la placa ArduIMU, la FEZ Panda II corre bajo .NET Micro Framework, la alternativa de Microsoft a Arduino, permitiendo a los usuarios programar y debuggear empleando Microsoft's free Visual C# Express. Las aplicaciones son cargadas mediante un cable USB (o serial) con todas las características de debugging como ejecución paso a paso o inspección de variables. La principal característica de ésta placa es que integra un micro procesador ARM7 de 32 bits corriendo a 72 Mhz, el cual es mucho más potente que el atmega que incorpora la ArduIMU. La finalidad de utilizar esta segunda placa como unidad de procesamiento principal del t-coptero es la de dejar que el microcontrolador que incorpora la placa ArduIMU se ocupe sólo de los cálculos matemáticos para la obtención de los ángulos de posición del aparato mientras la segunda unidad (la placa FezPanda II) se encarga de analizar ésta información e implementar los algoritmos de control y comunicación con mayor fluidez.

Figura 23: Detalle de la placa FezPanda II Las principales características de la placa FezPanda II son las siguientes: 

                       

Basado en el micro controlador NXP's LPC2387 o Procesador 72MHz. 32-bit ARM7 o 512 KB Flash (148KB para aplicaciones de usuario) . o 96 KB RAM (62KB par aplicaciaones de usuario).

Compatible con la mayoría de los shields de Arduino.

Conexión USB para debugging Librerías especializadas para configurar el puerto SUB y emular dispositivos como memorias thumbdrive, puertos virtuales COM, mouse, teclado.

USB Debugging y Virtual COM (CDC) pueden trabajar de manera simultánea Soporte USB Host con modificaciones Socket para Micro SD (4-bit de alta velocidad SDHC, sin límite de 2GB) con señal de detección de tarjeta 54x puertos digitales I/O 6x 10-bit entradas analógicas 10-bit salidas analógicas (con reproducción de audio WAV).

6x canales de Hardware PWM 2x canales CAN LED y botón configurable 4x UART puertos seriales (uno con capacidades de handshaking) Interfaz OneWire (disponible en cualquier pin IO).

Reloj de tiempo real (RTC) Acesso a los registros del procesador Generación de formas de onda con gran exactitud Soporte Ethernet a través del W5100 chipset ccon TCP, UDP, HTTP, DHCP y DNS. Puerto paralelo para displays JTAG Multi-Threading.

XML. FAT Critpografía (AES y XTEA).

Algoritmo DCM. Visión general

Para el cálculo de la inclinación del UAV en todo momento no es suficiente con calcular el recorrido para cada uno de los ejes como si fueran independientes. Debemos tener en cuenta que la posición de cada uno de sus brazos depende tanto del giro sobre su eje como de los giros de los demás brazos.

Veamos esto con un ejemplo: 1. El programa de la IMU inicializaría el ángulo del eje x a 0º: Inclinación-X = 0º

z

x

y

g

2. Por una ráfaga de viento el aparato de inclina 30º sobre su eje x. Teniendo como resultado: Inclinación-X = -30º z

x

g

y

3. Antes de producirse ninguna corrección, el t-coptero gira 180º sobre su eje z. Si suponemos de manera errónea que los giros en los distintos ejes son independientes tendríamos que: Inclinación-X = -30º Inclinación-Z = 180º z

x

g

y

4. Éstas inclinaciones serían transmitidas a la unidad de proceso principal (FezPanda) y ésta haría la pertinente corrección incrementando la potencia del motor del lateral rojo, lo contrarío a lo que debería hacer y se produciría un accidente.

Sistemas de referencia

Para el control del t-coptero podemos usar dos sistemas de referencia: 1. Referencia_Suelo (RefS). Los ejes X e Y formal el plano horizontal paralelo al suelo y el eje Z coincide con la fuerza de la gravedad.

2. Referencia_Aparato (RefK). Los tres ejes están ligados a la estructura.

Figura 24: Detalle de los dos sistemas de referencia usados en el control del UAV. En el control del multi-rotor, el primer problema que surge es que unos sensores nos dan la información referida a sistemas de coordenadas distintos.

Referencia Suelo (RefS):    

Acelerómetro Magnetómetro Barómetro GPS

Referencia Aparato (RefK):  

Gyroscopios Sensor ultrasonidos

Por lo tanto necesitamos una manera de transformar las magnitudes vectoriales de un sistema de referencia a otro. Una solución es utilizar los Cosenos Directores (DCM).

La Matriz de Cosenos Directores (DCM) es una matriz de 3x3 donde cada fila corresponde a los vectores unitarios del sistema RefS en el sistema RefK, o lo que es lo mismo, los cosenos de los ángulos formados por cada eje del RefS con los ejes del RefK. Y a la inversa cada Columna corresponde a las componentes de los vectores unitarios del sistema RefK en el sistema RefS. Teniendo la matriz DCM podemos transformar cualquier vector de un sistema de referencia a otro con una multiplicación matricial. Para pasar del sistema Refs al RefK multiplicaríamos el vector por la matriz DCM y para pasar del sistema RefK al RefS multiplicaríamos por la matriz transpuesta de DCM.

A la matriz DCM tambiĂŠn se la denomina Matriz de RotaciĂłn y una de las propiedades ĂŠsta es que permite agrupar varias rotaciones consecutivas en una Ăşnica matriz multiplicando las matrices de rotaciĂłn individuales. Hay que prestar atenciĂłn al orden en el que se realizan las operaciones porque la multiplicaciĂłn de matrices no es conmutativa.

Matriz de cosenos directores

Para calcular la matriz de cosenos directores veamos primero las proyecciones de los vectores unitarios de un Sistema de Referencia (RefS) sobre el otro sistema (RefK).

Figura 25: Sistema de referencia RefS sobre RefK Si analizamos la imagen anterior podemos deducir que la posiciĂłn de la aeronave estĂĄ descrita por 3 rotaciones consecutivas, en un orden determinado. Estas rotaciones se las conoce como ĂĄngulos de Euler. Con esto nos queda que la matriz de rotaciĂłn o DCM es: cos đ?œƒ cos ď š sin ď Ś sin đ?œƒ cos ď š − cos ď Ś sin ď š cos ď Ś sin đ?œƒ cos ď š + sin ď Ś sin ď š đ?‘… = cos đ?œƒ sin ď š sin ď Ś sin đ?œƒ sin ď š + cos ď Ś cos ď š cos ď Ś sin đ?œƒ sin ď š − sin ď Ś cos ď š − sin đ?œƒ sin ď Ś cos đ?œƒ cos ď Ś cos đ?œƒ EcuaciĂłn xx: Matriz de rotaciĂłn o Matriz de Cosenos Directores (DCM). Él cĂĄlculo de ĂŠsta matriz puede parecer a primera vista algo costoso de realizar en cuestiĂłn de cĂłmputo, ya que ĂŠstos cĂĄlculos se deberĂ­an realizar cada pocos milisegundos para un correcto control del aparato, pero podemos simplificarlos. Si tenemos en cuenta que los ĂĄngulos que puede girar el t-coptero en 20 milisegundos (por poner un ejemplo de tiempo de ciclo) son muy pequeĂąos todos los cosenos serĂĄn

prĂĄcticamente 1 y los productos seno*seno son prĂĄcticamente 0. Lo comprobamos a continuaciĂłn: Velocidad: 250 Âş/s <> 5Âş en 20 ms Grados

Radianes

Seno

Coseno

5Âş

0.0873

0.0872

0.9962

Seno (5Âş) * Seno (5ÂŞ) = 0.0076

De ĂŠsta manera, suponiendo que durante los 20 milisegundos la velocidad angular (ď ˇ) es constante tenemos que: đ?&#x2018;&#x2018;đ?&#x153;&#x192; = đ?&#x153;&#x201D; â&#x2C6;&#x2014; đ?&#x2018;&#x2018;đ?&#x2018;Ą

Con lo que la Rotacion Elemental producida en el instante dt queda reducida a: đ?&#x2018;&#x2026; đ?&#x2018;&#x2018;đ?&#x2018;Ą = đ?&#x2018;&#x2018;đ?&#x153;&#x192;x = đ?&#x153;&#x201D;x â&#x2C6;&#x2014; đ?&#x2018;&#x2018;đ?&#x2018;Ą

1 đ?&#x2018;&#x2018;đ?&#x153;&#x192;z â&#x2C6;&#x2019;đ?&#x2018;&#x2018;đ?&#x153;&#x192;y

â&#x2C6;&#x2019;đ?&#x2018;&#x2018;đ?&#x153;&#x192;z đ?&#x2018;&#x2018;đ?&#x153;&#x192;y 1 â&#x2C6;&#x2019;đ?&#x2018;&#x2018;đ?&#x153;&#x192;x đ?&#x2018;&#x2018;đ?&#x153;&#x192;x 1

đ?&#x2018;&#x2018;đ?&#x153;&#x192;y = đ?&#x153;&#x201D;y â&#x2C6;&#x2014; đ?&#x2018;&#x2018;đ?&#x2018;Ą

đ?&#x2018;&#x2018;đ?&#x153;&#x192;z = đ?&#x153;&#x201D;z â&#x2C6;&#x2014; đ?&#x2018;&#x2018;đ?&#x2018;Ą

Y teniendo en cuenta la propiedad asociativa de las matrices de rotaciĂłn que hemos comentado antes, tenemos que la matriz de rotaciĂłn para el instante (t+dt) es igual a la del instante t multiplicada por la matriz DCM de dt.

1 â&#x2C6;&#x2019;đ?&#x2018;&#x2018;đ?&#x153;&#x192;z đ?&#x2018;&#x2018;đ?&#x153;&#x192;y đ?&#x2018;&#x2026; đ?&#x2018;Ą + đ?&#x2018;&#x2018;đ?&#x2018;Ą = đ?&#x2018;&#x2026;(đ?&#x2018;Ą) đ?&#x2018;&#x2018;đ?&#x153;&#x192;z 1 â&#x2C6;&#x2019;đ?&#x2018;&#x2018;đ?&#x153;&#x192;x â&#x2C6;&#x2019;đ?&#x2018;&#x2018;đ?&#x153;&#x192;y đ?&#x2018;&#x2018;đ?&#x153;&#x192;x 1 đ?&#x2018;&#x2018;đ?&#x153;&#x192;x = đ?&#x153;&#x201D;x â&#x2C6;&#x2014; đ?&#x2018;&#x2018;đ?&#x2018;Ą

đ?&#x2018;&#x2018;đ?&#x153;&#x192;y = đ?&#x153;&#x201D;y â&#x2C6;&#x2014; đ?&#x2018;&#x2018;đ?&#x2018;Ą

đ?&#x2018;&#x2018;đ?&#x153;&#x192;z = đ?&#x153;&#x201D;z â&#x2C6;&#x2014; đ?&#x2018;&#x2018;đ?&#x2018;Ą

De ĂŠsta manera en el instante 0 cuando el t-coptero estĂĄ en tierra, parado e inicializando el sistema los dos sistemas de referencia coinciden y es cuando la matriz de rotaciĂłn o matriz DCM inicial es: đ?&#x2018;&#x2026; 0 =

Re normalizaciĂłn

1 0 0

0 0 1 0 0 1

Debido a las simplificaciones que se efectĂşan con ĂŠste sistema y a que los cĂĄlculos no son totalmente exĂĄctos, poco a poco en la matriz de rotaciĂłn R los vectores unitarios dejan de ser perpendiculares entre sĂ­, o lo que es lo mismo, los mĂłdulos de los vectores no son exactamente 1.

El proceso de corregir ĂŠstos errores acumulados se denomina â&#x20AC;&#x153;RenormalizaciĂłnâ&#x20AC;? y consiste en el siguiente mĂŠtodo: 1. Corregir Perpendicularidad.

Si recordamos, el producto escalar de dos vectores es igual al producto de sus mĂłdulos por el coseno del ĂĄngulo que forman. Por lo tanto el producto escalar de los vectores X e Y deberĂ­a ser cero. Si no es cero se estĂĄ produciendo un error debido a la falta de perpendicularidad entre los vectores.

Para corregir la desviaciĂłn en la perpendicularidad restamos a cada vector el producto de la mitad del error por el otro vector de la manera siguiente:

đ?&#x2018;&#x;zx đ?&#x2018;&#x;zy đ?&#x2018;&#x;zz

đ?&#x2018;&#x;xx đ?&#x2018;&#x;xy đ?&#x2018;&#x;xz

ortogonal

= đ?&#x2018;&#x2039;ortogonal = đ?&#x2018;&#x2039; â&#x2C6;&#x2019;

đ?&#x2018;&#x2019;đ?&#x2018;&#x;đ?&#x2018;&#x;đ?&#x2018;&#x153;đ?&#x2018;&#x; đ?&#x2018;&#x152; 2

đ?&#x2018;&#x;yx đ?&#x2018;&#x;yy đ?&#x2018;&#x;yz

ortogonal

= đ?&#x2018;&#x152;ortogonal = đ?&#x2018;&#x152; â&#x2C6;&#x2019;

đ?&#x2018;&#x2019;đ?&#x2018;&#x;đ?&#x2018;&#x;đ?&#x2018;&#x153;đ?&#x2018;&#x; đ?&#x2018;&#x2039; 2

ortogonal

= đ?&#x2018;?ortogonal = đ?&#x2018;&#x2039;ortogonal Ă&#x2014; đ?&#x2018;&#x152;ortogonal

Para que el vector Z sea ortogonal a los vectores X e Y sĂłlo tenemos que igualar Z al producto vectorial de X por Y. 2. Normalizar vectores.

El Ăşltimo paso en la re normalizaciĂłn es escalar los vectores de R para que todos sean vectores unitarios. Una manera de hacerlo podrĂ­a ser dividir cada uno de los elementos de cada fila entre el mĂłdulo del vector normalizado, sin embargo hay otra manera mĂĄs fĂĄcil llamada â&#x20AC;&#x153;expansiĂłn de Taylorâ&#x20AC;? *xx+. De ĂŠsta manera queda de la siguiente manera: 1 3 â&#x2C6;&#x2019; đ?&#x2018;&#x2039;ortogonal â&#x2C6;&#x2122; đ?&#x2018;&#x2039;ortogonal đ?&#x2018;&#x2039;ortogonal 2 1 đ?&#x2018;&#x152;normalizado = 3 â&#x2C6;&#x2019; đ?&#x2018;&#x152;ortogonal â&#x2C6;&#x2122; đ?&#x2018;&#x152;ortogonal đ?&#x2018;&#x152;ortogonal 2 1 đ?&#x2018;?normalizado = 3 â&#x2C6;&#x2019; đ?&#x2018;?ortogonal â&#x2C6;&#x2122; đ?&#x2018;?ortogonal đ?&#x2018;?ortogonal 2

đ?&#x2018;&#x2039;normalizado =

Ă ngulos de vuelo

Hemos explicado en quĂŠ consiste el cĂĄlculo de la matriz de cosenos directores pero puede que no quede totalmente claro su uso prĂĄctico en el sistema. Para poder controlar y mantener estable el UAV multi-rotor en el aire lo que necesitamos saber son los ĂĄngulos de vuelo o dicho de otra manera, los ĂĄngulos de Euler.

Cualquier rotaciĂłn en un espacio 3D queda determinada por 3 rotaciones elementales alrededor de sus ejes y ĂŠstas vienen determinadas por los ĂĄngulos de Euler. Ă&#x2030;stos son a modo prĂĄctico los ĂĄngulos que nos interesan: 1. Girar el t-coptero alrededor del eje Z un ĂĄngulo ď &#x2122;, conocido como Yaw. 2. Girar el t-coptero alrededor del eje Y un ĂĄngulo ď &#x2018;, conocido como Pitch.

3. Girar el t-coptero alrededor del eje X un ĂĄngulo ď &#x2020;, conocido como Roll.

Figura 26: Sistemas de referencia del suelo y del aparato junto a los ĂĄngulos de Euler.

Ahora el cĂĄlculo de los ĂĄngulos de vuelo es simple, conociendo la matriz de rotaciĂłn: đ?&#x2018;&#x;xx đ?&#x2018;&#x;xy đ?&#x2018;&#x;xz đ?&#x2018;&#x2026; = đ?&#x2018;&#x;yx đ?&#x2018;&#x;yy đ?&#x2018;&#x;yz = đ?&#x2018;&#x;zx đ?&#x2018;&#x;zy đ?&#x2018;&#x;zz cos đ?&#x153;&#x192; cos ď š sin ď Ś sin đ?&#x153;&#x192; cos ď š â&#x2C6;&#x2019; cos ď Ś sin ď š = cos đ?&#x153;&#x192; sin ď š sin ď Ś sin đ?&#x153;&#x192; sin ď š + cos ď Ś cos ď š â&#x2C6;&#x2019; sin đ?&#x153;&#x192; sin ď Ś cos đ?&#x153;&#x192;

cos ď Ś sin đ?&#x153;&#x192; cos ď š + sin ď Ś sin ď š cos ď Ś sin đ?&#x153;&#x192; sin ď š â&#x2C6;&#x2019; sin ď Ś cos ď š cos ď Ś cos đ?&#x153;&#x192;

ď Ś = đ?&#x2018;&#x17D;đ?&#x2018;&#x;đ?&#x2018;?đ?&#x2018;&#x153;đ?&#x2018; đ?&#x2018;&#x2019;đ?&#x2018;&#x203A;đ?&#x2018;&#x153;(â&#x2C6;&#x2019;đ?&#x2018;&#x;zx) đ?&#x153;&#x192; = đ?&#x2018;&#x17D;đ?&#x2018;&#x;đ?&#x2018;?đ?&#x2018;&#x153;đ?&#x2018;Ąđ?&#x2018;&#x17D;đ?&#x2018;&#x203A; đ?&#x2018;&#x;zy đ?&#x2018;&#x;zz

ď š = đ?&#x2018;&#x17D;đ?&#x2018;&#x;đ?&#x2018;?đ?&#x2018;&#x153;đ?&#x2018;Ąđ?&#x2018;&#x17D;đ?&#x2018;&#x203A;(đ?&#x2018;&#x;yx đ?&#x2018;&#x;xx)

Corrección de deriva

En el proceso descrito anteriormente hemos utilizado únicamente la información que nos proporcionan los giroscopios para calcular la matriz de rotación (DCM) y conocer los ángulos de Euler que describen la posición del t-coptero. Lo que ocurre es que los giroscopios tienen un problema llamado deriva.

La deriva (drift) es el error que se va acumulando debido a que las mediciones nunca son totalmente exactas y que cuando no hay movimiento el sensor giroscópico no da exactamente velocidad cero. Esto produce un corto periodo de tiempo que al integrar las velocidades el error acumulado sea de varios grados.

Podríamos pensar que debido a éste problema no nos sirven para nuestro objetivo pero no es así. Los giroscopios tienen la gran ventaja frente a otros sensores de que apenas les afectan los movimientos lineales o las vibraciones, tan solo tenenemos que buscar un modo de eliminar el problema de la deriva.

Para corregir la deriva necesitamos la información de otro sensor que no acumule deriva e implementar un sistema que permita corregirla. Usualmente para éste menester se utiliza un bucle de control PI, que es la opción que hemos usado en el proyecto. El propósito del PI es calcular el error entre los valores estimados a partir de los giroscopios (DCM) con los valores reales (tomados con otro sensor) y retroalimentar las correcciones para evitar que se vaya produciendo la deriva. El esquema es el siguiente: Gyro X, Y, Z

+ -

Corrección de deriva

Control PI

Matriz Rotación Renormalización

Cálculo de la deriva

Ángulos de vuelo

Yaw

Pitch, Roll

GPS/Brújula Acelerómetro

Figura 27: Esquema de cálculo de DCM y eliminación de la deriva.

Se trata de un proceso donde hacemos lo siguiente:   

Leemos las velocidades de giro de los giroscopios.

Corregimos las lecturas con los valores proporcionados por el control PI de las desviaciones anteriores.

Actualizamos la matriz de rotación (DCM) y re normalizamos.

  

Entregamos los ángulos de vuelo al programa principal que los transmitirá más tarde al FezPanda.

Se comparan los datos obtenidos de la DCM con los obtenidos con los sensores auxiliares y calculamos el error.

El error cometido se transmite al control PI para calcular las correcciones y retroalimentarlas.

Los GPS y magnetómetros nos proporcionan información de la orientación del aparato respecto al suelo, sin deriva, y esto es perfecto para corregir la deriva en el ángulo dirección (Yaw). Los acelerómetros no son suficientes para calcular la corrección del Yaw porque los acelerómetros nos dan un vector de dirección, el de la fuerza de la gravedad, perfecto para corregir el Pitch y Roll, pero no el Yaw puesto que el eje Z coincide con la dirección de la gravedad en el sistema de referencia del suelo Ref-S y no podemos obtener lecturas del acelerómetro en el plano horizontal. Para el proyecto que tratamos no haremos uso de ningún GPS ni magnetómetro para la corrección del ángulo Yaw, por lo que sólo corregiremos los valores del Pitch y Roll, los más importantes y necesarios para la estabilidad del aparato.

Con esto damos por terminado la explicación del algoritmo de cálculo de la matriz de rotación (DCM) que nos permitirá hallar en cada momento los ángulos de vuelo, necesarios para mantener estable el aparato, como veremos en los siguientes capítulos. Además en los capítulos destinados al diseño del aparato trataremos la implementación del algoritmo DCM para que se ejecute en la ArduIMU.

Algoritmo de Control.

Como en el caso del algoritmo DCM, vamos a explicar los aspectos más relevantes sobre el algoritmo de control utilizado antes de entrar en detalles de implementación que veremos más adelante en la etapa de diseño.

Una vez dispongamos de los ángulos de vuelo en la unidad de procesamiento principal FezPanda (transferidos desde la ArduIMU) para poder mantener el aparato estable necesitamos actuar sobre los motores acorde a la información recibida. En nuestro caso, debemos de poder mantener el aparato estable tanto en el Roll como en el Pitch haciendo posible por ejemplo que el aparato quede estático en un plano paralelo al suelo o darle una inclinación constante desde la cola para hacer que avance o retroceda. Éstos son los dos casos que deberemos manejar y para ello se ha optado por un control PID sobre éstos.

Control PID (Proporcional Integral Derivativo).

Un PID (Proporcional Integral Derivativo) es un mecanismo de control por realimentación que calcula la desviación o error entre un valor medido y el valor que se quiere obtener, para aplicar una acción correctora que ajuste el proceso. El algoritmo de cálculo del control PID se da en tres parámetros distintos: el proporcional, el integral, y el derivativo. El valor Proporcional determina la reacción del error actual. El Integral genera una corrección proporcional a la integral del error, esto nos asegura que aplicando un esfuerzo de control suficiente, el error de seguimiento se reduce a cero. El Derivativo determina la reacción del tiempo en el que el error se produce. La suma de estas tres acciones es usada para ajustar al proceso vía un elemento de control como la posición de una válvula de control o la energía suministrada a un calentador, por ejemplo. Ajustando estas tres variables en el algoritmo de control del PID, el controlador puede proveer un control diseñado para lo que requiera el proceso a realizar.

Figura 28: Esquema del controlador PID Para el correcto funcionamiento de un controlador PID que regule un proceso o sistema se necesita, al menos: 1. Un sensor, que determine el estado del sistema (termómetro, caudalímetro, manómetro, etc).

2. Un controlador, que genere la señal que gobierna al actuador.

3. Un actuador, que modifique al sistema de manera controlada (resistencia eléctrica, motor, válvula, bomba, etc).

Las tres componentes de un controlador PID son: parte Proporcional, acción Integral y acción Derivativa. El peso de la influencia que cada una de estas partes tiene en la suma final, viene dado por la constante proporcional, el tiempo integral y el tiempo derivativo, respectivamente. Se pretenderá lograr que el bucle de control corrija eficazmente y en el mínimo tiempo posible los efectos de las perturbaciones. La salida de estos tres términos, el proporcional, el integral, y el derivativo son sumados para

calcular la salida del controlador PID. Definiendo u (t) como la salida del controlador, la forma final del algoritmo del PID es:

Componente Proporcional.

La parte proporcional consiste en el producto entre la señal de error y la constante proporcional como para que hagan que el error en estado estacionario sea casi nulo, pero en la mayoría de los casos, estos valores solo serán óptimos en una determinada porción del rango total de control, siendo distintos los valores óptimos para cada porción del rango. Sin embargo, existe también un valor límite en la constante proporcional a partir del cual, en algunos casos, el sistema alcanza valores superiores a los deseados. Este fenómeno se llama sobreoscilación. La parte proporcional no considera el tiempo, por lo tanto, la mejor manera de solucionar el error permanente y hacer que el sistema contenga alguna componente que tenga en cuenta la variación respecto al tiempo, es incluyendo y configurando las acciones integral y derivativa.

La fórmula del proporcional está dada por:

Componente Integral.

El modo de control Integral tiene como propósito disminuir y eliminar el error en estado estacionario, provocado por el modo proporcional. El control integral actúa cuando hay una desviación entre la variable y el punto de consigna, integrando esta desviación en el tiempo y sumándola a la acción proporcional. La respuesta integral es adicionada al modo Proporcional para formar el control P + I con el propósito de obtener una respuesta estable del sistema sin error estacionario.

La fórmula del integral está dada por:

Debido a que el cálculo de la integral requiere cálculos complejos, se ha optado por implementar una aproximación, la integral de Riemann. A continuación vamos a explicarla: La integral definida de una función representa el área limitada por la gráfica de la función, con signo positivo cuando la función toma valores positivos y negativo cuando toma valores negativos.

Figura 29: Representación de la integral Una aproximación para calcular su valor es dividir el intervalo a-b en rectángulos de igual base i con una altura igual al valor de la función. La suma de las áreas de éstos rectángulos se aproxima al valor de la integral.

Figura 30: Aproximaciones al valor integral Cuanto más estrecha sea la base de los rectángulos mejor será la aproximación al valor real de la integral.

En nuestro caso tenemos que: F(x) = Evolución de las inclinaciones a lo largo de tiempo.

Variable x = Tiempo Base de los rectángulos = Duración del ‘Loop’, que consideraremos constante.

Por lo tanto, Integral = Sumatorio (desviaciones en la inclinación)*Tiempo_loop Y como el tiempo del loop es constante, podemos decir que la integral es proporcional al sumatorio de las desviaciones, pudiendo omitir éste valor, ya que con la constante Ki ya podremos regular la componente integral.

Componente Derivativa.

La acción derivativa se manifiesta cuando hay un cambio en el valor absoluto del error; (si el error es constante, solamente actúan los modos proporcional e integral). La función de la acción derivativa es mantener el error al mínimo corrigiéndolo proporcionalmente con la misma velocidad que se produce; de esta manera evita que el error se incremente.

Se deriva con respecto al tiempo y se multiplica por una constante D y luego se suma a las señales anteriores (P+I). La fórmula del derivativo está dada por:

Aplicación del controlador PID en el t-coptero

Más adelante, en los capítulos destinados al diseño se explicará como se ha implementado el controlador en el FezPanda, pero debe quedar clara la necesidad de un controlador que mantenga estabilizado el aparato.

Pongamos el caso de que el t-coptero está volando a cierta distancia del suelo de manera estacionaria, o sea manteniéndose en un plano paralelo al suelo. Cualquier pequeña ráfaga de viento puede desestabilizar el aparato inclinándolo. La necesidad de un sistema de control que rectifique ésta inclinación pues se ha perdido el paralelismo con el suelo provocándose el desplazamiento e inevitable accidente. La función del controlador PID, cómo ya se ha explicado es rectificar la potencia de los motores para la corrección de la inclinación hasta la deseada. Veamos lo en imágenes.

z

a.

x

z

b.

x

y

g

g

y

c.

z

z

d.

y x

x y

g

g

z

e.

Roll(grados)

(a) x

g

y

(b)

(c ) (d)

(e)

30º 0º

t Figura 31: Resultado del control PID ante un desequilibrio inesperado.

De la misma manera el control PID nos valdrá para mantener la inclinación deseada en el Pitch del UAV, haciendo posible el avance (>0º), retroceso (<0º), o movimiento nulo (=0º).

Comunicación con el UAV: un paso más allá.

En éste apartado no trataremos en la implementación del sistema de comunicación, pues se desarrollará en capítulos posteriores sino que daremos una visión global del sistema que implementará el t-coptero, objetivo del proyecto.

Como ya se ha comentado anteriormente los sistemas de comunicación más habituales en los UAV y más concretamente en los multi-rotores son los constituidos por emisoras radio-control de corto y medio alcance. Las emisoras por radio-

frecuencia, usadas desde hace muchos años han ido mejorando en estos últimos años el rango de uso y la seguridad en las transmisiones, empleando diversos sistemas para evitar las colisiones entre varias señales, y todo esto a un precio muy económico.

Actualmente se siguen usando las emisoras radio-control para el control de muchos UAV’s pero están siendo reemplazadas por sistemas más modernos de comunicación basadas en protocolos más robustos y eficientes. Ejemplos de estos sistemas de comunicación más modernos son los enlaces por satélite, comunicaciones wifi, zigbee o bluetooth, entre otros.

En los inicios del proyecto se optó por el uso de un sistema de comunicación zigbee, caracterizada por ser similar a las redes wifi pero mejorando el consumo energético y el alcance entre nodos. Más adelante se optó por ir un paso más adelante e implementar un sistema de comunicación basado en una tendencia actual: las aplicaciones web.

Con una comunicación tipo wifi o zigbee podríamos crear una aplicación que hiciera de panel de control para comunicarnos con el UAV mientras estuviera dentro del alcance de la señal wifi pero necesitaríamos un ordenador donde instalar dicha aplicación y el alcance de señal dependería mucho de las antenas utilizadas, necesitando un equipo considerable para poner en funcionamiento nuestro t-coptero. Pero ahora pensemos en un sistema de comunicación basado en internet y en sus posibilidades. Imaginemos un panel de control para nuestro UAV al que poder acceder desde cualquier dispositivo con acceso a internet y un navegador web para poder ejecutarlo y que las instrucciones se transmitieran desde éste al UAV de la misma manera, por internet.

Enumeremos algunas de sus ventajas: 

 

Cobertura muy por encima de los sistemas por radio-frecuencia convencionales. Podríamos mandar instrucciones al UAV estando éste situado a miles de kilómetros de nuestra posición.

Posibilidad de controlar el UAV con una gran variedad de dispositivos, incluyendo un Smartphone o tablet con acceso a internet, entre otros.

Posibilidad de controlar más de un UAV al mismo tiempo, aunque estén situados en posiciones muy alejadas entre ellos.

Vistas las posibilidades de una comunicación de tales características el paso siguiente es preguntarnos que es necesario para hacer posible tal sistema de comunicación. En primer lugar una aplicación web con la funcionalidad de un panel de control, alojada en un servidor al que poder acceder desde un navegador web. En segundo lugar un modo de comunicar el servidor web con el t-coptero para poder transmitir las instrucciones recibidas en el panel de control, pero ¿Cómo comunicamos el panel de control con el aparato?

Respondiendo a la anterior pregunta se ha optado por incluir en el sistema un móvil con sistema operativo Android, que formará parte del UAV. El uso del móvil además de permitir la comunicación del aparato con el panel de control añadirá al sistema una tercera unidad de procesamiento muy superior a las anteriores con posibilidades enormes para un futuro. Queda claro que el dispositivo android será el enlace entre el panel de control, situado en un servidor, y la unidad de control del t-coptero pero para hacer posible la comunicación tendremos que resolver dos cuestiones importantes: 1. Implementar la comunicación entre el dispositivo Android y la unidad de procesamiento principal del t-coptero, la placa FezPanda.

2. Implementar la comunicación entre el dispositivo móvil con el servidor donde estará alojado el panel de control.

Estos importantes aspectos serán tratados a fondo en el capítulo destinado al diseño del sistema de comunicación que veremos más adelante.

Para comprender mejor la composición de los sistemas de control y de comunicación tenemos el siguiente esquema donde podemos apreciar cómo se relacionan de manera simplificada los componentes descritos tanto para el sistema de control como para el de comunicación que permitirán tanto la estabilidad y control del aparato como la comunicación con el operario a través del panel de control. En el esquema estamos omitiendo muchos de los componentes como motores, controladores, batería, etc, para no complicar la comprensión, ya que más adelante mostraremos de manera más concisa las relaciones entre todos los componentes.

ArduIMU v2 Matriz DCM Ángulos de vuelo

FezPanda II Algoritmos PID Control motores

Xperia Arc (Android 2.3) Aplicación cliente

t-copter - UAV Servidor WEB Control conexiones Servir Panel Control

Panel de Control Interacción con usuario

Figura 32: Esquema de interacción de componentes del sistema.

En la imagen podemos ver los componentes más importantes en cada uno de los subsistemas del proyecto. En primer lugar tenemos el t-coptero en el que destacamos la IMU, la placa de proceso FezPanda y el dispositivo móvil Android. Cómo se ha comentado con anterioridad, la IMU es la encargada de calcular los ángulos de vuelo a través del algoritmo DCM y sus debidas correcciones y transferir dichos ángulos a la placa FezPanda, la encargada de realizar los cálculos más costosos como el control PID sobre los motores y la comunicación con el dispositivo Android. El móvil Xperia Arc se encarga de hacer de puente entre el sistema de control implementado por la FezPanda y el servidor web, encargado de servir el panel de control al usuario del UAV. Como se puede apreciar una comunicación via wifi o zigbee hubiera sido una opción mucho más sencilla y podríamos dedicar más tiempo a perfeccionar el control del vuelo del aparato. Sin embargo, un sistema de comunicación de éstas características hace del UAV un proyecto más atractivo y con más opciones de cara a unos futuros

proyectos. Esto desemboca en que el desarrollo del sistema de comunicación e implementación del panel de control será la fase del proyecto más costosa y en la que más tiempo dedicaremos para conseguir una comunicación de calidad.

Funcionalidad del prototipo Antes de empezar a detallar paso a paso la construcción del UAV y del panel de control se va a describir la funcionalidad que cabe esperar del t-coptero una vez finalizado el proyecto. Durante este capítulo de análisis hemos podido ver de manera general las particularidades del sistema que se va a desarrollar, de manera que falta por resaltar los requisitos u objetivos que cabrá esperar del prototipo desarrollado. Debido a la naturaleza del proyecto, la construcción de un UAV, no podemos pretender construir un prototipo de altas prestaciones, pues construir un modelo comercial de las características que pretendemos costaría una inversión económica importante y la mano de obra de varios ingenieros en distintos campos. Pretendemos construir un prototipo de bajo coste que realice algunas funciones muy básicas pero que iguale o supere en algunos campos a modelos comerciales con un coste mucho superior a este proyecto.

Los requisitos que se contemplan para éste proyecto son los siguientes:   

 

El t-coptero debe tener un vuelo estable, por lo que el sistema de control estabilizará el aparato en todos sus ejes.

El panel de control implementado debe ser accesible desde distintas plataformas como ordenadores, móviles, tablets, etc.

Debemos poder controlar el aparato desde el panel de control en movimientos muy básicos como: elevarse o descender, avanzar o retroceder y girar en una dirección u otra.

Debemos poder modificar los parámetros de control de los controladores PID desde el panel de control para ajustar el vuelo a nuestras necesidades.

El panel de control debe proporcionar además de los controles del aparato, información relacionada con los ángulos de vuelo actuales en cada instante, actualizándose en el navegador.

Para poder cumplir éstos requisitos habrá que ir superando otros aspectos no mencionados que iremos descubriendo en el próximo capítulo, destinado al diseño del aparato, donde podremos apreciar con mucho más detalle la fabricación de inicio a fin de nuestro multi-rotor, o como ya hemos mencionado en numerosas ocasiones, nuesto t-coptero.

Diseño Descripción.

Hemos llegado a la etapa de diseño, donde vamos a recorrer el proceso seguido para la construcción del UAV e implementación de su sistema de control. Empezaremos dando una visión muy general de la construcción de la estructura sin entrar en demasiados detalles pues es la parte del proyecto que menos importancia debe tener. Después describiremos el montaje de los componentes eléctricos (motores, controladores, batería) para más tarde centrarnos en los aspectos más importantes, la unidad de control y el sistema de comunicación. Cuando lleguemos a éstas dos últimas partes detallaremos tanto la instalación de los dispositivos que los componen así como su programación interna necesaria para cumplir su función. De la misma manera describiremos paso a paso el desarrollo del software externo al UAV alojado en el servidor web que nos permitirá controlar el aparato remotamente desde un navegador web.

Estructura y soporte.

La relación existente entre el peso del aparato y la autonomía de las baterías hace que para la construcción de las aeronaves se busque siempre materiales resistentes pero a la vez ligeros. Para la construcción de nuestro t-coptero se ha utilizado en su mayor parte fibra de carbono y aluminio.

Se han utilizado algunas piezas de algunos modelos de helicópteros radio control para simplificar el diseño y ahorrar tiempo en la construcción de la estructura y otras han sido fabricadas a partir de hojas de fibra de carbono de 1mm de espesor y de tubos de 12mm también de fibra de carbono.

Como ya se ha dicho, la configuración elegida para el multi-rotor ha sido de t-coptero (motores dispuestos en forma de T). Las piezas que se han tenido que fabricar han sido diseñadas por ordenador en CorelDraw, un conocido programa de diseño y cortadas en hojas de fibra de carbono de 1mm de grosor con un minitaladro tipo Dremel. Éstas, atornilladas con tornillos metálicos y algunos separadores de nylon conforman el cuerpo central del t-coptero, sujeto sobre un patinete de helicóptero de un modelo radio control. A continuación podemos ver con detalle las plantillas (no en tamaño real) utilizadas para cortar las piezas de fibra de carbono para el cuerpo del t-coptero y para el soporte de los motores.

Figura 33: Miniaturas de las plantillas utilizadas para el corte de las piezas en fibra de carbono.

Lo que acabamos de ver sería el cuerpo central del aparato. Para los ejes que soportan los motores y que tienen la singular forma de T se han utilizado tubos de 12mm de diámetro exterior y 10mm de diámetro interior fabricados también en fibra de carbono que irán sujetos a la estructura central con unos bloques de aluminio que son unas de las piezas de repuesto de helicópteros rc utilizadas.

En la siguiente figura podemos observar el cuerpo central del UAV y cómo se ha dispuesto en varias plataformas donde irán colocados los distintos elementos del sistema.

Figura 34: Vistas del cuerpo del UAV formado con hojas de fibra de carbono.

De la misma manera en la parte inferior una de las piezas en fibra de carbono servirĂĄ de soporte para sujetar la baterĂ­a que alimentarĂĄ al sistema.

Figura 35: Detalle inferior del aparato y vista del soporte de la batería.

Ahora que la estructura está casi montada veamos las monturas sobre las cuales irán situados los motores. Primero analicemos las dos monturas que sujetaran los motores principales. Éstas al igual que el cuerpo, están hechas con fibra de carbono y están sujetas al tubo mediante unas abrazaderas de aluminio, piezas de un modelo de helicóptero radio control. De ésta manera tenemos la base sobre la cual irán atornillados los motores principales, encargados de levantar la mayor parte del peso del aparato. Veamos una de éstas monturas en detalle:

Figura 36: Detalle de una de las dos monturas de los motores principales.

El tercer soporte, el que cargará con el motor de cola es algo más complejo que las dos monturas explicadas anteriormente. La complicación radica en que el soporte tiene que bascular para permitir el giro del motor, de manera que el t-coptero pueda realizar giros. Para éste extremo lo que hemos hecho es fijar el soporte de fibra de carbono a un trozo de tubo de también de carbono de unos 25mm con las mismas abrazaderas de aluminio de los dos casos anteriores. Éste trozo de tubo con el soporte estará unido al tubo que forma la cola del t-coptero con un eje metálico pegado a 4 rodillos de bolas para permitir un giro fino sin holgura. Observemos el esquema y la imagen real de cómo está sujeta a la cola el soporte giratorio que albergará el motor de cola.

Figura 37: Detalle de la sección del tubo de cola.

En la imagen anterior podemos apreciar la sección del tubo para poder ver como un eje de acero une las dos piezas y se sujeta a los tubos de 12mm con rodillos de bolas (en rojo) que permiten que el soporte del motor pueda girar. Ahora la imagen real.

Figura 38: Detalle del soporte basculante del motor de cola.

Para completar el diseño de la estructura hemos añadido unos patines o esquíes de helicóptero a nuestra estructura para darle robustez y estabilidad a la hora del despegue y aterrizaje. Éste es el resultado de cómo ha quedado la estructura al completo que por supuesto queda pendiente de mejoras y adaptaciones para futuras modificaciones del UAV.

Figura 39: Imagen de visión general de la estructura al completo.

Ahora que tenemos la estructura estamos listos para montar los motores, controladores y servo, como veremos en el apartado siguiente.

Motores y controladores.

Como ya hemos comentado con anterioridad el t-coptero se basa en dos motores principales que harán la mayor parte de la fuerza de elevación y un tercero, que realizará la función de timón para dirigir el aparato.

Los motores principales elegidos son dos motores Turnigy L3015A de 580W cada uno, que con una alimentación de 12V pueden requerir corrientes de hasta 52 amperios.

Para poder controlar éstos motores se han utilizado dos controladores (ESC) Turnigy capaces de funcionar a corrientes de hasta 60 amperios. Para el motor de cola se ha optado por un motor Turnigy 28-26-azj de 160W junto con un controlador de la misma marca de 18 amperios.

La colocación de los motores en la estructura no tiene ninguna complicación. Los dos motores principales y el de cola simplemente van atornillados a sus respectivos soportes.

Por otra parte los controladores de los motores (ESC) van sujetos sobre la primera base de fibra de carbono de la estructura como podemos ver en la imagen siguiente.

Figura 40: Detalle de la instalación de los controladores (ESC) en la estructura.

Cabe destacar que los cables de alimentación de los 3 ESC irán unidos, quedando de ésta manera dos cables, uno positivo y otro negativo, de manera que podamos más tarde conectarlos a la batería. La conexión con los motores es simple, los tres cables que salen de cada ESC conectarlos con sus respectivos motores y los cables de señal de cada ESC los conectaremos más tarde a las salidas PWM de la FezPanda.

Junto a los tres cables para los motores y los dos cables para la batería en la mayoría de los ESC’s comerciales tenemos 3 cables más finos, uno para la señal (en color blanco) que controlará el ESC y que ya hemos comentado y otros dos. Éstos dos cables se tratan de uno negro que se corresponde a masa o GND y otro rojo con una salida de +5V. Más adelante, como ya explicaremos, usaremos ésta salida de 5V para alimentar las placas del sistema de control y el servo del aparato.

En la imagen anterior se puede aprecia cómo van conectados los controladores con los motores pero veamos más claro con un esquema de conexión entre ESC’s y motores.

Motor A

ESC 60A

pwm1

ESC 60A

Motor B

pwm2

ESC 18A

pwm3

Motor C

Figura 41: Esquema de conexión del cableado entre motores y ESC’s.

Visto ya el montaje de los tres motores podemos ver que los dos principales no tienen ninguna complicación puesto que permanecerán agarrados en posición perpendicular al aparato en todo momento pero el motor de cola no, éste último debe poder rotar de acuerdo a las instrucciones de la unidad de control. Para ello se ha instalado un pequeño servo digital de 2kg de torque que tendrá la función de producir el giro en el soporte del motor. Para ello utilizamos unos agarres (piezas de repuesto de un helicóptero) que fijan el servo al extremo de la parte fija de la cola y de ésta manera con un pequeño brazo de nylon hacer girar el soporte giratorio que aguanta el motor.

Para entender mejor la instalación y uso del servo mejor observémoslo en una imagen.

Figura 42: Detalle de la instalación del servo en el extremo de la cola del aparato.

Como podemos observar, el servo tiene sujeto a su brazo de nylon una segunda pieza o brazo con articulaciones de bola en los extremos que hace de unión entre el brazo

del servo y el soporte giratorio donde se aloja el motor. El cable del servo por donde recibe el voltaje para funcionar y la señal PWM para funcionar lo conectaremos más tarde como ya explicaremos cuando entremos en detalles en el sistema de control y el sistema de alimentación.

Unidad de control.

Por ahora ya tenemos listos los motores y controladores y sujetos a la estructura en lo que formarían la primera planta de la estructura, que como ya hemos dicho se compone de diferentes planchas de fibra de carbono separadas con separadores de nylon. Pues ahora tratemos la unidad de control del aparato, situada en la parte superior del UAV. Como ya hemos dicho en la etapa de análisis, la unidad de control se compone de la ArduIMU y la placa FezPanda que actúan de manera conjunta, una calculando los ángulos de vuelo y otra realizando el control del aparato. Si bien es cierto que podríamos incluir también en ésta etapa el uso y conexión del dispositivo android junto al FezPanda y la implementación del programa android, ésta parte la retrasaremos para cuando tratemos el sistema de comunicación.

Para hacer lo más comprensible posible ésta parte, tratemos la instalación y uso de las dos placas por separado.

Obteniendo los ángulos de vuelo.

Como ya hemos hablado, para poder controlar y estabilizar el aparato necesitamos calcular los ángulos de vuelo. Y para el cálculo de éstos tenemos la placa ArduIMU v2, una placa de medición inercial con los sensores y microcontrolador suficientes.

Primero trataremos el programa implementado para la IMU y luego la instalación en la estructura.

Programación de la IMU

La programación de la placa se ha hecho a través del ide gratuito de Arduino y cargada en la placa a través de la conexión su conexión serie y un adaptador usb-ftdi.

El lenguaje utilizado para la programación con Arduino es un lenguaje similar al C con algunas funciones de C++ y alguna otra particularidad que no hablaremos para no

extendernos demasiado. Para Arduino un programa está compuesto por al menos dos partes necesarias. void setup(){ … } void loop(){ … } La parte o función setup() se ejecuta una sola vez y se utiliza para inicializar los modos de trabajo de los pins, los puerto serie, inicialización de variables, etc. Debe ser incluido en el programa aunque no haya declaraciones que ejecutar.

Después de llamar a la función setup(), la función loop() realiza el bucle principal, éste se ejecuta de manera cíclica permitiendo que el programa pueda responder continuamente ante los eventos que se produzcan en la tarjeta.

Dicho esto, para poder calcular los ángulos de vuelo se ha implementado el algoritmo DCM, que como ya sabemos calcula la matriz de rotación del aparato en referencia al suelo. Empecemos a ver cómo se ha implementado el programa principal a través de un diagrama de flujo que representa el transcurso del programa en la IMU, destacando las partes más importantes, teniendo en cuenta que el código se entrega junto a la memoria.

Inicialización Serie

setup() Calibrado Sensores

Lectura de valores analógicos de los sensores

loop() Actualización de la matriz DCM

Normalización

Corrección Deriva

Cálculo de los ángulos de Euler

Enviar datos por Serie

Figura 43: Diagrama de flujo del programa cargado en la IMU. El programa se compone de 3 partes. La primera es donde se declaran las variables y definen las constantes que se usarán en la aplicación. Constantes como los valores de los parámetros P e I de los controladores PI que el algoritmo DCM utilizará para corregir la deriva en los gyros. La segunda parte corresponde a la función setup() donde inicializaremos el sistema y la tercera al loop() que implementará el algoritmo DCM. Veamos estas partes por separado para una mejor comprensión.

Inicializaciones: setup()

En ésta función se inicializa la conexión serie de la placa para poder enviar más tarde los ángulos de vuelo a través de la conexión serie de la ArduIMU. También se realiza una inicialización en las lecturas de los giroscopios y los acelerómetros. Ésta consiste en hacer unas lecturas de calentamiento que se desechan

y más tarde unas cuantas lecturas de las que sacamos la media para tenerlas como el estado inicial de los sensores.

Implementación del algoritmo DCM: loop()

Tras la captura del estado inicial de los sensores en el setup() entramos en el bucle principal que se repetirá de manera continua hasta que se deje de alimentar la IMU. En el bucle la tarea que se repetirá es la del cálculo de la matriz de rotación DCM para la obtención y envío a través del serial de los ángulos de vuelo. Podemos dividir las tareas que realiza el bucle en estas funciones que se irán repitiendo en dicho orden y de manera iterativa: 1.

2.

3.

4.

5.

6.

Lectura de los datos analógicos de los sensores.

Actualización de la matriz DCM. Normalización.

Corrección de la deriva.

Cálculo de los ángulos de Euler o ángulos de vuelo.

Envío de los ángulos obtenidos a través de la conexión serie de la placa.

Una vez están los ángulos de Euler o de vuelo calculados el proceso siguiente como hemos visto en la lista anterior es enviarlos a la placa FezPanda II. Ya que la información se envía siempre al final de ciclo y ésta tarea es de duración indefinida, cuánto mejor tasa de envío tengamos mejor. Para lograr mayor velocidad en el envío y por tanto más velocidad en el ciclo la información la enviaremos en binario a través del puerto serie. Además para verificar que la información no se ha transmitido de manera errónea se ha incorporado dos checksum anidados en la trama enviada para verificar su integridad en la FezPanda II, la placa destino.

Conexión e instalación de la IMU en la estructura

Los giroscopios son sensores bastante robustos que no son muy sensibles a los movimientos lineales ni a las vibraciones pero los acelerómetros, usados para eliminar la deriva de los gyros si son sensibles a las vibraciones y debido a éstas podemos tener un mal funcionamiento de la IMU al obtener los ángulos de vuelo.

Para la instalación de la IMU sobre la estructura se ha probado varios sistemas que incluye el amarre de la placa sobre un material poroso para tratar que éste absorbiera las vibraciones, la suspensión de la placa por medio de gomas elásticas sobre la estructura, entre otras, pero las vibraciones persistían y eran lo suficientemente fuertes como para que los ángulos obtenidos fueran erróneos. La solución ha sido envolver la placa entre dos placas de aluminio para agregar peso al dispositivo y esto

sujetarlo a la estructura por medio de 4 tacos de espuma de manera que éstos absorban las vibraciones. Ésta solución ha permitido eliminar las vibraciones en gran medida que afectaban a las lecturas de los acelerómetros. Veamos la IMU dentro de las piezas de aluminio y el conjunto instalado en la parte superior de la estructura.

Figura 44: Soporte de aluminio de la IMU e instalación del conjunto sobre la estructura.

Como ya se ha dicho, la IMU se comunica a través de una conexión serie con la FezPanda de manera que utilizaremos los 4 pines de la placa que se corresponden con gnd, 5V, RX y TX. Por una parte tenemos los dos cables de datos (tx y rx) y los dos pines para alimentar la IMU a 5V. Veamos el esquema de conexión entre las dos placas ArduIMU y FezPanda y los pines utilizados encada una de ellas.

Figura 45: Esquema de conexión entre placas ArduIMU y FezPanda II. El esquema de conexión anterior muestra cómo hemos conectado la IMU con la FezPanda para transmitir vía serie los ángulos de vuelo desde la primera hasta la segunda. Cabe destacar que la IMU se alimenta a través de la salida de 5V de la FezPanda ya que el consumo de la IMU no es muy superior y no supone una gran carga para la segunda. Como podemos apreciar los pines rx y tx (recepción y envío) de la IMU lo conectaremos con los pines 33 y 31 respectivamente de la FezPanda que se corresponden con unos pines tx y rx de una de las conexiones serie de ésta. Cabe destacar que un pin rx de una placa se conecta con un pin tx de otra y viceversa. Ahora que tenemos claro el funcionamiento de la IMU en el sistema veamos cómo trabaja la unidad de procesamiento principal del aparato.

Procesamiento y control del aparato El algoritmo de control del aparato se realiza en la placa de desarrollo FezPanda II por disponer de un micro controlador más potente que la IMU, que pueda ofrecer una buena frecuencia en el algoritmo de control. Veamos ahora paso por paso como hemos instalado la tarjeta a la estructura, cómo se han conectado todos los dispositivos a los pines de la placa y finalmente como hemos realizado el algoritmo de control encargado de estabilizar y dirigir el aparato.

Instalación de la FezPanda II en la estructura.

El sujetar la placa a la estructura ha sido simple ya que se han utilizado separadores y tornillos de nylon para sujetar la placa sobre la plancha superior fibra de carbono, junto a la IMU. En la imagen podemos ver cómo queda y la situación de la placa junto a la IMU.

Figura 46: Instalación de la placa FezPanda II sobre la estructura del t-coptero.

Cableado de los distintos dispositivos a la placa.

Antes de ver los detalles del algoritmo utilizado para el control del aparato vamos a tratar el cableado y conexión de cada uno de los componentes del UAV a la placa FezPanda y a que pines los conectamos y porqué. Veamos el esquema de cómo se han conectado los dispositivos.

ESC 60A

ESC 60A

ESC 18A

Figura 47: Esquema de conexión de los diferentes dispositivos con la placa FezPanda II. En la imagen podemos ver los dispositivos conectados con la placa: la IMU, los tres controladores de motor y el servo. El cable de señal o entrada pwm de los controladores se conectan con los pines PWM 1, 2 y 3 respectivamente de la placa mientras que conectamos el pin PWM 5 con el cable de señal del servo de cola.

También conectamos el cable de toma tierra de los controladores al pin gnd de la placa.

Programando la FezPanda II

Como ya se ha dicho, ésta placa corre bajo el Micro framework .NET de Microsoft y para programarla se ha usado el entorno de desarrollo Visual C# Express , el cual es gratuito y trabaja con el lenguaje C# (C-Sharp).

Como ocurre con Arduino, el programa en C# para la placa que estamos programando se puede dividir en diferentes bloques o partes. Después de las referencias a librerías externas que todo programa tiene, tenemos la clase que encapsula el programa principal. Ésta clase se compone de las declaraciones de las variables de la clase y de los métodos de la clase, destacando que como diferencia con las otras clases, ésta, tendrá un método Main() que contendrá el programa principal. El método Main() se divide en dos partes importantes y necesarias, pues son los símiles a las funciones setup() y loop() de Arduino. En éste caso empezamos el método con las inicializaciones de variables y clases, y terminamos con un bucle infinito que se encarga de repetir el código contenido en el bucle de manera indefinida.

#referencias a librerías Class program { Declaraciones ; Void main() { Inicializaciones; While(true) { Instrucciones del bucle; } } }

Esquema que sigue un programa en C# para la placa FezPanda II. Atendiendo a las necesidades del control básico del aparato se han desarrollado varias clases para una mejor estructuración y reaprovechamiento de código. Se han realizado las siguientes clases: 







Clase 1. Clase para la comunicación entre la IMU y la placa FezPanda II. Lo que hace es abrir una comunicación serie con los pines conectados con la IMU y dispone de un método el cual lee los bytes de información de la entrada serie, comprueba los Checksum y si la información no se ha corrompido en el envío, se devuelve el valor actual de los tres ángulos de vuelo: roll, pitch y yaw.

Clase 2. Clase para la comunicación serie con el PC. Se habre una comunicación serie con los pines conectados con el conversor FTDI-USB para la comunicación con un terminal en el PC. Tiene métodos para la lectura y escritura en el canal. Ésta clase es utilizada para hacer pruebas y debuggear el programa.

Clase 3. Clase para el controlador PID. Ésta clase implementa de manera genérica un controlador PID. Hay que destacar, que además de variar los parámetros característicos, permite marcar unos límites superior e inferior para la salida del controlador.

Clase 4. Clase para la comunicación con el dispositivo Android. Ésta clase se ha realizado para permitir una comunicación entre la placa FezPanda II y el Smartphone con Android utilizado para la comunicación 3G. Permite tanto enviar como recibir cadenas de texto a través de la conexión USB de la placa utilizando el protocolo de comunicación ADB de Android. Más adelante, cuando tratemos el sistema de comunicación se describirá con más detalle en qué consiste éste protocolo y cómo se ha implementado la librería.

Algoritmo de control

El control del aparato se basa en una continua corrección de la potencia de los motores a través de unos controladores PID, para alcanzar en cada uno de los ángulos de vuelo el ángulo requerido u objetivo. Esto significa que para que el motor avance o retroceda y para que se mantenga estable en un plano horizontal al suelo habrá que actuar sobre los controladores PID que manejan los motores. El cambio de dirección sin embargo, como no disponemos de sensores para eliminar la deriva del gyro, no estará regulado por un controlador PID, sino que actuaremos directamente sobre el ángulo del motor con respecto al aparato, que si recordamos varia por la acción de un servo.

Por ejemplo, si queremos que el t-coptero avance, indicaríamos al controlador PID que se encarga del control en el ángulo Pitch que queremos un ángulo objetivo de 10º.

Esto haría que el controlador aumente la potencia del motor de cola hasta alcanzar la inclinación de 10º produciendo el avance como consecuencia.

Aquí tenemos de manera simplificada el diagrama de flujo de la aplicación desarrollada para el control del t-coptero, para más adelante tratar con más detenimiento las partes más importantes del mismo.

Inicio

Inicializaciones

NO ¿Tiempo_transcurrido >= Periodo?

SI Actualización de los ángulos de vuelo

Cálculo correcciones por PID

Actualización potencia de los motores

¿Órdenes desde dispositivo Android?

NO

SI Actualización parámetros según órden/órdenes del dispositivo móvil

¿Módo Depuración?

NO

SI Escribir información por salida Serie al conversor FTDI-USB

Figura 48: Diagrama de flujo del programa de control del aparato.

El algoritmo se compone por las inicializaciones de las variables y clases y el cuerpo del bucle principal que se repetirá de manera indefinida ejecutando las acciones de control pertinentes. Tomando como referencia el diagrama anterior, desconpongámos el algoritmo y veamos las partes más importantes del mismo.

Inicializaciones.

Cuando se pone en funcionamiento la placa FezPanda II, y por tanto arranca el algoritmo programado, la primera fase es la que realiza las inicializaciones. Ésta región de cógido sólo se ejecutará una vez antes de entrar en el bucle que se repetirá hasta la desconexión de la placa, por esto es importante una correcta inicialización de las variables y clases para que no se produzcan errores inesperados durante la ejecución del programa. Estas son las tareas que se realizan en ésta sección de código:      

Inicialización de la comunicación serie con la IMU. Inicialización de la comunicación serie con conversor FTDI-USB. Inicialización de la comunicación ADB con Android.

Inicializamos variables y salidas PWM. Asignamos a los motores la potencia mínima y posición neutra al servo.

Iniciamos los controladores PID y sus límites de salida.

Actualización de los ángulos de vuelo.

La obtención de los ángulos de vuelo actuales es el primer paso dentro de la parte cíclica del programa. Para tener un correcto control sobre los motores y por tanto, una buena estabilidad, los controladores PID se deben calcular la corrección de manera constante, es decir, actuar con una frecuencia determinada, que se corresponde con la frecuencia de ejecución del bucle principal. En nuestro caso para el control del aparato se realizará el bucle con un periodo de 5 milisegundos, o lo que es lo mismo, 200 iteraciones por segundo. Para asegurarnos de cumplir con dicha frecuencia al inicio de cada iteración se realizará una espera hasta que se hayan completado los 5 milisegundos del ciclo anterior para realizar el nuevo. Una vez se inicia la iteración se hace una lectura, a través de un método de la clase adecuada, de los últimos valores enviados por la IMU correspondientes a los ángulos Roll, Pitch y Yaw. El método de lectura de los ángulos lee la cadena de bytes del canal serie y si los checksum son correctos se descompone la trama en los tres segmentos que forman los tres ángulos de vuelo. De no ser correcto alguno de los dos chechsum el método devolverá los ángulos de vuelo del instante anterior.

Correcciones con los controladores PID.

Después de la actualización de los ángulos de vuelo y conocida la nueva posición del aparato en referencia al suelo podemos actuar sobre los motores para rectificar la posición utilizando controladores PID. Cómo ya se ha dicho, se ha implementado una clase que efectúa un control PID genérico, de manera que la podemos utilizar para distintos ejes. Para la estabilidad del aparato, necesitaremos un controlador PID en el eje X (ángulo Roll) y otro en el eje Y (ángulo Pitch), quedando el movimiento sobre el eje Z(ángulo Yaw ) a cargo del conjunto motor-servo de la cola del t-coptero. Dicho de otra manera, para la estabilidad del aparato y para hacerlo avanzar o retroceder actuaremos sobre los parámetros objetivos de los dos controladores PID, mientras que para la orientación del t-coptero actuaremos directamente sobre la inclinación del servo que rota el motor de cola. Para que quede totalmente claro cómo funcionará el control del aparato veámoslo con unos ejemplos: 



Queremos que el aparato avance lentamente. Tenemos que para Pitch=0, se mantiene estacionario, para Pitch>0 el aparato avanzaría y para un Pitch<0 retrocedería. Modificaríamos el objetivo en el PID que controla el ángulo Pitch a por ejemplo 5grados.

Queremos que el aparato gire levemente hacia la izquierda. Actuaríamos sobre el servo para que con el movimiento de su brazo rotara el motor levemente hacia la derecha, de manera que la fuerza generada por éste hiciera rotar el aparato hacia la izquierda.

La clase PID implementa el algoritmo descrito en la fase de análisis de manera que a través de unos métodos introducimos en cada iteración del bucle la inclinación actual, y el objetivo para que el controlador nos devuelva la corrección ante el error cometido.

Después de actualizar los ángulos de vuelo, el algoritmo procede actualizando los ángulos actual y objetivo de ambos controladores PID. Si dicho objetivo para los ángulos Roll y Pitch no han sido modificados por alguna orden recibida del dispositivo android, permanecerán igual a la iteración anterior y si han sido modificados, pues serán actualizados los PID y en esa misma iteración ya se tendrán en cuenta para calcular el error.

Atendiéndonos a lo visto en cuanto a señales PWM los motores se controlan enviando una señal al controlador que lo maneja. El pulso de dicha señal estará entre 1 y 2 milisegundos, que otorgan la mínima y máxima potencia respectivamente. En el código se asigna la potencia a los motores de diferente manera, así pues para los dos motores principales la potencia se asigna atendiendo a la potencia asignada desde el panel de

control y a la corrección PID, mientras que para el motor de cola tan solo actúa el controlador PID: Potencia_motor_principal = Compensación + Potencia_control + Control_PID Potencia_motor_cola = Potencia_motor + Control_PID 

  

Compensación: Es utilizada para igualar desde el inicio ambos motores en caso de diferencias físicas o de funcionamiento entre los dos, por ejemplo en el caso de que los dos motores no iniciaran al mismo tiempo el movimiento.

Potencia_control: Es la potencia asignada por el usuario desde el panel de control.

Potencia_motor: Potencia mínima que hace mantener la cola del t-coptero en el plano horizontal en plena suspensión del aparato.

Control_PID: Corrección sobre la potencia establecida por el usuario a fin de mantener la estabilidad o inclinación de cola adecuada.

Una vez se ha calculado el nuevo error cometido y su debida corrección para los ángulos Roll y Pitch, tenemos que dicha corrección será utilizada de manera diferente atendiendo al ángulo sobre el cual actúe el PID. En nuestro t-coptero tenemos los siguientes casos: 



PID para el control del Roll: La corrección obtenida para éste ángulo será utilizada como incremento en la potencia de uno de los motores principales y decremento en el motor opuesto.

PID para el control del PITCH: La corrección obtenida será sumada o restada a la potencia del motor de cola, elevándola o bajándola según sea necesario.

De ésta manera, después del cálculo de las correcciones PID se asignará a cada uno de los motores la nueva potencia calculada en base a los cambios desde el panel de control y a los controladores PID.

Ajuste de los parámetros PID

Como ya sabemos, las tres partes de un controlador PID son la parte Proporcional, la Integral y la acción Derivativa, y éstas dependen a su vez de los parámetros que las regulan. Para un ajuste óptimo de los controladores PID es necesario poder modificar éstos parámetros Kp, Ki y Kd en cualquier momento, pues no es lo mismo ajustar los controladores en un banco de pruebas que en vuelo. Para poder modificar los parámetros en la clase PID se ha incluido unos métodos que permiten el ajuste de éstos parámetros así como también acotar la salida del controlador.

De ésta manera el usuario puede ajustar los controladores PID modificando éstos valores desde el panel de control del aparato, como veremos más adelante, o incluso desde teclado en caso de tener activa la conexión serie con el pc para monitorizar el algoritmo.

Mensajes del dispositivo móvil.

La comunicación con el dispositivo móvil se realiza a través de la conexión USB de la placa FezPanda y del dispositivo móvil. No vamos a tratar el protocolo de comunicación todavía, lo veremos con más detenimiento en el apartado del sistema de comunicación. Para tratar la comunicación con el dispositivo de manera transparente se ha realizado una clase que nos permite recuperar las órdenes recibidas a través de un método.

En la fase de inicializaciones del programa principal encontrábamos que se inicializa la comunicación con el dispositivo android. Lo que realmente estamos haciendo es iniciar un hilo que permite a la clase ejecutar un código, paralelamente al algoritmo de control del aparato, para recibir las tramas desde el dispositivo móvil, en nuestro caso el Xperia Arc. De ésta manera, antes de finalizar la iteración actual de bucle de control de aparato, se comprueba a si han llegado tramas con información desde la última lectura. Para realizar ésta comprobación, al final del bucle se invoca un método de la clase que en primer lugar comprueba si ha llegado alguna cadena de datos desde el móvil, y de ser así se separa la trama en las diferentes órdenes enviadas y se ejecutan en el orden de llegada.

Cada orden enviada desde el dispositivo móvil incorpora un número id para identificar la orden y saber cómo interpretar los datos que le siguen. De ésta manera una vez se ha separado la trama en las diferentes órdenes, éstas se identifican y se ejecutan. En el caso de que no se hayan recibido órdenes a través de la conexión USB, el algoritmo seguirá su curso e iniciará una nueva iteración, repitiendo todas las fases que acabamos de ver.

Cuando tratemos más adelante el sistema de comunicación entenderemos por completo cómo se realizan los cambios en el sistema a través de las órdenes recibidas desde el dispositivo móvil. Por ahora hemos dado unas pinceladas para entender cómo se ha realizado el algoritmo de control sin entrar en detalles en la implementación de la clase que permite la comunicación con el móvil.

Modo depuración.

La ejecución del algoritmo en modo depuración no es más que la ejecución del mismo, tal como hemos visto en los apartados anteriores pero habilitando una salida al final de cada iteración donde se manda información sobre el estado de diferentes variables vía Serie al PC para ser mostrado en un Terminal. El modo de depuración se ha utilizado a lo largo de todo el proyecto como apoyo para la búsqueda y corrección de errores. Para cambiar la ejecución del programa de control de modo normal a modo depuración se ha utilizado una variable que guarda el tipo de ejecución que se está realizando. De ésta manera, al final de cada iteración después de la ejecución de las órdenes recibidas desde el dispositivo móvil, se comprueba si la ejecución es en modo depuración y de ser así, se envía la información vía Serie.

La comunicación Serie entre la placa FezPanda y el PC se ha realizado con un conversor FTDI-USB que hemos conectado a una de las conexiones Serie de la placa. La conexión se ha realizado de la siguiente manera:

GND GND

TX RX/D40 TX/D42

RX

Figura 49: Esquema de conexión entre FezPanda II y placa FTDI-USB De ésta forma a través de un terminal en el ordenador podemos observar de manera detenida el estado del aparato y controlar el funcionamiento del algoritmo en busca de errores y/o posibles problemas.

Alimentación.

Anteriormente se han explicado los diferentes tipos de baterías actuales y sus características. Para el proyecto, el sistema de alimentación de toda la electrónica se basa en una batería lipo de 3S, 4000 mAh y 30C. Debido a las diferentes necesidades de consumo de los diferentes elementos del UAV no hemos podido conectar todos los componentes directamente a la batería puesto que los controladores de motor se alimentan con voltajes de entre 2S y 4S, mientras que la FezPanda, la ArduIMU y el servo de cola se alimentan a 5V. Para no integrar en

el aparato una segunda batería de 5V ni un regulador de tensión que baje la tensión de la batería principal hasta los 5V necesarios para los componentes electrónicos se ha optado por utilizar una de las salidas de voltaje que incluyen los controladores ESC. La mayoría de modelos de ESC junto al cable de entrada de señal que permite su control incorpora dos cables más, uno con una salida de 5V y otro GND. Este voltaje estable a 5V y 3A, lo que nos permitirá alimentar el resto de componentes del aparato sin problemas.

No vamos a dar importancia a como se han soldado los cables a la batería ni conectores utilizados pues no es motivo de estudio en éste proyecto, pero si mostraremos un esquema en donde podamos apreciar el esquema de alimentación utilizado para todo el sistema.

ESC 60A ESC 60A ESC 18A

Figura 50: Esquema de alimentación de los diferentes componentes del sistema.

Sistema de comunicación.

Descripción.

El sistema de comunicación realizado se basa en comunicaciones vía sockets a través de internet. A través de un panel de control diseñado como una aplicación web, el usuario o piloto del aparato puede interactuar con el UAV o incluso ajustar los parámetros de control que regulan el Sistema de Control principal.

El panel de control ha sido diseñado en HTML y JavaScript utilizando los frameworks Jquery y Jquery UI para el diseño de los elementos gráficos y para mostrar a través de la aplicación datos e información del aparato actualizados dinámicamente, AJAX. De ésta manera, el usuario interactúa de manera gráfica con el panel de mandos, mientras éste realiza una conexión vía WebSocket con un servidor de sockets realizado en PHP que gestionará la comunicación entre el panel de control y el aparato.

Como hemos mencionado, el panel de control abre un socket con un servidor PHP, que al mismo tiempo tendrá abierto otro socket con el aparato, de manera que la información que se envíe desde el panel de control hacia el servidor PHP, ésta se pueda retransmitir al UAV. Éste tipo de comunicación centralizada en un servidor intermedio hace simple una posible comunicación del panel de control con más de un UAV al mismo tiempo.

Desde el otro lado de la comunicación, en el UAV, para poder mantener una conexión vía socket a través de internet con el servidor central necesitamos un dispositivo con conexión a internet. Se ha optado por embarcar en el aparato un dispositivo Android a través del cual una aplicación gestiona la información enviada/recibida del socket para enviar la respuesta al Sistema de Control del UAV. Veamos de manera simplificada un gráfico con los elementos que componen el sistema de comunicación realizado.

Figura 51: Detalle de los elementos que componen el sistema de comunicación.

De ésta manera podemos dividir el Sistema de Comunicación en tres elementos: El panel de control, el servidor central de sockets y el terminal Android embarcado en el UAV. En los siguientes apartados se va a describir con detalle los tres elementos que hemos destacado del sistema de comunicación. No obstante, haremos una breve descripción de las tecnologías o lenguajes utilizados, pero sin entrar en demasiados detalles para no extender demasiado el documento. Además se incluye información más detallada junto a la documentación de la memoria del proyecto para el caso en que se quiera profundizar más en alguno de los recursos utilizados.

El servidor.

Debido a que la mayoría de hostings, tanto gratuitos como de pago no permiten abrir comunicaciones sockets en sus servidores no dedicados, se ha optado por montar un servidor Web en exclusiva para la realización de éste proyecto.

El servidor en cuestión se compone de un Servidor Http Apache junto con el módulo de ejecución PHP para ejecutar el código del servidor de sockets.

Servidor Http Apache.

El servidor HTTP Apache es un servidor web HTTP de código abierto, para plataformas Unix (BSD, GNU/Linux, etc.), Microsoft Windows, Macintosh y otras, que implementa el protocolo HTTP/1.1 y la noción de sitio virtual. El servidor Apache se desarrolla dentro del proyecto HTTP Server (httpd) de la Apache Software Foundation.

Apache presenta entre otras características altamente configurables, bases de datos de autenticación y negociado de contenido, pero fue criticado por la falta de una interfaz gráfica que ayude en su configuración.

Apache tiene amplia aceptación en la red: desde 1996, Apache, es el servidor HTTP más usado. Alcanzó su máxima cuota de mercado en 2005 siendo el servidor empleado en el 70% de los sitios web en el mundo, sin embargo ha sufrido un descenso en su cuota de mercado en los últimos años.

La arquitectura del servidor Apache es muy modular. El servidor consta de una sección core y diversos módulos que aportan mucha de la funcionalidad que podría considerarse básica para un servidor web. En nuestro casi añadiremos el módulo de ejecución PHP para poder interpretar y ejecutar el código del servidor de sockets.

Comunicación basada en servidor de sockets.

Como ya se había descrito de manera simplificada anteriormente, el Sistema de Control lo podemos dividir en tres elementos principales de los cuales empezaremos con el desarrollo del segundo, el servidor de sockets, lo que facilitará la compresión del conjunto, y luego veremos porque. Repasemos antes de nada de que se trata un socket y cuál es su utilidad.

Socket designa un concepto abstracto por el cual dos programas (posiblemente situados en computadoras distintas) pueden intercambiar cualquier flujo de datos, generalmente de manera fiable y ordenada.

El término socket es también usado como el nombre de una interfaz de programación de aplicaciones (API) para la familia de protocolos de Internet TCP/IP, provista usualmente por el sistema operativo.

Los sockets constituyen el mecanismo para la entrega de paquetes de datos provenientes de la tarjeta de red a los procesos o hilos apropiados. Un socket queda definido por un par de direcciones IP local y remota, un protocolo de transporte y un par de números de puerto local y remoto.

En las comunicaciones a través de la red, cuándo es necesario transmitir datos de manera bidireccional entre dos nodos la mejor manera es utilizar sockets. A diferencia de otros tipos de comunicaciones con los sockets sólo se abre la conexión entre los nodos una sola vez, lo que permite una transmisión de datos de manera más fluida y rápida. Es por esto que la utilización de sockets es la mejor opción para la comunicación entre los distintos elementos del Sistema de Comunicación. Ahora ya sabemos que los sockets son el método de transmisión de datos utilizado, pero ¿Por qué utilizar un servidor de sockets entre el panel de control y el aparato cuando podríamos abrir un socket directamente entre éstos dos elementos?

La respuesta es simple. No podemos abrir un socket directamente entre el panel de mandos y el dispositivo Android situado en el aparato porque para la conexión a internet estamos utilizando la conexión 3g de un dispositivo móvil. Actualmente los dispositivos móviles cuando se conectan a la red a través de 3g no lo hacen con una IP estática, sino que lo hacen con una IP dinámica que no garantiza la misma IP para futuras conexiones. De ésta manera es imposible saber la dirección de red donde el panel de control debe enviar la petición de apertura del socket de datos. Y en el caso de que fuera el dispositivo Android el que abriera la conexión vía socket, tendría que estar lanzando peticiones de conexión continuamente, cosa poco deseable, hasta que el usuario abriera el panel de control para poder completar la conexión.

En nuestro caso, el servidor de sockets se ha implementado en la misma máquina que el servidor http, mejorando de ésta manera la velocidad de transmisión entre la aplicación web que implementa el panel de mandos y el citado servidor, sin embargo, y como veremos más adelante se implementó una primera versión del servidor que no ofrecía la fiabilidad ni las prestaciones que se requerían para éste tipo de control sobre un vehículo aéreo. Tras varias pruebas e investigación, se introdujo un cambio importante en la implementación del servidor, la utilización de una variante de los sockets más moderna, los websockets. Para el desarrollo del servidor se ha utilizado el lenguaje PHP.

PHP

PHP es un lenguaje de programación de uso general de script del lado del servidor originalmente diseñado para el desarrollo web de contenido dinámico. Fue uno de los primeros lenguajes de programación del lado del servidor que se podían incorporar directamente en el documento HTML en lugar de llamar a un archivo externo que procese los datos. El código es interpretado por un servidor web con un módulo de procesador de PHP que genera la página Web resultante. PHP ha evolucionado por lo que ahora incluye también una interfaz de línea de comandos que puede ser usada en aplicaciones gráficas independientes. PHP puede ser usado en la mayoría de los servidores web al igual que en casi todos los sistemas operativos y plataformas sin ningún costo.

Cuando el cliente hace una petición al servidor para que le envíe una página web, el servidor ejecuta el intérprete de PHP. Éste procesa el script solicitado que generará el contenido de manera dinámica (por ejemplo obteniendo información de una base de datos). El resultado es enviado por el intérprete al servidor, quien a su vez se lo envía al cliente. Mediante extensiones es también posible la generación de archivos PDF, Flash, así como imágenes en diferentes formatos.

Permite la conexión a diferentes tipos de servidores de bases de datos tales como MySQL, PostgreSQL, Oracle, ODBC, DB2, Microsoft SQL Server, Firebird y SQLite.

PHP también tiene la capacidad de ser ejecutado en la mayoría de los sistemas operativos, tales como Unix (y de ese tipo, como Linux o Mac OS X) y Microsoft Windows, y puede interactuar con los servidores de web más populares ya que existe en versión CGI, módulo para Apache, e ISAPI.

Implementación.

El principio de funcionamiento del servidor es sencillo, tenemos un panel de control y un helicóptero enviando mensajes a través de sockets a un servidor. En éste servidor, donde se reciben los mensajes se identifica el emisor de la trama y se reenvía a su destinatario. Si el mensaje capado por el servidor proviene del panel de control se envía al helicóptero a través de la conexión socket establecida con éste, y lo mismo en sentido contrario, si es el helicóptero quien envía el mensaje, la información se reenvía al panel de control.

Los mensajes enviados por los participantes en la comunicación se componen de distintos campos encapsulados en tramas. Son éstas tramas las que o bien contienen las órdenes que desde el panel de mandos se mandan al helicóptero o bien contienen

información enviada desde el helicóptero hacia el panel observado por el piloto.

Veamos cómo se descomponen las tramas: <id_mensaje|id_emisor|id_receptor|datos> id_mensaje: Identifica el tipo de información que se está enviando. Por ejemplo, ordenes de velocidad, información de estado de baterías, etc. id_emisor: Identifica el emisor del mensaje. id_receptor: Identifica el participante en la comunicación al que va destinado la trama de información. datos: Contiene la información a interpretar por el destinatario del mensaje para actuar en relación al tipo de mensaje.

En el caso del servidor al recibir un mensaje y separar los campos sólo se interpretarán los identificadores del emisor y el receptor, pues la única tarea del servidor es re direccionar los mensajes recibidos.

Primera implementación.

Cuando desde el navegador web ejecutamos una página cualquiera, en la que incluimos nuestro panel de control, el código que forman éstas páginas escritas en html, css, javascript y otros, se ejecutan en el lado cliente de la conexión, mientras los scripts PHP se ejecutan en el lado servidor de la conexión. Cómo desde el navegador no se puede abrir directamente un socket con el lado servidor de la conexión, la opción que se tomó en un principio fue que se llamaran a una serie de scripts en PHP que desde el lado servidor realizaran la conexión con el servidor de sockets.

De ésta manera, cuando desde el panel de control queremos dar una orden al helicóptero, ésta se crea en el panel de control en el lado del cliente y llama a ejecución un script en el lado servidor que abre una conexión socket con el servidor de sockets para transmitir la información hacia el helicóptero. Pongamos un ejemplo para verlo más claro: Supongamos que desde el panel de control generamos una orden de parada para los motores del helicóptero. Cómo no podemos abrir un socket desde el lado cliente, debemos ejecutar un script en PHP en el lado servidor al que le pasaremos la orden de parada de los motores, además de los demás campos en la trama de información. Éste script abrirá una conexión socket con el servidor de sockets y se enviará la trama, para que el servidor obtenga los identificadores y reenvíe al helicóptero la orden de parada de motores.

Ésta solución, que en un principio parecía válida, funciona correctamente para mensajes enviados con cierta separación entre ellos, pero no para mensajes enviados seguidos en un corto periodo de tiempo. Por ejemplo el control, de un joystick en el panel de control para variar la velocidad implica el envío de un mensaje por cada cambio de posición en el joystick, por lo que en un simple movimiento en aceleración puede implicar el envío de muchas tramas diferentes en un corto espacio de tiempo. El problema que encontramos con el envío de ráfagas de datos es que no se puede garantizar el orden de llegada de los paquetes, y esto en el ejemplo anterior puede suponer un accidente del aparato.

La causa de la llegada de las tramas desordenadas al destino en el envío a ráfagas es debido a que si bien una conexión por socket nos garantiza la llegada de los paquetes ordenados, realmente no estamos utilizando una misma conexión socket, sino que cada vez que se crea una trama en el panel de control y se realiza una llamada al script PHP para enviar la información por socket, se está utilizando una conexión independiente de las demás, y es aquí donde, si se realizan muchas conexiones seguidas en un corto periodo de tiempo pueden llegar desordenadas al destino. ¿De qué manera podríamos solucionar ésta situación? Con la adaptación del servidor a un tipo especial de sockets, los WebSockets.

Segunda Implementación. Utilizando WebSockets.

WebSocket es una tecnología que proporciona un canal de comunicación bidireccional y full-duplex sobre un único socket TCP. Está diseñada para ser implementada en navegadores y servidores web, pero puede utilizarse por cualquier aplicación cliente/servidor. La API de WebSocket está siendo normalizada por el W3C, y el protocolo WebSocket, a su vez, está siendo normalizado por el IETF. Como las conexiones TCP ordinarias sobre puertos diferentes al 80 son habitualmente bloqueadas por los administradores de redes, el uso de esta tecnología proporcionaría una solución a este tipo de limitaciones proveyendo una funcionalidad similar a la apertura de varias conexiones en distintos puertos, pero multiplexando diferentes servicios WebSocket sobre un único puerto TCP (a costa de una pequeña sobrecarga del protocolo).

Al utilizar los WebSocket desde javascript podemos abrir un socket directamente desde el panel de control (lado cliente de la comunicación) con el servidor de sockets situado en el lado servidor de la conexión. Esto nos permite no pasar por scripts en PHP y enviar las tramas generadas por el mismo socket, lo que además de aumentar la velocidad de transmisión, nos asegurará el orden correcto en la recepción de los paquetes de información enviados.

El cambio sobre la primera versión del servidor es mínima, tan solo hay que tener en cuenta en la implementación del servidor la negociación del protocolo WebSocket.

Veamos con un diagrama de flujo o actividades el algoritmo de funcionamiento del servidor implementado en PHP.

Inicio

Inicializaciones

NO ¿Nueva conexión entrante?

SI

¿Socket abierto ya con usuario?

NO Aceptar nuevo socket y guardar usuario

SI

Realizar negociación WebSocket con nuevo usuario

Procesar mensaje y separar campos

¿id_emisor = panel de control?

NO

NO

¿id_emisor = helicoptero?

SI Reenviar mensaje por WebSocket al panel de control

SI

Reenviar mensaje por socket al helicoptero

Figura 52: Diagrama de flujo del algoritmo del servidor de WebSockets.

Panel de control.

Hemos visto cómo se tratan en el servidor los mensajes enviados a través de sockets entre el helicóptero y el panel de control, sin embargo todavía no hemos visto cómo y cuando se generan éstos mensajes.

Como en todo sistema autónomo o tele guiado, el piloto o usuario debe poder comunicarse con el aparato para poder interactuar con el sistema. Por ejemplo, poder comandar en vivo el aparato o simplemente ver información sobre el estado del sistema o del entorno son tareas que un piloto debe poder realizar desde la estación de control del aparato.

Para nuestro prototipo en cuestión, hemos realizado un panel de control muy simple y con controles básicos que sirva de precedente para futuros desarrollos. Se ha desarrollado utilizando HTML para el cuerpo del panel de control, CSS para los estilos del diseño y JavaScript para el comportamiento de los distintos elementos de la interfaz y la comunicación.

Interfaz de usuario.

La interfaz implementada es muy simple y con pocos controles. Para el control completo de un aparato de éstas características el número de controles y opcines se vería ampliamente incrementado, sin embargo para el objetivo del proyecto, que es mostrar las posibilidades de las tecnologías utilizadas es suficiente. Apreciemos en una imagen el aspecto del panel de control que se ha diseñado.

Figura 53: Detalle de la pestaña principal del panel de control realizado.

Como podemos ver, el diseño está baso en pestañas, una principal y otra para el ajuste de los parámetros de control del aparato. En la pestaña principal, que observamos en la imagen anterior se han insertado varios controles, que aunque todos no tienen implementada su funcionalidad se han insertado pensando en futuras modificaciones.

Encontramos tres paneles, uno a la izquierda con información referente al aparato que irá actualizándose dinámicamente, otro panel a la derecha, en el que encontramos varios controles para actuar directamente sobre el aparato y un tercer panel central, con un mapa para mostrar la posición del aparato en futuras versiones (no se encuentra actualmente implementada su funcionalidad).

Figura 54: Detalle de la pestaña de ajustes del panel de control.

Como podemos apreciar en la imagen, en la pestaña de ajustes, el usuario o piloto del tricoptero tiene acceso al ajuste de los parámetros de control de los controladores PID que se encargan de la estabilidad y control del aparato. De ésta manera, se puede variar el comportamiento de dichos controladores de manera remota sin estar conectado físicamente con el aparato.

HTML + CSS + JavaScript

Google, Microsoft y Apple ya han hecho su apuesta: HTML5 + CSS3 + Javascript. ¿Qué significan estas siglas? Páginas web mucho más ricas, completas, interactivas e interesantes que las que se hacen hoy en día. Infinitas posibilidades con gráficos e imágenes vectoriales, fotos, vídeos y otros elementos.

- HTML (HyperText Markup Language) es el lenguaje en que se construyen los sitios web. En una casa sería la estructura, desde los cimientos al tejado. La versión actual,

HTML4, data de 1999. Desde hace más de 10 años no se revisa este código de programación. Por eso, entre otros motivos, la mayor parte de las páginas web son muy similares a sus versiones de hace una década. También por eso se han buscado soluciones como Flash para dotarlas de interactividad. Pero casi ninguna de estas soluciones es de código abierto como el HTML y la mayor parte dan multitud de problemas a los navegadores, que se cuelgan si el código no está muy afinado.

- CSS (Cascading Style Sheets) es el lenguaje que se utiliza para dar forma a los sitios web. En una casa sería la pintura, los muebles, la finalización. La versión actual, CSS2, data de 1998 aunque se retocó en 2007. Hace casi 12 años que no se revisa a fondo.

Por eso, tiene limitaciones tan importantes como que no permite poner el tipo de letra que se desee, redondear border o crear columnas. Por lo mismo, los diseñadores tienen que hacer 'trampas' para dar a un sitio web el aspecto deseado.

- Javascript es un lenguaje de programación que permite que el cliente -o sea, el usuario- pueda hacer cambios en un sitio web sin tener que recargarlo cada vez que quiera modificar algo. En una casa sería la disposición de los muebles. La desventaja de este idioma es que cada navegador puede interpretarlo de forma distinta, por lo que no es fácil utilizarlo correctamente. Por suerte, hay soluciones que lo facilitan. Este código se revisa habitualmente, la última vez, en junio de 2009.

La nueva versión de HTML, HTML 5, está a punto de completarse. La de CSS, CSS3, tardará algo más. Ambas, combinadas con Javascript, permitirán dotar a los sitios web de posibilidades casi infinitas. Por no entrar en detalles técnicos, decir que se podrá, por ejemplo, arrastrar elementos de un sitio a otro con gran facilidad, incrustar cualquier tipo de letra en una página, crear efectos hasta ahora imposibles sin usar tecnología cerrada -como rotar una página- o geolocalizar al usuario sin necesidad de una aplicación intermedia.

Las grandes compañías de la Red quieren que HTML5 + CSS3 + Javascript sea la tecnología predominante para el desarrollo de sitios web. Primero porque, frente a otras como Flash o Silverlight, es código abierto y por tanto común a todo el mundo.

Segundo, porque es una evolución lógica del modelo actual. Tercero, porque es muy potente.

Tanto la quieren que la apuesta por esta combinación ya es abierta. Google ha puesto en marcha el sitio HTML5Rocks.com con ejemplos y recursos para desarrolladores. Lo mismo ha hecho Apple, que ha abierto un completo espacio en su sitio web con información de todo tipo. Y Microsoft, aunque todavía no tiene una página con recursos, sí ha dejado ver multitud de ejemplos en la página donde están las primeras pruebas de su nueva versión de Internet Explorer, la 9.

Para la WebApp que tratamos, hemos hecho uso de éstos lenguajes para dar al panel de control la estética y funcionalidad requerida. Si bién podríamos haber usado PHP también para la funcionalidad de la página, se ha optado por JavaScript y seguir la corriente de los desarrolladores hacia la apuesta de futuro de HTML5 y JavaScript.

Además, ésta última combinación nos permitirá el uso de los WebSockets para la

transmisión de datos cliente-servidor y servidor-cliente salvando los obstáculos que teníamos con los sockets convencionales, todo ello explicado apartados anteriores.

Jquery / Jquery UI

JQuery es una biblioteca de JavaScript que permite simplificar de manera notable la manera de interactuar con los documentos HTML, manipular el árbol DOM, manejar eventos, desarrollar animaciones y agregar interacción con la técnica AJAX a páginas web. Actualmente, son pocos los programadores web que no conozcan ésta librería, ya que ayuda a simplificar y acelerar el desarrollo, sobre todo en páginas web dinámicas.

Para utilizar ésta útil librería, tan solo tenemos que agregar un único fichero JavaScript que contiene las funcionalidades comunes de DOM, eventos, efectos y AJAX. Si el framework JQuery nos ha supuesto una valiosa ayuda en la creación del panel de control del aparato en cuanto a manipulación de elementos y tratamiento de eventos, JQuery UI nos ha facilitado el darle una mejor funcionalidad y aspecto a cada uno de los elementos que componen el cuadro de mandos.

JQuery UI es una biblioteca basada en JQuery, y por tanto JavaScript, que añade al framework plug-ins, widgets y efectos visuales para la creación de aplicaciones web. La biblioteca se compone de cuatro módulos: -

-

-

Núcleo. Contiene las funciones básicas que componen el resto de módulos.

Interacciones. Añade comportamientos complejos a los elementos. Ejemplos de interacciones pueden ser hacer arrastrable un elemento, la posibilidad de redimensionar un elemento, ordenar listas de elementos, entre otros.

Widgets. Es el conjunto completo de controles UI. Botones, ventanas de dialogo, pestañas, calendario, barras de progreso, etc. Siendo importante la posibilidad de aplicar estilos CSS. Efectos. Una API para añadir transiciones animadas y facilidades para interacciones.

El uso de ésta librería es el mismo que la librería JQuery, sólo tenemos que añadir los ficheros .js a la página.

En cuanto a la personalización del estilo de los elementos como se ha dicho, se basa en aplicar a éstos estilos CSS, sin embargo, y para facilitar aún más su uso, la página oficial de JQuery UI ofrece un servicio llamado ThemeRoller donde poder personalizar de manera online la plantilla de estilos que se aplicarán a los elementos y descargarla lista para utilizar en nuestros proyectos.

AJAX.

En una aplicación web dinámica como es el caso de nuestro panel de control, el uso interactivo de los elementos y campos de información es fundamental. Si para ver los cambios en los controles o la actualización de la información recibida desde el aparato tuviéramos que ir recargando la página constantemente, sería imposible no sólo pilotar el robot sino la simple monitorización de sus sensores en tiempo real sería una tarea imposible. Sin embargo, existe algo conocido como Ajax que permite dotar de dinamismo a un página web.

AJAX, acrónimo de Asynchronous JavaScript And XML (JavaScript asíncrono y XML), es una técnica de desarrollo web para crear aplicaciones. Estas aplicaciones se ejecutan en el cliente, es decir, en el navegador de los usuarios mientras se mantiene la comunicación asíncrona con el servidor en segundo plano. De esta forma es posible realizar cambios sobre las páginas sin necesidad de recargarlas y dotarlas de interactividad, velocidad y usabilidad.

Ajax es una tecnología asíncrona, en el sentido de que los datos adicionales se solicitan al servidor y se cargan en segundo plano sin interferir con la visualización ni el comportamiento de la página. JavaScript es el lenguaje interpretado en el que normalmente se efectúan las funciones de llamada de Ajax mientras que el acceso a los datos se realiza mediante XMLHttpRequest, objeto disponible en los navegadores actuales. En cualquier caso, no es necesario que el contenido asíncrono esté formateado en XML. Ajax es una técnica válida para múltiples plataformas y utilizable en muchos sistemas operativos y navegadores, dado que está basado en estándares abiertos como JavaScript y Document Object Model (DOM).

El uso de frameworks, como es el caso de JQuery permite hacer uso de la técnica Ajax de manera más eficiente y transparente al desarrollador. De ésta manera, mediante JavaScript y JQuery podemos actuar directamente sobre los elementos del panel de mando y capturar los eventos desencadenados por los algunos controles del panel para enviar las órdenes de control a través de WebSocket hacia nuestro robot.

Implementación de la funcionalidad.

Ya hemos visto los lenguajes y técnicas que se han utilizado para dar forma a ésta aplicación web para el control a distancia de nuestro robot aéreo. HTML y CSS para el aspecto visual. JavaScript y la técnica Ajax, junto con los frameworks JQuery y JQuery UI para dotar de funcionalidad y dinamismo a los elementos del panel de mandos. Y por último WebSockets también implementados en JavaScript, para la comunicación bidireccional entre el panel de mandos y el servidor de sockets intermediario entre

éste y el aparato. Pero, ¿De qué manera terminan de encajar todas éstas piezas en el panel de control diseñado? Veámoslo.

Cuando se crea un elemento interactivo con el usuario, por ejemplo el control deslizante utilizado como mando de aceleración de los motores principales, con un script en JavaScript asignamos las variables sobre las que actuará el control y capturamos el evento de interacción (realizada por el usuario). La captura del evento nos permite captar el incremento o decremento de potencia y enviar ésta información a través de un WebSocket abierto en el arranque de la aplicación web y que mantiene una conexión activa con el servidor de sockets que reenviará la información al tricoptero.

Por otra parte, para visualización por pantalla de información proveniente del aparato, se crean elementos de texto actualizables. La manera de hacer esto es implementando un manejador que actúa sobre la recepción de datos a través del WebSocket ya mencionado. El manejador actúa clasificando la información recibida a través del socket y actualizando los campos de texto informativos con la nueva información recibida. Ejemplos de ello son los campos que indican el valor de cada uno de los ángulos (Pitch, Roll y Yaw) en los que se encuentra el aparato en el momento de la actualización.

Comunicación desde el aparato.

Hasta ahora hemos tratado el sistema de comunicación visto desde el lado del usuario o piloto del aparato y el sistema de control que se ha equipado en el tricoptero, pero ahora nos queda un punto clave, y es el otro extremo en la comunicación, el del aparato. Desde el robot, se envía información de los sensores que equipa hacia el panel de control y se reciben las órdenes que el usuario genera interactuando con los controles. Para ésta tarea de recibir y enviar mensajes vía internet vamos a utilizar un dispositivo móvil, más concretamente un Smartphone, que a través de la línea de datos del dispositivo mantendrá, través de la red, un socket abierto con el servidor de sockets por el que fluirá la información.

App android abordo.

Para la conexión vía socket entre el servidor de sockets y el robot aéreo se ha implementado una aplicación android que mantiene un canal de comunicación bidireccional abierta. Ésta aplicación hace de puente entre el servidor y el sistema de control del aparato, permitiendo la comunicación inalámbrica.

Para hacer llegar los mensajes desde el panel de control al sistema de control del aparato y viceversa, la app tiene que mantener abiertos dos canales de comunicación, uno con el servidor y otro con el microcontrolador (la placa FezPanda 2) del robot.

Para ésta segunda comunicación tenemos que conectar físicamente el Smartphone con la placa FezPanda 2, donde se implementa el sistema de control y tiene lugar el procesamiento principal. De ésta manera la aplicación recibirá la información por un canal y lo transmitirá por el otro y lo mismo en sentido contrario, ejerciendo la función de puente.

La conexión física entre el dispositivo móvil y la placa de procesamiento se ha realizado conectando con un cable los dos dispositivos a través de sus puertos microUSB. En el siguiente apartado trataremos más a fondo cómo se ha realizado ésta comunicación tanto físicamente como a nivel de software, ya que, por su complejidad requiere tratarlo aparte.

No vamos a entrar en detalles de cómo se programa una aplicación para Android, simplemente destacar que se ha implementado en Java, utilizando el entorno de desarrollo Eclipse con los plugins y librerías necesarios que Google pone a disposición para los desarrolladores.

Figura 55: Detalle de la aplicación Android.

Como podemos ver, se trata de una aplicación que carece casi por completo de controles para interactuar con un usuario, ya que la finalidad de la misma es interactuar con el sistema empotrado del robot. Tenemos un par de botones, uno

destinado para uso en pruebas y otro para iniciar/detener el transvase de mensajes de la red hacia el sistema de control y viceversa. También en la app tenemos dos salidas de información para monitorizar los mensajes entrantes desde los dos sentidos de la comunicación para la fase de debug y unos indicadores del estado de las conexiones.

En cuanto a la implementación, veamos con un diagrama cómo funciona el algoritmo que hay detrás de la aplicación:

Inicio

Inicializaciones

NO ¿Pulsado botón de inicio?

SI Abrimos socket a través de la red con el servidor remoto

NO ¿Conexión estrablecida con servidor remoto?

SI Abrimos socket de comunicacióncon la placa FezPanda II

NO ¿Conexión estrablecida con FezPanda II?

SI

NO ¿Mensaje entrante?

SI

¿Proviene del socket TCP abierto con el servidor?

¿Proviene del socket abierto con la FezPanda II?

NO

SI

SI

Descomponemos la trama recibida

SI

Descomponemos la trama recibida

¿Error en datos o destinatario incorrecto?

NO Enviamos por socket a través de la red al servidor

Enviamos por socket al FezPanda II

NO

¿Botón de detención?

SI

NO ERROR

Figura 56: Diagrama de flujo del algoritmo implementado por la app.

Al ejecutar la gestión de mensajes con el botón de inicio, se establece un socket TCP con la dirección IP del servidor y el número de puerto establecido para la comunicación. Si la apertura del socket se establece con éxito se pasa a intentar abrir el canal de comunicación a través del usb del Smartphone con la placa FezPanda II. Una vez abierto el canal de conexión con el dispostivo usb, de lo cual hablaremos en el próximo apartado, la aplicación estará en condiciones de recibir mensajes por ambos canales de comunicación y reenviarlos por el otro.

La llegada de un mensaje, ya sea a través de la red o a través del puerto usb, genera un evento que pasa el mensaje a la función correspondiente que descompone la trama recibida en los diferentes campos que la constituyen. Si el mensaje proviene del servidor y por tanto del panel de control, se comprueba que el id del destinatario sea el identificador del aparato, de ser correcto se vuelve a encapsular en una trama y se reenvía a través del canal de comunicación con la FezPanda II para que el sistema de control ejecute la orden. En el caso de que el mensaje provenga de la placa de la FezPanda II, se reenvía directamente el mensaje a través del socket TCP para que se reciba en el panel de control, donde interactúa el usuario o piloto.

Conexión entre los sistemas de Comunicación y de Control.

Como ya hemos explicado, necesitamos conectar la placa Fez Panda con el dispositivo Android para cerrar el círculo de comunicación y permitir al aparato tanto recibir como enviar información a través de la red.

Físicamente, hemos conectado los dos dispositivos a través de sus puertos mini-usb y micro-usb, sin embargo el procedimiento es algo más complejo. Para poder comunicar los dos dispositivos a través de usb necesitamos que uno de ellos adquiera funcionalidad USB-HOST y sea capaz de reconocer los dispositivos conectados a su puerto usb.

En nuestro caso la tarjeta Fez Panda hará de de USB Host y el dispositivo Android se convertirá en USB Client, sin embargo, la tarjeta no vine de fábrica con ésta funcionalidad aunque si sea soportada por el microprocesador que incorpora. Es pues necesario, hacer unas modificaciones en el hardware para permitir actual a la tarjeta en modo USB Host. Se trata de añadir dos resistencias de 15k de D+ y D- de la conexión USB a tierra, que para no hacer estos cambios permanentes los haremos sobre el cable usb que utilizaremos para interconectar los dispositivos. También añadiremos un cable con +5V para la alimentación del dispositivo cliente, en nuestro caso, el Smartphone

Android. Observemos el esquema de conexión y la imagen de la modificación resultante.

Figura 57: Detalle del esquema de conexión de las resistencias.

Figura 58: Detalle del cable finalizado con las modificaciones mencionadas.

Con el cable construido sólo falta poner la placa Fez Panda en modo Host, para esto conectaremos el pin MODE con el GND de la misma. De manera que cuando arranque la placa se encontrará en USB-HOST y estará en condiciones de reconocer el dispositivo Android cuando lo conectemos.

Una vez visto cómo se conectan ambos dispositivos de manera física, veamos cómo el dispositivo Android es capaz de enviar y recibir información como cliente USB.

Android Debug Bridge (ADB)

Android Debug Bridge (ADB) es una herramienta de línea de comandos que permite conectarse con una instancia de un dispositivo Android y comportarse como un programa cliente-servidor.

A partir de la versión de Android 1.5 todos los dispositivos soportan el protocolo ADB. Éste protocolo permite algunas funciones interesantes, como el envío de datos a través de TCP entre el teléfono y el PC. Éste es el protocolo que explotaremos para establecer la comunicación con la placa Fez Panda.

Cuando iniciamos un cliente ADB, el cliente primero comprueba que hay un servidor ADB escuchando, y de ser así se inicia una conexión TCP a través del puerto 5037, si no hay ningún servidor funcionando se inicia un proceso servidor. De ésta manera el servidor ADB permanecerá a la escucha del puerto 5037, que será el puerto utilizado para que los clientes se comuniquen con el servidor.

Como el protocolo recibe la información a través de TCP, la implementación de un simple servidor que habrá un socket con los clientes será suficiente para que el dispositivo intercambie información con la placa Fez Panda. Cuando el sistema de control del aparato envía información al panel de control, éste envía el mensaje empaquetado en una trama del protocolo ADB y será enviada a través de USB. El dispositivo móvil recibirá el mensaje ADB y mandará el contenido a través del puerto que estará escuchando el servidor de nuestra aplicación Android. La lista de comandos ADB al igual que el uso del protocolo lo podemos encontrar en la página de recursos que Google pone a disposición de los desarrolladores y que se indica en la bibliografía de la memoria.

CONCLUSIÓN. En el presente trabajo hemos demostrado cómo la interacción de las tecnologías móviles con los lenguajes WEB y el hardware libre hace posible la continua aparición en internet y en los medios de interesantes proyectos llevados a cabo sin una gran inversión económica o grandes medios técnicos para su desarrollo. Para dar cuenta de ello, hemos diseñado un tricoptero, que si bien es sólo un prototipo con funcionalidad reducida, puede controlarse a través de internet o un dispositivo móvil, otorgándole innumerables posibilidades. Las tecnologías utilizadas, destacando Android, HTML5 y Arduino (hardware libre) están teniendo un crecimiento increíble desde hace unos años y esto no ha hecho nada más que empezar. Continuamente salen al mercado nuevos y mejores dispositivos móviles, tarjetas de desarrollo basadas en hardware libre más potentes y a mejor precio y todo al mismo tiempo que se trabaja para sacar adelante HTML5, lo que supondrá grandes mejoras en la programación WEB.

Para éste proyecto, se han utilizado componentes económicos y comprados casi en su totalidad a empresas chinas del sector, quitando las placas de desarrollo que son originales, y aunque ha habido algunos problemillas en alguna etapa del proyecto, todo ha funcionado como se esperaba.

El tiempo empleado para la realización de proyecto ha sido de unos 7-8 meses a lo largo del curso 2011-2012, algo excesivo pero necesario para cumplir ciertos objetivos, que no todos lo que nos hubiera gustado. Hemos fabricado un robot aéreo capaz de obtener variables de su entorno para actuar sobre su sistema de motores. Se ha conseguido un medio de comunicación a través de las redes móviles en el cual un usuario es capaz de controlar el aparato y un sistema de control a bordo del tricoptero que se adaptase a las órdenes enviadas remotamente por el usuario, pero sin embargo, no se han podido realizar pruebas de vuelo por excedernos ya con la duración del proyecto y superar ya los objetivos del PFC.

Bibliografía.

[1] A.Barrientos, J.del Cerro, P.Gutiérrez, R.San Martín, A.Martínez, C.Rossi,“Vehículos aéreos no tripulados para uso civil. Tecnología y aplicaciones”, Grupo de Robótica y Cibernética, Universidad Politécnica de Madrid.

[2] http://developer.android.com/tools/help/adb.html [3] http://letsmakerobots.com/node/27057 [4] http://www.diydrones.com [5] http://letsmakerobots.com [6+ “CSS, hojas de estilo”, de www.desarrolloweb.com [7+ “Manual HTML”, de www.desarrolloweb.com [8+ “Programación en JavaScript”, de www.desarrolloweb.com [9+ “Manual de JQuery”, de www.desarrolloweb.com [10] http://www.jqueryui.com [11] http://www.wikipedia.com *12+ “Programando en PHP”, de www.desarrolloweb.com

*13+ â&#x20AC;&#x153;Direction Cosine Matrix IMU: Theoryâ&#x20AC;?, de William Premerlani and Paul Bizard [14] http://code.google.com/p/ardu-imu/wiki/HomePage?tm=6 [15] http://www.ghielectronics.com/community/forum