diseño, desarrollo y construcción de bancos de … · diseño, desarrollo y construcción de...

Jorge Visa Vidal

Javier Rico Azagra y Montserrat Gil Martínez

Escuela Técnica Superior de Ingeniería Industrial

Grado en Ingeniería Electrónica Industrial y Automática

2015-2016

Título

Director/es

Facultad

Titulación

Departamento

TRABAJO FIN DE GRADO

Curso Académico

Diseño, desarrollo y construcción de bancos de pruebaspara un UAV multi-rotor

Autor/es

© El autor© Universidad de La Rioja, Servicio de Publicaciones,

publicaciones.unirioja.esE-mail: [email protected]

Diseño, desarrollo y construcción de bancos de pruebas para un UAV multi-rotor, trabajo fin de grado

de Jorge Visa Vidal, dirigido por Javier Rico Azagra y Montserrat Gil Martínez (publicadopor la Universidad de La Rioja), se difunde bajo una Licencia

Creative Commons Reconocimiento-NoComercial-SinObraDerivada 3.0 Unported. Permisos que vayan más allá de lo cubierto por esta licencia pueden solicitarse a los

titulares del copyright.

“DISEÑO, DESARROLLO Y

CONSTRUCCIÓN DE BANCOS DE PRUEBAS PARA UN UAV MULTI-

ROTOR”

Peticionario: Universidad de la Rioja

Informantes: Jorge Visa Vidal

Alumno de Ingeniería Electrónica Industrial y Automática

Universidad de La Rioja

Lugar y Fecha: Logroño a 7 de Julio de 2016

Diseño, desarrollo y construcción de bancos de pruebas para un UAV multi-rotor.

Resumen Universidad de La Rioja

1 Jorge Visa Vidal

RESUMEN

Por un lado, este trabajo fin de grado diseña y desarrolla unos bancos de pruebas para caracterizar el sistema de propulsión de un UAV multi-rotor (categoría micro o mini), que es fundamental para su gobierno. Estos permiten identificar los parámetros característicos que relacionan la velocidad de los motores, o su señal de mando, con el par y fuerzas aerodinámicas generadas por las hélices.

Para ello se han diseñado dos mecanismos/estructuras que transmiten la fuerza de empuje y el par de arrastre generados por los rotores (conjunto motor-hélice) a una báscula. Se ha implementado un circuito de amplificación y conversión de señal para poder llevar ésta al ordenador vía USB. En este circuito también se ha llevado a cabo el control del motor a través de una señal de PWM enviada desde el PC. Consta también de una etapa de medición que genera una señal digital de pulsos (0-5V) cuando se produzca el paso de las hélices del rotor por delante de un sensor óptico, para calcular la velocidad de giro del motor.

Para el control de todo este sistema de adquisición y envío de datos se usa un Arduino Nano. La herramienta software de adquisición de datos está diseñada en el IDE de Arduino. Para el procesamiento y muestra de resultados se usa una interface diseñada con MATLAB.

Por otro lado, este trabajo fin de grado diseña y desarrolla un banco de pruebas que a modo de giroscopio permite el giro del UAV en los tres ejes (roll, pitch y yaw), sin que la aeronave se desplace en X, Y, Z. El diseño de esta estructura será clave a la hora de poder finalizar el estudio y desarrollo de los controladores de un UAV, ya que permitirá poder comprobar el control de actitud y orientación sin tener que volar en un espacio abierto, reduciendo así los posibles accidentes en caso de fallo de diseño de los controladores.

Esto permitirá diseñar y desarrollar estrategias de control de actitud (giro en roll y pitch) y orientación (giro en yaw) para muti-rotores, sin los inconvenientes que supone el vuelo libre. No obstante, los conocimientos y experiencia adquiridos serán luego extrapolables al vuelo normal.

Palabras clave:

UAV multi-rotor. Sistema de propulsión. Control de actitud y orientación.


Resumen Universidad de La Rioja

2 Jorge Visa Vidal

ABSTRACT

In one hand, this final project designs and develops two test benchs to characterize the propulsion system of a multi-rotor UAV (micro or mini class), which is fundamental for its control. These test benchs allow to identify the charasterictic parameters that link the motor speed, or its control signal, with the drag and thrust generated by the propeller of the rotors.

For this porpouse, two mechanisms/structures that transmit the drag and the thrust, generated by the rotors (motor and propeller), to a scale have been designed. An amplifier and converter circuit to carry the scale signal to a PC via USB has been implemented. This circuit has a part to control the motor too, with the PWM signal sent from the PC. The last part of this circuit is the pulse digital builder (0-5V), this signal appears when the blades of the proppeller cross the optical sensor, and with this signal we can calculate the motor speed.

An Arduino Nano has been used for the acquisition and delivery system. The software tool for this porpouse was programmed with the Arduino IDE. For the processing and display part of the results we use an interface programmed with MATLAB.

In the other hand, this final Project designs and develops a test bench, similar to a gyroscope, that allows the gyre of the UAV in the three axes (roll, pitch and yaw), without any movement of the drone in X, Y, Z. The design of this structure will be really important to finish the project and development of the UAV controllers, because the structure allow to test the attitude and orientation control without the necessity to fly the drone in the open air, so we achive to reduce the possibles accidents in case of design failures.

This goal will allow to design and develop attitude (roll and pitch gyre) and orientation (yaw gyre) control strategies, without the problems that the free flight generate. However, the experience and the knowledges acquired in this experiment will be use in a normal fligth.

Key words:

Multi-roto UAV. Propulsion system. Attitude and orientation control.

Diseño, desarrollo y construcción de bancos de pruebas para un UAV multi-rotor. Agradecimientos

2 Jorge Visa Vidal

AGRADECIMIENTOS

A mis padres y mi hermano, gracias por vuestro apoyo incondicional en todo momento. Sobre todo gracias a mis abuelos, que estén donde estén siempre estarán conmigo.

Sin la ayuda de Javier Rico, Montse Gil y Silvano Nájera este proyecto no hubiera podido llevarse a cabo, asique muchas gracias a todos.

Y finalmente gracias a todas esas personas que han estado a mi lado durante estos 4 años, todos ellos han aportado su granito de arena.

2 Jorge Visa Vidal



ROTOR”

DOCUMENTO Nº 1 ÍNDICE GENERAL






Índice general Universidad de La Rioja

2 Jorge Visa Vidal

ÍNDICE GENERAL

Memoria ................................................................................................. 9

1. Introducción ...................................................................................................................... 9

Motivación ............................................................................................................................ 9

Antecedentes ...................................................................................................................... 10

Objeto del trabajo ............................................................................................................... 11

Objetivos ............................................................................................................................. 12

2. Referencias ...................................................................................................................... 15

Bibliografía web ................................................................................................................... 15

Libros bibliográficos ............................................................................................................ 15

Artículos bibliográficos ........................................................................................................ 15

3. Definiciones y abreviaturas ............................................................................................. 16

4. Caracterización del sistema de propulsión de un UAV ................................................... 17

Estructuras mecánicas ......................................................................................................... 17

Electrónica de medida y mando .......................................................................................... 23

Interfaces de usuario en PC ................................................................................................. 27

5. Resultados experimentales ............................................................................................. 36

Hélices y motores utilizados ................................................................................................ 36

Experimentos realizados ..................................................................................................... 37

6. Plataforma para el control de actitud y orientación de un UAV ..................................... 47

Estructura mecánica ............................................................................................................ 47

UAV utilizado ....................................................................................................................... 50

7. Conclusiones.................................................................................................................... 52

Anexo 1. Diseño del circuito comparador para el cálculo de la velocidad de giro del motor................................................................................... 56

Anexo 2. Diseño del circuito de amplificación para la obtención de los datos de medida de la báscula de pesaje. .............................................. 59

Anexo 3. PCB del circuito del trabajo ..................................................... 66



3 Jorge Visa Vidal

Anexo 4. Herramienta software de adquisición de datos con el IDE de Arduino. ................................................................................................ 67

1. Guía del programa ........................................................................................................... 67

2. Programa principal .......................................................................................................... 70

3. Modo calibración............................................................................................................. 73

4. Modo test ........................................................................................................................ 74

5. Interrupciones ................................................................................................................. 76

6. Muestra de datos por pantalla ........................................................................................ 76

Anexo 5. Código del software de procesamiento de datos y muestra de resultados con MATLAB© ..................................................................... 78

Planos……………………………………………………………………………………………….104

1. Planos mecanismo para el cálculo de la fuerza de empuje .......................................... 104

2. Planos mecanismo para el cálculo del par de arrastre ................................................. 112

3. Planos plataforma para el control de actitud y orientación ......................................... 119

4. Planos bloqueo de los ejes de la plataforma de control de actitud y orientación........ 126

Pliego de condiciones .......................................................................... 131

1. Introducción al pliego de condiciones ........................................................................... 131

1.1 Condiciones Generales .............................................................................................. 131

1.2 Condiciones Administrativas ..................................................................................... 132

1.3 Normativa y Reglamentación .................................................................................... 133

1.3.1 Reglamento relacionado a productos electrónicos .......................................... 133

1.3.2 Normativa relacionada a materiales y equipos ................................................. 134

1.4 Condiciones facultativas ............................................................................................ 135

1.4.1 Dirección ............................................................................................................ 135

1.4.2 Libro de Órdenes ............................................................................................... 135

1.4.3 Modificaciones .................................................................................................. 135

1.5 Condiciones de los materiales y equipos .................................................................. 137

1.5.1 Condiciones técnicas de los materiales ............................................................. 137

1.6 Condiciones económicas ........................................................................................... 138

1.6.1 Errores en el proyecto ....................................................................................... 138

1.6.2 Liquidación ........................................................................................................ 138



4 Jorge Visa Vidal

1.7 Disposición final ........................................................................................................ 139

Mediciones .......................................................................................... 142

Presupuesto ........................................................................................ 146

1. Cuadro de precios ......................................................................................................... 146

2. Presupuesto .................................................................................................................. 148

3. Resumen del presupuesto ............................................................................................. 150



5 Jorge Visa Vidal

ÍNDICE DE FIGURAS

Memoria

Ilustración 1. Estructura para el cálculo del empuje ...................................................... 18 Ilustración 2. Diagrama de fuerzas del empuje. ............................................................. 19 Ilustración 3. Estructura para el cálculo del empuje con el sensor óptico incluido. ...... 20 Ilustración 4. Estructura para el cálculo del par de arrastre. ......................................... 21 Ilustración 5. Reacciones en una viga al par de un rotor. .............................................. 22 Ilustración 6. Estructura para el cálculo del par de arrastre con el sensor óptico incluido. .......................................................................................................................... 23 Ilustración 7. Circuito para medida de RPM. .................................................................. 24 Ilustración 8. Conexión báscula-Arduino-PC. ................................................................. 26 Ilustración 9. Imagen de la PCB ima vez realizada. ........................................................ 27 Ilustración 10. Modo normal de funcionamiento. ......................................................... 28 Ilustración 11- Directorio de trabajo de MATLAB. ......................................................... 29 Ilustración 12. Variables cargadas en el workspace de MATLAB. .................................. 30 Ilustración 13. Aplicación guide de MATLAB. ................................................................. 31 Ilustración 14. Bloque del par de la aplicación. .............................................................. 32 Ilustración 15. Bloque del empuje de la aplicación. ....................................................... 33 Ilustración 16. Gráfica de rpm vs tiempo. ...................................................................... 34 Ilustración 17. Gráfica de rpm vs PWM. ......................................................................... 34 Ilustración 18. Gráfica de fuerza vs . ........................................................................... 35 Ilustración 19. Motor Turnigy. ........................................................................................ 36 Ilustración 20. Motor DYS. .............................................................................................. 36 Ilustración 21. Curva estática del motor DYS. ................................................................ 37 Ilustración 22. Curva estática del motor Turnigy. .......................................................... 38 Ilustración 23. Respuesta dinámica del motor DYS. ....................................................... 39 Ilustración 24. Respuesta dinámica del motor DYS en el Ident de MATLAB. ................. 40 Ilustración 25. Respuesta dinámica en velocidad del rotor DYS y del modelo identificado. .................................................................................................................... 40 Ilustración 26. Respuesta dinámica del motor Turnigy. ................................................. 41 Ilustración 27. Respuesta dinámica en velocida del rotor Turnigy y del modelo identificado. .................................................................................................................... 42 Ilustración 28. Fuerza de empuje vs velocidad angular del rotor DYS. .......................... 43 Ilustración 29. Fuerza de empuje vs velocidad angular del rotor Turnigy. .................... 44 Ilustración 30. Par de arrastre vs velocidad angular del motor DYS. ............................. 45 Ilustración 31. Par de arrastre vs velocidad angular del motor Turnigy. ....................... 46

Diseño, desarrollo y construcción de bancos de pruebas para un UAV multi-rotor. Índice general

6 Jorge Visa Vidal

Ilustración 32. Ejes de movimiento de un UAV. ............................................................. 47 Ilustración 33. Plataforma de simulación ....................................................................... 48 Ilustración 34. Pieza 1 del mecanismo de anclaje de los ejes de la plataforma. ........... 49 Ilustración 35. Pieza 2 del mecanismo de anclaje de los ejes de la plataforma. ........... 50 Ilustración 36. UAV utilizado para probar la plataforma de simulación. ....................... 51

Anexos

Ilustración 37. Circuito comparador del fotodiodo. ....................................................... 57 Ilustración 38. Voltaje a la salida del circuito comparador del fotodiodo. .................... 58 Ilustración 39. Células de carga ...................................................................................... 59 Ilustración 40. Conexionado células de carga. ............................................................... 60 Ilustración 41. Amplificador en cascada. ........................................................................ 62 Ilustración 42. Amplificador en modo sumador. ............................................................ 63 Ilustración 43. Amplificador en modo seguidor de tensión. .......................................... 63 Ilustración 44. Gráfica de los valores de la báscula. ....................................................... 65 Ilustración 45. Capa superior de la PCB .......................................................................... 66 Ilustración 46. Capa inferior de la PCB. .......................................................................... 66 Ilustración 47. Menú principal del programa. ................................................................ 67 Ilustración 48. Menú inicial del modo calibración. ........................................................ 67 Ilustración 49. Mensaje de configuración del modo calibración. .................................. 68 Ilustración 50. Mensaje final del modo calibración. ...................................................... 68 Ilustración 51. Mensaje inicial del modo test. ............................................................... 69 Ilustración 52. Mensaje de aviso del modo test. ............................................................ 69 Ilustración 53. Mensaje final del modo test. .................................................................. 69

Diseño, desarrollo y construcción de bancos de pruebas para un UAV multi-rotor. Índice general

7 Jorge Visa Vidal

ÍNDICE DE TABLAS

Memoria Tabla 1. Clasificación de los UAV por sus capacidades de vuelo. ................................... 11 Anexos

Tabla 2. Medidas de la báscula sin amplificar. ............................................................... 61 Tabla 3. Medidas de la báscula con la etapa de amplificación. ..................................... 64

8 Jorge Visa Vidal



ROTOR”

DOCUMENTO Nº 2 MEMORIA






Memoria Universidad de La Rioja

9 Jorge Visa Vidal

MEMORIA

1. Introducción

Motivación Volar siempre ha sido y será uno de los mayores sueños del ser humano.

Llevamos más de 2400 años intentando cumplirlo y eso nos ha llevado a sitios inesperados, y que jamás pensaríamos que podíamos alcanzar, como el espacio.

Las posibilidades que ofrece sobrevolar la tierra y a la vez eludir el riesgo que conllevan las misiones de vuelo tripuladas han favorecido la proliferación de los UAVs (Unmanned Aerial Vehicles) también conocidos como drones.

Una de las primeras aplicaciones de los drones fueron los usos militares. Precisamente los drones tuvieron su origen como arma o aparato bélico. Dentro de la industria militar, los drones son vehículos idóneos para el espionaje militar, para misiones de reconocimiento y de pura observación desde el aire. También se pueden armar con misiles y bombas, reduciendo la presencia de tropas en los conflictos armados.

Más allá de su potencial bélico, los drones pueden servir para ayudar a las personas. Ya se han utilizado para el envío de ayuda humanitaria y para mejorar la sanidad en zonas que han quedado aisladas, ya sea por guerras o por desastres naturales. Aparte de esta labor, los drones pueden traer de vuelta información sobre el estado de la población en estos lugares, gracias a sensores incorporados que obtendrían datos sobre los biorritmos de posibles pacientes.

También podrían ser de gran ayuda para la aerovigilancia urbana y la vigilancia policial. La seguridad ciudadana es básica en cualquier población y, a pesar de los dilemas por el derecho a la intimidad, Reino Unido y Alemania ya están investigando como poder usar estos drones en la lucha contra el crimen.

Respecto a la violación de la intimidad, el alcalde de Nueva York destacó que existen más de 2.400 cámaras de vigilancia de edificios en la Gran Manzana. Evitar atracos y conflictos urbanos o controlar el tráfico podrían ser dos de sus funciones principales en las ciudades. Así como la vigilancia policial de traficantes y otras actividades ilegales.



10 Jorge Visa Vidal

El aeromodelismo consiste en un hobby para muchas personas y que cada vez está interesando a más gente, sobre todo gracias a la estupenda labor de páginas web como ‘ Do It Yourself Drones’ o ‘ Sparkfun’ que desarrollan hardware y software disponible para el usuario de a pie mediante la plataforma ‘ open-source hardware’ denominada Arduino.

Navegando por este tipo de páginas, siempre se encuentran nuevas aplicaciones, temas y consejos interesantes en los foros así como los materiales necesarios y un largo etcétera.

Antecedentes Las investigaciones en el campo de la robótica, de la inteligencia artificial

aeronáutica y de la microelectrónica han propiciado avances muy significativos en los UAV en los últimos 10 años. Las principales ventajas de un UAV son:

• Menor coste que las aeronaves tripuladas.

• No se arriesgan vidas.

• Capacidad de incorporar multitud de sensores.

• Posibilidad de acceder a sitios peligrosos o de difícil acceso.

Existen multitud de variantes de UAV´s y su clasificación se realiza dependiendo de las siguientes variables: alcance en kilómetros, altitud de vuelo en metros, autonomía en horas y carga útil máxima que puede transportar en kilogramos. La Tabla 1 recoge una primera clasificación. La mayoría de los UAV civiles se encuentran entre la categoría Micro y alcance cercano.



11 Jorge Visa Vidal

Tabla 1. Clasificación de los UAV por sus capacidades de vuelo.

En este trabajo se va trabajar con las categorías micro y mini, ya que los UAV´s son para aplicaciones sencillas y no se necesitan categorías superiores. Además los UAV que se van a utilizar son multi-rotor, es decir, que tienen más de dos rotores, y de sistema VTOL, lo que significa que son aeronaves de despegue y aterrizaje vertical.

Los multi-rotores modernos utilizan normalmente palas de paso fijo, además el ángulo del rotor no varía cuando las palas giran y finalmente el control del movimiento del vehículo se consigue mediante la variación de la velocidad relativa de cada rotor para cambiar el empuje y el par producido por cada uno de ellos.

Objeto del trabajo Para potenciar la seguridad, fiabilidad y precisión del vuelo y la misión

concreta de éste, el sistema de control del UAV es fundamental. Uno de los elementos clave para su gobernabilidad es el sistema de propulsión. En un UAV multi-rotor se disponen los rotores sobre cierta geometría de la aeronave. Cada rotor está formado por un motor que lleva acoplada una hélice. En función del potencial motriz y de la geometría de la hélice se generan las fuerzas y pares aerodinámicos que permiten girar al UAV, y en virtud de ello desplazarse.



12 Jorge Visa Vidal

Por tanto, en última instancia, el rotor (conjunto motor-hélice) es el responsable de la propulsión del UAV y, por tanto, la caracterización de los rotores es fundamental, siendo el objeto de este TFG.

Por otro lado, en la base del sistema de control del UAV está el control de los tres giros, roll, pitch y yaw, ya que éstos le permitirán desplazarse de forma orientada por el espacio. Entonces, se plantea también como objeto del TFG poder simular el vuelo de un UAV en una estructura que a modo de giroscopio permita el giro de la aeronave en los tres ejes sin desplazarse. De este modo se pueden realizar pruebas sobre el control de actitud y orientación del UAV sin tener que volar en un espacio abierto, reduciendo así los posibles accidentes en caso de fallo de diseño de los controladores.

Objetivos De acuerdo con el objeto del TFG, existen dos objetivos principales. Por un lado

identificar los parámetros de cada uno de los rotores de un UAV multi-rotor (categoría micro o mini), para posteriormente deducir las fuerzas aerodinámicas y los pares de arrastre que permitan caracterizar el sistema de propulsión de la aeronave, que es fundamental para su gobierno. Y el segundo objetivo es construir una plataforma que a modo de giroscopio permita el giro del UAV en los tres ejes sin que la aeronave se desplace, con el fin de poder realizar pruebas sobre el control de los tres ángulos.

Para el primer objetivo del trabajo se partirá únicamente del conjunto motor-hélice (rotor) y se desarrollará:

• Un mecanismo para calcular la fuerza de empuje de un rotor.

• Un mecanismo para calcular el par de arrastre de un rotor.

• Modificación del sistema electrónico de una báscula de pesado, para la captura de datos desde un sistema controlador (PC).

• Circuito de amplificación, recogida de datos y control de los mecanismos.

• Herramienta software de adquisición de datos.

• Herramienta software de procesamiento de datos y muestra de resultados.

El cálculo de ambos tipos de fuerza, tanto la del empuje como el arrastre de los rotores, es imprescindible para el desarrollo posterior de los controladores del UAV. Si



13 Jorge Visa Vidal

no se identifican estos parámetros será imposible llevar a cabo el control de cualquier tipo de aeronave.

Es necesaria la modificación de los circuitos electrónicos internos de la báscula de pesaje ya que se quiere conseguir obtener en un PC el valor del peso ejercido por ambos mecanismo sobre la báscula; para ello se modifican y conectan al circuito de control.

Se llevará a cabo el diseño de un circuito encargado de amplificar las señales que se obtienen de la báscula de pesaje, controlará las señales que se envían al rotor desde el PC y obtendrá las señales procedentes del fotodiodo de las máquinas para el cálculo de las velocidades de giro. Todo el circuito estará contenido en una placa de circuitos impresos (PCB).

La herramienta software de adquisición de datos llevará a cabo en el IDE (Integrated Development Environment) de Arduino, siendo un Arduino Nano el que controlará el sistema. Esta aplicación de usuario será la encargada de mandar las señales a los rotores y de recoger los datos tanto de la báscula de pesaje como del fotodiodo, para sacar por una pequeña interface los datos de la potencia del motor, las revoluciones por minuto y la fuerza en gramos que realiza el rotor.

Finalmente la herramienta software de procesamiento y muestra de datos, se llevará a cabo con MATLAB©. Esta aplicación de usuario permitirá cargar los datos del experimento que se haya realizado, e introduciendo los parámetros de longitudes y alturas de las máquinas permitirá el cálculo de la fuerza de empuje y del par de arrastre de los rotores. Además, mostrará una serie de gráficas necesarias para caracterizar la estática y dinámica de los mismos.

Para el segundo objetivo del trabajo se partirá del UAV, con todos sus componentes y controladores ya montados, y se desarrollará:

• Una estructura que permita el giro del UAV alrededor de los tres ejes principales con el menor rozamiento posible.

El diseño de esta estructura será clave a la hora de poder finalizar el estudio y desarrollo de los controladores de un UAV, ya que permitirá poder comprobar el control de actitud y orientación sin tener que volar en un espacio abierto, reduciendo así los posibles accidentes en caso de fallo de diseño de los controladores.

Como se puede apreciar este trabajo está muy ligado al desarrollo y construcción de un UAV desde cero, se puede decir que uno de los primeros pasos



14 Jorge Visa Vidal

(una vez realizado el diseño mecánico) antes de diseñar el controlador de este vehículo es identificar los parámetros de los rotores que se van a usar para equipar al UAV y uno de los pasos finales es poder comprobar el correcto funcionamiento de los controladores diseñados.



15 Jorge Visa Vidal

2. Referencias

Bibliografía web • http://www.dys.hk/ • http://www.turnigy.com/ • http://www.hobbyking.com/hobbyking/store/index.asp • http://diydrones.com/ • https://www.sparkfun.com/ • https://www.arduino.cc/

Libros bibliográficos • H. Lim, J. Park, D. Lee, and H. J. Kim. Build your own quadrotor: Open-source

projects on unmanned aerial vehicles. IEEE Robotics and Automation Magazine, Vol. 19, No 3, pp 33-45, 2012.

• Katsuhiko Ogata. Ingeniería de Control Moderna. Pearson Educación, 2003. • Ramón Pallás Areny. Sensores y acondicionadores de señal. Marcombo, 2003.

Artículos bibliográficos • Rico, R., Maisterra, P., Gil-Martínez, M., Rico-Azagra, J. y Nájera, Silvano.

Identificación experimental de los parámetros de un cuatrirrotor. Actas de las XXXVI Jornadas de Automática. Bilbao, 2015

• Ramón Rico Azagra. Sistema de vuelo RPAS de un multi-rotor. Trabajo Fin de Máster, Universidad de La Rioja, 2016.

http://www.dys.hk/

http://www.turnigy.com/

http://www.hobbyking.com/hobbyking/store/index.asp

http://diydrones.com/

https://www.sparkfun.com/

https://www.arduino.cc/



16 Jorge Visa Vidal

3. Definiciones y abreviaturas

• UAV: Viene del inglés Unmanned Aerial Vehicle, cuyo significado es Vehículo Aereo No Tripulado (VANT) en español.

• Arduino: Arduino es una compañía de hardware libre, y comunidad tecnológica, que diseña y manufactura placas de desarrollo de hardware y software compuesta respectivamente por circuitos impresos que integran un micro controlador, y un entorno de desarrollo (IDE) en donde se programa cada placa.

• IDE: Viene del inglés Integrated Development Environment, cuyo significado es entorno de desarrollo integrado en español.

• TFG: Siglas de Trabajo Fin de Grado. • VTOL: Viene del inglés Vertical Take-Off and Landing, cuyo significado es

despegue y aterrizado vertical es español. Está referido al sistema de propulsión del UAV.

• RPM: Siglas de Revoluciones Por Minuto. Está referido a la velocidad de giro del motor.

• PCB: Viene del inglés Printed Circuit Board, cuyo significado es placa de circuito impreso en español.

• PWM: Viene del inglés Pulse Width Modulation, cuyo significado es modulación por ancho de pulsos en español. Está referida a la acción de control que se le envía al motor.

• ESC: Viene del inglés Electronic Speed Control; cuyo significado en español es control electrónico de velocidad.

• Ident: Viene del inglés System Identification Toolbox, es un paquete de herramientas que tiene MATLAB para la identificación y modelado de sistemas.

• δ: Letra utilizada para hacer referencia al par de arrastre o drag. • T: Letra utilizada para hacer referencia a la fuerza de empuje o thrust. • τ: Letra utilizada para hacer referencia a la constante de tiempo en los modelos

de identificación de la dinámica de los motores.



17 Jorge Visa Vidal

4. Caracterización del sistema de propulsión de un UAV

Estructuras mecánicas Como el objetivo fundamental es identificar las dos principales fuerzas/pares que

provocan los rotores, se empezará por definirlas: • Par de arrastre o drag: Se genera en el plano de giro de la hélice y es un par de sentido contrario al de su rotación. • Fuerza de empuje o thrust: Se genera una fuerza aerodinámica de ascensión perpendicular a su plano de giro por el movimiento de aire de las hélices al rotar.

Para el diseño del sistema de control del UAV y su operación en vuelo real, estos pares/fuerzas son conocidos de forma indirecta a través de la velocidad de giro del rotor (conjunto motor-hélice), o más concretamente, a través de la señal de control a los motores.

Sin embargo, para ello es preciso conocer ciertas constantes que caracterizan el conjunto motor-hélice concreto que se disponga en el UAV. Se determinarán por experimentación, para lo que se han diseñado y construido las estructuras mecánicas correspondientes. Los procedimientos se describen a continuación.

Determinación de la constante de empuje o thrust La ecuación física del comportamiento es

𝑇 = 𝐶𝑇𝐴𝑟22

Dónde:

• 𝐶𝑇 es el coeficiente de empuje para cada rotor. • es la densidad del aire. • 𝐴 es el área que abarca la hélice en su giro. • 𝑟 es el radio del rotor. • es la velocidad angular de giro.

Que puede reducirse a:

𝑇 = 𝐾𝑡2



18 Jorge Visa Vidal

Dónde:

• Kt es una constante que depende de cada rotor 𝐾𝑡 = 𝐶𝑇𝐴𝑟2

Por tanto, es necesario conocer la Kt, que caracteriza a cada conjunto motor-hélice. Para determinarla, se necesita por un lado medir la velocidad de giro w [RPM] y por otro el empuje T. El mecanismo diseñado y construido para ello se muestra en la Ilustración 1. El dimensionamiento de dicha estructura puede verse en el apartado 1 de los Planos.

Ilustración 1. Estructura para el cálculo del empuje

La estructura consta de un perfil en L con dos brazos, uno vertical y otro horizontal. En la parte superior del brazo vertical se sujeta el rotor, que puede ir atornillado en una estructura similar al brazo de la aeronave. El ángulo en L está fijado a un bisagra que permite que la estructura pivote de forma libre en el plano perpendicular al de giro del rotor. El extremo del brazo horizontal apoya en la báscula de pesado. De este modo la fuerza de empuje ejercida por el giro de las hélices genera un par sobre la estructura que finalmente se traduce en una fuerza registrada por la báscula.



19 Jorge Visa Vidal

El esquema de fuerzas y pares correspondientes es el de la Ilustración 2, donde V=0.31m y H=0.21 m.

Ilustración 2. Diagrama de fuerzas del empuje.

Aplicando la ecuación del momento sobre el punto pivote A:

𝑀𝐴 = 0

−(𝑇 ∙ 𝑉) + (𝐹 ∙ 𝐻) = 0 Y despejando la variable empuje

𝑇 = 𝐿𝐻∙ 𝐹

Por tanto, midiendo la fuerza F mediante la báscula se conoce el empuje T

ejercido por el rotor. El experimento se repite para distintas señales PWM de control del motor (cada una de las cuales se corresponde con una potencia de alimentación), o sea para distintas velocidades w de giro del rotor.

La velocidad de giro del rotor w se determina a partir de un sensor óptico que se acopla en el la parte superior del brazo vertical, como se indica en la Ilustración 3.



20 Jorge Visa Vidal

Ilustración 3. Estructura para el cálculo del empuje con el sensor óptico incluido.

De este modo, un emisor/receptor de luz detecta el paso de hélice. Contando los pulsos detectados por unidad de tiempo se determina w. Para ello se han diseñado y construido los circuitos electrónicos correspondientes que se describen en el apartado 3 en Electrónica de Medida y Mando.

Un sistema micro controlador basado en Arduino gestiona la entrega de señales y recogida de datos (véase Apartado 3 en Interfaces de usuario en PC).

Por último, a partir de la gráfica T vs w obtenida experimentalmente (véase Apartado 3 en Experimentos realizados la Identificación del empuje de los rotores) se determina la constante de thrust Kt de acuerdo a la ecuación física anterior.



21 Jorge Visa Vidal

Par de arrastre o drag La ecuación física del comportamiento puede reducirse a:

𝛿 = 𝐾𝑑2

Donde:

• Kd es una constante que depende de cada rotor. • es la velocidad angular de giro.

Por tanto, es necesario conocer la Kd, que caracteriza a cada conjunto motor-hélice. Para determinarla, se necesita por un lado medir la velocidad de giro w [RPM] y por otro el par de arrastre δ. El mecanismo diseñado y construido para ello se muestra en la Ilustración 4. El dimensionamiento de dicha estructura puede verse en el apartado 2 de los Planos.

Ilustración 4. Estructura para el cálculo del par de arrastre.

La estructura consta de dos partes, un perfil vertical que hará de base y eje de giro y un perfil horizontal al cuál irá anclado el rotor, que estará unido al perfil vertical mediante un rodamiento y un casquillo. Al final del perfil horizontal se encuentra una varilla que apoya en la báscula de pesado. De este modo la fuerza tangencial ejercida por el rotor, genera un par que finalmente se traduce en una fuerza registrada por la báscula.



22 Jorge Visa Vidal

El esquema de fuerzas y pares correspondientes es el de la Ilustración 5, donde D=0.15m.

Ilustración 5. Reacciones en una viga al par de un rotor.

Aplicando la ecuación del momento sobre el punto pivote A:

𝑀𝐴 = 0

−𝛿 + (𝐹 ∙ 𝐿) = 0 Y despejando la variable del par

𝛿 = 𝐹 ∙ 𝐿

Por tanto, midiendo la fuerza F mediante la báscula se conoce el par de arrastre

δ ejercido por el rotor. El experimento se repite para distintas señales PWM de control del motor (cada una de las cuales se corresponde con una potencia de alimentación), o sea para distintas velocidades w de giro del rotor.

La velocidad de giro del rotor w se determina a partir de un sensor óptico que se acopla en el la parte superior del perfil vertical, como se indica en la Ilustración 6.



23 Jorge Visa Vidal

Ilustración 6. Estructura para el cálculo del par de arrastre con el sensor óptico incluido.

Electrónica de medida y mando En esta parte del trabajo se explicará y detallará el circuito de medida diseñado

para medir la velocidad de giro de los motores, tanto en la estructura para calcular el empuje como en la de calcular el par de arrastre, controlar las señales de PWM que le llegan al motor y recopilar las medidas en gramos de la báscula de pesaje.

Control del motor Se pretende conocer la relación existente entre la señal de mando PWM que

recibe la etapa de control de potencia del motor (ESC) y la velocidad de giro alcanzada por el conjunto motor-hélice. Ambas señales (la de mando y la de velocidad) se centralizan en un ordenador, y se gestionan a través de las aplicaciones de usuario.

Para interactuar con el sistema físico, se diseña el circuito de la Figura 7. Está

basado en un Arduino Nano, ya que ocupa un espacio muy reducido y cuenta con la potencia de cálculo y capacidad de memoria necesarias. Este actuará como sistema de adquisición y tratamiento de datos para y desde el ordenador.



24 Jorge Visa Vidal

Ilustración 7. Circuito para medida de RPM.

Para la medida de la velocidad, este circuito contará con la presencia de un sensor óptico, en este caso un fotodiodo, que detecta el paso de las aspas de la hélice. Estará encerrado en un pequeño tubo de cartón para que sólo este iluminada la zona que apunta directamente a la hélice acoplada al motor.

De esta forma se consigue que cuando el rotor este girando, por cada paso de

las aspas de la hélice, el sensor óptico detectará un cambio de luminosidad. Éste será tratado por un circuito comparador, el cual genera una señal digital de pulsos (0-5V) cuando se produzca el paso de un aspa. Justo en frente de las aspas de las hélices se colocará un flexo o una bombilla apuntando hacia ellas para conseguir así un mayor contraste del nivel de luminosidad en cada giro. El cálculo y diseño del circuito electrónico comparador que genera los pulsos de tensión 0-5V se detalla en el Anexo 1 de este trabajo.

Una vez que se ha generado esta señal de pulsos lo que el Arduino hace es

generar dos interrupciones, una para pulso alto (5V) y otra para pulso bajo (0V). Entonces tras realizar una serie de capturas de tiempo cuando se producen estas interrupciones, se transforma todo a RPM y se divide entre 2, ya que la hélice cruza dos veces por delante del fotodiodo en una misma vuelta. Finalmente el Arduino



25 Jorge Visa Vidal

manda esta señal de RPM al PC via USB SERIAL y la muestra por pantalla, juntos con otros datos.

El otro punto importante es el accionamiento del motor, cuya etapa de control

de potencia denominamos ESC. La señal de control del ESC se conectará a una salida analógica especial del Arduino Nano que genera señales PWM. Por otro lado, el ESC está conectado a la batería o a una fuente de alimentación a 11.1V. La potencia modulada se entrega al motor DYS o Turnigy, que girará a la velocidad correspondiente w medida por el procedimiento antes indicado.

El experimento para extraer las curvas que relacionan la señal de control PWM

con la velocidad de giro alcanzada (y después con el par/fuerza ejercidos) es el siguiente:

1) El Arduino mandará una señal de mando, la señal PWM, a los motores. 2) El circuito comparador recibirá la señal del sensor óptico y generará una señal digital que será leída por el Arduino para indicar el paso de una aspa de la hélice.

3) Finalmente el IDE de Arduino en el PC almacenará y mostrará por la pantalla la velocidad de giro del motor en revoluciones por minuto, y también la fuerza en gramos que el rotor está realizando sobre la báscula, a través de la estructura mecánica correspondiente (o bien para la medida del par de arrastre o bien para la medida de la fuerza de empuje). La toma de las medidas de fuerza se explica a continuación.

Captura de fuerzas sobre la báscula Tal y como se indicó en el Apartado 3 Estructuras mecánicas, las estructuras diseñadas para medir el par de arrastre y la fuerza de empuje, traducen éstos en fuerzas registradas con una báscula. Estas medidas deben ser trasferidas al ordenador a través del Arduino Nano.



26 Jorge Visa Vidal

Ilustración 8. Conexión báscula-Arduino-PC.

Para ello, previamente se he diseñado y desarrollado el circuito electrónico correspondiente que convierte las señales de pesaje registradas por un báscula comercial en señales que pueden ser capturadas por las entradas analógicas del Arduino. Todo esto se detalla en el Anexo 2.

El funcionamiento del circuito dentro del experimento para extraer las curvas de par de arrastre y de fuerza de empuje, y su posterior relación con la velocidad, es el siguiente:

1) La estructura, tanto la del empuje como la del par, harán una fuerza

sobre la báscula de pesaje. 2) El circuito amplificador elevará el rango de la señal y lo transformará en

positivo para que la entrada analógica del Arduino pueda leerlo. 3) Finalmente el IDE de Arduino mostrará por pantalla la fuerza en gramos

realizada por el roto, junto con la velocidad de giro explicada anteriormente.



27 Jorge Visa Vidal

Diseño de la PCB El siguiente paso es diseñar una PCB (Printed Circuit Board en inglés y Placa

Circuito Impreso en español) que contenga ambos circuitos, ya que sólo se van a usar dos entradas digitales, dos analógicas y el Arduino Nano, entran ambos en una misma PCB.

Esta PCB se diseña con el software llamado Fritzing, que tiene mucha utilidad cuando se va a diseñar PCBs que contengan Arduinos, ya que tiene muchas librerías de componentes y tiene creados por defectos las carcasas de la mayoría de modelos de Arduino. Se adjunta el diseño de la PCB en el Anexo 3 de este trabajo.

Ilustración 9. Imagen de la PCB una vez realizada.

Interfaces de usuario en PC Esta parte del trabajo consta fundamentalmente de dos desarrollos software,

uno en el IDE de Arduino y otro en MATLAB©. La gran diferencia entre ambos programas es que el del IDE es para controlar y adquirir datos del rotor y el de MATLAB© para procesarlos, mostrarlos, y finalmente obtener las constantes de caracterización del rotor buscada (constante de par de arrastre y constante de fuerza de empuje).

Aplicación software adquisición de datos en IDE de Arduino Este software se ha desarrollado con la función de adquirir, controlar y mostrar al

usuario una serie de datos del motor a través de una pequeña interface.



28 Jorge Visa Vidal

Se han programado tres modos de funcionamiento, el modo normal, el de calibración y el modo test o automático. En los modos normal y test el usuario podrá ver en pantalla el tiempo de paso de las aspas, la señal de mando enviada al motor (de 0 a 100 en tanto por ciento), las RPM y los gramos de fuerza que está haciendo la estructura sobre la báscula.

El modo de calibración es el más importante a la hora de realizar el experimento con un motor o un ESC nuevo, ya que con él se consigue adaptar las señales de control que le manda el Arduino a la señales del ESC, desde el 0 al 100 %.

El modo normal se puede utilizar para obtener datos del rotor de manera manual como se muestra en la Ilustración 10, se introduce un comando del 0 al 100, que será la señal de mando del motor, y obtendremos por pantalla las RPM y la fuerza en gramos que está haciendo sobre la báscula. Así como el instante de muestreo de cada medida. Estos datos aparecerán en 4 columnas, segundos, señal de mando, RPM y fuerza en gramos.

Ilustración 10. Modo normal de funcionamiento.

Se puede ir introduciendo de manera manual los valores que se desee de la aceleración del motor pero este modo no es recomendable para realizar un estudio del comportamiento del motor, para ello es mejor el modo test. El modo test es el más óptimo para realizar un estudio completo del motor, ya que de forma automática la señal de mando del motor aumentará en escalones del 5% desde el 0 hasta el 100%, permaneciendo aproximadamente 5 segundos en cada escalón de velocidad para poder obtener los datos necesarios del motor. Una vez que llegue al 100%, la señal de mando irá disminuyendo progresivamente hasta parar el motor sin ningún tipo de problema.

Una vez que se han explicado los tres modos de funcionamiento, el siguiente paso es explicar cómo pasar de un software a otro, es decir, como pasar los datos obtenidos en el experimento con el IDE de Arduino al software de MATLAB©.



29 Jorge Visa Vidal

Lo que se deberá hacer es copiar del interface del IDE del Arduino todas las columnas de datos del experimento que deseemos, incluyendo las cabeceras, es decir, “Segundos”, “Aceleración”, “RPM” y “Gramos”. Una vez copiadas, se pegaran y guardaran en un archivo del tipo .txt en la carpeta en la que se trabaja como directorio de MATLAB©.

A continuación se abrirá el programa de MATLAB© y se seleccionará la carpeta en la que tenemos los datos guardados y la aplicación como directorio de trabajo, comprobando así que nuestros datos en formato .txt se han guardado correctamente.

Todo el código del programa se adjuntará en el Anexo 4 de este trabajo.

Ilustración 11- Directorio de trabajo de MATLAB.

El siguiente paso es pinchar con el botón izquierdo sobre el archivo .txt que contiene nuestros datos y seleccionar la opción “Import Data…”, se abrirá una ventana emergente en la que saldrán los datos organizados por columnas, sólo tendremos que pinchar en el botón “Import Selection”, situado en la esquina superior derecha, y nuestras variables nos aparecerán como variables en el workspace de MATLAB©.



30 Jorge Visa Vidal

Ilustración 12. Variables cargadas en el workspace de MATLAB.

Por último, deberemos seleccionar todas las variables del workspace y guardarlas como un archivo de extensión .mat en la carpeta de trabajo de MATLAB© para después usarlas en la aplicación creada con este software.

Aplicación software de procesamiento de datos y muestra de resultados en MATLAB

Esta otra parte del software se ha llevado a cabo con MATLAB©, ya que tiene mucha más potencia a la hora de procesar datos que el IDE de Arduino. Para hacer más sencilla y más visible se ha realizado una aplicación con la herramienta GUIDE.

Es un pequeño interface con el usuario para que este pueda cargar los datos del

experimento que quiera, introducir los parámetros de las estructuras y pulsando un botón obtenga tres gráficas sobre el comportamiento del motor.



31 Jorge Visa Vidal

Ilustración 13. Aplicación guide de MATLAB.

Como se puede observar la pantalla está dividida en tres bloques principales:

1) Bloque del par de arrastre del rotor: Se utilizará este bloque cuando se quiera procesar y obtener los resultados de los experimentos de la estructura del cálculo del par. Para ello se dispone de una entrada de texto para escribir el nombre completo del archivo, incluyendo el formato del archivo (.mat) en el que se encuentren los datos del experimento guardados anteriormente.

El siguiente paso será pulsar el botón de “Cargar Datos”, para que MATLAB© los cargue en el programa.

A continuación, se deberá introducir el valor de “D” en metros, que es la distancia que va desde el eje del motor hasta el punto en el que estamos midiendo el par, el valor por defecto será 0.15m que es el de la estructura del trabajo.

Finalmente habrá que pulsar el botón de “Calcular” y obtendremos los resultados en el bloque de las gráficas.



32 Jorge Visa Vidal

Ilustración 14. Bloque del par de la aplicación.

2) Bloque del empuje del rotor: Por el contrario se utilizará este

bloque cuando se desee procesar los datos de los experimentos de la estructura del cálculo del empuje. Al igual que con el bloque del par se dispone de una entra de texto para introducir el nombre del archivo de los datos del experimento que se quiera utilizar.

El procedimiento es el mismo que antes, se pulsará el botón “Cargar Datos”, después se introducirán los parámetros de la maqueta, en este caso son dos, “H” que es la altura que va desde el eje del motor hasta la horizontal con el punto de medición del empuje y “L”, que es la distancia que va desde el punto de medición hasta la vertical donde está colocado el motor, ambos valores serán 0.31m y 0.21m respectivamente.

Una vez se introducen los parámetros de la maqueta, se pulsará el botón “Calcular” y los resultados se mostrarán en el bloque de las gráficas.



33 Jorge Visa Vidal

Ilustración 15. Bloque del empuje de la aplicación.

3) En este último bloque se mostrarán de manera gráfica los

resultados, una vez procesados los datos, de los experimentos que se han llevado a cabo, tanto del par como del empuje. Se mostrarán tres gráficas diferentes: - RPM vs Tiempo: En esta gráfica se podrá observar y analizar la

dinámica de nuestro motor, ya que se verá que tiempo de establecimiento tiene y como es la propia dinámica.



34 Jorge Visa Vidal

Ilustración 16. Gráfica de rpm vs tiempo.

- RPM vs PWM: En esta gráfica se podrá analizar la evolución de la

velocidad del motor respecto a la aceleración que se le envía desde el Arduino, se podrá observar que es prácticamente lineal esta evolución.

Ilustración 17. Gráfica de rpm vs PWM.



35 Jorge Visa Vidal

- Fuerza vs : En esta gráfica se mostrará la fuerza que ejerce el motor, dependiendo de qué bloque se utilice para calcular la fuerza será empuje o par, frente a la velocidad de giro del motor (), para poder calcular la constante K que relaciona la fuerza con la velocidad del motor. Como se puede observar es una función cuadrática.

Ilustración 18. Gráfica de fuerza vs .

Todo el código del programa se adjuntará en el Anexo 5 de este trabajo.



36 Jorge Visa Vidal

5. Resultados experimentales

Hélices y motores utilizados Se va a llevar a cabo el experimento del trabajo, para dos tipos diferentes de motores y de hélices:

• Motor brushless Turnigy Multistar 4220-650kv con hélice de 9.4x4.3”. • Motor brushless DYS BE1806-2300kv con hélice de 5x3”.

Ilustración 19. Motor Turnigy.

Ilustración 20. Motor DYS.



37 Jorge Visa Vidal

Experimentos realizados Se puede decir que se van a llevar a cabo 4 grandes experimentos, con cada uno de los motores y hélices usados. Fundamentalmente se va a identificar la estática y la dinámica de los motores así como la fuerza de empuje y el par de arrastre de los rotores permitan calcular las constantes de thrust y drag.

Identificación de la estática de los motores Se pretende obtener la curva estática del conjunto motor-hélice que relaciona

la velocidad de giro de la hélice que se alcanza en régimen permanente para cada señal de mando al motor. Utilizaremos el circuito diseñado y explicado anteriormente. Se realizaran todas las conexiones correctamente como se indican en el Anexo 6.

Se seleccionará el modo test en el IDE del Arduino y se obtendrá una lista en la que se presenta el PWM que se ha estado enviando, el tiempo de paso de las aspas, las RPM y la fuerza en gramos que se ha ejercido.

Se trasladarán estos datos a MATLAB© y se convertirán a un archivo .mat, como ya se ha explicado con anterioridad, y se hará uso de la aplicación. En este caso da igual el tipo de fuerza que empleemos ya que la estática del motor será igual.

Ilustración 21. Curva estática del motor DYS.

En esta gráfica la relación entre PWM y RPM se puede hallar mediante la pendiente de la curva, dependiendo del punto de operación este valor variará. Como se puede apreciar en la gráfica el valor del PWM oscila entre el 0 y el 100%.



38 Jorge Visa Vidal

Entre el 0 y 7 % aproximadamente presenta una zona muerta, es decir, no hay ningún movimiento. A partir de este valor hasta aproximadamente el 95%, la curva presenta un aumento lineal de la velocidad de giro que se corresponde con el valor de K. Sin embargo a partir del 95% este valor se mantiene constante, lo que significa que se produce una saturación del actuador.

Ilustración 22. Curva estática del motor Turnigy.

Si se observa la gráfica se aprecia que tiene una curva estática muy similar a la del motor DYS, aunque alcanza menor número de rpms. Presenta una zona muerta entre el 0 y el 7%, durante la cual no hay movimiento. Desde el 10% hasta el 95% de PWM presenta un aumento lineal de la velocidad de giro debido a la constante K, y además llega a saturación al 95% de su potencia.

Finalmente se puede llegar a la conclusión de que ambos motores presentan una estática muy parecida, con un inicio de zona muerta, un aumento lineal de la velocidad de giro del motor y para terminar presentan un intervalo de saturación del actuador.

Identificación de la dinámica de los motores Para un cierto incremento de la tensión de mando se trata de caracterizar la

evolución dinámica de la velocidad, desde la velocidad en régimen permanente correspondiente a la tensión de mando inicial, hasta la velocidad en régimen permanente correspondiente a la tensión de mando final. Los regímenes permanentes son los que determina la curva estática anterior.



39 Jorge Visa Vidal

Dicho de otro modo, cuando se le manda al motor una señal PWM para modificar su velocidad, el cambio no se produce de manera instantánea, sino que tiene una dinámica, es decir, le cuesta un cierto tiempo alcanzar el régimen permanente de velocidad.

En el caso de los motores de un UAV si se estudia el modelo matemático se obtendrá que se comportan como un sistema de primer de orden, ya que por lo general suelen ser modelados por el circuito correspondiente a los motores de escobillas de corriente continua. El parámetro dinámico que caracteriza a estos es la constante de tiempo.

Ilustración 23. Respuesta dinámica del motor DYS.

Usando estos datos recogidos por el programa se utiliza la herramienta Ident (System Identification Tool) de MATLAB para estudiar la respuesta del motor DYS:



40 Jorge Visa Vidal

Ilustración 24. Respuesta dinámica del motor DYS en el Ident de MATLAB.

De estos datos se extrae un escalón, concretamente el escalón de 20% a 25% de la entrada PWM, y en el Ident de MATLAB se analiza para obtener el modelo que mejor se ajusta, como se puede ver en la Ilustración 25. Se puede elegir sistemas de primer o segundo orden y de diferentes características, pero en este caso el que mejor se ajusta es un sistema de primer orden como era de esperar.

Ilustración 25. Respuesta dinámica en velocidad del rotor DYS y del modelo identificado.



41 Jorge Visa Vidal

El modelo al que la herramienta Ident de MATLAB ajusta el sistema es el siguiente:

𝑃(𝑠) =343.7

0.1156𝑠 + 1

Por tanto se identifica una constante de tiempo τ = 0.1156 seg. La ganancia estática obtenida para este experimento, K = 343.7, se encuentra dentro de los valores esperados según la Ilustración 21.

Por otro lado, si se analizan los resultados que se obtienen del experimento con el motor Turnigy, se consigue una gráfica de la dinámica del motor:

Ilustración 26. Respuesta dinámica del motor Turnigy.

De manera análoga al experimento con el motor DYS, se extrae un escalón de 40% a 45% de la entrada PWM, y en el Ident de MATLAB se analiza para obtener el modelo que mejor se ajusta, como se puede ver en la Ilustración 27. Tras realizar una serie de pruebas se llega a la conclusión, al igual que en el experimento anterior, de que el modelo que mejor se ajusta es un sistema de primer orden.



42 Jorge Visa Vidal

Ilustración 27. Respuesta dinámica en velocidad del rotor Turnigy y del modelo identificado.

El modelo al que la herramienta Ident de MATLAB ajusta el sistema es el siguiente:

𝑃(𝑠) =66.805

0.1147𝑠 + 1

Por tanto se identifica una constante de tiempo τ = 0.1147 seg. La ganancia estática obtenida para este experimento, K = 66.805, se encuentra dentro de los valores esperados según la Ilustración 22.

Identificación de la constante de empuje de los rotores Para distintas señales de mando al motor, se obtienen distintas velocidades de

régimen permanente () según la curva estática anterior. Para dada una de ellas se calcula el empuje (T) a partir de la fuerza medida con la báscula. La relación entre T y w permitirá la identificación experimental de la constante de thrust, Kt, del conjunto motor-hélice ensayado.

Para ello se coloca el brazo del UAV, o una estructura que lo sustituya, en la parte superior de la estructura de la Ilustración 1, agarrado entre las piezas que forman una pinza y se fija con fuerza, para evitar posibles movimientos. Por último, colocamos el contrapeso en la base de la estructura y realizamos las conexiones necesarias como se indica en el Anexo 6.



43 Jorge Visa Vidal

Se inicia el modo test en el IDE del Arduino y una vez acabado se copiar y guardan los datos en la extensión .mat (como ya se ha explicado anteriormente).

A continuación, se abre la aplicación diseñada en MATLAB© y se introduce el nombre del archivo en el apartado de “nombre del fichero” del bloque de empuje del motor. Pinchamos en “calcular” y en la parte derecha nos saldrán tres gráficas, en este caso, nos fijaremos sobre todo en la de “Fuerza vs RPM”.

Una vez se tiene todo, ya se puede calcular la constante Kt que relaciona la fuerza de empuje del rotor con la velocidad de giro del motor, el software será el encargado de calcular el valor de esta constante:

𝐾𝑡 = 𝑇2

Ilustración 28. Fuerza de empuje vs velocidad angular del rotor DYS.

La constante varía en los diferentes puntos de aplicación, pero entre el 45% y el 75% del PWM se mantiene sin apenas variar.

El programa nos muestra el valor superior e inferior, de esta constante, durante todo el rango de aplicación, además tambien realiza una media de todos estos valores y se obtiene que el empuje de este motor DYS puede ser modelado usando una constante de :



44 Jorge Visa Vidal

𝐾𝑡 = 3.39 ∙ 10−7𝑁𝑚

𝑟𝑎𝑑/𝑠2

Ilustración 29. Fuerza de empuje vs velocidad angular del rotor Turnigy.

La constante varía en los diferentes puntos de aplicación, pero entre el 25% y el 95% del PWM se mantiene sin apenas variar.

El programa nos muestra el valor superior e inferior, de esta constante, durante todo el rango de aplicación, además tambien realiza una media de todos estos valores y se obtiene que el empuje de este motor Turnigy puede ser modelado usando una constante de :

𝐾𝑡 = 2.12 ∙ 10−5𝑁𝑚

𝑟𝑎𝑑/𝑠2

En la gráficas de los rotores se puede observar que el empuje guarda una relación cuadrática con la velocidad de giro del motor, por lo que se puede considerar correcta la hipótesis de partida de este trabajo.



45 Jorge Visa Vidal

Identificación del par de arrastre de los rotores De manera homóloga se va a calcular la constante de drag Kd que relaciona el

par de arrastre (δ) con la velocidad de giro del motor ().

Se utiliza la estructura de la Ilustración 4. Anclamos el motor a la pieza de sujeción y anclamos ésta a la estructura a través de la varillas que tiene. El siguiente paso es conectar todo el circuito correctamente al igual que para el experimento anterior, solo habría que sustituir una estructura por otra, en caso de duda ver Anexo 6.

A continuación, al igual que antes, se inicia y ejecuta el modo test en el IDE de Arduino, se copian y guardan todos los datos en un archivo .mat, para finalmente ejecutar la aplicación de MATLAB©.

Se introduce el nombre del archivo de dato y se pincha en “Calcular” en el bloque del par del motor, aparecerán las tres gráficas pero la más importante en este caso es la de “Fuerza vs RPM”.

Una vez es conocido el valor del par de arrastre (δ) para cada uno de los valores del PWM enviados a los motores y el valor de la velocidad de giro del motor (), ya se puede calcular el valor de la contante Kd que relacione ambos valores:

𝐾𝑑 = 𝛿2

Ilustración 30. Par de arrastre vs velocidad angular del motor DYS.



46 Jorge Visa Vidal

Se comprueba el comportamiento cuadrático del par de arrastre frente a la velocidad de giro del motor, haciendo la media de la constante que relaciona ambos valores se puede llegar a la conclusión de que para ajusta el comportamiento de esta fuerza:

𝐾𝑑 = 3.07 ∙ 10−9𝑁𝑚

𝑟𝑎𝑑/𝑠2

De manera análoga hacemos lo mismo para los datos con el experimento del motor Turnigy.

Ilustración 31. Par de arrastre vs velocidad angular del motor Turnigy.

De nuevo con esta gráfica se comprueba el comportamiento cuadrático del par de arrastre frente a la velocidad de giro del motor. Se llega a la conclusión de que para ajusta el comportamiento de esta fuerza:

𝐾𝑑 = 6.17 ∙ 10−7𝑁𝑚

𝑟𝑎𝑑/𝑠2



47 Jorge Visa Vidal

6. Plataforma para el control de actitud y orientación de un UAV

Estructura mecánica El segundo gran objetivo de este TFG es construir una plataforma que consiga

aportar estabilidad neutra a nuestro UAV, es decir que permita su giro en los tres ejes (roll, pitch y yaw), sin que la aeronave se desplace en X, Y, Z.

Esto permitirá diseñar y desarrollar estrategias de control de actitud (giro en roll y pitch) y orientación (giro en yaw) para muti-rotores, sin los inconvenientes que supone el vuelo libre. No obstante, los conocimientos y experiencia adquiridos serán luego extrapolables al vuelo normal.

Ilustración 32. Ejes de movimiento de un UAV.

Tras una larga búsqueda de ideas, finalmente se llega a la conclusión de que un diseño óptimo es hacer una estructura que contenga un giróscopo en su interior en la que el UAV pueda moverse con libertad por los tres ejes.



48 Jorge Visa Vidal

Ilustración 33. Plataforma de simulación

El cuerpo exterior de esta plataforma está formado por una estructura metálica cuadrada con patas en forma de T, a la que se le han colado dos rodamientos justo en la parte central del lado superior y del lado inferior.

Posteriormente se ha diseñado un aro metálico al que se le han acoplado dos

varillas, una en cada lado exterior del eje vertical del aro, que irán situadas en los rodamientos del cuerpo exterior de la plataforma, con esto conseguimos un movimiento en el eje vertical (yaw) sin apenas rozamientos. Además se colocarán dos rodamientos en la parte interior del aro, uno en cada extremo del eje horizontal.

A continuación se diseñará un aro metálico de radio más pequeño que el

anterior, al que se le acoplarán dos varillas metálicas en ambos extremos del eje horizontal, que irá colocado dentro del primer aro gracias a las varillas que se introducirán en los rodamientos del mismo, con ello se consigue un movimiento en el eje horizontal (pitch) sin apenas rozamiento. Por otro lado, se colocarán dos rodamientos también en este segundo aro en ambos extremos del eje vertical.

Finalmente se construirá una estructura en forma de cuna en la que el UAV irá

colocado, agarrado a través de una serie de bridas. También se le añadirán dos



49 Jorge Visa Vidal

varillas a ambos lado de la cuna, las cuales irán colocadas dentro de los rodamientos del segundo aro, consiguiendo así un movimiento en el tercer eje (roll) que nos faltaba.

Además se ha diseñado un mecanismo de bloqueo de los ejes de la plataforma

para mantener el UAV en una posición estática al inicio del experimento para poder llevar a cabo la calibración de los sistemas del mismo y que posteriormente no haya ningún fallo de orientación.

Ilustración 34. Pieza 1 del mecanismo de anclaje de los ejes de la plataforma.



50 Jorge Visa Vidal

Ilustración 35. Pieza 2 del mecanismo de anclaje de los ejes de la plataforma.

UAV utilizado En este apartado del trabajo se va realizar la descripción del multi-rotor utilizado

en el experimento con la plataforma para el control de actitud y orientación. Se ha utilizado un UAV de despegue vertical compuesto por los siguientes elementos:

• Estructura formada por 4 brazos de nailon de la marca HobbyKing, mod.

FPV250 (250mm entre ejes de motores) con un peso de 110g. Dispone en su parte central una zona en la que albergar toda la electrónica.

• Sistema de propulsión formado por 4 motores brushless DYS BE1806/2300kv de 24g con hélices de 5x3” y 4 ESC (Electronic Speed Controller) Afro de 12ª opto acoplados.

• Placa de control APM 3.1 con procesador ATMEGA2560. Integra giróscopo de 3

ejes, acelerómetro (MPU-6000) y barómetro (MS5611). • Módulo de telemetría 3DR de 100mW en banda de 915MHz. • Radioenlace Turnigy 9X de 8 canales en 2.4Ghz.



51 Jorge Visa Vidal

• Batería LiPo de 3 celdas de 1800mah amarrada al cuerpo central mediante velcro en posición de reparto simétrico de peso.

• Sistema de geo localización mediante GPS Ublox LEA 6H conectado a la placa

APM. • Otros elementos de protección de pequeño tamaño y peso (BEC, avisador

batería, etc…).

Las características mecánicas del conjunto son:

• Peso del conjunto: 0.485 kg • Dimensión del brazo: 0.11 m • Tensión nominal de la batería: 11.1 V

Ilustración 36. UAV utilizado para probar la plataforma de simulación.



52 Jorge Visa Vidal

7. Conclusiones

En primer lugar se ha diseñado y construido dos mecanismos/estructuras que transmiten las fuerzas aerodinámicas, tanto el par de arrastre como la fuerza de empuje, generadas por los rotores (conjunto motor-hélice) sobre una báscula de pesaje. Además se ha implementado un sistema de amplificación y conversión de la señal obtenida por la báscula para poder transmitirla al PC vía USB. Este sistema consta también de una etapa de control de la señal de mando del motor (PWM) que se envía desde el PC. Finalmente el circuito consta con una tercera etapa dedicada a la generación de una señal digital de pulsos (0-5V), correspondiente con el paso de las hélices del rotor por delante del sensor óptico colocado en el mecanismo/estructura. Esta señal ha sido imprescindible para poder calcular la velocidad de giro del motor.

Se ha utilizado un Arduino Nano para gobernar este sistema, tanto la parte de adquisición y envío de datos como para la parte de control del motor. La herramienta software de adquisición de datos ha sido diseñada por completo en el IDE de Arduino. Por otro lado, la parte de procesamiento y muestra de resultados ha sido programada con MATLAB.

Se ha conseguido que los experimentos de identificación de los parámetros del conjunto motor-hélice proporcionen medidas y resultados precisos que permitan posteriormente realizar, diseñar y validar un modelo del sistema de propulsión del UAV con una gran similitud con la realidad.

El cálculo de las constantes de drag y thrust permite posteriormente modelar ambas fuerzas aerodinámicas a través de la dependencia polinómica que tienen con la velocidad de giro del motor.

En segundo lugar, se ha diseñado y construido una plataforma a modo de giroscopio que permite el giro del drone en los tres ejes (roll, pitch y yaw), sin que este se desplace en ningún eje. Este bench ha sido clave a la hora de probar los controladores del UAV ya diseñado en otro Trabajo Fin de Master, se ha podido comprobar el control de actitud y orientación si necesidad de volarlo en un espacio abierto. Además los conocimientos y experiencias adquiridos con este experimento serán extrapolados en un futuro al vuelo normal.

Además este trabajo abre sobre todo las vías de continuación en el desarrollo de controladores y modelos de UAV´s, ya que se aporta la manera de identificar la



53 Jorge Visa Vidal

dinámica y estática de los motores así como las fuerzas aerodinámicas que generan los rotores, y finalmente se presenta una estructura que permite comprobar y corregir el sistema de control de actitud y de orientación del UAV sin que éste se desplace.

Las posibilidades que ofrece este trabajo pueden ser importantes en diversos escenarios. A nivel docente se convierte en la manera perfecta de poder mostrar el comportamiento y funcionamiento del sistema de control de un UAV sin tener que desplazarse a un espacio abierto y sin necesidad de tener licencia de vuelo. Para equipos de investigación puede ser una herramienta interesante para llevar a cabo la identificación de los motores y hélices de una manera rápida y sencilla, pudiendo así centrarse en el desarrollo e innovación de los sistemas de control, además tendrán una plataforma sobre los que probarlos ahorrando tiempo en desplazamientos a lugares de vuelo y posibles accidentes por fallo del UAV, lo que supondrá también un ahorro económico.

El desarrollo de este trabajo ha sido el primer paso hacia la mejora y facilidad de identificación de parámetros del UAV y simulación de vuelo, siendo el fin último optimizar tiempo y esfuerzo en esta parte del desarrollo de un UAV para poder centrarse en la creación, desarrollo y mejora de modelos matemáticos de estas aeronaves.

54 Jorge Visa Vidal

“DISEÑO, DESARROLLO Y CONSTRUCCIÓN DE BANCOS DE PRUEBAS PARA UN UAV MULTI-

ROTOR”

DOCUMENTO Nº 3 ANEXOS






Anexos Universidad de La Rioja

55 Jorge Visa Vidal

ÍNDICE

Anexo 1. Diseño del circuito comparador para el cálculo de la velocidad de giro del motor................................................................................... 56

Anexo 2. Diseño del circuito de amplificación para la obtención de los datos de medida de la báscula de pesaje. .............................................. 59

Anexo 3. PCB del circuito del trabajo ..................................................... 66

Anexo 4. Herramienta software de adquisición de datos con el IDE de Arduino. ................................................................................................ 67

1. Guía del programa ........................................................................................................... 67

2. Programa principal .......................................................................................................... 70

3. Modo calibración............................................................................................................. 73

4. Modo test ........................................................................................................................ 74

5. Interrupciones ................................................................................................................. 76

6. Muestra de datos por pantalla ........................................................................................ 76

Anexo 5. Código del software de procesamiento de datos y muestra de resultados con MATLAB© ..................................................................... 78



56 Jorge Visa Vidal

ANEXO 1. DISEÑO DEL CIRCUITO COMPARADOR PARA EL CÁLCULO DE LA VELOCIDAD DE GIRO DEL MOTOR.

En este anexo se va detallar y explicar el cálculo y diseño del circuito comparador para medida de la velocidad de giro del motor en ambas estructuras, ya sea la del cálculo del empuje o la del cálculo del par de arrastre.

Para ello se va a diseñar un circuito comparador que compare la señal obtenida por el fotodiodo con dos voltajes de referencia, cuando la señal del fotodiodo este por encima de la de referencia, la salida correspondiente será de 5V aproximadamente gracias a la resistencias de pull up. Por el contrario, cuando la señal del fotodiodo esté por debajo de la de referencia, la salida será de 0V.



57 Jorge Visa Vidal

Ilustración 37. Circuito comparador del fotodiodo.

Como se puede observar en la ilustración 37, se ha dado un valor de 1kΩ a 𝑅2 un valor de 10 kΩ a 𝑅4 𝑦 𝑅5, un valor de 15 kΩ a 𝑅1 y un valor de 22 kΩ a 𝑅3. Los voltajes de referencia serán V1 y V2, se han calculado de la siguiente manera:

𝑉1 =𝑉𝑐𝑐 ∙ (𝑅2 + 𝑅3)𝑅1 + 𝑅2 + 𝑅3

𝑉2 =𝑉𝑐𝑐 ∙ 𝑅3

𝑅1 + 𝑅2 + 𝑅3

Se sustituye los valores:

𝑉1 = 3.02 𝑉

𝑉2 = 2.89 𝑉



58 Jorge Visa Vidal

Finalmente se realiza una serie de pruebas con distintos valores de Rs (la

resistencia del fotodiodo) y se llega a la conclusión de que el valor óptimo es 470 kΩ. Se comprueba la salida del circuito comparador con un osciloscopio para comprobar que funciona correctamente:

Ilustración 38. Voltaje a la salida del circuito comparador del fotodiodo.

En el canal 1 (CH1) está conectada la salida del pin de interrupción alta y en el canal 2 (CH2) el pin de interrupción baja.



59 Jorge Visa Vidal

ANEXO 2. DISEÑO DEL CIRCUITO DE AMPLIFICACIÓN PARA LA OBTENCIÓN DE LOS DATOS DE MEDIDA DE LA BÁSCULA DE PESAJE.

En este anexo se va detallar y explicar el cálculo y diseño del circuito de amplificación de la señal obtenida de la báscula de pesaje, para su posterior uso en el cálculo de las fuerzas aerodinámicas generadas por el conjunto motor-hélice.

Se dispone de una báscula de pesaje comercial, con un máximo de 5 Kg de medida. Como se necesita que los datos que la báscula recoge sean transferidos al ordenador se va a modificar el circuito interno de la misma.

Una vez abierta la báscula, en el interior se encuentran 4 células de carga, una por cada pata, y fijándose bien se descubre que cada célula consta de tres hilos, blanco, negro y rojo, es decir, son células de carga con dos resistencias en serie, por tanto están conectadas en “Medio Puente de Wheatstone”.

Ilustración 39. Células de carga



60 Jorge Visa Vidal

Puede resultar extraña esta configuración de las células de carga, ya que lo normal es que estén conectadas en puente completo pero eso no afecta al experimento para nada.

El siguiente paso es medir con el multímetro los valores de las resistencias para

identificar que es cada cable. Primero se mide, en cada célula, entre el cable blanco y rojo, se obtiene un valor de 1 kΩ, después entre rojo y negro, se obtiene de nuevo 1 kΩ y finalmente se mide entre blanco y negro, obteniendo un valor de 2 kΩ aproximados. Con esto se verifica que efectivamente son dos resistencias en serie, conectadas en medio puente.

Se aplica continuidad con el multímetro y se observa que los cables blancos (B) de

las células superiores están conectados entres si, y los de las inferiores igual, además que los cables negros (N) de las células de la parte izquierda están conectados entre sí y en la derecha pasa lo mismo.

Finalmente se observa que la alimentación positiva va conectada al cable rojo (R)

de la célula inferior derecha y la negativa o tierra a la célula superior izquierda. Por último los dos cables rojos que quedan serán las salidas del sistema de medida de la báscula, S+ y S-.

Ilustración 40. Conexionado células de carga.



61 Jorge Visa Vidal

Una vez se han identificado todos los cables se procede a cortarlos de la placa base original de la báscula y a soldarlos directamente entre ellos como el esquema de la ilustración 40.

El siguiente paso es diseñar el circuito de amplificación de las señales de la báscula

de pesaje, ya que tras realizar una serie de medidas, ver tabla 2, los valores obtenidos son muy pequeños.

Peso (gramos) Diferencia de tensión (mV)

Sin peso - 0.5 100 -0.4 350 -0.3 500 0

1000 0.1 1500 0.2 2000 0.4 2500 0.6 3000 1 3500 1.3 4000 1.5 4500 1.9 5000 2.3

Tabla 2. Medidas de la báscula sin amplificar.

En un primer momento se piensa en una sola etapa de amplificación con un amplificador operacional en modo diferencial pero sólo con eso no es suficiente, por lo que tras la búsqueda de nuevas ideas se llega a la solución óptima para resolver este problema de amplificación. Para ello se va a utilizar un amplificador operacional de instrumentación en cascada en modo diferencial.



62 Jorge Visa Vidal

Ilustración 41. Amplificador en cascada.

Se desea conseguir una etapa de amplificación con una ganancia entre 4000 y 4500, con este amplificador en cascada se sabe que la ganancia depende de:

𝐺𝑑 = 𝐾 ∙ (1 + 𝐺)

Siendo K y G:

𝐾 = 𝑅3𝑅2

=𝑅´3𝑅´2

𝐺 = 2 ∙ 𝑅1𝑅𝐺

=2 ∙ 𝑅´1𝑅𝐺

Si se dan valores de 𝑅2 = 𝑅3 = 𝑅´2 = 𝑅´3 = 100 𝑘Ω y d 𝑅1 = 𝑅´1 = 10 𝑘Ω y finalmente de 𝑅𝐺 = 4.7 Ω (ya que se necesita un valor pequeño para que la G sea grande), se obtiene una ganancia final de 4256 aproximadamente.

El siguiente problema a resolver es que la primera medida de la báscula, sin ningún peso encima, es un valor negativo, y el Arduino no acepta valores negativos en sus entradas analógicas, por tanto, se necesita diseñar una etapa para subir el valor de esta señal de medida hasta un rango positivo.

Se opta por utilizar un amplificador operacional en modo sumador, llevando a la entrada no inversora el valor medido por la báscula y a la entrada inversora la tensión obtenida por un potenciómetro de 10 kΩ conectado a -15V y a 0V, para poder regular



63 Jorge Visa Vidal

la tensión final al valor que se desee. Se dejará por defecto una salida aproximadamente de 0.45 V cuando no haya peso en la báscula.

Ilustración 42. Amplificador en modo sumador.

Se opta por dar el mismo valor a las 4 resistencias, un valor de 10 kΩ.

Para evitar problemas a la entrada de 𝑅2 con la tensión de salida del potenciómetro, se coloca un seguidor de tensión entre el potenciómetro y 𝑅2.

Ilustración 43. Amplificador en modo seguidor de tensión.

Finalmente se desea obtener una resolución de 0.01 V, para ello se necesita un ADC de:

𝑅𝑒𝑠𝑜𝑙𝑢𝑐𝑖ó𝑛 = 𝑉𝐹

(2𝑛 − 1)

Donde 𝑉𝐹 es la tensión máxima que acepta a la entrada el sistema de medida (Arduino en este caso, es de 5V) y n es la incógnita que se quiere despejar.

Por tanto se obtiene que se necesita un ADC de:



64 Jorge Visa Vidal

0.01 = 5

(2𝑛 − 1)

𝑛 ≈ 9 𝑏𝑖𝑡𝑠

Como el Arduino lleva incorporado un ADC interno de 10 bits, no es necesario que se use un ADC en la etapa final de la amplificación de la señal de la báscula.

El último paso de esta etapa es comprobar que se ha realizado correctamente el diseño de la amplificación de la señal, para ello se vuelve a hacer con el multímetro una serie de medidas:

Peso (gramos) Diferencia de tensión (V)

Sin peso 0.440 8 0.465

10.6 0.485 11.2 0.490 30 0.525 53 0.575

105.3 0.725 158.3 0.875 201.4 0.985 295 1.245

325.5 1.298 395.5 1.498 470.6 1.690 576.7 1.995 743.9 2.435 902.2 2.860

1167.2 3.570 1335.3 4.045 1640.8 4.820 1693.8 4.960

Tabla 3. Medidas de la báscula con la etapa de amplificación.

Si se realiza una función con estos datos, ver tabla 3, se obtiene una gráfica lineal de los valores cuya recta es:

𝑦 = 0.0027 ∙ 𝑥 + 0.2606



65 Jorge Visa Vidal

Ilustración 44. Gráfica de los valores de la báscula.

Además se puede concluir que el peso máximo que el Arduino podrá medir será 1700 gramos aproximadamente, ya que por encima de este valor se superan los 5V.

0 500 1000 1500 2000 0

1000

2000

3000

4000

5000

6000

Medida (V)

Medida (mV)

Lineal (Medida (mV))



66 Jorge Visa Vidal

ANEXO 3. PCB DEL CIRCUITO DEL TRABAJO

Ilustración 45. Capa superior de la PCB

Ilustración 46. Capa inferior de la PCB.



67 Jorge Visa Vidal

ANEXO 4. HERRAMIENTA SOFTWARE DE ADQUISICIÓN DE DATOS CON EL IDE DE ARDUINO.

1. Guía del programa En este anexo se va a detallar el contenido y funcionamiento de esta

herramienta software desarrollada en el IDE de Arduino para la adquisición de datos de nuestro sistema.

Como bien se explica en la memoria se han programado tres modos diferentes de funcionamiento. Al iniciar la aplicación de usuario la cabecera del programa será la correspondiente a la ilustración 47, en la que se empieza en el modo normal de funcionamiento, pero da la opción de elegir el modo calibración introduciendo el comando “-1” o el modo test introduciendo el “-2”.

A continuación se van a explicar los tres modos de funcionamiento del programa: 1) El primer paso antes de iniciar el experimento es desconectar el ESC de

la alimentación, y si es la primera vez que vas a realizar este estudio quitar las hélices del motor, por si hubiera algún problema.

Una vez se abre el monitor serie desde el IDE de Arduino, se introduce el

comando “-1” para acceder al modo de calibración. Como se puede apreciar en la ilustración 48 aparecerá el siguiente menú, donde se recuerda quitar el ESC de la alimentación, no de la señal del Arduino.

Ilustración 48. Menú inicial del modo calibración.

Ilustración 47. Menú principal del programa.



68 Jorge Visa Vidal

Introducimos el comando “-1” para seguir con la calibración y aparecerá la siguiente pantalla:

Ilustración 49. Mensaje de configuración del modo calibración.

La señal de control del motor ya ha sido ajustada a los rangos de las señales del Arduino, en este momento se debe conectar la alimentación del ESC de nuevo y esperar a que emita dos pitidos (En caso de que el ESC no emita pitidos buscar en la instrucciones como avisa de que está funcionando correctamente), en cuanto haya emitido los dos pitidos mandar rápidamente cualquier comando, por ejemplo un 0.

Un consejo para realizar esta parte es, antes de conectar de nuevo la

alimentación del ESC, teclear un 0 pero no enviarlo, a continuación conectar la alimentación al ESC y en cuanto emita los dos pitidos pulsar “enter” para enviar el comando “0”.

Una vez se haya realizado este procedimiento el ESC estará calibrado para las

señales de Arduino y el programa volverá al funcionamiento normal, volviendo a la pantalla inicial del programa.

Ilustración 50. Mensaje final del modo calibración.

2) Para realizar el modo test, hay que seguir una serie de sencillos pasos,

primero introducir el comando “-1” en la pantalla principal, y aparecerá la siguiente pantalla:



69 Jorge Visa Vidal

Ilustración 51. Mensaje inicial del modo test.

Si se desea continuar con el modo test, se introduce el comando “1”, si se desea volver al menú inicial del programa se introduce el “2”. Una vez introducido el comando “1”, aparecerá un mensaje de aviso de que va a comenzar el test.

Ilustración 52. Mensaje de aviso del modo test.

Una vez se ha realizado completamente el test aparecerá un mensaje para informar de que todo ha salido correctamente y que el programa vuelve al menú principal.

Ilustración 53. Mensaje final del modo test.

A continuación se adjunta el código del programa completo de la aplicación de adquisición de datos con el IDE de Arduino.



70 Jorge Visa Vidal

2. Programa principal //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // ARCHIVO DE CABECERA #include <Servo.h> //------------------------------------------------------------------------------------------------------------------------- // PINES #define MOTOR_PIN 10 // Pin para mandarle señales al ESC desde el Arduino // Señal de interrupcion del fotodiodo const byte lowPin = 0; // On DIGITAL PIN 2 for UNO! const byte highPin = 1; // On DIGITAL PIN 3 for UNO! //------------------------------------------------------------------------------------------------------------------------- Servo m1; // Nombre del motor //------------------------------------------------------------------------------------------------------------------------- // BANDERAS bool instructFlag = HIGH; //Flag para mostrar las instrucciones del modo de operación. HIGH es enseñarlas y LOW ocultarlas. bool printFlag = LOW; //Flag para controlar cuando debe mostrar por el monitor serie el tiempo, la acelaración, las RPM y PONER ALGO DE LA BALANZA. //------------------------------------------------------------------------------------------------------------------------- // VARIABLES PARA CONTROLAR EL MOTOR byte m1Throttle = 0; // Aceleración del motor, entre 0 y 100% unsigned int m1Signal = 0; // Longitud del pulso actual a mandar al motor const unsigned int lowServo = 1000; // Límite de la señal más baja del servo, en microsegundos, 1000 por defecto. const unsigned int highServo = 2000; //Límite de la señal más alta del servo, en microsegundos, 2000 por defecto. //------------------------------------------------------------------------------------------------------------------------- // VALORES DE CONVERSIÓN NUMÉRICA const byte numBlades = 2; //Número de palas que tiene el motor. const unsigned long RPMconversion = 60000000/numBlades; //Para convertir de pulsos a RPM //------------------------------------------------------------------------------------------------------------------------- // VARIABLES DEL TIEMPO volatile unsigned long timeNow = 0; volatile unsigned long timeNowTest = 0; volatile unsigned long timeLast = 0; volatile unsigned long deltaT = 0; volatile unsigned long timeTest = 0; volatile unsigned long timeLastTest = 0; //------------------------------------------------------------------------------------------------------------------------- // VARIABLES DEL PUERTO SERIE



71 Jorge Visa Vidal

int incomingByte = 0; // Variable para almacenar el dato que llega por el puerto serie (Usado para aceleración y selección del modo, normal,de calibración o test.) int aux = 30; // Varibale para reducir la velocidad del motor una vez finalizado el modo test. int serialByte= 0; // Variable para almacenar el comando que el usuario ha introducido por el serial en el modo test. byte printReductionFactor = 1; //Factor para reducir la frecuencia de mostrar los eventos de cruce de palas(Se muestra 1 vez cada cruce, se muestra 2 veces cada cruces...). byte printCount = 1; // Usado con el anterior Used in conjunction with printReductionFactor to reduce print events from blade crossings unsigned int RPM = 0; // //------------------------------------------------------------------------------------------------------------------------- // VARIABLES DE LA BÁSCULA const int numReadings =127; // Número de lecturas int readings[numReadings]; // Vector de lecturas de la entrada analógica int readIndex = 0; // Índice del vector double total = 0; // Valor total double average = 0; // Media double SCALEmeas = 0; // Voltaje medido en la báscula int GRAMS = 0; // Gramos que se miden en la báscula (Viene de la ecuación del voltaje medido) int inputPin = A2; // Salido del circuito del amplificador de la báscula //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ void setup() Serial.begin(115200); attachInterrupt(lowPin, bottomState,FALLING); // Se crea una interrupción para detectar el cruce de la pala de la hélice m1.attach(MOTOR_PIN); // Conectamos el motor al pin m1.writeMicroseconds(lowServo+5); // Se empieza a armar la secuencia(salida baja por un corto periodo de tiempo) delay(1000); m1.writeMicroseconds(lowServo); // Inicializamos todas las lecturas a 0: for (int thisReading = 0; thisReading < numReadings; thisReading++) readings[thisReading] = 0; //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ void loop() // Restamos la última lectura total = total - readings[readIndex]; // Leemos la entrada analógica readings[readIndex] = analogRead(inputPin); // Sumamos la la última lectura al total



72 Jorge Visa Vidal

total = total + readings[readIndex]; // Avanzamos una posición en el array readIndex = readIndex + 1; // Si llegamos al final del array... if (readIndex >= numReadings) // ... volvemos a ponernos al principio readIndex = 0; //Calculamos la media: average = total / numReadings; // Si es adecuado mostramos las instrucciones if (instructFlag == HIGH) printInstructions(); // Comprobamos si el usuario a introducido un nuevo comando por el serial if (Serial.available() > 0) getSerialInput(); // Si hay un nuevo comando leelo y actua acorde a su significado // Muestra los datos si se ha producido o cambio en la aceleración del motor o se ha contado un pulso if (printFlag == HIGH) RPM = round(((double)RPMconversion)/((double)deltaT)); // Calculamos las RPM SCALEmeas = average*5000/1023; // Escalamos el voltaje de la báscula para la resolución de Arduino GRAMS = (SCALEmeas - 446.06)/2.6728; // Pasamos los voltios a gramos printData(); //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ //Esta función es la encargada de interpreta lo que entra por el serial y ejecutar el modo apropiado void getSerialInput() incomingByte = Serial.parseInt(); // Leer el byte de entrada (No reconocerá números digitales) if (incomingByte >= 0) getMotorSpeed(); else if (incomingByte == -1) calibrationMode(); else if (incomingByte == -2) TestMode(); //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ //Esta función es la encargada de coger el valor que entra por el serial y ajusta el motor a la velocidad correspondiente



73 Jorge Visa Vidal

void getMotorSpeed() // Coge la velocidad del motor desde la entrada del serial m1Throttle = constrain(incomingByte, 0, 100); m1Signal = map(m1Throttle, 0, 100, lowServo, highServo); // Mapa de acerleraciones desde 0 hasta 100%, solo acepta valores entero NO DECIMALES setMotorSpeed(); //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ //Esta es la función que ajusta la velocidad del motor, tambien almacenada el tiempo para posteriores usos void setMotorSpeed() m1.writeMicroseconds(m1Signal); // Ajusta la nueva velocidad del motor timeNow = micros(); // Coge el timepo actual en MICROSEGUNDOS printFlag = HIGH; // Mostramos los datos actualizados

3. Modo calibración //Este modo de funcionamiento permite calibrar el ESC a la señales del Arduino de una manera sencilla y rápida. //Para ajustar el rango de la amplitud de la señal modificar los valores de "lowServo" y de "highServo". Arduino tiene ciertas limitaciones con estas amplitudes mejor evitar modificarlas. // Mirar el código de la liberia Servo.h para más información void calibrationMode() Serial.println(" "); Serial.println("Empezando modo de calibracion..."); m1.writeMicroseconds(lowServo); Serial.println("Pulsa 1 para salir de este modo:"); Serial.println(" Primero, DESCONECTE EL ESC DE LA ALIMENTACION, luego pulse -1 si desea continuar con la calibracion."); while (Serial.available() <= 0) // Esperar sin hacer nada hasta que el usuario responda incomingByte = Serial.parseInt(); // Leemos lo que el usuario ha escrito if (incomingByte == -1) Serial.println("TODAS LAS ACELERACIONES HAN SIDO CALIBRADAS AL 100%"); delay(2000); // Pausa para dejar que el usuario reaccione por si ha habido algun error m1.writeMicroseconds(highServo); Serial.println("CONECTE LA ALIMENTACION AL ESC:"); Serial.println("CUANDO EL ESC EMITA DOS PITIDOS, PULSA CUALQUIER NUMERO RAPIDAMENTE PARA CALIBRAR LOS MOTORES A CERO."); //Consultar si tu ESC emite dos pitidos while (Serial.available() <= 0) // Esperar sin hacer nada hasta que el usuario responda m1.writeMicroseconds(lowServo); delay(1000); Serial.println("Velocidad del motor calibrada a cero");



74 Jorge Visa Vidal

Serial.println("La aceleracion del ESC deberia estar calibrada para los rangos del Arduino. Volviendo al modo normal de operacion..."); Serial.println(" "); instructFlag = HIGH; else m1.writeMicroseconds(lowServo); instructFlag = HIGH; timeNow = micros(); // Coge el tiempo actual en MICROSEGUNDOS printFlag = 1;

4. Modo test // Usamos este modo para captar datos de manera automática, desde una aceleración del 0% hasta el 100%, al final del test //obtendremos los datos de todas las aceleraciones sin tener que ir metiendolas de manera manual. void TestMode() incomingByte= -5; Serial.println(" "); Serial.println("Empezando modo test..."); Serial.println("El modo test ira desde una aceleracion del 0 hasta el 100% en intervalos del 5%"); Serial.println("Si desea continuar pulse 1, sino pulse 2 para volver al menu inicial "); while (Serial.available() <= 0) // Esperar sin hacer nada hasta que el usuario responda serialByte = Serial.parseInt(); // Leemos el comando escrito en el serial: if (serialByte == 1) Serial.println("El modo test empezara en 3 segundos..."); // Se deja algo de tiempo antes de empezar el test Serial.print("Segundos"); Serial.print("\t"); Serial.print("Señal de control"); Serial.print("\t"); Serial.print("RPM"); Serial.print("\t"); Serial.println ("Gramos"); delay (3000); timeTest= micros(); //Coge el tiempo al empezar el modo test while (incomingByte < 100) incomingByte = incomingByte + 5; //Aumentamos la aceleración del motor de 5 en 5 m1Throttle = constrain(incomingByte, 0, 100); m1Signal = map(m1Throttle, 0, 100, lowServo, highServo); m1.writeMicroseconds(m1Signal); // Ajustamos la nueva velocidad del motor for (int x = 0; x < 1500; x ++) // Muestra datos durantes aproximadamente 5 segundos RPM = round(((double)RPMconversion)/((double)deltaT)); // Calculamos las RPM



75 Jorge Visa Vidal

timeLastTest = micros(); // Coge el tiempo actual timeNowTest= timeLastTest-timeTest; // Restamos la última lectura total = total - readings[readIndex]; // Leemos la entrada analógica readings[readIndex] = analogRead(inputPin); // Sumamos la la última lectura al total total = total + readings[readIndex]; // Avanzamos una posición en el array readIndex = readIndex + 1; // Si llegamos al final del array... if (readIndex >= numReadings) // ... volvemos a ponernos al principio readIndex = 0; //Calculamos la media: average = total / numReadings; SCALEmeas = average*5000/1023; // Escalamos el voltaje de la báscula para la resolución de Arduino GRAMS = (SCALEmeas - 446.06)/2.6728; // Pasamos los voltios a gramos printDataTest(); aux = 100; //Usamos la variable AUX para decrementar la aceleración del motor hasta 0 while (aux > 5) aux = aux - 20; //Decrementamos la aceleración de 20 en 20 m1Throttle = constrain(aux, 0, 100); m1Signal = map(m1Throttle, 0, 100, lowServo, highServo); m1.writeMicroseconds(m1Signal); delay (1500); // Dejamos un tiempo de 1.5 seg entre cada reducción de la aceleración Serial.println("El modo test ha finalizado con exito. Volviendo al modo normal..."); Serial.println(" "); delay (3000); instructFlag = HIGH; //Volvemos al modo normal else instructFlag = HIGH; //Volvemos al modo normal



76 Jorge Visa Vidal

5. Interrupciones //Usamos estas dos interrupciones para capturar el evento de cruce de las palas por el fotodiodo con la ayuda del circuito comparador diseñado. //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ void bottomState() detachInterrupt(lowPin); // Dejamos de leer eventos del lowPin timeNow = micros(); // Coge el tiempo actual en MICROSEGUNDOS deltaT = timeNow-timeLast; //Calculamos la variación de tiempo desde el último evento de cruce de la pala timeLast = timeNow; // Almacenamos el tiempo actual para el próximo evento de cruce printFlag = 1; // Mostramos los datos del test durante el próximo main loop attachInterrupt(highPin, topState,RISING); // Vinculamos el highState pin al registro cuando la sombre de la pala ha pasado completamente el fotodiodo //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ void topState() detachInterrupt(highPin); // Dejamos de leer eventos del highPin attachInterrupt(lowPin, bottomState, FALLING); //Vinculamos el bottomState pin para coger el siguiente cruce

6. Muestra de datos por pantalla //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Mostramos los datos más recientes void printData() Serial.print( timeNow*0.000001, 3); // Mostrar la ultima captura de tiempo Serial.print("\t"); Serial.print(m1Throttle); // Mostrar el porcentaje de aceleración del motor Serial.print("\t"); Serial.print(RPM); // Mostrar las RPM Serial.print("\t"); Serial.println(GRAMS); // Mostrar el voltaje de la báscula printFlag = LOW; // No volver a mostrar hasta que una función cambie el valor del flag. //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Muestra las instrucciones y las cabeceras de los datos void printInstructions() Serial.println(" "); Serial.println("Escribe el tanto por ciento de señal de control del motor que desees (Debe ser un numero entero entre 0 y 100)."); Serial.println("Para modo de calibracion del ESC: Pulse \"-1\""); Serial.println("Para modo test: Pulse \"-2\"");



77 Jorge Visa Vidal

Serial.print("Segundos"); Serial.print("\t"); Serial.print("Señal de control"); Serial.print("\t"); Serial.print("RPM"); Serial.print("\t"); Serial.println ("Gramos"); instructFlag = LOW; // Don't print instructions again: //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Muestra los datos en el modo test (Es diferente al del modo normal ya que el tiempo se pone a cero cuando comienza el modo test) void printDataTest() Serial.print( timeNowTest*0.000001, 3); // Mostrar la ultima captura de tiempo Serial.print("\t"); Serial.print(m1Throttle); // Mostrar el porcentaje de aceleración del motor Serial.print("\t"); Serial.print(RPM); // Mostrar las RPM Serial.print("\t"); Serial.println(GRAMS); // Mostrar el voltaje de la báscula



78 Jorge Visa Vidal

ANEXO 5. CÓDIGO DEL SOFTWARE DE PROCESAMIENTO DE DATOS Y MUESTRA DE RESULTADOS CON MATLAB©

function varargout = Aplicacion(varargin) % APLICACION MATLAB code for Aplicacion.fig % APLICACION, by itself, creates a new APLICACION or raises the existing % singleton*. % % H = APLICACION returns the handle to a new APLICACION or the handle to % the existing singleton*. % % APLICACION('CALLBACK',hObject,eventData,handles,...) calls the local % function named CALLBACK in APLICACION.M with the given input arguments. % % APLICACION('Property','Value',...) creates a new APLICACION or raises the % existing singleton*. Starting from the left, property value pairs are % applied to the GUI before Aplicacion_OpeningFcn gets called. An % unrecognized property name or invalid value makes property application % stop. All inputs are passed to Aplicacion_OpeningFcn via varargin. % % *See GUI Options on GUIDE's Tools menu. Choose "GUI allows only one % instance to run (singleton)". % % See also: GUIDE, GUIDATA, GUIHANDLES % Edit the above text to modify the response to help Aplicacion % Last Modified by GUIDE v2.5 01-Jul-2016 09:39:18 % Begin initialization code - DO NOT EDIT gui_Singleton = 1; gui_State = struct('gui_Name', mfilename, ... 'gui_Singleton', gui_Singleton, ... 'gui_OpeningFcn', @Aplicacion_OpeningFcn, ... 'gui_OutputFcn', @Aplicacion_OutputFcn, ... 'gui_LayoutFcn', [] , ... 'gui_Callback', []); if nargin && ischar(varargin1) gui_State.gui_Callback = str2func(varargin1); end



79 Jorge Visa Vidal

if nargout [varargout1:nargout] = gui_mainfcn(gui_State, varargin:); else gui_mainfcn(gui_State, varargin:); end % End initialization code - DO NOT EDIT % --- Executes just before Aplicacion is made visible. function Aplicacion_OpeningFcn(hObject, eventdata, handles, varargin) % This function has no output args, see OutputFcn. % hObject handle to figure % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % varargin command line arguments to Aplicacion (see VARARGIN) % Choose default command line output for Aplicacion handles.output = hObject; % Update handles structure guidata(hObject, handles); axes(handles.ImPar) %Insertamos imagen en el cuadro del par handles.imagen=imread('Par.PNG'); imagesc(handles.imagen) axis off axes(handles.ImEmpuje) %Insertamos imagen en el cuadro del empuje handles.imagen=imread('Empuje.PNG'); imagesc(handles.imagen) axis off % UIWAIT makes Aplicacion wait for user response (see UIRESUME) % uiwait(handles.figure1); % --- Outputs from this function are returned to the command line. function varargout = Aplicacion_OutputFcn(hObject, eventdata, handles) % varargout cell array for returning output args (see VARARGOUT); % hObject handle to figure % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % Get default command line output from handles structure varargout1 = handles.output; function EDist_Callback(hObject, eventdata, handles) % hObject handle to EDist (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA)



80 Jorge Visa Vidal

% Hints: get(hObject,'String') returns contents of EDist as text % str2double(get(hObject,'String')) returns contents of EDist as a double % --- Executes during object creation, after setting all properties. function EDist_CreateFcn(hObject, eventdata, handles) % hObject handle to EDist (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles empty - handles not created until after all CreateFcns called % Hint: edit controls usually have a white background on Windows. % See ISPC and COMPUTER. if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end function ELarge_Callback(hObject, eventdata, handles) % hObject handle to ELarge (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % Hints: get(hObject,'String') returns contents of ELarge as text % str2double(get(hObject,'String')) returns contents of ELarge as a double % --- Executes during object creation, after setting all properties. function ELarge_CreateFcn(hObject, eventdata, handles) % hObject handle to ELarge (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles empty - handles not created until after all CreateFcns called % Hint: edit controls usually have a white background on Windows. % See ISPC and COMPUTER. if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end function EHigh_Callback(hObject, eventdata, handles) % hObject handle to EHigh (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA)



81 Jorge Visa Vidal

% Hints: get(hObject,'String') returns contents of EHigh as text % str2double(get(hObject,'String')) returns contents of EHigh as a double % --- Executes during object creation, after setting all properties. function EHigh_CreateFcn(hObject, eventdata, handles) % hObject handle to EHigh (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles empty - handles not created until after all CreateFcns called % Hint: edit controls usually have a white background on Windows. % See ISPC and COMPUTER. if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end function ENomFichP_Callback(hObject, eventdata, handles) % hObject handle to ENomFichP (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % Hints: get(hObject,'String') returns contents of ENomFichP as text % str2double(get(hObject,'String')) returns contents of ENomFichP as a double % --- Executes during object creation, after setting all properties. function ENomFichP_CreateFcn(hObject, eventdata, handles) % hObject handle to ENomFichP (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles empty - handles not created until after all CreateFcns called % Hint: edit controls usually have a white background on Windows. % See ISPC and COMPUTER. if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end function ENomFichE_Callback(hObject, eventdata, handles) % hObject handle to ENomFichE (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % Hints: get(hObject,'String') returns contents of ENomFichE as text



82 Jorge Visa Vidal

% str2double(get(hObject,'String')) returns contents of ENomFichE as a double % --- Executes during object creation, after setting all properties. function ENomFichE_CreateFcn(hObject, eventdata, handles) % hObject handle to ENomFichE (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles empty - handles not created until after all CreateFcns called % Hint: edit controls usually have a white background on Windows. % See ISPC and COMPUTER. if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end % --- Executes on button press in PBCarDatP. function PBCarDatP_Callback(hObject, eventdata, handles) % hObject handle to PBCarDatP (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) global Ac; global Seg; global Gr; global Rpm; load (handles.ENomFichP.String); Ac = Aceleracion; Seg = Segundos; Gr = Gramos; Rpm = RPM; % --- Executes on button press in PBCalPar. function PBCalPar_Callback(hObject, eventdata, handles) % hObject handle to PBCalPar (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) global Ac; global Seg; global Gr; global Rpm; D = str2num(handles.EDist.String); handles.TFuerza.String = 'PAR DE ARRASTRE DEL ROTOR'; handles.ImFormula.Visible = 'On'; %Hacemos visible la formula de fuerza y velocidad axes(handles.ImFormula) %Insertamos formula que relaciona la fuerza con la velocidad de giro handles.imagen=imread('ForPar.PNG');



83 Jorge Visa Vidal

imagesc(handles.imagen) axis off dato_ant = Ac(1); x = 1; k=1; PWM(x)= dato_ant; for i = 1:length(Ac) %Buscamos el cambio de aceleración en el motor dato = Ac(i); if dato ~= dato_ant indices(x)=i-1; %En la variable indices tenemos la última posición de cada escalón de la aceleración x= x+1; PWM(x) = dato; end dato_ant = dato; end potencia0 = [Seg(1:indices(1)),Ac(1:indices(1)),Rpm(1:indices(1)),Gr(1:indices(1))]; %Guardamos los datos de cada aceleración en un vector potencia5 = [Seg((indices(1)+1):indices(2)),Ac((indices(1)+1):indices(2)),Rpm((indices(1)+1):indices(2)),Gr((indices(1)+1):indices(2))]; potencia10 = [Seg((indices(2)+1):indices(3)),Ac((indices(2)+1):indices(3)),Rpm((indices(2)+1):indices(3)),Gr((indices(2)+1):indices(3))]; potencia15 = [Seg((indices(3)+1):indices(4)),Ac((indices(3)+1):indices(4)),Rpm((indices(3)+1):indices(4)),Gr((indices(3)+1):indices(4))]; potencia20 = [Seg((indices(4)+1):indices(5)),Ac((indices(4)+1):indices(5)),Rpm((indices(4)+1):indices(5)),Gr((indices(4)+1):indices(5))]; potencia25 = [Seg((indices(5)+1):indices(6)),Ac((indices(5)+1):indices(6)),Rpm((indices(5)+1):indices(6)),Gr((indices(5)+1):indices(6))]; potencia30 = [Seg((indices(6)+1):indices(7)),Ac((indices(6)+1):indices(7)),Rpm((indices(6)+1):indices(7)),Gr((indices(6)+1):indices(7))]; potencia35 = [Seg((indices(7)+1):indices(8)),Ac((indices(7)+1):indices(8)),Rpm((indices(7)+1):indices(8)),Gr((indices(7)+1):indices(8))]; potencia40 = [Seg((indices(8)+1):indices(9)),Ac((indices(8)+1):indices(9)),Rpm((indices(8)+1):indices(9)),Gr((indices(8)+1):indices(9))]; potencia45 = [Seg((indices(9)+1):indices(10)),Ac((indices(9)+1):indices(10)),Rpm((indices(9)+1):indices(10)),Gr((indices(9)+1):indices(10))]; potencia50 = [Seg((indices(10)+1):indices(11)),Ac((indices(10)+1):indices(11)),Rpm((indices(10)+1):indices(11)),Gr((indices(10)+1):indices(11))]; potencia55 = [Seg((indices(11)+1):indices(12)),Ac((indices(11)+1):indices(12)),Rpm((indices(11)+1):indices(12)),Gr((indices(11)+1):indices(12))];



84 Jorge Visa Vidal

potencia60 = [Seg((indices(12)+1):indices(13)),Ac((indices(12)+1):indices(13)),Rpm((indices(12)+1):indices(13)),Gr((indices(12)+1):indices(13))]; potencia65 = [Seg((indices(13)+1):indices(14)),Ac((indices(13)+1):indices(14)),Rpm((indices(13)+1):indices(14)),Gr((indices(13)+1):indices(14))]; potencia70 = [Seg((indices(14)+1):indices(15)),Ac((indices(14)+1):indices(15)),Rpm((indices(14)+1):indices(15)),Gr((indices(14)+1):indices(15))]; potencia75 = [Seg((indices(15)+1):indices(16)),Ac((indices(15)+1):indices(16)),Rpm((indices(15)+1):indices(16)),Gr((indices(15)+1):indices(16))]; potencia80 = [Seg((indices(16)+1):indices(17)),Ac((indices(16)+1):indices(17)),Rpm((indices(16)+1):indices(17)),Gr((indices(16)+1):indices(17))]; potencia85 = [Seg((indices(17)+1):indices(18)),Ac((indices(17)+1):indices(18)),Rpm((indices(17)+1):indices(18)),Gr((indices(17)+1):indices(18))]; potencia90 = [Seg((indices(18)+1):indices(19)),Ac((indices(18)+1):indices(19)),Rpm((indices(18)+1):indices(19)),Gr((indices(18)+1):indices(19))]; potencia95 = [Seg((indices(19)+1):indices(20)),Ac((indices(19)+1):indices(20)),Rpm((indices(19)+1):indices(20)),Gr((indices(19)+1):indices(20))]; potencia100 = [Seg((indices(20)+1):length(Ac)),Ac((indices(20)+1):length(Ac)),Rpm((indices(20)+1):length(Ac)),Gr((indices(20)+1):length(Ac))]; %Para el escalon de 0 total = 0; GramTotal = 0; num_datos = 0; for i = 1:length(potencia0) if potencia0(i,3)<= 20000 %Filtramos lo valores muy altos de las RPMs total = total + potencia0(i,3); num_datos = num_datos +1; end GramTotal= GramTotal + potencia0(i,4); %Vamos sumando los gramos end RPMmedia(k) = total/num_datos; %Guardamos las medias de las RPM en un vector GramosMaqueta = (GramTotal/length(potencia0)); GRAMOSmedia(k) = (GramTotal/length(potencia0))-GramosMaqueta; %Guardamos las medias de las medidas de los GRAMOS en un vector PAR(k) = ((GRAMOSmedia(k)/1000)*9.81)*D; k = k +1; %Para el escalon de 5 total = 0; GramTotal = 0; num_datos = 0; for i = 1:length(potencia5) if potencia5(i,3)<= 20000 %Filtramos lo valores muy altos de las RPMs total = total + potencia5(i,3);



85 Jorge Visa Vidal

num_datos = num_datos +1; end GramTotal= GramTotal + potencia5(i,4); %Vamos sumando los gramos end RPMmedia(k) = total/num_datos; %Guardamos las medias de las RPM en un vector GRAMOSmedia(k) = (GramTotal/length(potencia5))-GramosMaqueta; %Guardamos las medias de las medidas de los GRAMOS en un vector PAR(k) = ((GRAMOSmedia(k)/1000)*9.81)*D; k = k +1; %Para el escalon de 10 total = 0; GramTotal = 0; num_datos = 0; for i = 1:length(potencia10) if potencia10(i,3)<= 20000 %Filtramos lo valores muy altos de las RPMs total = total + potencia10(i,3); num_datos = num_datos +1; end GramTotal= GramTotal + potencia10(i,4); %Vamos sumando los gramos end RPMmedia(k) = total/num_datos; %Guardamos las medias de las RPM en un vector GRAMOSmedia(k) = (GramTotal/length(potencia10))-GramosMaqueta; %Guardamos las medias de las medidas de los GRAMOS en un vector PAR(k) = ((GRAMOSmedia(k)/1000)*9.81)*D; k = k +1; %Para el escalon de 15 total = 0; GramTotal = 0; num_datos = 0; for i = 1:length(potencia15) if potencia15(i,3)<= 20000 %Filtramos lo valores muy altos de las RPMs total = total + potencia15(i,3); num_datos = num_datos +1; end GramTotal= GramTotal + potencia15(i,4); %Vamos sumando los gramos end RPMmedia(k) = total/num_datos; %Guardamos las medias de las RPM en un vector GRAMOSmedia(k) = (GramTotal/length(potencia15))-GramosMaqueta; %Guardamos las medias de las medidas de los GRAMOS en un vector PAR(k) = ((GRAMOSmedia(k)/1000)*9.81)*D; k = k +1; %Para el escalon de 20 total = 0; GramTotal = 0; num_datos = 0; for i = 1:length(potencia20) if potencia20(i,3)<= 20000 %Filtramos lo valores muy altos de las RPMs total = total + potencia20(i,3); num_datos = num_datos +1; end



86 Jorge Visa Vidal

GramTotal= GramTotal + potencia20(i,4); %Vamos sumando los gramos end RPMmedia(k) = total/num_datos; %Guardamos las medias de las RPM en un vector GRAMOSmedia(k) = (GramTotal/length(potencia20))-GramosMaqueta; %Guardamos las medias de las medidas de los GRAMOS en un vector PAR(k) = ((GRAMOSmedia(k)/1000)*9.81)*D; k = k +1; %Para el escalon de 25 total = 0; GramTotal = 0; num_datos = 0; for i = 1:length(potencia25) if potencia25(i,3)<= 20000 %Filtramos lo valores muy altos de las RPMs total = total + potencia25(i,3); num_datos = num_datos +1; end GramTotal= GramTotal + potencia25(i,4); %Vamos sumando los gramos end RPMmedia(k) = total/num_datos; %Guardamos las medias de las RPM en un vector GRAMOSmedia(k) = (GramTotal/length(potencia25))-GramosMaqueta; %Guardamos las medias de las medidas de los GRAMOS en un vector PAR(k) = ((GRAMOSmedia(k)/1000)*9.81)*D; k = k +1; %Para el escalon de 30 total = 0; GramTotal = 0; num_datos = 0; for i = 1:length(potencia30) if potencia30(i,3)<= 20000 %Filtramos lo valores muy altos de las RPMs total = total + potencia30(i,3); num_datos = num_datos +1; end GramTotal= GramTotal + potencia30(i,4); %Vamos sumando los gramos end RPMmedia(k) = total/num_datos; %Guardamos las medias de las RPM en un vector GRAMOSmedia(k) = (GramTotal/length(potencia30))-GramosMaqueta; %Guardamos las medias de las medidas de los GRAMOS en un vector PAR(k) = ((GRAMOSmedia(k)/1000)*9.81)*D; k = k +1; %Para el escalon de 35 total = 0; GramTotal = 0; num_datos = 0; for i = 1:length(potencia35) if potencia35(i,3)<= 20000 %Filtramos lo valores muy altos de las RPMs total = total + potencia35(i,3); num_datos = num_datos +1; end GramTotal= GramTotal + potencia35(i,4); %Vamos sumando los gramos end



87 Jorge Visa Vidal

RPMmedia(k) = total/num_datos; %Guardamos las medias de las RPM en un vector GRAMOSmedia(k) = (GramTotal/length(potencia35))-GramosMaqueta; %Guardamos las medias de las medidas de los GRAMOS en un vector PAR(k) = ((GRAMOSmedia(k)/1000)*9.81)*D; k = k +1; %Para el escalon de 40 total = 0; GramTotal = 0; num_datos = 0; for i = 1:length(potencia40) if potencia40(i,3)<= 20000 %Filtramos lo valores muy altos de las RPMs total = total + potencia40(i,3); num_datos = num_datos +1; end GramTotal= GramTotal + potencia40(i,4); %Vamos sumando los gramos end RPMmedia(k) = total/num_datos; %Guardamos las medias de las RPM en un vector GRAMOSmedia(k) = (GramTotal/length(potencia40))-GramosMaqueta; %Guardamos las medias de las medidas de los GRAMOS en un vector PAR(k) = ((GRAMOSmedia(k)/1000)*9.81)*D; k= k+1; %Para el escalon de 45 total = 0; GramTotal = 0; num_datos = 0; for i = 1:length(potencia45) if potencia45(i,3)<= 20000 %Filtramos lo valores muy altos de las RPMs total = total + potencia45(i,3); num_datos = num_datos +1; end GramTotal= GramTotal + potencia45(i,4); %Vamos sumando los gramos end RPMmedia(k) = total/num_datos; %Guardamos las medias de las RPM en un vector GRAMOSmedia(k) = (GramTotal/length(potencia45))-GramosMaqueta; %Guardamos las medias de las medidas de los GRAMOS en un vector PAR(k) = ((GRAMOSmedia(k)/1000)*9.81)*D; k = k +1; %Para el escalon de 50 total = 0; GramTotal = 0; num_datos = 0; for i = 1:length(potencia50) if potencia50(i,3)<= 20000 %Filtramos lo valores muy altos de las RPMs total = total + potencia50(i,3); num_datos = num_datos +1; end GramTotal= GramTotal + potencia50(i,4); %Vamos sumando los gramos end RPMmedia(k) = total/num_datos; %Guardamos las medias de las RPM en un vector



88 Jorge Visa Vidal

GRAMOSmedia(k) = (GramTotal/length(potencia50))-GramosMaqueta; %Guardamos las medias de las medidas de los GRAMOS en un vector PAR(k) = ((GRAMOSmedia(k)/1000)*9.81)*D; k = k +1; %Para el escalon de 55 total = 0; GramTotal = 0; num_datos = 0; for i = 1:length(potencia55) if potencia55(i,3)<= 20000 %Filtramos lo valores muy altos de las RPMs total = total + potencia55(i,3); num_datos = num_datos +1; end GramTotal= GramTotal + potencia55(i,4); %Vamos sumando los gramos end RPMmedia(k) = total/num_datos; %Guardamos las medias de las RPM en un vector GRAMOSmedia(k) = (GramTotal/length(potencia55))-GramosMaqueta; %Guardamos las medias de las medidas de los GRAMOS en un vector PAR(k) = ((GRAMOSmedia(k)/1000)*9.81)*D; k = k +1; %Para el escalon de 60 total = 0; GramTotal = 0; num_datos = 0; for i = 1:length(potencia60) if potencia60(i,3)<= 20000 %Filtramos lo valores muy altos de las RPMs total = total + potencia60(i,3); num_datos = num_datos +1; end GramTotal= GramTotal + potencia60(i,4); %Vamos sumando los gramos end RPMmedia(k) = total/num_datos; %Guardamos las medias de las RPM en un vector GRAMOSmedia(k) = (GramTotal/length(potencia60))-GramosMaqueta; %Guardamos las medias de las medidas de los GRAMOS en un vector PAR(k) = ((GRAMOSmedia(k)/1000)*9.81)*D; k = k +1; %Para el escalon de 65 total = 0; GramTotal = 0; num_datos = 0; for i = 1:length(potencia65) if potencia65(i,3)<= 20000 %Filtramos lo valores muy altos de las RPMs total = total + potencia65(i,3); num_datos = num_datos +1; end GramTotal= GramTotal + potencia65(i,4); %Vamos sumando los gramos end RPMmedia(k) = total/num_datos; %Guardamos las medias de las RPM en un vector GRAMOSmedia(k) = (GramTotal/length(potencia65))-GramosMaqueta; %Guardamos las medias de las medidas de los GRAMOS en un vector



89 Jorge Visa Vidal

PAR(k) = ((GRAMOSmedia(k)/1000)*9.81)*D; k = k +1; %Para el escalon de 70 total = 0; GramTotal = 0; num_datos = 0; for i = 1:length(potencia70) if potencia70(i,3)<= 20000 %Filtramos lo valores muy altos de las RPMs total = total + potencia70(i,3); num_datos = num_datos +1; end GramTotal= GramTotal + potencia70(i,4); %Vamos sumando los gramos end RPMmedia(k) = total/num_datos; %Guardamos las medias de las RPM en un vector GRAMOSmedia(k) = (GramTotal/length(potencia70))-GramosMaqueta; %Guardamos las medias de las medidas de los GRAMOS en un vector PAR(k) = ((GRAMOSmedia(k)/1000)*9.81)*D; k = k +1; %Para el escalon de 75 total = 0; GramTotal = 0; num_datos = 0; for i = 1:length(potencia75) if potencia75(i,3)<= 20000 %Filtramos lo valores muy altos de las RPMs total = total + potencia75(i,3); num_datos = num_datos +1; end GramTotal= GramTotal + potencia75(i,4); %Vamos sumando los gramos end RPMmedia(k) = total/num_datos; %Guardamos las medias de las RPM en un vector GRAMOSmedia(k) = (GramTotal/length(potencia75))-GramosMaqueta; %Guardamos las medias de las medidas de los GRAMOS en un vector PAR(k) = ((GRAMOSmedia(k)/1000)*9.81)*D; k = k +1; %Para el escalon de 80 total = 0; GramTotal = 0; num_datos = 0; for i = 1:length(potencia80) if potencia80(i,3)<= 20000 %Filtramos lo valores muy altos de las RPMs total = total + potencia80(i,3); num_datos = num_datos +1; end GramTotal= GramTotal + potencia80(i,4); %Vamos sumando los gramos end RPMmedia(k) = total/num_datos; %Guardamos las medias de las RPM en un vector GRAMOSmedia(k) = (GramTotal/length(potencia80))-GramosMaqueta; %Guardamos las medias de las medidas de los GRAMOS en un vector PAR(k) = ((GRAMOSmedia(k)/1000)*9.81)*D; k = k +1;



90 Jorge Visa Vidal

%Para el escalon de 85 total = 0; GramTotal = 0; num_datos = 0; for i = 1:length(potencia85) if potencia85(i,3)<= 20000 %Filtramos lo valores muy altos de las RPMs total = total + potencia85(i,3); num_datos = num_datos +1; end GramTotal= GramTotal + potencia85(i,4); %Vamos sumando los gramos end RPMmedia(k) = total/num_datos; %Guardamos las medias de las RPM en un vector GRAMOSmedia(k) = (GramTotal/length(potencia85))-GramosMaqueta; %Guardamos las medias de las medidas de los GRAMOS en un vector PAR(k) = ((GRAMOSmedia(k)/1000)*9.81)*D; k = k +1; %Para el escalon de 90 total = 0; GramTotal = 0; num_datos = 0; for i = 1:length(potencia90) if potencia90(i,3)<= 20000 %Filtramos lo valores muy altos de las RPMs total = total + potencia90(i,3); num_datos = num_datos +1; end GramTotal= GramTotal + potencia90(i,4); %Vamos sumando los gramos end RPMmedia(k) = total/num_datos; %Guardamos las medias de las RPM en un vector GRAMOSmedia(k) = (GramTotal/length(potencia90))-GramosMaqueta; %Guardamos las medias de las medidas de los GRAMOS en un vector PAR(k) = ((GRAMOSmedia(k)/1000)*9.81)*D; k = k +1; %Para el escalon de 95 total = 0; GramTotal = 0; num_datos = 0; for i = 1:length(potencia95) if potencia95(i,3)<= 20000 %Filtramos lo valores muy altos de las RPMs total = total + potencia95(i,3); num_datos = num_datos +1; end GramTotal= GramTotal + potencia95(i,4); %Vamos sumando los gramos end RPMmedia(k) = total/num_datos; %Guardamos las medias de las RPM en un vector GRAMOSmedia(k) = (GramTotal/length(potencia95))-GramosMaqueta; %Guardamos las medias de las medidas de los GRAMOS en un vector PAR(k) = ((GRAMOSmedia(k)/1000)*9.81)*D; k = k +1; %Para el escalon de 100 total = 0;



91 Jorge Visa Vidal

GramTotal = 0; num_datos = 0; for i = 1:length(potencia100) if potencia100(i,3)<= 20000 %Filtramos lo valores muy altos de las RPMs total = total + potencia100(i,3); num_datos = num_datos +1; end GramTotal= GramTotal + potencia100(i,4); %Vamos sumando los gramos end RPMmedia(k) = total/num_datos; %Guardamos las medias de las RPM en un vector GRAMOSmedia(k) = (GramTotal/length(potencia100))-GramosMaqueta; %Guardamos las medias de las medidas de los GRAMOS en un vector PAR(k) = ((GRAMOSmedia(k)/1000)*9.81)*D; %Hacemos un filtro para poder plotear TODOS los valores de las RPM for i = 1:length(Rpm) if Rpm(i)>=20000 j=i+1; while Rpm(j)>=20000 j=j+1; end Rpm(i)= Rpm(j); end end Velocidad = RPMmedia*((2*pi/60)); %Pasamos las rpm a rad/s Ktotal = 0; Kmay= 0; Kmen= 1; for i = 1:length(Velocidad) if Velocidad(i) >0 Kpar(i)=(PAR(i))/(Velocidad(i))^2; Ktotal= Ktotal + Kpar(i); if Kpar(i)>Kmay Kmay = Kpar(i); %Calculamos el valor más alto de la constante end if Kpar(i)<Kmen && Kpar(i)>0 Kmen = Kpar(i); %Calculamos el valor más bajo de la constante end end end Kmediapar = Ktotal/length(Kpar); %Calculamos la constante que relaciona la fuerza con la velocidad de giro handles.TConstante.String = 'Kpar ='; handles.TValor.String = Kmediapar; %Sacamos el valor por pantalla handles.TMayConstante.String = 'Kpar-mayor ='; handles.TMayValor.String = Kmay; handles.TMenConstante.String = 'Kpar-menor ='; handles.TMenValor.String = Kmen;



92 Jorge Visa Vidal

axes(handles.PlotDinamica); % Hacemos que en la gráfica de la izquierda aparezca RPM vs Tiempo plot(Seg,Rpm); axes(handles.PlotRPM); % Hacemos que en la gráfica de la izquierda aparezca RPM vs PWM plot(PWM,RPMmedia); axes(handles.PlotFuerza); % Hacemos que en la gráfica de la izquierda aparezca Fuerza vs Velocidad plot(Velocidad,PAR); % --- Executes on button press in PBCarDatE. function PBCarDatE_Callback(hObject, eventdata, handles) % hObject handle to PBCarDatE (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) global Ac; global Seg; global Gr; global Rpm; load (handles.ENomFichE.String); Ac = Aceleracion; Seg = Segundos; Gr = Gramos; Rpm = RPM; % --- Executes on button press in PBCalEmpuje. function PBCalEmpuje_Callback(hObject, eventdata, handles) % hObject handle to PBCalEmpuje (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) global Ac; global Seg; global Gr; global Rpm; H = str2num(handles.EHigh.String); L = str2num(handles.ELarge.String); handles.TFuerza.String = 'EMPUJE DEL ROTOR'; handles.ImFormula.Visible = 'On'; %Hacemos visible la formula de fuerza y velocidad axes(handles.ImFormula) %Insertamos formula que relaciona la fuerza con la velocidad de giro handles.imagen=imread('ForEmp.PNG'); imagesc(handles.imagen) axis off dato_ant = Ac(1); x = 1; k=1; PWM(x)= dato_ant; for i = 1:length(Ac) %Buscamos el cambio de aceleración en el motor dato = Ac(i); if dato ~= dato_ant indices(x)=i-1; %En la variable indices tenemos la última posición de cada escalón de la aceleración



93 Jorge Visa Vidal

x= x+1; PWM(x) = dato; end dato_ant = dato; end potencia0 = [Seg(1:indices(1)),Ac(1:indices(1)),Rpm(1:indices(1)),Gr(1:indices(1))]; %Guardamos los datos de cada aceleración en un vector potencia5 = [Seg((indices(1)+1):indices(2)),Ac((indices(1)+1):indices(2)),Rpm((indices(1)+1):indices(2)),Gr((indices(1)+1):indices(2))]; potencia10 = [Seg((indices(2)+1):indices(3)),Ac((indices(2)+1):indices(3)),Rpm((indices(2)+1):indices(3)),Gr((indices(2)+1):indices(3))]; potencia15 = [Seg((indices(3)+1):indices(4)),Ac((indices(3)+1):indices(4)),Rpm((indices(3)+1):indices(4)),Gr((indices(3)+1):indices(4))]; potencia20 = [Seg((indices(4)+1):indices(5)),Ac((indices(4)+1):indices(5)),Rpm((indices(4)+1):indices(5)),Gr((indices(4)+1):indices(5))]; potencia25 = [Seg((indices(5)+1):indices(6)),Ac((indices(5)+1):indices(6)),Rpm((indices(5)+1):indices(6)),Gr((indices(5)+1):indices(6))]; potencia30 = [Seg((indices(6)+1):indices(7)),Ac((indices(6)+1):indices(7)),Rpm((indices(6)+1):indices(7)),Gr((indices(6)+1):indices(7))]; potencia35 = [Seg((indices(7)+1):indices(8)),Ac((indices(7)+1):indices(8)),Rpm((indices(7)+1):indices(8)),Gr((indices(7)+1):indices(8))]; potencia40 = [Seg((indices(8)+1):indices(9)),Ac((indices(8)+1):indices(9)),Rpm((indices(8)+1):indices(9)),Gr((indices(8)+1):indices(9))]; potencia45 = [Seg((indices(9)+1):indices(10)),Ac((indices(9)+1):indices(10)),Rpm((indices(9)+1):indices(10)),Gr((indices(9)+1):indices(10))]; potencia50 = [Seg((indices(10)+1):indices(11)),Ac((indices(10)+1):indices(11)),Rpm((indices(10)+1):indices(11)),Gr((indices(10)+1):indices(11))]; potencia55 = [Seg((indices(11)+1):indices(12)),Ac((indices(11)+1):indices(12)),Rpm((indices(11)+1):indices(12)),Gr((indices(11)+1):indices(12))]; potencia60 = [Seg((indices(12)+1):indices(13)),Ac((indices(12)+1):indices(13)),Rpm((indices(12)+1):indices(13)),Gr((indices(12)+1):indices(13))]; potencia65 = [Seg((indices(13)+1):indices(14)),Ac((indices(13)+1):indices(14)),Rpm((indices(13)+1):indices(14)),Gr((indices(13)+1):indices(14))]; potencia70 = [Seg((indices(14)+1):indices(15)),Ac((indices(14)+1):indices(15)),Rpm((indices(14)+1):indices(15)),Gr((indices(14)+1):indices(15))]; potencia75 = [Seg((indices(15)+1):indices(16)),Ac((indices(15)+1):indices(16)),Rpm((indices(15)+1):indices(16)),Gr((indices(15)+1):indices(16))];



94 Jorge Visa Vidal

potencia80 = [Seg((indices(16)+1):indices(17)),Ac((indices(16)+1):indices(17)),Rpm((indices(16)+1):indices(17)),Gr((indices(16)+1):indices(17))]; potencia85 = [Seg((indices(17)+1):indices(18)),Ac((indices(17)+1):indices(18)),Rpm((indices(17)+1):indices(18)),Gr((indices(17)+1):indices(18))]; potencia90 = [Seg((indices(18)+1):indices(19)),Ac((indices(18)+1):indices(19)),Rpm((indices(18)+1):indices(19)),Gr((indices(18)+1):indices(19))]; potencia95 = [Seg((indices(19)+1):indices(20)),Ac((indices(19)+1):indices(20)),Rpm((indices(19)+1):indices(20)),Gr((indices(19)+1):indices(20))]; potencia100 = [Seg((indices(20)+1):length(Ac)),Ac((indices(20)+1):length(Ac)),Rpm((indices(20)+1):length(Ac)),Gr((indices(20)+1):length(Ac))]; %Para el escalon de 0 total = 0; GramTotal = 0; num_datos = 0; for i = 1:length(potencia0) if potencia0(i,3)<= 25000 %Filtramos lo valores muy altos de las RPMs total = total + potencia0(i,3); num_datos = num_datos +1; end GramTotal= GramTotal + potencia0(i,4); %Vamos sumando los gramos end RPMmedia(k) = total/num_datos; %Guardamos las medias de las RPM en un vector GramosMaqueta = (GramTotal/length(potencia0)); GRAMOSmedia(k) = (GramTotal/length(potencia0))-GramosMaqueta; %Guardamos las medias de las medidas de los GRAMOS en un vector EMPUJE(k) = ((GRAMOSmedia(k)/1000)*9.81)*(L/H); k = k +1; %Para el escalon de 5 total = 0; GramTotal = 0; num_datos = 0; for i = 1:length(potencia5) if potencia5(i,3)<= 25000 %Filtramos lo valores muy altos de las RPMs total = total + potencia5(i,3); num_datos = num_datos +1; end GramTotal= GramTotal + potencia5(i,4); %Vamos sumando los gramos end RPMmedia(k) = total/num_datos; %Guardamos las medias de las RPM en un vector GRAMOSmedia(k) = (GramTotal/length(potencia5))-GramosMaqueta; %Guardamos las medias de las medidas de los GRAMOS en un vector EMPUJE(k) = ((GRAMOSmedia(k)/1000)*9.81)*(L/H); k = k +1; %Para el escalon de 10 total = 0;



95 Jorge Visa Vidal

GramTotal = 0; num_datos = 0; for i = 1:length(potencia10) if potencia10(i,3)<= 25000 %Filtramos lo valores muy altos de las RPMs total = total + potencia10(i,3); num_datos = num_datos +1; end GramTotal= GramTotal + potencia10(i,4); %Vamos sumando los gramos end RPMmedia(k) = total/num_datos; %Guardamos las medias de las RPM en un vector GRAMOSmedia(k) = (GramTotal/length(potencia10))-GramosMaqueta; %Guardamos las medias de las medidas de los GRAMOS en un vector EMPUJE(k) = ((GRAMOSmedia(k)/1000)*9.81)*(L/H); k = k +1; %Para el escalon de 15 total = 0; GramTotal = 0; num_datos = 0; for i = 1:length(potencia15) if potencia15(i,3)<= 25000 %Filtramos lo valores muy altos de las RPMs total = total + potencia15(i,3); num_datos = num_datos +1; end GramTotal= GramTotal + potencia15(i,4); %Vamos sumando los gramos end RPMmedia(k) = total/num_datos; %Guardamos las medias de las RPM en un vector GRAMOSmedia(k) = (GramTotal/length(potencia15))-GramosMaqueta; %Guardamos las medias de las medidas de los GRAMOS en un vector EMPUJE(k) = ((GRAMOSmedia(k)/1000)*9.81)*(L/H); k = k +1; %Para el escalon de 20 total = 0; GramTotal = 0; num_datos = 0; for i = 1:length(potencia20) if potencia20(i,3)<= 25000 %Filtramos lo valores muy altos de las RPMs total = total + potencia20(i,3); num_datos = num_datos +1; end GramTotal= GramTotal + potencia20(i,4); %Vamos sumando los gramos end RPMmedia(k) = total/num_datos; %Guardamos las medias de las RPM en un vector GRAMOSmedia(k) = (GramTotal/length(potencia20))-GramosMaqueta; %Guardamos las medias de las medidas de los GRAMOS en un vector EMPUJE(k) = ((GRAMOSmedia(k)/1000)*9.81)*(L/H); k = k +1; %Para el escalon de 25 total = 0; GramTotal = 0; num_datos = 0;



96 Jorge Visa Vidal

for i = 1:length(potencia25) if potencia25(i,3)<= 25000 %Filtramos lo valores muy altos de las RPMs total = total + potencia25(i,3); num_datos = num_datos +1; end GramTotal= GramTotal + potencia25(i,4); %Vamos sumando los gramos end RPMmedia(k) = total/num_datos; %Guardamos las medias de las RPM en un vector GRAMOSmedia(k) = (GramTotal/length(potencia25))-GramosMaqueta; %Guardamos las medias de las medidas de los GRAMOS en un vector EMPUJE(k) = ((GRAMOSmedia(k)/1000)*9.81)*(L/H); k = k +1; %Para el escalon de 30 total = 0; GramTotal = 0; num_datos = 0; for i = 1:length(potencia30) if potencia30(i,3)<= 25000 %Filtramos lo valores muy altos de las RPMs total = total + potencia30(i,3); num_datos = num_datos +1; end GramTotal= GramTotal + potencia30(i,4); %Vamos sumando los gramos end RPMmedia(k) = total/num_datos; %Guardamos las medias de las RPM en un vector GRAMOSmedia(k) = (GramTotal/length(potencia30))-GramosMaqueta; %Guardamos las medias de las medidas de los GRAMOS en un vector EMPUJE(k) = ((GRAMOSmedia(k)/1000)*9.81)*(L/H); k = k +1; %Para el escalon de 35 total = 0; GramTotal = 0; num_datos = 0; for i = 1:length(potencia35) if potencia35(i,3)<= 25000 %Filtramos lo valores muy altos de las RPMs total = total + potencia35(i,3); num_datos = num_datos +1; end GramTotal= GramTotal + potencia35(i,4); %Vamos sumando los gramos end RPMmedia(k) = total/num_datos; %Guardamos las medias de las RPM en un vector GRAMOSmedia(k) = (GramTotal/length(potencia35))-GramosMaqueta; %Guardamos las medias de las medidas de los GRAMOS en un vector EMPUJE(k) = ((GRAMOSmedia(k)/1000)*9.81)*(L/H); k = k +1; %Para el escalon de 40 total = 0; GramTotal = 0; num_datos = 0; for i = 1:length(potencia40)



97 Jorge Visa Vidal

if potencia40(i,3)<= 25000 %Filtramos lo valores muy altos de las RPMs total = total + potencia40(i,3); num_datos = num_datos +1; end GramTotal= GramTotal + potencia40(i,4); %Vamos sumando los gramos end RPMmedia(k) = total/num_datos; %Guardamos las medias de las RPM en un vector GRAMOSmedia(k) = (GramTotal/length(potencia40))-GramosMaqueta; %Guardamos las medias de las medidas de los GRAMOS EMPUJE(k) = ((GRAMOSmedia(k)/1000)*9.81)*(L/H); k = k +1; %Para el escalon de 45 total = 0; GramTotal = 0; num_datos = 0; for i = 1:length(potencia45) if potencia45(i,3)<= 25000 %Filtramos lo valores muy altos de las RPMs total = total + potencia45(i,3); num_datos = num_datos +1; end GramTotal= GramTotal + potencia45(i,4); %Vamos sumando los gramos end RPMmedia(k) = total/num_datos; %Guardamos las medias de las RPM en un vector GRAMOSmedia(k) = (GramTotal/length(potencia45))-GramosMaqueta; %Guardamos las medias de las medidas de los GRAMOS en un vector EMPUJE(k) = ((GRAMOSmedia(k)/1000)*9.81)*(L/H); k = k +1; %Para el escalon de 50 total = 0; GramTotal = 0; num_datos = 0; for i = 1:length(potencia50) if potencia50(i,3)<= 25000 %Filtramos lo valores muy altos de las RPMs total = total + potencia50(i,3); num_datos = num_datos +1; end GramTotal= GramTotal + potencia50(i,4); %Vamos sumando los gramos end RPMmedia(k) = total/num_datos; %Guardamos las medias de las RPM en un vector GRAMOSmedia(k) = (GramTotal/length(potencia50))-GramosMaqueta; %Guardamos las medias de las medidas de los GRAMOS en un vector EMPUJE(k) = ((GRAMOSmedia(k)/1000)*9.81)*(L/H); k = k +1; %Para el escalon de 55 total = 0; GramTotal = 0; num_datos = 0; for i = 1:length(potencia55) if potencia55(i,3)<= 25000 %Filtramos lo valores muy altos de las RPMs



98 Jorge Visa Vidal

total = total + potencia55(i,3); num_datos = num_datos +1; end GramTotal= GramTotal + potencia55(i,4); %Vamos sumando los gramos end RPMmedia(k) = total/num_datos; %Guardamos las medias de las RPM en un vector GRAMOSmedia(k) = (GramTotal/length(potencia55))-GramosMaqueta; %Guardamos las medias de las medidas de los GRAMOS en un vector EMPUJE(k) = ((GRAMOSmedia(k)/1000)*9.81)*(L/H); k = k +1; %Para el escalon de 60 total = 0; GramTotal = 0; num_datos = 0; for i = 1:length(potencia60) if potencia60(i,3)<= 25000 %Filtramos lo valores muy altos de las RPMs total = total + potencia60(i,3); num_datos = num_datos +1; end GramTotal= GramTotal + potencia60(i,4); %Vamos sumando los gramos end RPMmedia(k) = total/num_datos; %Guardamos las medias de las RPM en un vector GRAMOSmedia(k) = (GramTotal/length(potencia60))-GramosMaqueta; %Guardamos las medias de las medidas de los GRAMOS en un vector EMPUJE(k) = ((GRAMOSmedia(k)/1000)*9.81)*(L/H); k = k +1; %Para el escalon de 65 total = 0; GramTotal = 0; num_datos = 0; for i = 1:length(potencia65) if potencia65(i,3)<= 25000 %Filtramos lo valores muy altos de las RPMs total = total + potencia65(i,3); num_datos = num_datos +1; end GramTotal= GramTotal + potencia65(i,4); %Vamos sumando los gramos end RPMmedia(k) = total/num_datos; %Guardamos las medias de las RPM en un vector GRAMOSmedia(k) = (GramTotal/length(potencia65))-GramosMaqueta; %Guardamos las medias de las medidas de los GRAMOS en un vector EMPUJE(k) = ((GRAMOSmedia(k)/1000)*9.81)*(L/H); k = k +1; %Para el escalon de 70 total = 0; GramTotal = 0; num_datos = 0; for i = 1:length(potencia70) if potencia70(i,3)<= 25000 %Filtramos lo valores muy altos de las RPMs total = total + potencia70(i,3); num_datos = num_datos +1;



99 Jorge Visa Vidal

end GramTotal= GramTotal + potencia70(i,4); %Vamos sumando los gramos end RPMmedia(k) = total/num_datos; %Guardamos las medias de las RPM en un vector GRAMOSmedia(k) = (GramTotal/length(potencia70))-GramosMaqueta; %Guardamos las medias de las medidas de los GRAMOS en un vector EMPUJE(k) = ((GRAMOSmedia(k)/1000)*9.81)*(L/H); k = k +1; %Para el escalon de 75 total = 0; GramTotal = 0; num_datos = 0; for i = 1:length(potencia75) if potencia75(i,3)<= 25000 %Filtramos lo valores muy altos de las RPMs total = total + potencia75(i,3); num_datos = num_datos +1; end GramTotal= GramTotal + potencia75(i,4); %Vamos sumando los gramos end RPMmedia(k) = total/num_datos; %Guardamos las medias de las RPM en un vector GRAMOSmedia(k) = (GramTotal/length(potencia75))-GramosMaqueta; %Guardamos las medias de las medidas de los GRAMOS en un vector EMPUJE(k) = ((GRAMOSmedia(k)/1000)*9.81)*(L/H); k = k +1; %Para el escalon de 80 total = 0; GramTotal = 0; num_datos = 0; for i = 1:length(potencia80) if potencia80(i,3)<= 25000 %Filtramos lo valores muy altos de las RPMs total = total + potencia80(i,3); num_datos = num_datos +1; end GramTotal= GramTotal + potencia80(i,4); %Vamos sumando los gramos end RPMmedia(k) = total/num_datos; %Guardamos las medias de las RPM en un vector GRAMOSmedia(k) = (GramTotal/length(potencia80))-GramosMaqueta; %Guardamos las medias de las medidas de los GRAMOS en un vector EMPUJE(k) = ((GRAMOSmedia(k)/1000)*9.81)*(L/H); k = k +1; %Para el escalon de 85 total = 0; GramTotal = 0; num_datos = 0; for i = 1:length(potencia85) if potencia85(i,3)<= 25000 %Filtramos lo valores muy altos de las RPMs total = total + potencia85(i,3); num_datos = num_datos +1; end GramTotal= GramTotal + potencia85(i,4); %Vamos sumando los gramos



100 Jorge Visa Vidal

end RPMmedia(k) = total/num_datos; %Guardamos las medias de las RPM en un vector GRAMOSmedia(k) = (GramTotal/length(potencia85))-GramosMaqueta; %Guardamos las medias de las medidas de los GRAMOS en un vector EMPUJE(k) = ((GRAMOSmedia(k)/1000)*9.81)*(L/H); k = k +1; %Para el escalon de 90 total = 0; GramTotal = 0; num_datos = 0; for i = 1:length(potencia90) if potencia90(i,3)<= 25000 %Filtramos lo valores muy altos de las RPMs total = total + potencia90(i,3); num_datos = num_datos +1; end GramTotal= GramTotal + potencia90(i,4); %Vamos sumando los gramos end RPMmedia(k) = total/num_datos; %Guardamos las medias de las RPM en un vector GRAMOSmedia(k) = (GramTotal/length(potencia90))-GramosMaqueta; %Guardamos las medias de las medidas de los GRAMOS en un vector EMPUJE(k) = ((GRAMOSmedia(k)/1000)*9.81)*(L/H); k = k +1; %Para el escalon de 95 total = 0; GramTotal = 0; num_datos = 0; for i = 1:length(potencia95) if potencia95(i,3)<= 25000 %Filtramos lo valores muy altos de las RPMs total = total + potencia95(i,3); num_datos = num_datos +1; end GramTotal= GramTotal + potencia95(i,4); %Vamos sumando los gramos end RPMmedia(k) = total/num_datos; %Guardamos las medias de las RPM en un vector GRAMOSmedia(k) = (GramTotal/length(potencia95))-GramosMaqueta; %Guardamos las medias de las medidas de los GRAMOS en un vector EMPUJE(k) = ((GRAMOSmedia(k)/1000)*9.81)*(L/H); k = k +1; %Para el escalon de 100 total = 0; GramTotal = 0; num_datos = 0; for i = 1:length(potencia100) if potencia100(i,3)<= 25000 %Filtramos lo valores muy altos de las RPMs total = total + potencia100(i,3); num_datos = num_datos +1; end GramTotal= GramTotal + potencia100(i,4); %Vamos sumando los gramos end




RPMmedia(k) = total/num_datos; %Guardamos las medias de las RPM en un vector GRAMOSmedia(k) = (GramTotal/length(potencia100))-GramosMaqueta; %Guardamos las medias de las medidas de los GRAMOS en un vector EMPUJE(k) = ((GRAMOSmedia(k)/1000)*9.81)*(L/H); Velocidad = RPMmedia*((2*pi/60)); %Pasamos las rpm a rad/s Ktotal = 0; Kmay= 0; Kmen= 1; for i = 1:length(Velocidad) if Velocidad(i) >0 Kemp(i)=(EMPUJE(i))/(Velocidad(i))^2; Ktotal= Ktotal + Kemp(i); if Kemp(i)>Kmay Kmay = Kemp(i); %Calculamos el valor más alto de la constante end if Kemp(i)<Kmen && Kemp(i)>0 Kmen = Kemp(i); %Calculamos el valor más bajo de la constante end end end Kmediaemp = Ktotal/length(Kemp);%Calculamos la constante que relaciona la fuerza con la velocidad de giro handles.TConstante.String = 'Kempuje ='; handles.TValor.String = Kmediaemp; %Sacamos el valor por pantalla handles.TMayConstante.String = 'Kempuje-mayor ='; handles.TMayValor.String = Kmay; handles.TMenConstante.String = 'Kempuje-menor ='; handles.TMenValor.String = Kmen; axes(handles.PlotDinamica); % Hacemos que en la gráfica de la izquierda aparezca RPM vs Tiempo plot(Seg,Rpm); axes(handles.PlotRPM); % Hacemos que en la gráfica de la izquierda aparezca RPM vs PWM plot(PWM,RPMmedia); axes(handles.PlotFuerza); % Hacemos que en la gráfica de la izquierda aparezca Fuerza vs Velocidad plot(Velocidad,EMPUJE);




ROTOR”

DOCUMENTO Nº 4 PLANOS






Planos Universidad de La Rioja


ÍNDICE

1. Planos mecanismo para el cálculo de la fuerza de empuje .......................................... 104

2. Planos mecanismo para el cálculo del par de arrastre ................................................. 112

3. Planos plataforma para el control de actitud y orientación ......................................... 119

4. Planos bloqueo de los ejes de la plataforma de control de actitud y orientación........ 126




1. Planos mecanismo para el cálculo de la fuerza de empuje

1

2

3

4

5

6

Escalas

ComprobadoId.s.normas

Dibujado

Cantidad Denominacion Marca Plano Nº Modelo Material Observaciones Peso

Fecha Nombre

Número

ReferenciaSustituye aSustituido por

Proyección

ESCUELA TÉCNICA SUPERIORDE INGENIERÍA INDUSTRIAL

UNIVERSIDAD DE LA RIOJA Grado en ingeniería electrónica industrial y automática

Trabajo Fin de Grado1:4

Jorge Visa

Estructura para el cálculo del empuje del conjuntomotor-hélice

1 Pieza 1 11 Pieza 2 21 Pieza 3 31 Pieza 4 41 Pieza 5 51 Pieza 6 6

0

7/07/2016

250

27

11,5

13.5

135°

Ø3

Escalas


DibujadoFecha Nombre

Número


Proyección




Jorge Visa

Pieza 1 estructura para el cálculo del empuje delconjunto motor-hélice

1

7/07/2016

150

27

135°

Escalas



Número


Proyección




Jorge Visa


2

7/07/2016

120

40Ø5

12,518

20

Escalas



Número


Proyección




Jorge Visa


3

7/07/2016

80

6018

Escalas



Número


Proyección




Jorge Visa


4

7/07/2016

120

4027

15

27

12,520

Ø5

Escalas



Número


Proyección




Jorge Visa


5

7/07/2016

81

13

27

27 27

13

Escalas



Número


Proyección




Jorge Visa


6

7/07/2016




2. Planos mecanismo para el cálculo del par de arrastre

1

2

34

Escalas


Dibujado

Cantidad Denominacion Marca Plano Nº Modelo Material Observaciones Peso

Fecha Nombre

Número


Proyección




Jorge Visa

Estructura para el cálculo del par de arrastre delconjunto motor-hélice

1 Pieza 1 11 Pieza 2 21 Pieza 3 31 Pieza 4 41 Pieza 4 motor grande 5

0

7/07/2016

170

27

Ø10 27.5

13.5

Escalas



Número


Proyección




Jorge Visa

Pieza 1 estructura para el cálculo del par de arrastredel conjunto motor-hélice

1

7/07/2016

150

55

Ø5Ø10

18

Ø3

6.5

97.5

17.5

30

27.5

52.5

2,5

Ø19

Escalas



Número


Proyección




Jorge Visa


2

7/07/2016

120

60 30

30

18

Escalas



Número


Proyección




Jorge Visa


3

7/07/2016

70

35

Ø5

M2

7,57,5

35

23,5

2717,

5

12

Escalas



Número


Proyección




Jorge Visa


4

7/07/2016

70

35

7,5

7,5

12

9,5

26

17,5

35

Ø5

M2

Escalas



Número


Proyección




Jorge Visa

Pieza 4 motor grande estructura para el cálculo delpar de arrastre del conjunto motor-hélice

5

7/07/2016




3. Planos plataforma para el control de actitud y orientación

300

30550

580

30

30

Escalas



Número


Proyección




Jorge Visa

Estructura exterior plataforma de control de actitud yorientación del UAV

7/07/2016

1

20

Ø497

Ø500

Escalas



Número


Proyección

Trabajo Fin de Grado



1:10

Jorge Visa

Aro exterior plataforma de control de actitud yorientación del UAV

7/07/2016

2

20

Ø447Ø450

Escalas



Número


Proyección




Jorge Visa

Aro interior plataforma de control de actitud yorientación del UAV

7/07/2016

3

25

Ø4

Escalas



Número


Proyección




Jorge Visa

Unión aro-rodamiento plataforma de control deactitud y orientación del UAV

7/07/2016

4

Escalas



Número


Proyección



40

20

260 3

80

5 Ø4

20 10

Ø5,5


Jorge Visa

Soporte UAV plataforma de control de actitud yorientación del UAV

7/07/2016

5

Escalas



Número


Proyección



121

15Ø6

Ø5


Jorge Visa

Unión soporte UAV-rodamiento plataforma decontrol de actitud y orientación del UAV

7/07/2016

6




4. Planos bloqueo de los ejes de la plataforma de control de actitud y orientación

Escalas



Número


Proyección




1:1

Jorge Visa

Pieza 1 bloqueo ejes plataforma de control deactitud y orientación del UAV

41

41

21

10

10

55

21

7/07/2016

1

45

Escalas



Número


Proyección




1:1

Jorge Visa

Pieza 2 bloqueo ejes plataforma de control deactitud y orientación del UAV

47

47 2110

20,6

25

1015

21

7/07/2016

2




ROTOR”

DOCUMENTO Nº 5 PLIEGO DE CONDICIONES






Pliego de condiciones Universidad de La Rioja


ÍNDICE

1. Introducción al pliego de condiciones ........................................................................... 131

1.1 Condiciones Generales .............................................................................................. 131

1.2 Condiciones Administrativas ..................................................................................... 132

1.3 Normativa y Reglamentación .................................................................................... 133

1.3.1 Reglamento relacionado a productos electrónicos .......................................... 133

1.3.2 Normativa relacionada a materiales y equipos ................................................. 134

1.4 Condiciones facultativas ............................................................................................ 135

1.4.1 Dirección ............................................................................................................ 135

1.4.2 Libro de Órdenes ............................................................................................... 135

1.4.3 Modificaciones .................................................................................................. 135

1.5 Condiciones de los materiales y equipos .................................................................. 137

1.5.1 Condiciones técnicas de los materiales ............................................................. 137

1.6 Condiciones económicas ........................................................................................... 138

1.6.1 Errores en el proyecto ....................................................................................... 138

1.6.2 Liquidación ........................................................................................................ 138

1.7 Disposición final ........................................................................................................ 139




PLIEGO DE CONDICIONES

1. Introducción al pliego de condiciones El autor de este proyecto ha cursado los estudios de Grado en Ingeniería

Electrónica Industrial y Automática en la Universidad de La Rioja, cumpliendo con la normativa establecida por la Escuela Superior de Ingeniería Industrial en la normativa de trabajo fin de grado.

El objeto de este Pliego de Condiciones es recoger y establecer todas las disposiciones técnicas, administrativas y económicas, y las normativas que ha de regir este proyecto.

El diseño de este proyecto y sus características han sido descritos en detalle en la memoria del proyecto y sus anexos.

Las condiciones que se especifican en este documento tratan de cumplir con la calidad esperada para este proyecto. En caso de no realizarse según estas condiciones, el proyectista no se responsabilizará de los fallos o averías que puedan ocasionarse en su funcionamiento, y los problemas derivados repercutirían sobre terceras personas.

Todas las modificaciones que puedan sufrir el proyecto y sus documentos deberán ser aprobadas por el ingeniero o proyectista.

1.1 Condiciones Generales Este proyecto se ajusta a los reglamentos y normativas electrónicas vigentes. Una

vez terminado el proyecto se podrán llevar a cabo modificaciones pero siempre bajo la supervisión del proyectista.

La propiedad intelectual del autor y director del Trabajo Fin de Grado se regirá por

el Real Decreto Legislativo 1/1996, de 12 de abril, por el que se aprueba el texto refundido de la Ley de Propiedad Intelectual.




1.2 Condiciones Administrativas El proyecto constará de los siguientes documentos:

• Un Índice General que indicará la página de comienzo de cada uno de los documentos que forman el proyecto.

• Una Memoria donde se considerarán las necesidades a satisfacer y los factores técnicos a tener en cuenta entrando en profundidad en las posibles soluciones técnicas y en la justificación de la solución elegida.

• Anexos donde se recogerá la documentación considerada de interés para ampliar la descripción detallada de los componentes del sistema.

• Una serie de Planos que describirán todas y cada una de las piezas necesarias para la realización de las maquetas, y los planos de los circuitos impresos, los cuales deberán servir para la perfecta realización de los componentes del sistema.

• Pliego de Condiciones, este documento en el que se establecen las diferentes condiciones técnicas, económicas y administrativas para que proyecto pueda materializarse, evitando posibles malinterpretaciones.

• Presupuesto donde se recogerá el coste de todos los componentes utilizados y la suma total que, junto a la mano de obra, dará el coste final del proyecto. Dicho presupuesto contiene la valoración económica global, desglosada y ordenada por partidas.




1.3 Normativa y Reglamentación El proyecto estará regido tanto por la normativa española como por la

internacional:

1.3.1 Reglamento relacionado a productos electrónicos Respecto al desarrollo de productos electrónicos, se puede en encontrar en

AENOR (Asociación Española de Normalización y Certificación)) las siguientes normativas:

• Norma UNE1302--2:1973. Vocabulario electrotécnico. Electrónica. • Norma UNE-EN611000-4-3-1998. Compatibilidad electromagnética. • Norma EB123500 0:1992. Placas de circuitos impresos flexibles con taladros

para inserción de componentes. • UNE 20-050-74. Código para las marcas de resistencia y condensadores. Valores

y tolerancias. • UNE 20-531-73. Series de colores nominales para resistencias y condensadores. Otras normas para la fabricación y empleo de placas de circuitos impresos (PCB)

son las siguientes: NORMAS DIN • DIN 40801. Parte 1. Circuitos impresos, fundamentos, retículos. • DIN 40801. Parte 2. Circuitos impresos, fundamentos, orificios y espesores

nominales. • DIN 40803. Parte 1. Circuitos impresos, placas de circuito impreso,

requisitos generales y comprobaciones, tablas de tolerancia as. • DIN 40803. Parte 2. Circuitos impresos, placas de circuito impreso,

documentación. • DIN 40804. Circuitos impresos, conceptos. • DIN 41494. Formas de construcción para dispositivos electrónicos, placas

de circuito impreso, medidas. NORMAS UNE • UNE 20-524-75. Técnica circuitos impresos. Parámetros fundamentales.

Sistema de cuadrícula. • UNE 20-524. Equipos electrónicos y sus componentes. Soldabilidad de circuitos

impresos. • UNE 20-524. Técnica de circuitos impresos. Terminología. .




• UNE 20 552 75. Diseño y utilización de componentes para cableados y circuitos impresos.

• UNE 20620-1:199 93. Material base para circuitos impresos. Métodos de ensayo.

• UNE 20621-3:198 84. Circuitos impresos. Diseño y utilización de placas impresas.

Este proyecto debido a sus características se rige bajo el reglamento de Baja Tensión:

“Se calificará como instalación eléctrica de baja tensión todo conjunto de aparatos y de circuitos asociados en previsión de un fin particular: producción, conversión, transformación, transmisión, distribución o utilización de la energía eléctrica, cuyas tensiones nominales sean iguales o inferiores a 1000 V para corriente alterna y 1500 V para corriente continua.”

1.3.2 Normativa relacionada a materiales y equipos Los materiales y equipos de este proyecto deben cumplir los estándares

nacionales e internacionales en vigor y de obligado cumplimiento. Entre otros: • UNE 20-324 Grados de protección de los envolventes del material eléctrico de

baja tensión. • UNE 20-334 Conductos para instalaciones eléctricas. • UNE 21-401 Conductores eléctricos aislados. • UNE 21-402. Conductores eléctricos aislados y desnudos.




1.4 Condiciones facultativas

1.4.1 Dirección La dirección del montaje del será llevada a cabo, en su totalidad por el ingeniero

proyectista, o por cualquier otra persona en la que éste delegue, atendiendo a la capacidad de dicha persona para responsabilizarse de dicha dirección.

Una vez realizada la instalación, ésta podrá ser utilizada por cualquier persona con conocimientos demostrables suficientes sobre el sistema y sus componentes, las tecnologías implicadas y el funcionamiento global y, por partes, del sistema.

En caso de avería o pérdida de información por una utilización incorrecta, el

ingeniero proyectista o la persona en la que haya delegado la dirección del proyecto, quedan exentas de responsabilidad.

1.4.2 Libro de Órdenes El montaje e instalación de todos los elementos que componen el proyecto se

realizará atendiendo al siguiente orden de prioridad en caso de que haya alguna contradicción:

• Presupuesto. • Planos. • Pliego de condiciones • Memoria

Este libro de órdenes debe estar conforme al Decreto 462/1971 de 11 de marzo, y la Orden de 9 de junio de 1971.

1.4.3 Modificaciones Si fuera necesario realizar alguna modificación en el presente proyecto, deberá

comunicarse con anterioridad a su realización al Ingeniero Director, quién deberá dar la correspondiente autorización.

En caso de realizarse modificaciones en la instalación que no hayan sido

previamente comunicadas y autorizadas por el ingeniero Director, las consecuencias




que dichos cambios puedan ocasionar serán de total responsabilidad del instalador que las realice.

Respecto a los cambios en la instalación realizados por el propietario de la misma,

no serán tratados de forma especial y, en ningún caso, quedan eximidos de la autorización del ingeniero Director.




1.5 Condiciones de los materiales y equipos A continuación se detallan las condiciones tanto de hardware como de software

con las que hay que contar para hacer uso de la aplicación del proyecto.

1.5.1 Condiciones técnicas de los materiales Todos los materiales y componentes, utilizados en el proyecto, deben cumplir

todas las especificaciones técnicas que aparecen descritas tanto en la Memoria, como en los planos, estando presente en estos últimos las particularidades técnicas referentes a valores, referencias y demás especificaciones relevantes utilizadas en resistencias, condensadores, transformadores, circuitos integrados, sensores, etc. y deben cumplir asimismo todas las normas descritas en este pliego de condiciones.

Si se considera necesario reemplazar algún componente o material por otro, los

nuevos deberán tener las mismas características que los reemplazados, inhibiéndose el ingeniero proyectista de cualquier responsabilidad por fallo, si no se cumplen estos requisitos.

Para el desarrollo e implementación del proyecto se deberá disponer de un PC que

será el encargado de recoger los datos, analizarlos y procesarlos. Para ello deberá disponer al menos del siguiente software:

• Windows 7 • Matlab – Simulink R2014a • IDE de Arduino




1.6 Condiciones económicas

1.6.1 Errores en el proyecto En el caso de existir algún tipo de error en el proyecto se avisará inmediatamente

al proyectista y se le informará con detalle de los errores encontrados.

Además se dejará de usar la aplicación hasta que los errores queden solucionados para prevenir cualquier tipo de daño.

1.6.2 Liquidación Terminada la instalación de ambas máquinas y del test bench, se procederá a la

liquidación final, en la que se incluye el importe de las unidades de realización, así como las posibles modificaciones del proyecto que hayan sido aprobadas por la dirección del proyecto.

Al suscribir el contrato, el cliente habrá de abonar el 80% del presupuesto. El 20%

quedará como garantía durante los seis primeros meses, a partir de la fecha de puesta en marcha del sistema.

Si transcurridos seis meses desde la puesta en marcha no se ha manifestado

ningún defecto o error de funcionamiento, el cliente abonará el 20% que estaba pendiente. A partir de ese momento, se considerarán concluidos los compromisos entre ambas partes, a excepción del periodo de garantía.




1.7 Disposición final Las partes contratantes, tanto la dirección del proyecto como la empresa cliente,

se ratifican en el contenido del presente pliego de condiciones, que tiene igual validez, a todos los efectos, que una escritura pública, prometiendo su fiel cumplimiento.




ROTOR”

DOCUMENTO Nº 6 MEDICIONES






Mediciones Universidad de La Rioja


ÍNDICE

Mediciones .......................................................................................... 142




MEDICIONES CÓDIGO DESCRIPCIÓN CANTIDAD

C01.: Materiales para las estructuras de cálculo de fuerzas aerodinámicas C01.1 Listón de madera

27mmx27mmx900mm 1

C01.2 Listón de madera 18mmx69mmx900mm

1


1

C01.4 Rodamiento 61800-2RS1 1 C01.5 Varilla roscada 3mm 1 C01.6 Varilla roscada 5mm 1 C01.7 Tornillo 10mm 1 C01.8 Tuerca 3mm 10 C01.9 Tuerca 5mm 10 C01.10 Tuerca 10mm 4 C01.11 Tuerca mariposa 5mm 2 C01.12 Bisagra 1 C01.13 Báscula digital 1

C02.: Materiales para el circuito de amplificación y control del sistema C02.1 PCB 1 C02.2 Fotodiodo 2 C02.3 Amplificador Op. UA741 5 C0.4 Amplificador Op.

LF353N 1

C021.5 Potenciómetro 10K 1 C02.6 Resistencias varias 17 C02.7 Condensadores 100pF 2 C02.8 Conectores + Cables 1 C02.9 Fuente alimentación ATX

DELL N35OP-00 1

C02.10 Arduino Nano ATmega328 1




C05: UAV completo C05.1 UAV utilizado en la

plataforma de control 1

C06: Mano de obra C06.1 Horas de investigación 100 C06.2 Horas de diseño 25 C06.3 Horas de montaje 150 C06.4 Horas de programación 125

C03.: Materiales para los rotores (conjunto motor-hélice) C03.1 Motor Turnigy Multistar

4220-650kv + hélice 1

C03.2 Motor DYS BE1806-2300kv + hélice

1

C03.3 Afro OPTO ESC 20A 1 C03.4 Afro OPTO ESC 12A 1 C03.5 Batería Lipo 1

C04.: Materiales para la plataforma de control de actitud y orientación C04.1 Perfil de aluminio

4000mmx30mmx10mm 1

C04.2 Pletina de acero 3000mmx20mmx3mm

1

C04.3 Rodamiento MR105 ZZ

6

C04.4 Varilla 5mm 1 C04..5 Pletina de aluminio

3mmx50mmx400mm 1




ROTOR”

DOCUMENTO Nº 7 PRESUPUESTO






Presupuesto Universidad de La Rioja


ÍNDICE

Presupuesto ........................................................................................ 146

1. Cuadro de precios ......................................................................................................... 146

2. Presupuesto .................................................................................................................. 148

3. Resumen del presupuesto ............................................................................................. 150




PRESUPUESTO

1. Cuadro de precios CÓDIGO DESCRIPCIÓN PRECIO


27mmx27mmx900mm 5


8


12

C01.4 Rodamiento 61800-2RS1 8 C01.5 Varilla roscada 3mm 2.5 C01.6 Varilla roscada 5mm 2.5 C01.7 Tornillo 10mm 2 C01.8 Tuerca 3mm 0.10 C01.9 Tuerca 5mm 0.10 C01.10 Tuerca 10mm 0.20 C01.11 Tuerca mariposa 5mm 0.15 C01.12 Bisagra 2.5 C01.13 Báscula digital 12

C02.: Materiales para el circuito de amplificación y control del sistema C02.1 PCB 15 C02.2 Fotodiodo 0.2 C02.3 Amplificador Op. UA741 0.4 C0.4 Amplificador Op.

LF353N 0.5

C021.5 Potenciómetro 10K 0.2 C02.6 Resistencias varias 0.2 C02.7 Condensadores 100pF 0.2 C02.8 Conectores + Cables 2 C02.9 Fuente alimentación ATX

DELL N35OP-00 25

C02.10 Arduino Nano ATmega328 27





4220-650kv + hélice 21.20


8.80

C03.3 Afro OPTO ESC 20A 11.75 C03.4 Afro OPTO ESC 12A 8.75 C03.5 Batería Lipo 25


4000mmx30mmx10mm 25


5


2.50

C04.4 Varilla 5mm 1.50 C04.5 Pletina de aluminio

3mmx50mmx400mm 10


plataforma de control 250

C06: Mano de obra C06.1 Horas de investigación 40 C06.2 Horas de diseño 35 C06.3 Horas de montaje 30 C06.4 Horas de programación 35




2. Presupuesto CÓDIGO DESCRIPCIÓN CANTIDAD PRECIO IMPORTE


27mmx27mmx900mm 1 5 5


1 8 8


1 12 12

C01.4 Rodamiento 61800-2RS1 1 8 8 C01.5 Varilla roscada 3mm 1 2.5 2.5 C01.6 Varilla roscada 5mm 1 2.5 2.5 C01.7 Tornillo 10mm 1 2 2 C01.8 Tuerca 3mm 10 0.10 1 C01.9 Tuerca 5mm 10 0.10 1 C01.10 Tuerca 10mm 4 0.20 0.8 C01.11 Tuerca mariposa 5mm 2 0.15 0.3 C01.12 Bisagra 1 2.5 2.5 C01.13 Báscula digital 1 12 12

Total capítulo 57.6

C02.: Materiales para el circuito de amplificación y control del sistema C02.1 PCB 1 15 15 C02.2 Fotodiodo 2 0.2 0.4 C02.3 Amplificador Op. UA741 5 0.4 2 C0.4 Amplificador Op.

LF353N 1 0.5 0.5

C021.5 Potenciómetro 10K 1 0.2 0.2 C02.6 Resistencias varias 17 0.2 3.4 C02.7 Condensadores 100pF 2 0.2 0.4 C02.8 Conectores + Cables 1 2 2 C02.9 Fuente alimentación ATX

DELL N35OP-00 1 25 25

C02.10 Arduino Nano ATmega328

1 27 27






4220-650kv + hélice 1 21.20 21.20


1 8.80 8.80

C03.3 Afro OPTO ESC 20A 1 11.75 11.75 C03.4 Afro OPTO ESC 12A 1 8.75 8.75 C03.5 Batería Lipo 1 25 25



4000mmx30mmx10mm 1 25 25


1 5 5


6 2.50 15

C04.4 Varilla 5mm 1 1.50 1.50 C04.5 Pletina de aluminio

3mmx50mmx400mm 1 10 10



plataforma de control

1 250 250

Total capítulo 250

C06: Mano de obra C06.1 Horas de

investigación 100 40 4000

C06.2 Horas de diseño 25 35 875 C06.3 Horas de

montaje 150 30 4500

C06.4 Horas de programación

125 35 4375

Total capítulo 13750




3. Resumen del presupuesto CAPÍTULO RESUMEN EUROS %

C01 Materiales estructuras cálculo

de fuerzas 57.6 0.40

C02 Materiales circuito electrónico del sistema

75.9 0.53

C03 Materiales para los rotores (conjunto motor-hélice)

75.5 0.53

C04 Materiales para la plataforma de simulación

56.5 0.39

C05 UAV completo 250 1.75 C06 Mano de obra 13750 96.40

TOTAL EJECUCIÓN MATERIAL 14265.5

13% Gastos generales…………………………………………....... 1854.515

6% Beneficio industrial……………………………………………… 855.93

SUMA DE GG Y BI 2710.445

21% De IVA……………………………………………………………….. 3564.85

TOTAL PRESUPUESTO GENERAL 20540.79

Asciende el presupuesto general a la expresada cantidad de VEINTE MIL QUINIENTOS CUARENTA EUROS con SETENTA Y NUEVE CÉNTIMOS.

FIRMADO:

D. Jorge Visa Vidal

Logroño a 7 de Julio de 2016

diseño, desarrollo y construcción de bancos de … · diseño, desarrollo y construcción de...

Documents