2711 Pub

Ayrton Jesús Hernández Casas
Diseño e implementación de un cuadricóptero basado en

Arduino
TRABAJO FINAL DE GRADO
Dirigido por José Luis Ramírez Falo
Grado de Ingeniería Electrónica Industrial y Automática
Tarragona 2020
Diseño e implementación de un Drone
de 4 motores controlado por el microntrolador ARDUINO Ayrton Jesús Hernández Casas
y un dispositivo Android
Índice de figuras
Gráfico 1. Drone en configuración en X ..........................................................................10

Gráfico 2. Drone en configuración en + ...........................................................................10
Gráfico 3. Drone en configuración en H ..........................................................................11
Gráfico 4. Movimientos que puede realizar un Drone ...................................................... 11
Gráfico 5. Explicación del movimiento Guiñada (Yaw)................................................... 12
Gráfico 6. Explicación del movimiento Alabeo (Roll) ..................................................... 12
Gráfico 7. Explicación del movimiento Cabeceo (Pitch) .................................................. 12
Gráfico 8. Explicación del movimiento Altitud (Throttle)................................................ 13
Gráfico 9. Dinámica Alabeo / Cabeceo (I) ....................................................................... 13
Gráfico 10. Dinámica Alabeo / Cabeceo (II).................................................................... 13
Gráfico 11. Sistema automático de control de Lazo Cerrado ............................................ 15
Gráfico 12. Sensor MPU-6050 ........................................................................................ 16
Gráfico 13. Dirección de los ejes X, Y y Z del sensor MPU-6050 ................................... 16
Gráfico 14. Sensor MPU-6050 y sus pines de conexión ................................................... 17
Gráfico 15. Arduino UNO ............................................................................................... 19
Gráfico 16. Arduino UNO con sus pines señalados.......................................................... 20
Gráfico 17. Motor sin escobillas (Brushless) ................................................................... 22
Gráfico 18. Diagrama de un motor brushless trifásico ..................................................... 22
Gráfico 19. Variador Electrónico de Velocidad (ESC) ..................................................... 24
Gráfico 20. Señal PWM para el control de la velocidad de motores Brushless ................. 25
Gráfico 21. Esquema general de un ESC ......................................................................... 26
Gráfico 22. Módulo Bluetooth HC-06 ............................................................................. 27
Gráfico 23. Batería LiPo de 3 celdas ............................................................................... 28
Gráfico 24. Impresión fallida de uno de los brazos del cuadricóptero .............................. 30
Gráfico 25. Impresión fallida de la parte superior de unos de los brazos del cuadricóptero
........................................................................................................................................ 30
Gráfico 26. Vista de planta del extremo del brazo impreso del drone ............................... 30
Gráfico 27. Vista de perfil del extremo del brazo impreso del drone ................................ 31
Gráfico 28. Vista de planta de la base impresa del drone ................................................. 31
Gráfico 29. Vista inferior de la base impresa del drone .................................................... 32
Gráfico 30. Modelo XXX de la impresora utilizada ......................................................... 32
Gráfico 31. Vista de perfil del extremo del brazo del drone ............................................. 34
Gráfico 32. Vista de planta del extremo del brazo del drone ............................................ 34
Gráfico 33. Vista de planta de la base del drone .............................................................. 35
Gráfico 34. Vista inferior de la base del drone ................................................................. 35
Gráfico 35. Piezas del cuadricóptero ............................................................................... 36
Gráfico 36. Chasis armado (Vista de planta) .................................................................... 36
Gráfico 37. Chasis armado (Vista de perfil) SIN componentes ........................................ 37
Gráfico 38. Drone armado ............................................................................................... 37
Gráfico 39. Esquema de conexiones del Drone ................................................................ 38
Gráfico 40. Placa de distribución de potencia del modelo PDB-XT60 ............................. 39
Gráfico 41. Sensor MPU-6050 inclinado con las direcciones de sus aceleraciones ...........41
Gráfico 42. Ángulo de inclinación del sensor MPU-6050 (ejemplo I) .............................. 42
Gráfico 43. Ángulo de inclinación del sensor MPU-6050 (ejemplo II) ............................. 42
Gráfico 44. Esquema del filtro complementario ............................................................... 44
Gráfico 45. Conexión de la placa Arduino con el módulo MPU-6050.............................. 45
1
de 4 motores controlado por el microcontrolador ARDUINO Ayrton Jesús Hernández Casas
Gráfico 46. Estructura de 2 registros contiguos. ............................................................... 46

Gráfico 47. Registros donde se almacenan las aceleraciones en los ejes X, Y, Z leidas por
el sensor ........................................................................................................................... 46
Gráfico 48. Ejemplo de valores almacenados en dos registros. ........................................ 47
Gráfico 49. Operaciones a nivel de bit ............................................................................. 47
Gráfico 50. Registro para la configuración previa del acelerómetro ................................. 48
Gráfico 51. Módulo MPU-6050 inclinado 32 º ................................................................ 49
Gráfico 52. Lectura de las aceleraciones de los ejes X, Y, Z ............................................ 49
Gráfico 53. Velocidades angulares obtenidas por el giroscopio ........................................ 50
Gráfico 54. Obtención de los ángulos de rotación X e Y usando el filtro complementario (I)
........................................................................................................................................ 51
Gráfico 55. Obtención de los ángulos de rotación X e Y usando el filtro complementario (II)
........................................................................................................................................ 52
Gráfico 56. Obtención de los ángulos de rotación X e Y usando el filtro complementario
(III) .................................................................................................................................. 52
Gráfico 57. Señal PWM no calibrada .............................................................................. 53
Gráfico 58. Esquema de conexión del ESC, motor, batería con el Arduino ...................... 54
Gráfico 59. Conexión final resultante para la calibración del ESC y motor brushless ....... 54
Gráfico 60. Esquema de conexión del Arduino con el módulo HC-06 ............................. 56
Gráfico 61. Esquema de conexión general para encender dos leds (Ejemplo)................... 56
Gráfico 62. Esquema de conexión final para encender 2 leds mediante app ..................... 58
Gráfico 63. Esquema de conexión para las pruebas del módulo HC-06 y ESC ................. 59
Gráfico 64. Esquema de conexión final utilizando ambos componentes ESC - HC06 ......61
Gráfico 65. Sistema de control de lazo cerrado con control PID ......................................62
Gráfico 66. Sistema balancín a construir..........................................................................65
Gráfico 67. Base del balancín .......................................................................................... 66
Gráfico 68. Balancín ....................................................................................................... 66
Gráfico 69. Sistema balancín SIN componentes electrónicos (con sus medidas) .............. 67
Gráfico 70. Sistema balancín CON todos los componentes electrónicos .......................... 67
Gráfico 71. Esquema de conexiones del sistema Balancín ............................................... 68
Gráfico 72. Oscilaciones mantenidas de una planta genérica (Ejemplo) ........................... 69
Gráfico 73. Lugar geométrico de las raíces de un sistema de 1er orden ............................ 70
Gráfico 74. Lugar geométrico de las raíces de un sistema de 2do orden ........................... 70
Gráfico 75. Lugar geométrico de las raíces de un sistema de 3er orden ............................ 71
Gráfico 76. Respuesta del sistema balancín para una ganancia de (Kp = 1.3 Ki = 0 Kd= 0)
........................................................................................................................................ 71
........................................................................................................................................ 72
Gráfico 78. Respuesta del sistema balancín para una ganancia de (Kp = 1.3 Ki = 0.009 Kd=
0) ..................................................................................................................................... 73
Gráfico 79. Estudio de la respuesta del sistema balancín para una ganancia de (Kp = 1.3 Ki
= 0.009 Kd = 0)................................................................................................................ 73
0.8) .................................................................................................................................. 74
0.2) .................................................................................................................................. 75
0) ..................................................................................................................................... 75
2
0) ..................................................................................................................................... 76
0) ..................................................................................................................................... 76
........................................................................................................................................ 77
0.1) .................................................................................................................................. 78
0.15) ................................................................................................................................ 78
Gráfico 88. Diagrama de flujo del control PID del sistema balancín ................................ 79
Gráfico 89. Estructura de control del balancín utilizando la app ......................................79
Gráfico 90. Evolución de la respuesta del mpu-6050 en función del valor del mando ......80
Gráfico 91. Registro para despertar el módulo MPU-6050............................................... 81
Gráfico 92. Registro para la configuración de la sensibilidad del giroscopio. ................... 81
Gráfico 93. Registro para la configuración de la sensibilidad del acelerómetro. ............... 81
Gráfico 94. Comportamiento del drone aplicando un controlador proporcional................ 85
Gráfico 95. Relación entre la variación de la ganancia y el valor que toma el error ..........86
Gráfico 96. Comportamiento del drone aplicando un controlador PI ................................ 86
Gráfico 97. Ejemplo de cómo funciona la parte integral .................................................. 87
Gráfico 98. Ejemplo de cómo funciona la parte derivativa ............................................... 87
Gráfico 99. Comportamiento del drone aplicando un controlador PID ............................. 88
Gráfico 100. Posible lazo de realimentación de nuestro sistema drone ............................. 89
Gráfico 101. Dirección de giro correcta de las hélices del drone ......................................90
Gráfico 102. Estrategia de control del modo Acrobático .................................................. 91
Gráfico 103. Estrategia de control del modo Acrobático con la posibilidad de posicionar el
drone a 0º ......................................................................................................................... 92
Gráfico 104. Creación de la señal PWM sincronizada con el lazo de control ................... 93
Gráfico 105. Hélice sin calibrar ....................................................................................... 95
Gráfico 106. Velocidad del motor izquierdo trasero sin haber calibrado su hélice ............ 95
Gráfico 107. Origen de las vibraciones en nuestro sistema .............................................. 96
Gráfico 108. Hélice ya calibrado ..................................................................................... 96
Gráfico 109. Velocidad del motor izquierdo trasero con su hélice calibrada .................... 97
Gráfico 110. Aislamiento del sensor MPU-6050 del frame utilizando goma espuma ....... 98
Gráfico 111. Aislamiento del microcontrolador del frame utilizando goma espuma ......... 98
Gráfico 112. Ejemplo de una señal atenuada por un filtro digital paso bajo...................... 99
Gráfico 113. Configuración del filtro digital paso-bajo, de acuerdo al datasheet del MPU-
6050................................................................................................................................. 99
Gráfico 114. Filtro digitales paso-bajo del acelerómetro y giroscopio respectivamente .. 100
Gráfico 115. Comparación en la lectura de las velocidades angulares sin emplear filtro (izq)
y empleando filtro (der) ................................................................................................. 101
Gráfico 116. Comparación entre la velocidad angular Roll sin filtrar y la filtrada (Filtro
EMA) ............................................................................................................................ 102
Gráfico 117. Filtro EMA: Velocidad del motor sin emplear filtro (izq) y empleando filtro
(der) ............................................................................................................................... 103
Gráfico 118. Efecto “windup” ....................................................................................... 104
Gráfico 119. Técnica antiwindup por limitación del término integral ............................. 105
Gráfico 120. Técnica antiwindup por integración condicional ....................................... 105
Gráfico 121. Banco de pruebas para la sintonización PID del drone .............................. 106
3
Gráfico 122. Velocidad angular del eje pitch (sintonización de Kp) – Prueba I .............. 107
Gráfico 123. Velocidad angular del eje pitch (sintonización de Kp) – Prueba II ............. 108
Gráfico 124. Velocidad angular del eje pitch (sintonización de Kp) – Prueba III ........... 108
Gráfico 125. Velocidad angular del eje pitch (sintonización de Kd) – Prueba I .............. 109
Gráfico 126. Velocidad angular del eje pitch (sintonización de Kd) – Prueba II ............. 110
Gráfico 127. Velocidad angular del eje pitch (sintonización de Kd) – Prueba III ........... 110
Gráfico 128. Velocidad angular del eje pitch (sintonización de Ki) – Prueba I ............... 111
Gráfico 129. Velocidad angular del eje pitch (sintonización de Ki) – Prueba II.............. 111
Gráfico 130. Función inicializar motores del sistema drone ........................................... 113
Gráfico 131. Cálculo de la velocidad angular y aplicación del filtro EMA ..................... 114
Gráfico 132. Filtro EMA expresado mediante código .................................................... 115
Gráfico 133. Algoritmo de control de los motores del sistema drone ............................. 115
Gráfico 134. Función para crear la señal PWM a enviar a los actuadores ....................... 116
Gráfico 135. Interfaz inicial para el desarrollo de una nueva aplicación en Mit App Inventor
...................................................................................................................................... 117
Gráfico 136. Incorporación de la funcionalidad bluetooth a la aplicación (Mit App Inventor)
...................................................................................................................................... 118
Gráfico 137. Ejemplo sobre cómo insertar capas para establecer orden en la aplicación (Mit
App Inventor) ................................................................................................................ 118
Gráfico 138. Diseño final de nuestra app de control del sistema balancín ...................... 119
Gráfico 139. Programación en bloques de nuestra app controladora para el sistema balancín
...................................................................................................................................... 121
Gráfico 140. Descarga de la aplicación en (Mit App Inventor) ...................................... 122
Gráfico 141. Versión final de la app controladora del sistema balancín.......................... 122
Gráfico 142. Diseño final de nuestra app de control del sistema drone ........................... 123
Gráfico 143. Programación en bloques de nuestra app controladora para el sistema drone
(Parte I).......................................................................................................................... 123
Gráfico 144. Programación en bloques de nuestra app controladora para el sistema drone
(Parte II) ........................................................................................................................ 124
Gráfico 145. Versión final de la app controladora del sistema drone .............................. 124
Gráfico 146. Ángulo de inclinación del eje pitch tras recibir comandos de la app .......... 126
Gráfico 147. Velocidad angular del eje pitch tras recibir comandos de la app ................ 127
Gráfico 148. Ángulo de inclinación del eje roll tras recibir comandos de la app............. 127
Gráfico 149. Velocidad angular del eje roll tras recibir comandos de la app .................. 128
4
Índice de tablas
Tabla 1. Características del sensor MPU-6050................................................................. 18

Tabla 2. Características del Arduino UNO....................................................................... 21
Tabla 3. Comparativa entre motores con escobillas y sin escobillas ................................. 23
Tabla 4. Especificaciones del motor sin escobillas a utilizar ............................................ 24
Tabla 5. Especificaciones de los ESC a utilizar ............................................................... 27
Tabla 6. Especificaciones de la batería LiPo adquirida .................................................... 29
Tabla 7. Balance de pesos de los componentes SIN el chasis ...........................................33
Tabla 8. Distribución de pines de los distintos componentes del sistema cuadricóptero ... 39
Tabla 9. Especificaciones de la PDB a utilizar ................................................................. 40
Tabla 10. Distribución de pines para el ejemplo de encender 2 leds utilizando el HC-06 . 57
Tabla 11. Distribución de pines para las pruebas del ESC y módulo HC-06..................... 60
Tabla 12. Distribución de pines de los distintos componentes del sistema Balancín ......... 68
Tabla 13. Tabla de valores para el cálculo de los parámetros P, PI, PD o PID según Ziegler-
Nichols ............................................................................................................................ 69
Tabla 14. Parámetros PID del lazo de velocidad angular................................................ 112
Tabla 15. Parámetros PID del lazo de aceleración. ........................................................ 112
5
Índice
1 Introducción................................................................................................................9
2 Estructura y componentes del Cuadricóptero ............................................................. 10
2.1 Dinámica ...........................................................................................................10
2.2 Mecanismo funcional ......................................................................................... 13
2.2.1 Control Automático .................................................................................... 14
2.3 Descripción de los componentes ........................................................................ 16
2.3.1 El sensor MPU-6050................................................................................... 16
2.3.2 El Microcontrolador Arduino UNO............................................................. 19
2.3.3 Motores sin escobillas (Brushless) .............................................................. 21
2.3.4 Variador Electrónico de Velocidad (ESC) ................................................... 24
2.3.5 Módulo Bluetooth HC-06 ...........................................................................27
2.3.6 Batería LiPo de 3 celdas.............................................................................. 28
2.3.7 El Chasis..................................................................................................... 29
3 Diseño ...................................................................................................................... 33
3.1 Mecánica ...........................................................................................................33
3.1.1 Chasis elegido ............................................................................................. 33
3.1.2 Ensamblaje ................................................................................................. 36
3.2 Electrónica ......................................................................................................... 38
3.2.1 Esquema de las conexiones electrónicas del drone ......................................38
3.2.2 Placa de distribución de potencia (PDB) ..................................................... 39
3.3 Software ............................................................................................................ 41
3.3.1 Inicialización del sensor MPU-6050............................................................ 41
3.3.2 Inicialización del variador electrónico de velocidad (ESC) .......................... 53
3.3.3 Inicialización del módulo Bluetooth HC-06 ................................................ 56
3.3.4 Primeras pruebas con el ESC y el módulo bluetooth HC-06 ........................ 59
3.4 Control PID ....................................................................................................... 62
3.4.1 Teoría ......................................................................................................... 63
3.4.2 Construcción del balancín ...........................................................................65
3.4.3 Sintonización del controlador PID del sistema balancín .............................. 68
3.4.4 Explicación del código PID del Balancín .................................................... 79
3.4.5 Sistema Drone ............................................................................................ 85
3.4.5.1 Efectos de un controlador PID en un drone ..........................................85
3.4.5.2 Descripción del problema .................................................................... 89
3.4.5.3 Descripción de la solución ................................................................... 91
6
3.4.5.4 Las vibraciones (ruido) ........................................................................ 94

3.4.5.5 Sintonización PID .............................................................................. 103
3.4.5.6 Explicación del código del sistema drone ........................................... 112
3.5 Controladora de Vuelo (App Android) ............................................................. 117
3.5.1 Desarrollo del módulo controlador del sistema balancín ............................ 117
3.5.2 Desarrollo del módulo controlador del sistema drone ................................ 123
4 Resultados .............................................................................................................. 126
5 Conclusiones........................................................................................................... 129
6 Bibliografia ............................................................................................................. 131
6.1 Lista de referencias de las imágenes ................................................................. 133
6.2 Lista de referencias de las tablas ...................................................................... 140
7 Anexos ................................................................................................................... 141
7.2 Código del control del sistema balancín ........................................................... 141
7.2.1 Programa principal.................................................................................... 141
7.2.2 Función inicializadora del MPU-6050 ....................................................... 145
7.2.3 Función inicializadora de los motores ....................................................... 145
7.2.4 Función calibración del giroscopio ............................................................ 146
7.2.5 Función calibración del acelerómetro ........................................................ 146
7.2.6 Función para la lectura de datos sin procesar del MPU-6050 ..................... 147
7.2.7 Función para el cálculo del ángulo de inclinación ..................................... 147
7.2.8 Función filtro complementario .................................................................. 148
7.2.9 Función mapear valores ............................................................................ 148
7.2.10 Función lectura de datos bluetooth ............................................................ 149
7.2.11 Función PID ............................................................................................. 150
7.2.12 Actuador del sistema ................................................................................. 151
7.3 Código para el cuadricóptero ........................................................................... 152
7.3.1 Programa principal.................................................................................... 152
7.3.2 Función mostrar leyenda ........................................................................... 158
7.3.3 Función inicializadora de los motores ....................................................... 160
7.3.4 Función contar tiempo .............................................................................. 161
7.3.5 Función calcular ángulo ............................................................................ 161
7.3.6 Función lectura de las velocidades angulares ............................................ 162
7.3.7 Función filtro paso bajo (EMA) ................................................................ 162
7.3.8 Función lectura de datos bluetooth ............................................................ 163
7.3.9 Función actualizar consignas..................................................................... 166
7.3.10 Funciones PID .......................................................................................... 166
7
7.3.11 Actuador del sistema ................................................................................. 170

7.3.12 Función crear señal PWM ......................................................................... 173
7.3.13 Función crear flanco alto/bajo (PWM) ...................................................... 174
7.3.14 Función actualizar velocidad del motor ..................................................... 175
7.3.15 Función bajar flanco PWM ....................................................................... 175
7.3.16 Función para visualizar las variables ......................................................... 175
7.3.17 Funciones relacionadas con la visualización de datos ................................ 178
7.3.18 Función apagar constantes Ki.................................................................... 180
8
1 Introducción
Con el pasar de los años, y gracias al continuo avance en el campo de la electrónica,

se ha estado popularizando un término que probablemente ya es conocido por la gran
mayoría, y es el drone. Oficialmente, el drone recibe el nombre de VANT, que viene del
acrónimo en Español Vehículos Aéreos No Tripulados, aunque en inglés recibe el nombre
de UAV, por sus siglas Unmanned Aerial Vehicle. (Wikipedia, Sin fecha).
A pesar de la gran variedad de nombres que este dispositivo aerodinámico recibe, se
está refiriendo a un mismo concepto. Lo más característico que tienen los drones es el hecho
de poder pilotarlos desde un lugar remoto. Esto es posible gracias al hecho de que la
información (aceleración, altitud, visión, entre otros) que tendría el piloto en cuestión si
estuviese dentro de la aeronave se puede conseguir a través de sensores electrónicos
integrados en ella, lo que se traduce en una gran ventaja en el aspecto económico y de la
seguridad de la persona que esté controlando el drone, al no encontrarse físicamente dentro
del mismo.
Existen diversos tipos de drones dentro del mercado, unos mejores que otros
(explicado más adelante). Sin embargo, hay uno por el cual hemos tenido predilección
debido a la gran estabilidad y maniobrabilidad que éste tiene, (además de la posibilidad de
su construcción casera), y es el quadcopter. Se caracteriza por disponer de 4 motores. Estos
4 motores se encuentran equidistantes horizontalmente desde el centro, y dispuestos de
varias maneras. Entre las más comunes, están las de en forma de “+”, “X” o “H”. No
obstante, para poder conseguir esta estabilidad y maniobrabilidad, es necesario que exista un
“método” automático (sin necesidad de intervención humana) que asegure que el drone vuele
de manera estable y que no se estrelle. Es aquí donde entra el concepto de control
automático, muy importante para poder pilotar dispositivos a control remoto.
Los principales objetivos del presente proyecto son, en primer lugar, realizar un
algoritmo de control que le permita al drone mantenerse estable en el aire de manera
automática y, en segundo lugar, desarrollar y diseñar una app Android con la finalidad de
establecer una comunicación a distancia vía Bluetooth entre el cuadricóptero y el dispositivo
móvil.
La memoria va a estar dividida en 3 partes principales:
1era parte (Estructura y componentes del quadcopter): Introduciremos los
distintos tipos de cuadricóptero, explicaremos su funcionamiento y
detallaremos los distintos componentes mecánicos y electrónicos que lo
conforman.
2da parte (Diseño): Trataremos el montaje del chasis estructural donde todos
los dispositivos estarán ensamblados y alojados. Además, describiremos las
distintas conexiones entre los componentes que conforman el cuadricóptero,
así como también describiremos la placa PDB donde están conectados los
cuatro variadores electrónicos de velocidad (ESC). Finalmente,
desarrollaremos no sólo la programación del algoritmo de control de nuestro
drone y de un sistema balancín, sino que también describiremos el proceso de
diseñar la interfaz de nuestra app Android.
9
3era parte (Resultados y conclusiones): Finalizaremos mostrando los

resultados conseguidos y comentaremos si se han cumplido los objetivos
propuestos.
2 Estructura y componentes del Cuadricóptero
2.1 Dinámica
Como bien se mencionó anteriormente, el quadcopter (o cuadricóptero) es un drone

con 4 motores distribuidos a la misma distancia partiendo del centro. Dependiendo de la
forma del chasis y de los motores, existen diferente configuraciones. A continuación,
mostraremos algunos ejemplares.
Gráfico 1. Drone en configuración en X
Gráfico 2. Drone en configuración en +
10
Gráfico 3. Drone en configuración en H
Ahora bien, para el correcto manejo del drone, es importante primero comprender
cuáles son los principales movimientos que el mismo puede realizar. Estos movimientos son
los siguientes: Guiñada (Yaw), Alabeo (Roll), Cabeceo (Pitch) y Altitud (Throttle). A
continuación, procederemos a explicar cada uno de ellos.
Gráfico 4. Movimientos que puede realizar un drone
Guiñada (Yaw): Corresponde a la rotación en el sentido contrario (o no) de

las agujas del reloj con respecto al eje vertical perpendicular al drone. En
los cuadricópteros, este movimiento se consigue al hacer girar los 2 rotores
en un sentido y los otros 2 rotores en otro sentido; si se desea hacer girar el
drone en el sentido contrario de las agujas del reloj, 2 de estos rotores han de
estar girando más rápido en este sentido (contrario a las agujas del reloj) que
los otros 2 rotores (que seguirán girando en el sentido contrario que las
anteriores). (Quadcopters | Drone Flyers, 2015)
11
Gráfico 5. Explicación del movimiento Guiñada (Yaw)
Alabeo (Roll): Corresponde al movimiento hacia la izquierda o hacia la

derecha con respecto al eje longitudinal del drone. Para conseguir este
movimiento, lo que debemos hacer es hacer girar los pares opuestos de los
motores a distintas velocidades; si se desea girarlo hacia la izquierda, los 2
rotores que se encuentran en el lado derecho deben girar más rápido que los
rotores del lado izquierdo, y si se desea girarlo hacia la derecha, los 2 rotores
que se encuentran en el lado izquierdo deben girar más rápido que los rotores
del lado derecho. (Quadcopters | Drone Flyers, 2015)
Gráfico 6. Explicación del movimiento Alabeo (Roll)
Cabeceo (Pitch): Corresponde a la rotación hacia adelante o hacia atrás con

respecto al eje transversal del drone. Para conseguir este movimiento, se
procede a realizarlo de la misma manera con que conseguimos efectuar el
alabeo, pero con la diferencia de que los rotores que girarán más rápidos que
los otros estarán separados por el eje transversal del drone y no longitudinal
(como ocurre con el alabeo). A continuación, se adjunta una imagen para
mayor comprensión. (Quadcopters | Drone Flyers, 2015)
Gráfico 7. Explicación del movimiento Cabeceo (Pitch)
Altitud (Throttle): Corresponde al movimiento hacia arriba o hacia abajo

(elevación en vertical) del drone. Para conseguir que el drone ascienda,
deberemos incrementar la velocidad de giro de todos los motores, y para
hacer que descienda, debemos reducir suavemente la velocidad de giro de los
motores.
12
Gráfico 8. Explicación del movimiento Altitud (Throttle)
Por otra parte, como se ha podido observar en las imágenes anteriores, un rotor gira
en el mismo sentido que su homólogo ubicado en el extremo opuesto, y lo mismo ocurre
para el otro par. Esta disposición de los motores se encuentra en cualquier tipo de
configuración de cuadricóptero. Si los motores no estuviesen dispuestos de esta manera, el
drone empezaría a girar sobre sí mismo y dificultaría su control.
En resumen, para conseguir que el drone se desplace hacia una dirección (izquierda,
derecha, arriba o abajo), debemos hacer girar 2 rotores del mismo bando más rápido que los
otros 2 con respecto al eje longitudinal o transversal (según hacia donde se desee desplazar).
Esto es debido a que cuando comenzamos a girar varios motores con distintas velocidad de
giro, se consigue desestabilizar la posición de equilibrio horizontal que previamente tenía el
drone cuando sus motores giraban a la misma velocidad, creándose una fuerza con dirección
hacia arriba en el bando donde los motores giran más rápido.
Gráfico 9. Dinámica Alabeo / Cabeceo (I)
Nota: Azul: Velocidad normal, Naranja: Alta velocidad
Gráfico 10. Dinámica Alabeo / Cabeceo (II)
2.2 Mecanismo funcional
Una vez que se ha visto cómo el cuadricóptero logra moverse y desplazarse en la

dirección que deseemos, es importante también conocer la manera en cómo todos sus
componentes (mecánicos y eléctricos) trabajan en conjunto y se relacionan entre ellos.
Como bien sabemos hasta este punto, los 4 motores que se ubican en cada uno de los
extremos del drone son los que hacen posible la elevación del mismo. Sin embargo, estos 4
motores son trifásicos (brushless) y necesitan de corriente alterna (AC) para poder funcionar.
La batería que se usará proporciona corriente continua (DC), por lo que se debe utilizar un
ítem aparte el cual proporcione corriente alterna para el funcionamiento de estos motores.
13
Es aquí donde entran en juego los ESC: Electronic Speed Controller, Control Electrónico
de Velocidad, o también conocido como Variador Electrónico de Velocidad.
De manera muy resumida, los ESC se encargan de controlar la velocidad, y con ello,
la dirección del drone. No obstante, debe haber un componente o aparato cuya función sea
la de transmitir la información adecuada a estos variadores de velocidad, y así poder
conseguir la estabilidad deseada del vuelo; entrando en juego la Placa procesadora.
Para que la placa procesadora le envíe la información adecuada a los variadores
electrónicos de velocidad, es necesario que la placa reciba datos de entrada, es decir,
información del exterior. Los dispositivos que se encargan de recibir esta información son
llamados sensores. En otras palabras, los sensores son los responsables de captar los datos
del mundo externo que los rodea. En el cuadricóptero, nuestro único sensor será el MPU-
6050, el cual a su vez incluye 2 sensores integrados; acelerómetro y giroscopio (se describirá
más adelante).
Ahora bien, es importante remarcar que estos datos de entrada que recopilará el
sensor MPU-6050 no será la única información que recibirá la placa procesadora, sino que
también recibirá información del control manual. Como su nombre lo indica, este
componente será el responsable de poder controlar el vuelo del drone a través de una app
diseñada por nosotros en un dispositivo Android. Y, como este control debe ser de manera
remota (inalámbrica), hace falta la presencia de otro dispositivo que se encargue de
comunicar esta app con la placa procesadora. Es aquí donde entra en juego el módulo de
comunicaciones inalámbrico, el cual utilizará un módulo Bluetooth HC-06 (se describirá
más adelante). Todos estos dispositivos electrónicos serán alimentados por una batería.
Sin embargo, para que todos estos componentes en conjunto consigan la elevación,
el control, la estabilidad y la maniobrabilidad del drone, se debe recurrir a un algoritmo o
sistema automático de control que garantice que el mismo no se llegue a estrellar, y es aquí
donde entra el concepto de control automático.
2.2.1 Control Automático
Un sistema automático de control es un conjunto de componentes físicos conectados

o relacionados entre ellos que realiza la regulación de procesos sin la intervención humana.
(Blog de Recursos para Tecnología en Enseñanza Secundaria, Sin fecha). Los componentes
principales de un control automático son los siguientes:
El sensor o captador: Es el instrumento encargado de captar la información
externa en donde se encuentra. En nuestro sistema, dicho sensor es el MPU-
6050, cuya función es medir la aceleración y la velocidad angular.
El controlador: Es el dispositivo encargado de evaluar y procesar la señal de

error. Esta señal de error no es más que la diferencia entre una señal de
referencia y la señal captada por el sensor previamente. Además, el
controlador también será el responsable de decirle a los actuadores qué hacer
para corregir o minimizar esta señal de error. En nuestro sistema, el
controlador será el microcontrolador Arduino Uno.
14
Actuador: Es el elemento que recibe la orden del controlador, y en función

de ella, activa un elemento final de control. En nuestro sistema, los actuadores
serán los variadores electrónicos de velocidad (ESC) junto con los 4 motores
sin escobillas.
Planta: Es el sistema sobre el que se pretende actuar o aplicar el control.

Nuestro sistema en sí será el drone junto con todos los componentes que lo
conforman.
A continuación, se muestra un diagrama de bloques de un sistema de control

automático de lazo cerrado en donde interactúan todos estos elementos.
Gráfico 11. Sistema automático de control de Lazo Cerrado
Como bien se ha mencionado anteriormente, el sensor será el MPU-6050. Este

dispositivo es capaz de medir la velocidad angular y la aceleración en sus tres componentes
X, Y y Z. La información recabada por este módulo es la que analizará el controlador y, en
función de su análisis, procederá a actuar de una manera u otra.
El controlador es el elemento que determina el comportamiento del bucle, por lo que
podría decirse que es el cerebro del sistema. Mientras que la señal de error se mantenga en
los márgenes previstos, el controlador no ejercerá un control sobre el elemento actuador. Sin
embargo, si la señal de error se aleja del valor prefijado, el controlador modifica su señal
(variación en la alimentación) y les ordena a los actuadores que efectúen su acción sobre la
planta con tal de minimizar esta señal de error. Esta señal de error es la que aleja al sistema
de ser estable.
Ahora bien, hay muchos tipos de controladores. Entre los más comunes, están los del
tipo manual, neumático o electrónico. El que usaremos en nuestro sistema es del tipo
electrónico; los microcontroladores (PIC).
Con tal de conseguir que un sistema alcance la estabilidad, por lo general, se suele
utilizar un controlador PID, cuyas siglas significan: Proporcional, Integral y Derivativo. La
definición del mismo, utilidad, así como sus características, se describen más adelante en el
apartado de Diseño del Controlador PID.
15
2.3 Descripción de los componentes
A continuación, se procederá a describir los distintos componentes que conforman el

cuadricóptero teniendo en cuenta sus características principales y las funciones que deben
cumplir.
2.3.1 El sensor MPU-6050
Se trata de una unidad de medición inercial que combina un acelerómetro de 3 ejes y

un giroscopio de 3 ejes, por lo tanto, lo convierten en un dispositivo de medida inercial de 6
grados de libertad. (Robologs, 2014).
La dirección de los ejes X, Y y Z está indicado en el propio módulo, como se puede
observar en la figura 13.
Gráfico 12. Sensor MPU-6050
Gráfico 13. Dirección de los ejes X, Y y Z del sensor MPU-6050
El sensor acelerómetro mide la aceleración en las tres dimensiones del espacio; X, Y

y Z. Debido a que la única fuerza que actúa sobre el sensor es la fuerza de gravedad, los
valores que se obtienen de los componentes de este sensor corresponden a la de la gravedad.
Por trigonometría, se obtienen los ángulos de inclinación respecto al eje X y al eje Y.
(Llamas, CÓMO USAR UN ACELERÓMETRO EN NUESTROS PROYECTOS DE
ARDUINO, 2016).
16
𝑦
𝜃𝑋 = tan−1 ( ) (1)
√𝑥 2 + 𝑧 2
𝑥
𝜃𝑌 = tan−1 ( )
√𝑦 2 + 𝑧 2 (2)
En cuanto al ángulo con respecto al eje Z, se necesitaría de otro componente llamado

magnetómetro, que es un tipo de brújula digital. (Aprendiendo arduino, 2016). Sin embargo,
para nuestro sistema, conocer los grados de inclinación de los ejes X e Y será suficiente para
el control de estabilidad.
Por otro lado, el sensor giroscopio mide la velocidad angular del dispositivo en las
tres dimensiones; X, Y, Z. Para el cálculo del ángulo de rotación actual, es necesario conocer
el ángulo inicial en que se encuentra el dispositivo e integrar la velocidad que éste lleva.
(Naylamp Mechatronics, 2016). Su fórmula es la siguiente:
𝜃𝑋 = 𝜃𝑋 𝐴𝑛𝑡𝑒𝑟𝑖𝑜𝑟 + 𝜔𝑋 ∙ ∆𝑡 (3)
𝜃𝑌 = 𝜃𝑌 𝐴𝑛𝑡𝑒𝑟𝑖𝑜𝑟 + 𝜔𝑌 ∙ ∆𝑡 (4)
Donde:
𝜃𝑋 es el ángulo que gira el eje X sobre su propio eje.
𝜃𝑋 𝐴𝑛𝑡𝑒𝑟𝑖𝑜𝑟 es el ángulo calculado en la última llamada a esta fórmula.
𝜔𝑋 es la lectura actual del giroscopio del ángulo X.
∆𝑡 es el tiempo que transcurre cada vez que es llamada la fórmula.
Ahora bien, el módulo MPU-6050 cuenta con 8 pines que pasarán a describirse a
continuación:
Gráfico 14. Sensor MPU-6050 y sus pines de conexión
VCC: Entrada de alimentación de 5 V, a pesar de que el dispositivo trabaja

realmente con un voltaje de operación de 3.3 V, internamente este sensor
17
cuenta con un regulador de voltaje que le permita operar a ese nivel de

tensión.
GND: Conexión a tierra.
SCL (Serial Clock) y SDA (Serial Data). Estos dos pines son utilizados para
la interfaz de comunicación I2C. Este protocolo de comunicación permite al
módulo trabajar como maestro (master) y comunicarse con otros dispositivos
que trabajen como esclavos (slaves). A través de un bus de 2 líneas (los pines
SCL y SDA), se efectúa dicha comunicación entre el módulo maestro y el
dispositivo esclavo donde la información es enviada por medio del serial
data.
Para cada dispositivo externo a comunicarse, debe existir una
dirección específica (representado a través del pin ADO, explicado más
adelante) por la cual el módulo maestro se comunicará con el esclavo.
XDA (Auxiliary Data) y XCL (Auxiliary Clock): Estos dos pines también se
utilizan para el protocolo de comunicación I2C pero con sensores externos,
como los magnetómetros o los barómetros.
ADO: Este pin permite direccionar al dispositivo. Al encontrarse en nivel

bajo (LOW), se le direcciona el número 0x68, mientras que si se encuentra a
nivel alto (HIGH), se le direcciona el 0x69. Por defecto, el sensor cuenta con
la dirección de 0x68 al disponer de una resistencia conectada a tierra en este
pin.
INT (Interruption): Este pin se encarga de generar interrupciones. En el caso

de que el sensor se encuentre conectado a una placa controladora (como el
Arduino) y que a su vez se esté utilizando el pin INT, el microcontrolador
dejará de realizar las funciones que está haciendo para atender a la petición
de interrupción del módulo para la interpretación y procesamiento de los
nuevos datos de lectura que el mismo tiene.
Cabe destacar el hecho de que el MPU-6050 también incluye un procesador interno
DMP (Digital Motion Processor), cuyas siglas en español significan Procesador digital de
movimientos, el cual se encarga de ejecutar complejos algoritmos de captura de movimiento.
A continuación, se adjunta la tabla de características del módulo MPU-6050. (García V. ,
2015).
Voltaje de entrada 3.3 V ~ 5 V
Consumo de corriente 3.5 mA
Sensibilidad del giroscopio ±250, ±500, ±1000, y ±2000 grados/segundos
(Rango de escala programable)
Sensibilidad del acelerómetro ±2g, ±4g, ±8g y ±16g
(Rango de escala programable)
Convertidor AD de 16 bits SI
Protocolo de comunicación I2C y SPI
Tabla 1. Características del sensor MPU-6050
18
Por último, es importante tener en cuenta de que el módulo MPU-6050 es susceptible

a los ruidos e interferencias, por lo que es menester el uso de un filtro que ayude a minimizar
este ruido y no cause alteraciones en las medidas. La definición, el tipo y el uso del filtro se
describirán más adelante en el apartado de Inicialización del sensor MPU-6050 y en el
apartado de Las vibraciones (Control PID).
2.3.2 El Microcontrolador Arduino UNO
Es una placa electrónica de código abierto basado en el microchip ATmega328P.

Cuenta con 14 entradas / salidas digitales, de las cuales 6 se pueden utilizar como salidas
PWM (Modulación por ancho de pulsos) y otras 6 son entradas analógicas. Puede ser
alimentado vía conexión USB, o bien mediante una fuente externa con dos posibles
alternativas; mediante una fuente fija de 5 V o una fuente variable. Es recomendable que el
voltaje de entrada se encuentre entre los 7 ~ 12 V según su hoja de datos. (Jadiaz, 2016).
Gráfico 15. Arduino UNO
Ahora bien, la manera en que se consigue adjudicar un determinado pin ya sea como
entrada o como salida es mediante el comando de programación pinMode(). Para la lectura
de datos, se utiliza la función digitalRead() y para la escritura se utiliza la función
digitalWrite(). (Jadiaz, 2016).
Cada pin posee un tensión de salida de 5 V y tienen una resistencia pull-up de 20
hasta 50 kilo ohms que están desactivadas por defecto. Pero que, sin embargo, pueden
activarse con la función de digitalWrite() con un valor de HIGH o LOW respectivamente
siempre y cuando dicho pin está configurado como entrada. La corriente máxima de salida
es de 40 mA.
Además, algunos pines tienen funciones específicas que pasarán a ser descritos a
continuación.
19
Gráfico 16. Arduino UNO con sus pines señalados
Descripción de los pines digitales
Puertos de comunicación serial: 0 (RX) y 1 (TX). En donde el pin 0 es

utilizado para recibir y el pin 1 para transmitir datos del tipo serie TTL.
Interruptores externos: 2 y 3. Estas terminales pueden ser configuradas para

que una interrupción se “dispare” ya sea con un valor bajo, un pulso de subida
o bajada, o un cambio de valor. Esto se consigue mediante el comando de
programación attachInterrupt().
PWM (Pulse Width Modulation): 3, 5, 6, 9, 10 y 11. Estos pines proporcionan

una señal de salida del tipo PWM de 8 bits con la función analogWrite().
SPI: 0 (SS), 11 (MOSI), 12 (MISO), 13 (SCK). Estas terminales soportan

comunicación SPI.
Descripción de los pines analógicos

Los pines de entrada analógicos soportan conversiones analógico-digital
(Conversor ADC) con una resolución de 10 bits (hasta 1024 valores)
utilizando la función analogRead(). Los pines analógicos son: A0, A1, A2,
A3, A4, A5. Además, estos pines también pueden usarse como pines
digitales.
I2C: 4 (SDA) y 5 (SCL). Estos pines (A4 y A5) soportan comunicaciones

del tipo I2C mediante la librería Wire.h. Mediante este protocolo de
comunicación se logrará comunicar con el módulo sensor MPU-6050.
Descripción de los pines de alimentación
VIN: Es el voltaje de entrada al microcontrolador cuando se está utilizando
una fuente de alimentación externa.
20
5 V: Es la alimentación regulada para alimentar otros componentes de la

placa.
3V3: Este pin proporciona 3.3 V.
GND: Son los pines de tierra.

Descripción de otros pines
AREF: Es la referencia de voltaje para las entradas analógicas, esto se
consigue mediante la función analogReference().
RESET: Se utiliza para resetear el microcontrolador.

A continuación, se adjunta la tabla de características del microcontrolador Arduino
UNO.
Microcontrolador ATmega328
Voltaje de entrada recomendado 7 V ~ 12 V
Voltaje de entrada (límites) 6 V ~ 20 V
Voltaje pines I/O 5V
Corriente DC por pin de I/O 40 mA
Corriente DC para el pin 3V3 50 mA
Pines I/O digitales 14 (6 con salida PWM)
Pines analógicos 6
Memoria FLASH 32 kB
SRAM 2 kB
EEPROM 1 kB
Clock speed 16 MHz
Tabla 2. Características del Arduino UNO
2.3.3 Motores sin escobillas (Brushless)
Se tratan de motores eléctricos en la que su estator y rotor están formados por

bobinados de cobre. El rotor resulta ser la parte móvil en donde están situados los imanes
permanentes, y el estator (o carcasa) es la parte fija en donde están dispuestos los bobinados
del hilo conductor. (ACLAV, 2017).
Cuando la corriente alterna recorre por los bobinados de la carcasa, se generan
campos electromagnéticos de manera secuencial en los bobinados. Los mismos proceden a
interactuar con el campo magnético que es creado por los imanes permanentes del rotor,
produciendo una fuerza que provoca los giros en el rotor, y por ende, el eje del motor también
llega a girar. (ACLAV, 2017).
21
Gráfico 17. Motor sin escobillas (Brushless)
Para la alimentación de este tipo de motores se suele utilizar corriente alterna

(trifásica). Sin embargo, la batería que alimentará todos los componentes electrónicos del
drone proporciona corriente continua, por lo que se debe utilizar un dispositivo aparte el cual
proporcione corriente alterna para el funcionamiento de estos motores, y es aquí donde
entran en juego los ESC, (dispositivo descrito más adelante).
A continuación, se adjunta el esquema general de un motor brushless trifásico:
Gráfico 18. Diagrama de un motor brushless trifásico
El motor internamente posee un número múltiplo de 3 bobinas distribuidas de forma

equidistantes entre sí alrededor del perímetro del motor. Al pasar corriente por estas bobinas,
se creará un campo magnético del mismo sentido de la corriente. Alternando los sentidos de
la corriente que circula a través de las bobinas se consigue alternar las polaridades de los
campos eléctricos creados, y, por ende, se consigue obtener polos opuestos entre las bobinas
y los imanes en ciertos momentos deseados. (ELECTRONOOBS, 2016).
Para que el eje del motor gire, la corriente debe circular a través de dos bobinas de
manera que se cree un campo magnético opuesto al campo de los imanes. Sin embargo, para
que el eje continúe girando, la corriente ahora deberá circular a través de otras bobinas de
22
tal manera de que se cree otro campo magnético que sea opuesto al campo creado por los
imanes, empujando al eje para que éste continúe girando, y así sucesivamente.
En otras palabras, el motor brushless trifásico debe ser alimentado siguiendo una
cierta secuencia de los sentidos que tomará la corriente al circular a través de las bobinas del
motor. El dispositivo (ESC) es la que se encargará de alimentar al motor en la secuencia
correcta.
Una de las principales razones por las que se optó por este tipo de motor es que
carecen de escobillas, por lo que no tiene las desventajas del rozamiento y del consecuente
desgaste que estas producen. Otras de las ventajas que tienen estos motores brushless frente
a los que tienen escobillas son su elevada velocidad de giro y su potencia. Esto no ocurre en
los motores con escobillas, ya que al aumentar la velocidad estas provocan fricción, y por
tanto, disminuye el par motor. (Compañía Levantina de Reductores, S.f).
Ahora bien, uno de los criterios más importantes que se debe de tener presente a la
hora de adquirir estos motores es su empuje.
El empuje es la fuerza con que cada motor ejerce sobre el drone para elevarlo.
(Roberto, S.f). En el caso de un cuadricóptero, la fuerza necesaria para hacerlo elevar vendrá
representada por la suma del empuje de los cuatro motores en conjunto.
Para el tipo de motor que se ha adquirido, éste contiene un empuje de 885 gramos
cada uno, el cual el empuje total resulta ser de 3540 gramos. Esto quiere decir que los
motores serán capaces de levantar un peso total de 3540 gramos. En la etapa de Diseño,
apartado de Mecánica, se trata esta temática con más profundidad (pág 33).
A continuación, se procederá a visualizar dos tablas; una primera tabla en la que se
realizará la comparativa entre los motores con escobillas y sin escobillas, y una segunda
tabla en donde se mostrarán las características más relevantes del tipo de motor Brushless
adquirido.
Características Motor con escobillas Motor sin escobillas
Ciclo de vida Menor Mayor
Precio Económico Caro
Rendimiento Menor Mayor
Rango de velocidad Bajo Alto
Necesidad de control
electrónico NO SI
Necesidad de
Mantenimiento continuo SI NO
Tabla 3. Comparativa entre motores con escobillas y sin escobillas
Modelo A2212/13 T
KV (RPM/Volt) 1000 KV
Batería ideal para funcionar 2 ~ 3 celdas
Máxima eficiencia de corriente 4 ~ 10 A (>75%)
Corriente máxima 12 A / 60 segundos
Número de Polos 14
Máxima Eficacia 80 %
23
Empuje 885 g
Resistencia interna 0.090 ohms
Peso 53 g
Diámetro del eje 3.17 mm
Largo 40 mm
Anchura 27.7 mm
Tabla 4. Especificaciones del motor sin escobillas a utilizar
2.3.4 Variador Electrónico de Velocidad (ESC)
Los variadores electrónicos de velocidad, (en inglés; Electronic Speed Controller,

ESC), son unos componentes electrónicos utilizados para regular la velocidad de giro de los
motores eléctricos sin escobillas mediante la generación de pulsos. (Inquietum Natura,
2017).
Como se ha comentado con anterioridad, los motores Brushless adquiridos necesitan
de corriente alterna para poder operar, y la batería a utilizar proporciona corriente continua.
Esta es la razón del por qué se utilizan estos variadores electrónicos de velocidad, ya que no
sólo permiten regular la velocidad de giro de estos motores, sino que también convierten la
tensión continua de la batería en una fuente de tensión variable y apta para su alimentación,
generando la secuencia de activación o desactivación de las entradas al motor.
(ELECTRONOOBS, 2016).
Gráfico 19. Variador Electrónico de Velocidad (ESC)
Como se puede observar en la imagen, el ESC se compone de las siguientes partes:

Cable rojo y negro (lado izquierdo): Se conectan directamente a la batería.
Tres cables negros (lado derecho): Son los 3 cables de trifásica y van
conectados al motor para proveerle de los pulsos necesarios, (generados por
la placa controladora), para hacerlo girar.
24
Conector con cabezal de 3 cables (lado izquierdo): Corresponden al cabezal

de recepción de pulsos desde la placa controladora para posteriormente
proveérselos al motor brushless.
En general, los variadores electrónicos de velocidad son controlados mediante la

modulación de ancho de pulsos (Pulse Width Modulation), o conocido también por sus siglas
en inglés como PWM.
La modulación de ancho de pulsos de una señal es una técnica en la que se modifica
el ciclo de trabajo de una señal periódica, con la finalidad de controlar la cantidad de energía
que se envía a una carga. (facilelectro, 2019).
La placa controladora será la responsable de generar esta señal PWM a una
determinada frecuencia y ancho de pulso con la finalidad de poder controlar la velocidad de
giro del motor.
El ancho de pulso (que es el tiempo el cual la señal está a nivel alto) debe de variar
dentro del rango de los 1 a 2 milisegundos, para así obtener una correcta variación en la
velocidad de giro del motor.
En caso de que el ancho de pulso sea de:
1 ms: el motor se encontrará parado.
1.5 ms: el motor funcionará a mitad de su potencia.
2 ms: el motor funcionará al 100 % de su potencia.
Gráfico 20. Señal PWM para el control de la velocidad de motores Brushless
25
De manera muy resumida se procederá a explicar, en primer lugar, el proceso previo

que ocurre antes de que el variador electrónico de velocidad ejerza su función, y, en segundo
lugar, cuando ya el ESC está listo para ejercerlo.
1) Una vez que la persona ya haya realizado una acción en el mando de control
del drone, la placa controladora recibirá dichos datos de manera inalámbrica
(mediante el módulo de comunicaciones Bluetooth, explicado más a detalle
en el siguiente apartado).
2) La placa procederá a enviar los datos calculados en función de la posición del

drone y en función de la comanda elegida a realizar por parte del usuario. La
información de estos datos viajará por medio del conector hasta el ESC.
Una vez que la información llega al ESC:
3) El variador demandará la energía necesaria a la batería por medio de sus

cables de conexión.
4) Ocurre la traducción a pulsos dentro del variador, y luego se le transmiten al

motor por medio de los 3 conectores negros.
5) El motor finalmente se mueve.
Como bien se ha mencionado en el apartado de Motores sin escobillas (Brushless),

el motor posee tres fases (o tres entradas) que deben ser conmutadas siguiendo una cierta
secuencia para mantener al eje girando. Es aquí donde entra en juego el variador electrónico
de velocidad.
A continuación, se adjunta el esquema general de un ESC:
Gráfico 21. Esquema general de un ESC
26
Como puede observarse en la imagen, el ESC cuenta con 6 transistores del tipo
MOSFET. Estos transistores actúan como interruptores que se abren cuando se aplica la
tensión necesaria en sus puertas. A través de estos transistores, se conseguirá controlar el
movimiento y la velocidad de giro del motor Brushless activando los 2 MOSFETs
apropiados para crear el campo magnético rotatorio y que, de esta manera, el motor logre
girar. Sin embargo, procederemos a explicar el proceso de activación de los variadores ESC
y motores en la sección de Inicialización del variador electrónico de velocidad ESC.
Para saber qué tipo de variador debemos elegir para nuestros motores Brushless, se
debe tener en cuenta un factor muy importante y es el: nivel de amperaje o intensidad
eléctrica soportada por los variadores. Estos variadores indican en una etiqueta la cantidad
de amperios que son capaces de soportar. Es importante que los ESC a utilizar admitan más
amperaje del que los motores puedan llegar a utilizar en su máxima potencia. A continuación,
se adjunta la tabla de características de los ESC a utilizar.
Tensión de entrada Batería LiPo 2~6 S
Máxima corriente de salida 20 A
Presencia de UBEC NO
Peso (incluyendo cables) ~6g
Dimensiones 24.5 x 12.5 x 3mm
Tabla 5. Especificaciones de los ESC a utilizar
2.3.5 Módulo Bluetooth HC-06
El dispositivo HC-06 se trata de un pequeño módulo de comunicaciones inalámbrica

capaz de transmitir y recibir datos a través de tecnología Bluetooth. Es el módulo de
comunicaciones a utilizar en nuestro sistema.
Gráfico 22. Módulo Bluetooth HC-06
Solo puede ser configurado como esclavo, y es de hecho el rol que va a tomar, ya que
se encargará de hacer cumplir las órdenes que reciba desde el dispositivo Android, el cual
actuará como maestro. Dispone de 4 pines de conexión, los cuales se describirán brevemente
a continuación:
VCC: Es la conexión a la alimentación, tiene un rango de operación entre los
3.3V ~ 5 V.
27
GND: Es el pin de conexión a Tierra.
TX: Es el pin de transmisión de datos, el cual va conectado al pin RX del

Arduino.
RX: Es el pin de recepción de datos, el cual va conectado al pin TX del

Arduino.
2.3.6 Batería LiPo de 3 celdas
Es un tipo de batería conformada por una o varias celdas rectangulares

interconectadas entre sí, hecha a base de polímeros de iones de litio. Gracias a este
componente químico, las baterías LiPo se caracterizan por tener una alta densidad de energía.
(TºBem, 2017).
Gráfico 23. Batería LiPo de 3 celdas
En este tipo de baterías, cada celda tiene una tensión nominal de 3.7 V. Una celda
puede conformar una batería por sí sola. Sin embargo, estas celdas se suelen agrupar en serie
con la finalidad de conseguir mayores voltajes. Debido a que la batería adquirida
corresponde a una de 3 celdas, tenemos una tensión de salida de 11.1 V.
Es importante tener en cuenta la corriente y la tensión que se necesita para alimentar
a todos los componentes electrónicos del sistema de manera simultánea antes de proceder a
adquirir la batería, teniendo también en consideración el hecho de que la misma debe ser
capaz de mover los 4 motores brushless. Es por esta razón que se ha elegido la batería de
polímero de litio (LiPo), debido a la gran potencia que la misma ofrece para el correcto
funcionamiento de los motores.
En una etiqueta adherida a la propia batería, suele contener información relevante
que se debe entender y así saber si dicha batería es idónea para nuestro sistema. Uno de estos
valores corresponde con unidades de V, y es la tensión de salida que entrega la batería; es
imprescindible verificar que esta tensión de salida sea compatible con la alimentación que
requiere el tipo de motor a utilizar. Mientras más voltaje tenga la batería, más capacidad
tendrá de alimentar y mover motores más grandes.
28
No obstante, si lo que se busca es conseguir un mayor tiempo de duración de

suministro de energía, se debe de poner especial atención a otro dato que está en unidades
de mAh (miliamperios hora). Este dato indica el tiempo en que la misma puede proporcionar
energía, es decir, indica los miliamperios que puede suministrar la batería durante una hora.
En el caso de la batería adquirida, tiene una capacidad de 2200 mAh, lo que significa
que la misma es capaz de suministrar alrededor de 2.2 A en una hora. Otro dato a tener en
cuenta, (y que está presente también en la etiqueta), es la constante de descarga de la batería,
representado por un número junto a una letra C.
Este valor es un factor e indica la constante de descarga de la batería. Para obtener la
cantidad máxima de corriente que la batería puede ofrecer, es necesario multiplicar este
factor (constante de descarga) por la capacidad de la batería (mAh). (Mi Drone de Carreras,
2018).
En el caso de la batería adquirida, la cantidad máxima de corriente que la misma
puede ofrecer es de 25 𝐶 𝑥 2200 𝑚𝐴ℎ = 55000 𝑚𝐴. Esto significa que se tiene una
corriente constante máxima de 55 Amperios. A continuación, se anexa una tabla resumen
con las características más importantes de la batería en cuestión.
Voltaje de salida 11.1 V
Capacidad 2200 mAh
Constante de descarga 25 C
Capacidad de carga recomendada 1~3C
Capacidad de carga máxima 5C
Peso 184 g
Dimensiones 106x34x24 mm
Tabla 6. Especificaciones de la batería LiPo adquirida
2.3.7 El Chasis
El chasis es el cuerpo del drone; es el que se encarga de dar soporte a todas las demás
piezas. Dependiendo de la estructura y forma que tenga el chasis, el drone puede clasificarse
de acuerdo al número de rotores o motores que lo conforman. Es decir, el drone puede
tratarse de un cuadricóptero (4), hexacóptero (6) u octocóptero (8).
Los chasis de los drones están fabricados generalmente con tres distintos tipos de
materiales, los cuales pasarán a ser descritos brevemente a continuación.
Fibras de carbono: Se caracterizan por ser de un material muy resistente,
pesado y, entre los distintos materiales que pueden conformar un drone,
resulta ser el más costoso.
Fibra de vidrio: Se caracterizan por no ser tan resistentes que los de fibra de
carbono. Sin embargo, resultan ser más ligeros y, por ende, más económicos
que los de fibra de carbono.
Plástico: Representa el tipo de material más adquirido debido a que es el más

económico y, además, ofrece la posibilidad de imprimir en 3D los chasis
29
diseñados y/o elaborados por los usuarios. Se ha optado por utilizar el

plástico como elemento integrante del chasis del drone a montar.
A continuación, se proceden a mostrar las primeras impresiones fallidas de uno de
los brazos del cuadricóptero.
Gráfico 24. Impresión fallida de uno de los brazos del cuadricóptero.
Gráfico 25. Impresión fallida de la parte superior de unos de los brazos del cuadricóptero.
A continuación, se proceden a mostrar las impresiones finales de las piezas de nuestro

cuadricóptero.
Gráfico 26. Vista de planta del extremo del brazo impreso del drone
30
Gráfico 27. Vista de perfil del extremo del brazo impreso del drone
Gráfico 28. Vista de planta de la base impresa del drone
31
Gráfico 29. Vista inferior de la base impresa del drone
Gráfico 30. Impresora 3D utilizada
32
3 Diseño
En este apartado se contemplan todos los procesos y procedimientos

correspondientes para cumplir con los objetivos planteados. Se divide en varias etapas; una
etapa mecánica, en la que se trata del montaje del chasis estructural donde todos los
dispositivos estarán ensamblados y alojados, una etapa electrónica, donde describiremos las
distintas conexiones entre los componentes que conforman el cuadricóptero. Además,
también describiremos la placa PDB donde estarán conectados los cuatro variadores
electrónicos de velocidad (ESC). Finalmente, una etapa de programación, en la que
corresponde con el diseño y desarrollo del controlador PID y del control remoto del drone.
3.1 Mecánica
Como se ha mencionado anteriormente, en esta etapa se procederá a explicar el

modelo del chasis elegido, así como también se describirá el proceso de ensamblaje de los
distintos componentes con el chasis estructural.
3.1.1 Chasis elegido
Para la elección del chasis actual, se ha tenido en cuenta varios factores, entre ellos
están: la calidad del material que lo conformará, su ligereza, su robusteza y su duración.
Poner especial atención en todos estos factores es importante, ya que el chasis no sólo debe
aguantar el peso de todos los componentes ensamblados en él, sino que también estará sujeto
a las fuerzas o sobrecargas que ocurren cuando el drone se encuentra en el aire.
A continuación, se procederá a representar el peso de cada uno de los componentes
(sin tener en cuenta el peso del propio chasis), así como de su peso total, y se comparará con
el empuje total de los cuatro motores brushless.
Peso de los componentes
Placa Arduino UNO 25 g
4 motores Brushless 212 g
Batería LiPo 184 g
4 variadores ESC 24 g
Placa PDB 11 g
TOTAL 456 g
Tabla 7. Balance de pesos de los componentes SIN el chasis
Se puede observar que el peso total de todos los componentes principales del drone
(sin tener en cuenta el peso del propio chasis) es de aproximadamente 456 gramos. Por otra
parte, el empuje que posee cada motor es de 885 gramos, siendo el empuje total de 3540
gramos. Esto quiere decir que el peso del “esqueleto” del drone debe ser inferior al siguiente
número:
456 𝑔 + 𝑃𝑒𝑠𝑜 𝑑𝑒𝑙 𝑐ℎ𝑎𝑠𝑖𝑠 < 3540 𝑔
𝑃𝑒𝑠𝑜 𝑑𝑒𝑙 𝑐ℎ𝑎𝑠𝑖𝑠 < 3540 𝑔 − 456 𝑔
𝑃𝑒𝑠𝑜 𝑑𝑒𝑙 𝑐ℎ𝑎𝑠𝑖𝑠 < 3084 𝑔
33
El peso del chasis debe ser inferior a 3084 gramos para que el conjunto de los 4
motores sea capaz de hacer volar al drone. Una vez sabido el empuje total y el peso total de
los elementos, se procede a escoger un modelo de chasis que se ajuste a las necesidades y
que cumplan con el requisito importante del peso y de los factores característicos
mencionados anteriormente.
Para la búsqueda de distintos modelos de chasis, se ha consultado una página web de
diseños 3D llamado Thingiverse en donde sus usuarios comparten sus propias creaciones,
proyectos e ideas a la comunidad. Dentro de los muchos diseños que se encuentran, se ha
encontrado uno que cumple con las características deseadas. A continuación, se procederá a
mostrar las imágenes de planta y de perfil de cada uno de los elementos estructurales del
chasis mediante el software de diseño y modificación de piezas para impresión 3D online
gratuito llamado TinkerCAD.
22.23 cm
6.85 cm
Gráfico 31. Vista de perfil del extremo del brazo del drone
Gráfico 32. Vista de planta del extremo del brazo del drone
34
Gráfico 33. Vista de planta de la base del drone
Gráfico 34. Vista inferior de la base del drone
35
3.1.2 Ensamblaje
Una vez impresas las distintas partes del cuerpo del drone, nos centramos ahora en
el ensamblaje de sus piezas. Este punto resulta ser el más delicado, ya que debemos
garantizar la sujeción de todos los componentes y asegurarnos de que estos no se desprendan
en pleno vuelo.
Gráfico 35. Piezas del cuadricóptero.
Para el ensamblaje de las dos plataformas y de los brazos del cuadricóptero, hacemos
uso tornillos de cabeza hexagonal y tuercas de sujeción.
Gráfico 36. Chasis armado (Vista de planta)
36
Gráfico 37. Chasis armado (Vista de perfil) SIN componentes
Gráfico 38. Drone armado
37
3.2 Electrónica
En esta etapa, centraremos nuestra atención en explicar las distintas conexiones entre
los distintos componentes a nivel de hardware del sistema en su totalidad, así como de la
asignación de los pines de los componentes conectados al microcontrolador arduino; el
esquema general del que nos regimos.
3.2.1 Esquema de las conexiones electrónicas del drone
El esquema de conexiones de los componentes para el sistema cuadricóptero se

muestra a continuación:
Gráfico 39. Esquema de conexiones del Drone
38
Componente Pin del componente Pin de conexión a la placa

Arduino
Led rojo indicador (+) Ánodo D12
VCC 3V3
Módulo bluetooth HC-06 GND GND
TX RX (D0)
RX TX(D1)
Variador ESC motor izquierdo PWM (blanco) D3
frontal GND GND
Variador ESC motor derecho PWM (blanco) D5
frontal GND GND
trasero GND GND
trasero GND GND
VCC 5V
Módulo MPU-6050 GND GND
SCL A5
SDA A4
Tabla 8. Distribución de pines de los distintos componentes del sistema cuadricóptero
3.2.2 Placa de distribución de potencia (PDB)
Una PDB (por sus siglas en inglés, Power Distribution Board), se trata de una placa
que se encarga de distribuir la corriente entregada por la batería. No sólo son muy utilizadas
en el mundo de los drones, sino que en la electrónica en general. Además, suelen ser de
pequeño tamaño y evitan que tengamos malas conexiones entre los distintos elementos
electrónicos.
La Placa de Distribución de Potencia que hemos utilizado es del modelo PDB-XT60.
Este se encuentra conectado con nuestra batería LiPo de 3 celdas por medio del conector
XT60.
Gráfico 40. Placa de distribución de potencia del modelo PDB-XT60
39
En nuestro sistema, la PDB se encargará de distribuir la potencia que llega desde la

batería para alimentar nuestros variadores de velocidad ESC. A continuación, se adjunta la
tabla de características de la placa.
Rango de la tensión de entrada 9 ~ 18 V DC
Salida de corriente continua 25 A con 4 ESC conectados
16 A con 6 ESC conectados
Número de salidas de conexiones ESC 6
Presencia de salida UBEC de 5 V SI
Peso (incluyendo el conector XT60) ~ 11 g
Dimensiones 36 x 50 x 4 mm
Tabla 9. Especificaciones de la PDB a utilizar
40
3.3 Software
En esta etapa se procederá a realizar la programación, calibración y configuración

previa de los distintos componentes electrónicos que conforman el drone antes de pasar a
aplicar el controlador PID.
3.3.1 Inicialización del sensor MPU-6050
Este dispositivo representa el sensor del sistema de lazo cerrado, es el encargado de

realizar las mediciones pertinentes y que pasan a ser interpretadas por la placa procesadora.
La importancia de conseguir una buena lectura e interpretación de los datos recogidos por el
sensor radica en el hecho de que el controlador realizará los cálculos necesarios en base a
esta información para alcanzar la estabilidad del drone (control PID).
Cabe destacar el hecho de que para realizar la programación de este módulo, se
utilizan librerías creadas por terceros. Esto se debe a que la programación desde cero para la
lectura de datos que capta el sensor es ardua y conlleva mucho tiempo. A continuación, se
procederá a explicar un poco de teoría relacionado a los sensores acelerómetros y giroscopios
junto con sus ventajas e inconvenientes, luego se explicará el código realizado y los
resultados obtenidos para las primeras mediciones de prueba sin el uso del drone, con la
finalidad de familiarizarnos con el sensor y así conocer un poco mejor la forma en que éste
funciona.
Primeras mediciones con el módulo MPU-6050
En el apartado de “El sensor MPU-6050” (pág. 16), se hablan de las características

del acelerómetro integrado en este módulo dispositivo. Este sensor permite calcular el ángulo
de inclinación respecto al eje X y al eje Y mediante la lectura de las aceleraciones a las que
está sometido el sensor en los tres ejes espaciales (X, Y, Z). A continuación, se comenzará
con el primer caso en donde el sensor está inicialmente en posición horizontal en el plano
Y-Z y se le hace girar con respecto al eje X (posición en 2D).
Gráfico 41. Sensor MPU-6050 inclinado con las direcciones de sus aceleraciones
Como se puede observar en la imagen superior, el sensor también se ve afectado por

la fuerza de gravedad (componente Ag). Gracias a ésta fuerza (en combinación con las
41
lecturas del acelerómetro), es posible conocer el ángulo de inclinación respecto al eje X e Y,

y por ende, conocer la orientación del sensor (y del drone).
Gráfico 42. Ángulo de inclinación del sensor MPU-6050 (ejemplo I)
Aplicando un poco de trigonometría (Pitágoras), se puede obtener el ángulo de

inclinación ϕ deseado.
𝐴𝑦
Φ = tan−1 ( ) (5)
𝐴𝑧
Esta ecuación corresponde en caso de que el sensor está inicialmente en posición
horizontal en el plano Y-Z y se le hace girar con respecto al eje X. Para calcular el ángulo
de inclinación en caso de que el sensor se encuentre inicialmente en posición horizontal en
el plano X-Z y se le haga girar con respecto al eje Y, se procede a realizar el mismo análisis
del caso anterior.
Gráfico 43. Ángulo de inclinación del sensor MPU-6050 (ejemplo II)
Aplicando un poco de trigonometría (Pitágoras), se puede obtener el ángulo de

inclinación ϴ deseado.
𝐴𝑥
ϴ = tan−1 ( ) (6)
𝐴𝑧
42
En el caso de que el sensor se encuentre en una posición de 3D, las ecuaciones

cambian y resultan ser las mismas que las ecuaciones número 1 y 2.
Además, este módulo sensor también incluye un giroscopio de 3 ejes encargado de
registrar de forma independiente las rotaciones en el eje X, Y y Z (Roll, Pitch y Yaw
respectivamente). Para el cálculo del ángulo de rotación actual, es necesario conocer el
ángulo inicial en que se encuentra el dispositivo e integrar la velocidad que éste lleva. Sin
embargo, el hecho de realizar cálculos que conlleven la integración con respecto al tiempo
supone la acumulación de errores de medición y ruido.
El ruido se define como todas las interferencias que afectan a los dispositivos
electrónicos. En el caso del acelerómetro, las lecturas tienden a ser ruidosas, ya que se ven
influenciadas por el movimiento del propio sensor y a las vibraciones como consecuencia de
éste último. Cabe destacar también que el acelerómetro es capaz de detectar cualquier otra
aceleración que no sea de la gravedad, pudiendo ser esto último un inconveniente en ciertas
situaciones.
Por otra parte, el giroscopio presenta medidas con mucha precisión. No obstante, el
hecho de calcular el ángulo con respecto al tiempo hace que sea inevitable que se produzca
un error. Con el paso del tiempo, estos errores se van acumulando hasta el punto de que el
valor medido por el dispositivo diste mucho del valor real. (aprendiendo arduino, 2016). A
esto último se le conoce como deriva (conocido en inglés como drift).
Todo lo anteriormente mencionado conlleva al hecho de tener que buscar una
alternativa que sea capaz de eliminar el problema del ruido, de la deriva y de conseguir que
el acelerómetro no cambie de ángulo al detectar otra fuerza que no sea la gravedad. Es aquí
donde entra en juego el concepto de filtro digital.
Un filtro digital es un algoritmo implementado en hardware y/o software que opera
sobre valores numéricos asociados a muestras de señales analógicas, previamente
digitalizadas por conversores A/D, para generar una señal digital de salida filtrada. (Serrudo,
2017).
Con el uso de un filtro en nuestro sistema, se conseguirá resolver la problemática del
ruido, de la deriva y del cambio de ángulo del acelerómetro al detectar otra fuerza.
Se debe de escoger un tipo de filtro adecuado para nuestro sistema. Entre los filtros
más populares (y sencillos de aplicar en el microcontrolador Arduino), se encuentra el filtro
complementario.
El filtro complementario consiste en realidad en la unión de dos filtros diferentes; un
filtro paso-alto (High Pass Filter, conocido también por sus siglas HPF) para las mediciones
del giroscopio, y un filtro paso-bajo (Low Pass Filter, conocido también por sus siglas LPF)
para las señales del acelerómetro. (Robologs, 2014).
El filtro paso-alto se caracteriza por dejar pasar únicamente valores que se encuentren
por encima de un cierto límite, mientras que los filtros paso-bajos sólo permiten pasar los
que se encuentren por debajo.
43
Gráfico 44. Esquema del filtro complementario
Existen varias formulaciones para un filtro complementario, entre las más usadas,
está la siguiente:
𝜃 = 𝐴 ∗ (𝜃𝑝𝑟𝑒𝑣 + 𝜃𝑔𝑖𝑟 ∙ ∆𝑡) + 𝐵 ∗ 𝜃𝑎𝑐𝑒𝑙 (7)
Donde:
- 𝜃𝑝𝑟𝑒𝑣 es el ángulo de rotación total calculado previamente.
- 𝜃𝑔𝑖𝑟 es el ángulo del giroscopio medido previamente.
- ∆𝑡 es el tiempo transcurrido desde la última vez que se hecho uso del filtro.
- 𝜃𝑎𝑐𝑒𝑙 es el ángulo del acelerómetro previamente calculado mediante el uso del
arco tangente.
- A y B son dos constantes que pueden tomar valores arbitrarios siempre y cuando
se cumpla la siguiente condición:
𝐴+𝐵 <1 (8)
Ahora bien, ya hemos visto la teoría que hay detrás de este dispositivo. Es momento
de pasar a familiarizarnos con el sensor acelerómetro de manera práctica. Para ello, debemos
realizar la conexión de la placa Arduino con el módulo MPU-6050 y proceder luego con la
programación.
44
Gráfico 45. Conexión de la placa Arduino con el módulo MPU-6050
Cabe mencionar que hacemos uso de la librería propia de Arduino llamada Wire, con
la finalidad de establecer una comunicación con el módulo MPU-6050 mediante el protocolo
I2C. La primera línea de nuestro primer código de prueba para el acelerómetro incluye esta
librería. Luego, definimos y declaramos las variables necesarias para almacenar la lectura
de las aceleraciones en sus 3 ejes (X, Y, Z). Debido a que el módulo sensor entrega valores
del tipo enteros de un tamaño de 16 bits (2 bytes), debemos definir estas variables del tipo
enteros “int16_t”.
En la función setup del Arduino, establecemos una comunicación serial con tal de
poder visualizar los datos recogidos por el sensor a través del monitor serial. Luego,
comenzamos nuestra primera comunicación I2C con el módulo, donde debemos despertarle
del sleep mode1. Para ello, debemos buscar por internet el datasheet2 de este módulo para
saber cuál es el registro interno que alberga esta característica. El registro en cuestión es el
PWR_MGMT_1, donde escribimos un “0x00” a través de la función Wire.write (0x00) y así
despertarlo del modo de bajo consumo.
En la función loop (bucle), inicializamos de nuevo la comunicación I2C con el
módulo (había finalizado en la etapa setup previamente). Luego, debemos indicarle al
módulo MPU-6050 donde vamos a comenzar a leer los datos que este almacena en sus
registros internos. Estos datos (en este caso) no son más que las lecturas de las aceleraciones
en sus tres ejes.
El primer registro del cual comenzaremos a leer sus datos es el ACCEL_XOUT_H.
Mediante la sintaxis Wire.write (0x3B), le indicamos al módulo que comenzaremos dicha
lectura a partir de este registro. Ahora bien, sabemos que necesitamos 3 registros para
almacenar los 3 valores de las aceleraciones de cada eje. Sin embargo, debemos exigir la
lectura de 6 registros (y no 3) a través de la siguiente sintaxis Wire.requestFrom
(MPU_address, 2*3, true).
La razón del porque debemos exigir la lectura de seis registros y no tres, es debido al
hecho de que cada valor que mide el sensor tiene un tamaño de 2 bytes. Como cada registro
1
Sleep mode: Es el modo de bajo consumo para dispositivos electrónicos (Modo de suspensión).
2
Datasheet: Es la hoja de datos donde alberga las características y funcionalidades de un componente.
45
sólo tiene la capacidad de almacenar 1 byte, debemos reservar 2 registros por cada valor a
almacenar, obteniéndose un total de 6 registros.
El primer registro contiene lo que se denomina la parte alta del byte (High byte) y el
segundo registro contiene la parte baja del byte (Low byte). A continuación, adjuntamos una
imagen para mayor compresión.
Gráfico 46. Estructura de 2 registros contiguos.
Es ahora cuando procedemos a obtener y almacenar las lecturas del acelerómetro. No

obstante, es imprescindible conocer cuáles son los registros y sus respectivas direcciones de
memoria de los cuales obtendremos dichas lecturas. De acuerdo al datasheet del MPU-6050,
los registros que almacenan las aceleraciones de los ejes X, Y, Z son los siguientes:
Gráfico 47. Registros donde se almacenan las aceleraciones en los ejes X, Y, Z leidas por el sensor
Como podemos observar en la imagen de arriba (y también como hemos mencionado

anteriormente), la lectura e interpretación de datos comenzará con el registro
ACCEL_XOUT_H, cuya dirección en memoria es 0x3B (número 59 en decimal). Como se
trata del primer registro, en él se alberga la parte alta del byte, mientras que el registro que
le sigue (con dirección 0x3C y de nombre ACCEL_XOUT_L), alberga la parte baja del byte.
Lo mismo aplica para los demás registros.
Los valores de salida del acelerómetro (16 bits) son almacenados en dos registros,
por lo que necesitamos combinar estos datos separados en dos registros para obtener el valor
completo final. Es aquí donde las operaciones lógicas a nivel de bit comienzan a ser
necesarios.
Por ejemplo, imaginemos que los registros ACCEL_XOUT_H y ACCEL_XOUT_L
contienen los siguientes valores:
46
Gráfico 48. Ejemplo de valores almacenados en dos registros.
Sabemos que la combinación de ambos valores que almacenan es el valor total de la

aceleración en el eje X. Por lo que simplemente debemos buscar la manera de juntar estos
dos valores y almacenarlo en la variable que hemos ya definido y declarado previamente.
Una de las maneras de conseguir esto, es mediante el uso del operador de
desplazamiento de bits hacia la izquierda (<<) para el valor almacenado en el registro
ACCEL_XOUT_H. Al resultado obtenido tras este desplazamiento, aplicaríamos el
operador de suma lógica (Operador OR o ‘|’), y así obtendríamos el valor del sensor de 16
bits deseado.
Continuando con el ejemplo del gráfico 48, explicamos los pasos a seguir para poder
obtener el valor de la aceleración del eje X. A continuación, adjuntamos una imagen la cual
contiene todas estas operaciones a realizar, para mayor compresión.
Gráfico 49. Operaciones a nivel de bit
A) Debemos convertir el byte alto y el byte bajo a un formato de 16 bits,

añadiéndoles 8 ceros (0) por la izquierda del byte.
B) Al primer byte (número 1), desplazamos 8 bits hacia la izquierda. El resultado

final es como la que se puede observar en la imagen.
C) Aplicamos el operador lógico OR al byte 1 (con sus 8 bits iniciales ya

desplazados) junto con el byte número 2. El resultado final es la aceleración del
eje X en formato de 16 bits.
47
Mediante la siguiente línea de código, conseguimos realizar las operaciones

anteriormente descritas:
Ax = Wire.read() << 8 | Wire.read()
Siendo ‘Ax’ la variable donde se almacena el valor de la aceleración en el eje X.
Cabe destacar que esta misma serie de pasos se aplica para la obtención del valor de la
aceleración para los otros ejes. Sin embargo, antes de que procedamos a imprimir estos
valores almacenados a través de la consola llamado monitor serial, debemos tener presente
que estos datos corresponden con valores sin procesar.
Para procesar esta información, debemos dividir estos valores obtenidos por una
constante. Esta constante variará en función de la configuración de sensibilidad que hayamos
escogido, y la podemos encontrar en la documentación del módulo MPU-6050.
En nuestro primer ejemplo práctico (sin usar el drone), procesaremos la información
obtenida del acelerómetro. Para llevar a cabo esto, buscamos en el datasheet la dirección de
memoria del registro que nos permita realizar la configuración del rango de escala completa
de salida para el acelerómetro.
Gráfico 50. Registro para la configuración previa del acelerómetro
Como observamos en la imagen, la dirección de memoria de este registro

corresponde al 0x1C. Ahora que sabemos esta información, escogemos la sensibilidad que
tendrá el acelerómetro. En nuestro pequeño ejemplo, escogemos una sensibilidad de ±2g.
Para configurar esta sensibilidad, escribimos la siguiente sintaxis: Wire.write (0x1C),
Wire.write (0x00). Cabe destacar que estas dos líneas de código han de estar dentro de la
función setup y no en la de loop.
Una vez que hayamos configurado el acelerómetro, debemos buscar el valor de la
sensibilidad correspondiente en el datasheet. Para el rango de escala completa seleccionado,
la sensibilidad es de 16384 LSB / g.
Por cada valor de 16384 que leamos de los datos sin procesar (valores raw), significa
que estamos midiendo una aceleración de 1g (9.8m/s²). Por ende, debemos dividir estos
valores raw entre el rango de escala seleccionado; 16384, y así obtener las mediciones en
función de la aceleración.
Para poder testear el código y comprobar que funciona, vamos a inclinar el módulo
sensor 32 º como se puede observar en la siguiente imagen, y luego intentaremos calcular el
ángulo de inclinación mediante la fórmula número 6.
48
Gráfico 51. Módulo MPU-6050 inclinado 32 º
Compilamos el código, y obtenemos a través del monitor serial los siguientes valores:
Gráfico 52. Lectura de las aceleraciones de los ejes X, Y, Z
Obteniendo la media de las aceleraciones en el eje X y el eje Z, tenemos:

- Ax: 0.4753
- Az: 0.7633
Utilizando la fórmula 6 para calcular el ángulo de inclinación:
0.4753
tan−1 ( ) = 31.91 º
0.7633
Como podemos observar, el ángulo de inclinación calculado está muy cercano del
ángulo teórico, con una desviación de 0.10 º por debajo de la inclinación real.
Ahora bien, procederemos a continuación a obtener la orientación del módulo MPU-
6050 a través de las lecturas del giroscopio. La forma de proceder con la programación del
sensor giroscopio es similar para el caso del acelerómetro; debemos declarar y definir las
49
variables donde almacenaremos las lecturas que capta el sensor en sus 3 ejes (X, Y, Z).
Debido a que el módulo sensor entrega valores del tipo enteros de un tamaño de 16 bits (2
bytes), debemos definir estas variables nuevamente del tipo entero “int16_t”.
En la función setup del Arduino, establecemos la misma configuración para la
comunicación I2C con el módulo MPU-6050 que hemos hecho previamente para utilizar el
acelerómetro, con la salvedad de que debemos de buscar la nueva dirección de memoria del
registro que nos permita realizar esta configuración en el datasheet. Según este documento,
la dirección de memoria de este registro corresponde al 0x1B. Ahora que sabemos esta
información, procedemos a configurar el rango de escala a 250 º/s a través de la siguiente
sintaxis: Wire.write (0x1C), Wire.write (0x00).
En la función loop (bucle), inicializamos de nuevo la comunicación I2C con el
módulo. De manera similar a como hemos procedido con el acelerómetro, debemos indicarle
al módulo MPU-6050 donde vamos a comenzar a leer los datos que este almacena en los
registros internos pertenecientes a los del giroscopio.
De acuerdo con el datasheet¸ el primer registro del cual comenzaremos a leer sus
datos es el GYRO_XOUT_H, y mediante la sintaxis Wire.write (0x43), le indicamos al
módulo que comenzaremos la lectura de sus datos a partir de este registro. Igualmente que
en el acelerómetro, requerimos un total de 6 registros para almacenar los valores de las
velocidades angulares en sus 3 ejes (X, Y, Z). A partir de aquí, aplicamos los mismos pasos
especificados en la figura 49 para almacenar los valores recogidos por el sensor.
Ahora bien, dependiendo de la configuración previa del giroscopio, buscamos en el
datasheet del módulo el valor de la sensibilidad del bit menos significativo. Para el rango de
escala completa seleccionado, la sensibilidad es de 131 LSB º/s. Una vez encontrado,
debemos dividir los valores sin procesar del giroscopio por esta constante e imprimirlos a
través del monitor serial.
Para poder testear el código y comprobar que funciona, procedemos a cargarlo a la
placa microcontroladora y rotamos el módulo lentamente en torno al eje X (Roll). A
continuación, adjuntamos los valores obtenidos a través del monitor serial, en donde las 3
primeras columnas corresponden a las velocidades angulares de los ejes X, Y, Z, y las 2
últimas columnas corresponden a los ángulos de rotación en los ejes X e Y.
Gráfico 53. Velocidades angulares obtenidas por el giroscopio
Sin embargo, como podemos observar en la imagen, estos valores no concuerdan con
la realidad, ya que presentan un alto grado de desviación. Esto se debe a que las limitaciones
50
que entrega el giroscopio no pueden ser compensadas por el acelerómetro si éste último no
se llega a usar.
Una de estas limitaciones que presenta el giroscopio es la del error acumulativo por
causa de la integración de la velocidad angular, tendiendo a acumular errores (y ruido) en
las mediciones, y por ende, provocando el efecto de deriva, como bien hemos explicado
anteriormente. Esta es la razón por la que hacemos uso del filtro complementario.
Primeras mediciones con el módulo MPU-6050 haciendo uso del filtro complementario
El filtro complementario en sí combina las mediciones del acelerómetro y del

giroscopio. De esta manera, le permite al módulo MPU-6050 obtener mediciones de la
orientación más precisas que si llegásemos a usar el acelerómetro y giroscopio por separado.
Para la aplicación de este filtro, comenzamos con la declaración y definición de las
variables donde almacenaremos la lectura de los valores sin refinar; tanto del acelerómetro
como del giroscopio. Luego, realizamos la misma configuración de setup que hemos hecho
previamente en los casos anteriores.
En la función de loop, debemos realizar las lecturas de las aceleraciones y
velocidades angulares sin refinar. Para ello, hemos declarado y definido previamente una
función llamada read_Rawvalues. Con esta función, podemos obtener las lecturas del
acelerómetro y del giroscopio.
Una vez terminada la lectura de estos datos, procedemos a calcular el ángulo de
inclinación del módulo sensor MPU-6050 utilizando el valor de las aceleraciones (ya
refinadas). Para realizar el cálculo del ángulo, hacemos uso de las fórmulas 1 y 2.
Ahora es momento de aplicar el filtro digital. Llamamos a la función
filtro_complementario, y aplicamos la fórmula 7. El resultado final serán los ángulos de
rotación del módulo de los ejes X e Y. A continuación, adjuntamos los resultados obtenidos
con la aplicación del filtro.
Gráfico 54. Obtención de los ángulos de rotación X e Y usando el filtro complementario (I)
51
Gráfico 55. Obtención de los ángulos de rotación X e Y usando el filtro complementario (II)
Gráfico 56. Obtención de los ángulos de rotación X e Y usando el filtro complementario (III)
Estos valores reflejan una mayor precisión que los obtenidos sin el uso del filtro
complementario. Es importante eliminar el efecto de deriva y el ruido de estas mediciones,
puesto que a partir de estas lecturas, el controlador PID tomará las acciones pertinentes para
mantener en vuelo (y de manera estable), al drone.
Sin embargo, para la absoluta estabilidad del drone, no sólo es importante el correcto
filtrado del ruido presente en las mediciones que realiza el módulo MPU-6050, sino que
también debemos cerciorarnos de la correcta calibración de los variadores de velocidad (y
por ende, también de los motores). En el siguiente apartado explicaremos cómo realizar esta
calibración.
52
3.3.2 Inicialización del variador electrónico de velocidad (ESC)
Los variadores electrónicos de velocidad (ESC), junto con los motores, son los
actuadores de nuestro sistema. Están encargados de regular la velocidad de giro de nuestros
motores eléctricos sin escobillas. Además, convierten la tensión continua de la batería en
tensión variable, apta para estos motores.
El propósito de esta sección es la de familiarizarnos sobre el funcionamiento de los
motores y de los ESC, así como de entender la manera en que ambos componentes se
complementan. Para las primeras mediciones de prueba, las realizaremos sin el uso del
drone.
En general, los variadores electrónicos de velocidad son controlados mediante la
modulación de ancho de pulsos PWM. Mediante el uso de la librería “Servo”, la placa
controladora será la responsable de generar esta señal PWM a una frecuencia de 50 Hz y a
un determinado ancho de pulso con la finalidad de poder controlar la velocidad de giro del
motor.
Como bien se ha explicado en el apartado de Variador Electrónico de Velocidad, este
ancho de pulsos debe de variar dentro del rango de los 1 a 2 milisegundos. Sin embargo,
cada ESC posee sus propias variaciones de este rango de operación, pudiendo variar desde
los 1.2 ms (punto bajo) hasta los 1.9 ms (punto alto). A continuación, se adjunta una imagen
para mayor compresión.
Gráfico 57. Señal PWM no calibrada
Teóricamente, nuestro motor ya debería a comenzar a girar muy lentamente al

superar el ancho de pulso de 1ms. No obstante, en esta situación, el motor no hará nada hasta
que alcancemos los 1.2 milisegundos. Es aquí donde entra el juego la calibración del ESC.
Calibración del ESC
Para llevar a cabo la calibración, debemos de realizar la conexión entre el motor

brushless, el variador, la batería LiPo, y el microcontrolador Arduino, tal como se adjunta
en el siguiente esquema.
53
Gráfico 58. Esquema de conexión del ESC, motor, batería con el Arduino
La alimentación del Arduino lo haremos a través del cable USB. A continuación,

adjuntamos el esquema de conexión resultante.
Gráfico 59. Conexión final resultante para la calibración del ESC y motor brushless
Antes de proceder a conectar la placa arduino al ordenador, debemos de mantener

la batería desconectada de la placa de distribución de energía (PDB).
En primer lugar, definimos la librería Servo.h. Con esta librería, podemos generar
fácilmente la señal PWM a 50 Hz. Luego, definimos el ancho de pulsos mínimo y máximo
de la señal PWM en unidades de microsegundos, (1000 y 2000 respectivamente). Después,
creamos el objeto perteneciente a la clase “Servo”, importante para el posterior control del
54
variador ESC. Creamos y definimos también la variable llamada “pwm_motor”, donde la

inicializamos con el valor mínimo anteriormente creado.
En la función setup, a través de la función attach (), le hacemos saber al arduino cuál
es el pin que está conectado con la señal de control del ESC. Por medidas de seguridad,
enviamos al controlador ESC el valor mínimo de ancho de pulsos, esto garantiza que el
motor se apague en caso de que esté encendido. Establecemos un retardo de 4 segundos para
una correcta configuración del variador.
Una vez transcurridos los 4 segundos, procedemos a enviar al variador el valor de
2000 microsegundos. El variador emitirá unos pitidos para indicarnos de que se ha entrado
correctamente al modo de configuración. Esperamos unos segundos y conectamos la batería
a la placa PDB. Pulsamos cualquier tecla para el envío del valor mínimo de ancho de pulsos
(1000 microsegundos). El variador emitirá nuevamente unos pitidos para indicarnos de que
se ha calibrado correctamente.
En la función loop, a través del monitor serial escribimos el valor que nosotros
deseemos al ESC, siempre y cuando esté comprendido entre 1000 y 2000 microsegundos.
El proceso del envío del valor del ancho de pulsos al variador ocurre con un periodo de cada
20 milisegundos, que es el periodo para una señal de 50 Hz.
Lógicamente, esta calibración debemos realizarla en cada uno de los cuatro motores
antes de proceder a utilizar ya sea el sistema balancín (explicado más adelante) o el mismo
drone.
55
3.3.3 Inicialización del módulo Bluetooth HC-06
El módulo inalámbrico de comunicaciones HC-06 nos permite enviar y recibir

información entre la app Android y nuestro drone. Antes de proceder a utilizarlo para nuestro
sistema final, nos centramos primero en aprender un poco de su configuración previa, su
programación y de cómo ocurre la vinculación entre el módulo y un teléfono Android.
Con la finalidad de familiarizarnos con este dispositivo, hemos decidido realizar un
ejemplo sencillo donde se ilustre su funcionamiento y la utilidad del mismo. Este ejemplo
se basa en encender dos leds a través de una app sencilla previamente desarrollada por
nosotros, mediante la plataforma de App Inventor. El usuario escogerá entre las opciones de
encendido y apagado presentes en la app. Luego, la app enviará el dato elegido al módulo
receptor Bluetooth conectado al arduino. En función de ese dato, el microcontrolador
encenderá o apagará el led correspondiente.
A continuación, adjuntamos el esquema de conexión del módulo HC-06 con el
arduino, así como el esquema de conexión general de este pequeño ejemplo práctico.
Gráfico 60. Esquema de conexión del Arduino con el módulo HC-06
Gráfico 61. Esquema de conexión general para encender dos leds (Ejemplo)
56
Sin embargo, primero debemos realizar la programación y ejecutar el programa antes

de conectar los pines TX y RX del módulo HC-06 al arduino. De lo contrario, nuestro
dispositivo móvil no se vinculará con el módulo.
Para la programación de este pequeño ejemplo, comenzamos con la asignación del
número de pin que está conectado cada led al arduino. Luego, procedemos con la definición
y declaración de la variable state, de tipo entero. En esta variable se guardará el valor que la
app enviará al módulo (y por ende, al microcontrolador) en función de la opción que haya
escogido el usuario desde la aplicación. Inicializamos a 0 la variable state. Además, creamos
2 variables del tipo booleano (verdadero o falso) que nos ayudarán con el control del
encendido y apagado de ambos leds.
En la función setup, establecemos en 9600 como la velocidad de datos en bits por
segundos, así como también establecemos los pines de los leds verde y rojo como salidas.
En la función loop, comenzamos con la siguiente línea de código:
If (Serial.available ()>0)
Con la función Serial.available, determinamos la cantidad de bytes que no se han
leído del puerto serial. Si existe más de 1 byte sin leer, entonces la función utilizará la
variable state que hemos creado previamente para que, mediante la sintaxis Serial.read,
obtengamos el byte del buffer serial. (Marmolejo, 2017).
Si el valor de la variable state vale 1, el usuario enciende el led verde si el
mismo estaba apagado, y lo apaga si se encontraba encendido.
Si el valor de la variable state vale 2, el usuario enciende el led rojo si el
mismo estaba apagado, y lo apaga si se encontraba encendido.
Ahora bien, procedemos a compilar el código. Una vez que ha terminado el proceso
de compilación y nos hayamos cerciorado de que no hay errores, procedemos a conectar los
cables TX y RX del módulo HC-06 al arduino.
A continuación, adjuntamos la distribución de pines para este esquema de conexión.
Arduino
VCC 3V3
TX RX (D0)
RX TX(D1)
Led rojo (ánodo) D3
Leds Led verde (ánodo) D2
Tabla 10. Distribución de pines para el ejemplo de encender 2 leds utilizando el HC-06
57
Gráfico 62. Esquema de conexión final para encender 2 leds mediante app
Los resultados de este primer pequeño ejemplo han sido los esperados. El módulo
bluetooth recibe las órdenes desde la aplicación Android, y éste las transmite al
microcontrolador para que efectúe las acciones pertinentes a realizar.
De la misma manera, podemos realizar esta analogía pero basado en nuestro sistema
Drone. Sin embargo, en lugar de querer encender leds, la interfaz de la app será distinta y
nos permitirá controlar el direccionamiento del drone (Pitch, Yaw, Roll, Throttle).
58
3.3.4 Primeras pruebas con el ESC y el módulo bluetooth HC-06
Es importante de que el variador ESC responda de manera efectiva ante los comandos
que recibe de la controladora de vuelo al momento de dirigir nuestro drone. Con tal de
asegurarnos de la buena comunicación entre los dispositivos módulo bluetooth, el arduino,
el variador ESC y el motor, hemos decidido crear un pequeño programa que consiste en
controlar la velocidad de giro del motor a través del móvil.
Gráfico 63. Esquema de conexión para las pruebas del módulo HC-06 y ESC
Para realizar las primeras pruebas utilizando el módulo bluetooth HC-06 y el variador
ESC, hemos decidido incluir 4 leds de distinto color.
- Rojo: el motor está apagado.
- Azul: la velocidad de giro del rotor aumenta.
- Blanco: la velocidad de giro del rotor disminuye.
- Verde: el motor está encendido.
Cada uno de estos leds se encuentra conectado a resistencias de 330 ohm a tierra. A
continuación, adjuntamos la distribución de pines para este esquema de conexión.
Arduino
VCC 3V3
TX RX (D0)
RX TX(D1)
Variador ESC PWM (blanco) D9
GND GND
Led rojo (ánodo) D4
Leds Led azul (ánodo) D6
59
Led blanco (ánodo) D5

Led verde (ánodo) D3
Tabla 11. Distribución de pines para las pruebas del ESC y módulo HC-06
Para realizar la programación y ejecutar el programa, debemos de desconectar los

pines TX y RX del módulo HC-06 al arduino. De lo contrario, nuestro dispositivo móvil no
se vinculará con el módulo.
Para la programación de este ejemplo, comenzamos con la asignación del número de
pin que cada led estará conectado al arduino. Luego, procedemos con la definición y
declaración de la variable state, de tipo entero. En esta variable se guardará el valor que la
app enviará al módulo (y por ende, al microcontrolador) en función de la opción que haya
escogido el usuario desde la aplicación. Inicializamos a 0 la variable state. Además, creamos
una variable del tipo booleano (verdadero o falso) que nos ayudará con el control del
encendido y apagado del motor. Definimos y creamos una variable llamada “vel_inicial”,
inicializado en un valor de 1050. Esta es la velocidad inicial que tendrá el motor cuando el
usuario active la opción de encender el giro del rotor.
En la función setup, establecemos en 9600 como la velocidad de datos en bits por
segundos, así como también establecemos los pines de todos los leds como salidas. Además,
apagamos los leds y encendemos el led rojo, puesto que el motor comienza estando apagado.
En la función loop, comenzamos con la siguiente línea de código:
If (Serial.available ()>0)
Con la función Serial.available, determinamos la cantidad de bytes que no se han
leído del puerto serial. Para realizar la lectura de bytes, utilizamos la instrucción
Serial.read().
Si el valor de la variable state vale 1, el usuario enciende el giro del rotor.
Apagamos el led rojo y activamos el verde. Modificamos el valor de la
variable “motor_on” a verdadero.
Si el valor de la variable state vale 2, aumentamos el giro del rotor. Llamamos

a una función llamada mapear_valores, encargado de no sobrepasar los
límites de los valores PWM permitidos. Encendemos el led azul y apagamos
el led blanco.
Si el valor de la variable state vale 3, disminuimos el giro del rotor. Llamamos

a una función llamada mapear_valores, encargado de no sobrepasar los
límites de los valores PWM permitidos. Encendemos el led blanco y
apagamos el led azul.
Si el valor de la variable state vale 4, el usuario apaga el giro del rotor.

Apagamos todos los leds y dejamos activado el rojo. Modificamos el valor de
la variable “vel_inicial” a 1050 y cambiamos la variable de “motor_on” a
falso.
60
Ahora bien, procedemos a compilar el código. Una vez que ha terminado el proceso
de compilación y nos hayamos cerciorado de que no hay errores, procedemos a conectar los
cables TX y RX del módulo HC-06 al arduino.
Gráfico 64. Esquema de conexión final utilizando ambos componentes ESC - HC06
Los resultados han sido los esperados. El módulo bluetooth recibe las órdenes desde
la aplicación Android, y éste las transmite al microcontrolador para que efectúe las acciones
pertinentes a realizar. Al presionar el ícono de la flecha girando hacia la izquierda,
disminuimos la velocidad de giro del rotor, y la aumentamos al presionar la flecha contigua.
61
3.4 Control PID
Hasta ahora, hemos visto por separado la configuración de los componentes

principales que integra nuestro drone. No obstante, es ahora cuando debemos juntar todos
estos elementos y hacerlos funcionar en un todo, obteniendo de esta manera un sistema. Sin
embargo, para que todos estos componentes en conjunto consigan la elevación, el control, la
estabilidad y la maniobrabilidad del drone, se debe recurrir a un algoritmo o sistema
automático de control que garantice que el mismo no se llegue a estrellar, y es aquí donde
entra el concepto de control PID.
El control PID es un mecanismo de control que a través de un lazo de
retroalimentación permite regular la velocidad, temperatura, presión o flujo dependiendo de
la variable a controlar en un sistema. (García P. , 2013).
Se trata de un algoritmo de control de lazo cerrado el cual calcula y compara la
variable controlada que se está midiendo (real) con la variable deseada (o de referencia).
Para que el controlador PID efectúe la correcta regulación de un determinado proceso, se
necesita que dicho sistema cuente con al menos de los siguientes elementos:
Un (1) sensor, que es el responsable de obtener información externa del
sistema y así saber del estado en que se encuentra.
Un (1) controlador, que se encargará de generar la señal que gobierna al
actuador en función de la señal de error que previamente el controlador ha
evaluado.
Un (1) actuador, encargado de modificar el sistema de una manera controlada.
Los controladores PID incluyen tres parámetros fundamentales que proporcionan una
acción Proporcional, Integral y Derivativa. Estas tres acciones son las que le dan el nombre
a este tipo de mecanismo de control, en donde cada uno tiene una función determinada en la
estabilización del sistema. (Pardos, 2019).
Gráfico 65. Sistema de control de lazo cerrado con control PID
A continuación, se procederá a explicar cada uno de estos 3 módulos que conforman

un controlador PID:
62
3.4.1 Teoría
Control Proporcional
Este representa el control principal y su función es la de crear una respuesta

proporcional a la señal de error 𝑒(𝑡). En otras palabras, la acción proporcional multiplica
internamente esta señal de error por una constante Kp, el cual representa una ganancia
proporcional ajustable. La fórmula para este tipo de control viene dada por la siguiente
expresión:
𝑃𝑠𝑎𝑙𝑖𝑑𝑎 = 𝐾𝑝 ∙ 𝑒(𝑡) (9)
La finalidad que tiene este controlador es la de minimizar el error del sistema. En el

caso de que el error sea grande, la acción de este controlador será grande y tenderá a
minimizar el error. El hecho de querer aumentar la acción del controlado trae consigo los
siguientes efectos: (Pardos, 2019).
- La velocidad de respuesta del sistema aumenta.
- El error del sistema en régimen estacionario disminuye.
- La inestabilidad del sistema aumenta.
Los dos primeros efectos son deseables. Sin embargo, el último es el que se debe
intentar minimizar.
En otras palabras, el controlador proporcional se caracteriza por ejercer una gran
influencia en la velocidad de respuesta del sistema; al tener una constante Kp pequeña, el
sistema va a demorar en alcanzar la consigna (valor de referencia), y por ende, el actuador
ejercerá un pobre control y el tiempo de respuesta del sistema aumenta. Por otro lado, al
tener una constante Kp grande, se consigue disminuir el tiempo de respuesta, pero el sistema
tenderá a oscilar, es decir, a ser inestable. (Pardos, 2019).
Cabe resaltar que la parte proporcional no elimina por completo el error a largo plazo.
Por lo tanto, la mejor manera de solucionar el error permanente es incluyendo al sistema
módulos o componentes con acciones integral y derivativa. (Wikipedia, Sin fecha).
Control Integral
La acción integral se encarga de eliminar el error residual que queda del controlador
proporcional, reduciéndolo a cero, o en otras palabras, calcula la integral de la señal de error
𝑒(𝑡). La fórmula para este tipo de control viene dada por la siguiente expresión:
𝑡
𝐼𝑠𝑎𝑙𝑖𝑑𝑎 = 𝐾𝑖 ∙ ∫ 𝑒(𝜏) ∙ 𝑑𝜏 (10)
0
Esta integral representa la acumulación de la señal de error. A medida que transcurra

el tiempo, pequeños errores se van sumando de manera que la acción de este control
aumente, consiguiendo reducir el error del sistema en régimen estacionario. Es decir, permite
al controlador eliminar el error por completo a largo plazo. (Pardos, 2019).
63
El tiempo que le tome al sistema en eliminar dicho error dependerá de qué tan grande
sea la constante Ki. El hecho de querer eliminar este error lo más rápido posible al
incrementar la constante Ki trae consigo los siguientes efectos:
- El error en régimen permanente disminuirá.
- La inestabilidad del sistema aumentará.
- La velocidad del sistema aumenta.
La constante Ki de integración indica la velocidad con la que se repite la acción
proporcional. (Canalés, 2014).
Control Derivativo
La acción derivativa se manifiesta cuando hay un cambio en el valor absoluto del

error, siendo el error la diferencia entre la medida real y el valor de referencia. La función
de este módulo o control es la de eliminar las oscilaciones generando una corrección en la
señal de control proporcional a la derivada de la señal de error 𝑒(𝑡). (Wikipedia, Sin fecha).
La fórmula para este tipo de control viene dada por la siguiente expresión:
𝑑𝑒
𝐷𝑠𝑎𝑙𝑖𝑑𝑎 = 𝐾𝑑 ∙ (11)
𝑑𝑡
Esta derivada de la señal de error representa la velocidad de variación de esta señal

de error.
Los sistemas que se mueven a una velocidad muy alta alrededor del punto de
referencia tienden a crear oscilaciones e inestabilidad en torno al valor de la consigna,
provocando que el propio sistema pase de largo de este punto debido a su inercia. Para
solucionar este problema, el controlador debe reconocer la velocidad a la que el sistema se
acerca a la referencia para poder frenarle con antelación a medida que se acerque a la
referencia deseada y evitar que la sobrepase. (Pardos, 2019).
El hecho de incrementar la constante de derivación Kd trae consigo los siguientes
efectos:
- El error en régimen permanente permanecerá igual.
- La estabilidad del sistema aumentará.
- La velocidad del sistema disminuye un poco.
La aplicación de este tipo de control es idónea para sistemas con demasiada
oscilación. Finalmente, las salidas de estos tres módulos (proporcional, integral y derivativo)
se unen y son sumadas para obtener la ecuación del control PID total:
𝑡
𝑑𝑒
𝑦(𝑡) = 𝐾𝑝 ∙ 𝑒(𝑡) + 𝐾𝑖 ∙ ∫ 𝑒(𝑡) ∙ 𝑑𝑡 + 𝐾𝑑 ∙
𝑑𝑡 (12)
0
Donde:,
- y(t): Es la señal de control.
- e(t): Es la señal de error.
- Kp, Ki, Kd: Representan los parámetros del controlador PID.
64
El comportamiento del controlador PID dependerá mucho de la suma de estos tres

componentes (proporcional, integral y derivativo), controlados a través de sus tres
parámetros (Kp, Ki, Kd). Estas tres constantes necesitan ser calibradas y ajustadas, de tal
manera que el bucle de control corrija eficazmente y en el menor tiempo posible el efecto de
las perturbaciones.
Una vez explicada la teoría que envuelve a los controladores PID, ahora podemos
enfocar nuestra atención en los pasos a seguir para la construcción y programación de un
controlador PID, enfocándonos en primer lugar en un sistema balancín.
3.4.2 Construcción del balancín
Como bien sabemos, el drone no volará de manera estable si los motores no han sido
previamente calibrados de manera correcta. Es por esta razón, que es importante que
hayamos realizado el proceso de calibración antes de proceder a continuar con la
construcción del PID.
Sin embargo, el hecho de saber cómo controlar los motores de nuestro drone no
garantiza que el mismo vuele de manera estable. Para poder controlar correctamente los
motores, primero debemos asegurarnos que por cada inclinación que realicemos con el
drone, la diferencia entre el ángulo que midamos y el ángulo deseado no sea tan grande, y si
lo es, deberemos de corregir este error.
En síntesis, para poder garantizar un vuelo estable, debemos primero asegurarnos de
que este error sea lo más pequeño posible. Por lo tanto, tendremos que realizar primero varias
pruebas y medidas relacionadas con el cálculo del ángulo antes de hacer volar nuestro drone.
Para ello, la mejor alternativa es comenzar con la construcción de un balancín adaptado solo
para 2 motores, los cuales van a representar solamente a un eje, en este caso el eje X.
Gráfico 66. Sistema balancín a construir
La implementación de este balancín nos permitirá hallar las constantes (Kp, Ki, Kd).
Estos valores afectarán el comportamiento del controlador PID del balancín. La finalidad de
construir este sistema es la de adquirir una mejor noción sobre el funcionamiento de un
controlador PID digital
Ahora bien, a continuación, procederemos con la construcción del balancín y, una
vez finalizado, pasaremos a realizar el circuito esquemático.
65
Materiales necesarios para la construcción del sistema balancín:

- 1 tabla de madera de 1.20 metro de largo, 4 cm de ancho y 1 cm de alto.
- Tornillos para madera.
- 1 barra de 60 cm de madera.
- 1 barra M-8 enroscada de metal.
- 2 tuercas M-8.
- 2 sujeciones de 1.2 cm de diámetro.
- 1 tabla de madera de 23 x 18 cm.
La tabla de madera de 1 metro de largo será suficiente para el montaje del sistema
balancín. De esta tabla, realizamos los siguientes cortes para obtener lo que nos interesa:
- 1 tabla de aproximadamente 75 cm.
- 2 tablitas de 10 cm.
Procederemos a construir la base de nuestro sistema balancín con estos materiales.
Gráfico 67. Base del balancín
A continuación, perforamos 3 agujeros equidistantes entre sí a una distancia de

aproximadamente 27 cm. El agujero central será por donde pasará la barra enroscada de
metal, mientras que en los extremos será por donde pasarán las bridas que sujetarán a la base
de los 2 motores.
Debemos dejar la barra enroscada de manera que las partes que sobresalgan tengan
la misma distancia. Luego, colocamos cada una de las tuercas M-8 en cada costado de la
barra.
Gráfico 68. Balancín
Finalmente, cortamos 2 tablas de madera de 18 cm de largo. Estos serán el soporte

de nuestro balancín. Unimos cada una de estas dos tablas a los costados de la base con 2
tornillos. Para una mayor sujeción, cortamos un cuadrado de madera de 4 cm de lado y lo
atornillamos a la mitad de la altura de ambos soportes.
66
Una vez colocados los soportes, procedemos a taladrar un agujero sobre la parte de
arriba de cada soporte. Ahora colocamos el balancín entre la mitad. El resultado final es el
siguiente:
Gráfico 69. Sistema balancín SIN componentes electrónicos (con sus medidas)
Gráfico 70. Sistema balancín CON todos los componentes electrónicos
El esquema de conexiones de los componentes para el sistema balancín se muestra a

continuación:
67
Gráfico 71. Esquema de conexiones del sistema Balancín

Arduino
VCC 3V3
TX RX (D0)
RX TX(D1)
GND GND
GND GND
VCC 5V
Módulo MPU-6050 GND GND
SCL A5
SDA A4
Tabla 12. Distribución de pines de los distintos componentes del sistema Balancín
3.4.3 Sintonización del controlador PID del sistema balancín
La rapidez que tenga nuestro sistema en conseguir la estabilidad dependerá del ajuste
de los parámetros Kp, Ki y Kd. El proceso de escoger los valores de tales parámetros de
manera que satisfagan las especificaciones de diseño del controlador se le conoce como
sintonización.
Existen muchas formas de ajustar un PID. Entre los más famosos, está el método de
Ziegler-Nichols.
68
Criterio de Ziegler-Nichols
Este criterio permite definir la ganancia proporcional, integral y derivativa a partir de

la respuesta del sistema en lazo abierto o a partir de la respuesta en lazo cerrado. (Pardo,
2013). Hemos decidido utilizar el segundo método (en lazo cerrado).
La sintonización de las constantes bajo el método de lazo cerrado, consiste en hacer
funcionar el sistema utilizando únicamente la acción proporcional, (manteniendo la acción
integral y derivativa a cero). Debemos de ir aumentando poco a poco la ganancia
proporcional hasta que el sistema presente una oscilación mantenida. Esta oscilación
mantenida adquiere la forma de una onda sinusoidal. (Pardo, 2013).
Una vez que hemos conseguido que el sistema oscile de manera mantenida, debemos
de sacar 2 parámetros:
𝐾𝑐 = Es la ganancia crítica que hace que el sistema presente oscilaciones mantenidas.
𝑃𝑐 = Es el periodo de las oscilaciones mantenidas.
Gráfico 72. Oscilaciones mantenidas de una planta genérica (Ejemplo)
Una vez conocidos estos 2 parámetros, podemos calcular los parámetros de nuestro
controlador (P, PI, PD, o PID).
Control Kp Ki Kd
P 0.50*Kc
PI 0.45*Kc 0.54*Kc/Pc
PD 0.80*Kc 0.075*Kc*Pc
PID 0.59*Kc 1.18*Kc/Pc 0.075*Kc*Pc
Tabla 13. Tabla de valores para el cálculo de los parámetros P, PI, PD o PID según Ziegler-Nichols
Este método ofrece la posibilidad de sintonizar los parámetros sin llegar a conocer
el modelo matemático que rige la planta. Debido a que no conocemos el modelo matemático
de nuestro sistema balancín, hemos optado por utilizar el método de Ziegler-Nichols en lazo
cerrado.
Sin embargo, para que podamos utilizar el criterio propuesto por Ziegler y Nichols,
y para que el sistema oscile, éste deberá tener un orden igual o superior a 3. La explicación
del por qué es bien sencilla; los sistemas de 1er orden y 2do orden no oscilan de manera
mantenida. Esto también lo podemos ver al estudiar el lugar geométrico de las raíces de las
plantas a controlar.
69
Por ejemplo, el comportamiento de un sistema de primer orden es el siguiente:
Gráfico 73. Lugar geométrico de las raíces de un sistema de 1er orden
A medida que incrementamos la ganancia proporcional, el polo se va alejando del

semiplano derecho y nunca llegará a cruzar por el eje imaginario. Por lo tanto, no conseguirá
a oscilar.
Para el caso de sistemas de 2do orden, tenemos lo siguiente:
Gráfico 74. Lugar geométrico de las raíces de un sistema de 2do orden
Cuando comenzamos a aumentar la ganancia, los polos comenzarán a buscarse y

crecerán perpendicularmente, como se puede observar en la imagen. Estos polos nunca van
a llegar a cruzar el eje imaginario, y por tanto, nunca oscilarán y no podremos utilizar el
criterio.
Ahora bien, para sistemas de 3er orden tenemos lo siguiente:
70
Gráfico 75. Lugar geométrico de las raíces de un sistema de 3er orden
A medida que vayamos incrementando la ganancia, los polos se van a distribuir de

tal forma hasta el punto de que 2 de ellos crucen por el eje imaginario, y que otro polo
comience a alejarse de dicho eje. El cruce de estos 2 polos por el eje imaginario le permitirá
al sistema el poder oscilar de manera mantenida, y que por ende, podamos utilizar el criterio
de Ziegler-Nichols.
La ganancia que hace que 2 de los polos del sistema se posicionen sobre el eje
imaginario recibe el nombre de ganancia crítica. Cuando el sistema llega a esta ganancia
crítica, indica que está al borde de la inestabilidad. Un pequeño incremento en esta ganancia
provocará la inestabilidad.
Ahora bien, sabemos que el criterio de Ziegler-Nichols se aplica para sistemas de
3er orden en adelante. Sin embargo, al no saber el modelo matemático que rige nuestro
sistema balancín, no sabemos exactamente cuál es el orden que tiene nuestra planta.
De todas maneras, hemos decidido igualmente aplicar este criterio y observar cuál es
el comportamiento del mismo.
Comenzamos con reducir las ganancias integrales y derivativas a 0, e incrementamos
poco a poco la ganancia proporcional. Empezamos con una ganancia proporcional igual a
Kp = 1.3.
Ángulo vs tiempo
0
-5 0 0.5 1 1.5 2 2.5 3
Ángulo de inclinación (º)
-10
-15
-20
-25
-30
-35
-40
-45
-50
Tiempo (s)
71
Podemos observar que aún no hemos conseguido las oscilaciones mantenidas,

además que la salida no oscila en torno a la consigna (0º). Aumentamos la ganancia
proporcional a Kp = 2.5.
Ángulo vs tiempo
20
10
0
0 2 4 6 8
-10
-20
-30
-40
-50
Tiempo (s)
La respuesta del sistema para una ganancia de 2.5 presenta oscilaciones que
disminuyen con el paso del tiempo. A medida que hemos seguido incrementando la
ganancia, estas oscilaciones crecen en el tiempo y no llegan a mantenerse estables. Esto nos
da un indicio de que el modelo matemático de nuestro sistema balancín es de un orden
inferior a 3, y que ésta es la razón por la que no conseguimos hacerlo oscilar de manera
mantenida. En conclusión, no podemos aplicar el criterio de Ziegler-Nichols.
No obstante, existen otras opciones para la sintonización de parámetros de un
controlador PID, entre los más populares, está el ajuste manual de un PID.
Sintonización manual de un controlador PID
Para ajustar el PID de manera manual, debemos de variar los parámetros del
controlador a medida que observamos el comportamiento del sistema. Para ello, seguiremos
el siguiente orden:
1. Ajustamos primero la ganancia proporcional para disminuir el error del sistema y
aumentar la velocidad, hasta que comience a oscilar.
2. Aumentamos la constante integral luego con tal de eliminar el error en estado
estacionario.
3. Por último, incrementamos la ganancia derivativa con tal de conseguir más
estabilidad en el sistema.
Al observar la gráfica 76, el sistema presenta una oscilación leve y un tiempo de
establecimiento medianamente rápido (Ts = 1 s). No obstante, la salida del sistema dista
mucho del valor de la consigna, obteniéndose un error elevado. Procedemos a incrementar
la constante integral (Ki) para eliminar el error residual del sistema.
72
Gráfico 78. Respuesta del sistema balancín para una ganancia de (Kp = 1.3 Ki = 0.009 Kd= 0)
Para una constante proporcional Kp de 1.3 y Ki de 0.009, podemos observar que

obtenemos la respuesta temporal característica de un sistema lineal de segundo orden
subamortiguado ante una entrada de escalón unitario. Por lo que deducimos que nuestro
sistema es de 2do orden.
Estudiando los parámetros de la respuesta temporal de la figura anterior, tenemos lo
siguiente:
Gráfico 79. Estudio de la respuesta del sistema balancín para una ganancia de (Kp = 1.3 Ki = 0.009 Kd = 0)
Donde:
- Tp (Tiempo de pico): Es el tiempo que transcurre hasta que se alcanza el
primer pico. En este caso, tenemos un Tp de 0,906 segundos.
- Tr (Tiempo de crecimiento): Es el tiempo que tarda la salida en alcanzar
por primera vez el valor final (la consigna). En este caso, tenemos un Tr
de 0,6 segundos.
73
- Ts (Tiempo de establecimiento): Es el tiempo necesario para que el

sistema se encuentre dentro de un porcentaje (entre un 2 o 5 % del valor
final). En este caso, tenemos un Ts de 2,562 segundos.
A pesar de tener una buena respuesta del sistema (un tiempo de establecimiento
medianamente rápido), podemos observar que tenemos un primer sobrepico relativamente
alto (22º medido a partir de los 0º, la consigna). Hemos intentado reducir este sobrepico
incrementando la ganancia derivativa.
Ángulo vs tiempo
20
10
0
0 2 4 6 8 10
-10
-20
-30
-40
-50
Tiempo (s)
Gráfico 80. Respuesta del sistema balancín para una ganancia de (Kp = 1.3 Ki = 0.009 Kd= 0.8)
Al incrementar la ganancia derivativa a 0.8, el primer sobrepico ha disminuido 12º

con respecto al gráfico anterior. Sin embargo, podemos notar la presencia de ruido en la
salida. Además, el tiempo de establecimiento Ts es de 6 segundos (3.438 segundos más de
retardo con respecto al Ts de la salida anterior). Lógicamente, si seguimos incrementando la
ganancia derivativa, la presencia de ruido será mayor. Por lo tanto, disminuimos la constante
Kd para observar el comportamiento del sistema.
74
Ángulo vs tiempo
4
Ángulo de inclinación (º) 2

0
0 2 4 6 8 10 12
-2
-4
-6
-8
-10
-12
-14
Tiempo (s)
Para una constante derivativa de 0.2, conseguimos disminuir el sobrepico. No

obstante, la presencia de ruido sigue siendo evidente. Con la finalidad de obtener una
respuesta con un sobrepico no tan pronunciado como de la figura 79, reducimos la ganancia
proporcional, (manteniendo el mismo valor de la constante integral), y esto es lo que hemos
obtenido.
Ángulo vs tiempo
40
30
20
10
0
0 2 4 6 8 10 12 14 16
-10
-20
-30
-40
-50
Tiempo (s)
Para este gráfico, podemos apreciar un sobrepico bastante pronunciado (de

aproximadamente 30º) y un tiempo de respuesta de 3.5 segundos. Reducir la ganancia
proporcional no ha conseguido disminuir el sobrepico. Estos parámetros no nos sirven.
El comportamiento que toma el sistema si incrementamos a Kp = 1.4 y Ki = 0.009 es
el siguiente:
75
Ángulo vs tiempo
40
Ángulo de inclinación (º) 30

20
10
0
0 1 2 3 4 5 6
-10
-20
-30
-40
-50
Tiempo (s)
El sistema de la figura 83, presenta oscilaciones entorno al valor de referencia hasta

volverse medianamente estable al paso de 4 segundos, además de seguir teniendo un
sobrepico bastante pronunciado (30º). La salida de este sistema no es deseable.
Ángulo vs tiempo
30
20
10
0
0 5 10 15 20 25 30
-10
-20
-30
-40
-50
-60
Tiempo (s)
El presente gráfico 84 presenta un primer sobrepico elevado, con un tiempo de pico

y de crecimiento iguales que las del gráfico 79, pero con un tiempo de establecimiento de
3.6 segundos. Estos valores medidos se realizaron basándonos en las primeras oscilaciones
del sistema antes de que se estabilice.
Por otra parte, hemos introducido perturbaciones al sistema. Al cabo de 15 segundos,
hemos cambiado la posición del balancín de manera manual moviéndolo hacia la izquierda,
y lo dejamos soltar. El controlador corrige esta desviación y trata de estabilizar el balancín
nuevamente, y para ello, le toma un Ts ≈ 3 segundos.
76
Al cabo de 20 segundos desde que iniciamos el control, desplazamos la posición del

balancín nuevamente hacia la izquierda, y observamos la reacción del sistema.
En esta última perturbación, apreciamos un primer sobrepico mayor que el primer
sobrepico del anterior caso. No obstante, la salida tarda más en estabilizarse y llegar al
ángulo de referencia.
Cabe decir que la respuesta del sistema de la gráfica 79 puede ser aceptable. Pero si
queremos mejorar aún más la salida y hacer que el sistema sea más estable, debemos seguir
buscando esos parámetros P, I, D que nos permitan obtener una respuesta temporal rápida,
sin oscilaciones, sin un sobrepico tan pronunciado, y que sea estable a medida de que pase
el tiempo.
Con tal de conseguir “suavizar” o reducir el sobrepico, decidimos fijar un valor bajo
a la constante proporcional de Kp = 1.1 y dejar las constantes Ki y Kd en cero. La gráfica
resultante:
Ángulo vs tiempo
10
0
0 1 2 3 4 5 6
-10
-20
-30
-40
-50
Tiempo (s)
Podemos observar que aún no hemos conseguido las oscilaciones mantenidas,

además que la salida no oscila en torno a la consigna (0º). Para eliminar el error residual y
conseguir un poco de estabilidad, aumentamos la constante integral y derivativa,
respectivamente.
77
Ángulo vs tiempo
30
Ángulo de desplazamiento (º) 20
10
0
0 2 4 6 8 10 12
-10
-20
-30
-40
-50
Tiempo (s)
Como era de esperarse, conseguimos eliminar el error residual. La salida tarda en

estabilizarse aproximadamente 2.5 segundos. No obstante, el sobrepico sigue siendo muy
elevado. Con tal de reducirlo, reducimos un poco la constante integral y aumentamos la
derivativa.
Ángulo vs tiempo
10
0
Ángulode inclinación (º)
0 1 2 3 4 5 6 7 8 9
-10
-20
-30
-40
-50
Tiempo (s)
Al estudiar el gráfico de arriba, podemos observar que hemos conseguido reducir el

sobrepico de 20º a 5.45º. Sin embargo, como desventaja, el tiempo de establecimiento ha
aumentado a 3.2 segundos.
En conclusión, podemos utilizar los parámetros Kp, Ki, Kd hallados en el gráfico 79
a pesar de su pronunciado sobrepico, (aunque con un tiempo de estabilización rápido). Los
parámetros para el gráfico 87, sin embargo, se caracterizan por presentar un tiempo de
establecimiento mayor, (aunque con un sobrepico menor). El hecho de escoger cuáles
parámetros utilizar dependerá del tipo de respuesta que deseamos obtener.
78
3.4.4 Explicación del código PID del Balancín
Antes de proceder con la programación del controlador PID de nuestro sistema

balancín, debemos saber de antemano la estructura que tendrá nuestro algoritmo. Por ende,
hemos decidido realizar un diagrama de flujo donde se ilustren las principales acciones a
llevar a cabo. Este diagrama nos ayudará a tener una idea más clara de la estructura general
de nuestro algoritmo de control.
Gráfico 88. Diagrama de flujo del control PID del sistema balancín
Es importante recordar que será la controladora de vuelo la responsable de conseguir

que el drone se desnivele para que nosotros podamos dirigirlo a la dirección que queramos.
Es por ello que hemos decidido añadir la controladora de vuelo a nuestro sistema balancín
de un eje. Esta controladora de vuelo será la app Androide.
El mecanismo de funcionamiento del controlador PID es el siguiente: Lo primero
que hará esta estructura de control, será comparar el ángulo de inclinación del balancín con
el ángulo de inclinación que recibimos desde el módulo MPU-6050. Luego, procedemos a
hacer la resta de estas señales para obtener el error o la desviación. Si no enviamos nada
desde el mando de control, el balancín tenderá a mantenerse estable en el ángulo de 0º.
Gráfico 89. Estructura de control del balancín utilizando la app
79
Por ejemplo, si desde el mando enviamos un ángulo de inclinación de 0º de roll, y el

sensor arroja un valor de lectura de inclinación de +10º, habrá que actuar sobre los motores
de tal manera que el módulo MPU obtenga un valor de lectura de 0º. En este caso, la señal
de error tendrá el siguiente valor:
𝐸𝑟𝑟𝑜𝑟 = ºÁ𝑛𝑔𝑢𝑙𝑜𝑚𝑎𝑛𝑑𝑜 (0º) − ºÁ𝑛𝑔𝑢𝑙𝑜𝑚𝑝𝑢 (+10º) = −10 º
Este error es enviado al control PID, y su función será generar una señal de respuesta
en microsegundos; acelerando y desacelerando los motores correspondientes con tal de
contrarrestar el efecto de la perturbación. (ArduProject.es, 2018).
Con el paso del tiempo, la desviación se va a ir corrigiendo hasta que la señal de error
sea 0. A este punto, el drone permanecerá estable.
Gráfico 90. Ejemplo de la evolución de la respuesta del mpu-6050 en función del valor del mando
A continuación, procederemos a explicar la estructura de control reflejada en el

gráfico número 88.
Primero debemos comenzar con la inclusión de las librerías. La librería Wire nos
ayudará con la comunicación I2C con el módulo MPU-6050. Específicamente, nos permite
acceder a la lectura y escritura de los registros donde se alojan los datos recogidos por el
sensor. Por otra parte, la librería Servo nos permitirá generar la señal PWM para mover
nuestros variadores de velocidad, y, por ende, los motores. Es por ello que debemos de crear
en primer lugar los objetos de la clase Servo, los cuales representarán a nuestros 2 motores;
el de la izquierda y el de la derecha. Luego, procedemos con la declaración y definición de
las variables globales que usaremos a lo largo del programa.
En la función setup del arduino, comenzamos con nuestra primera comunicación I2C
con el módulo, donde debemos despertarle del sleep mode. Para ello, debemos de acudir al
datasheet del módulo y buscar la dirección del registro que contenga el bit a
activar/desactivar.
El registro PWR_MGMT_1 nos permite no sólo despertar del sleep mode al módulo,
sino que también activa el modo de configuración de ambos sensores para la futura
modificación de los parámetros internos. Su dirección en memoria es el 0x6B.
80
Gráfico 91. Registro para despertar el módulo MPU-6050
Ahora debemos configurar la sensibilidad que tendrán nuestros sensores

(acelerómetro y giroscopio).
El registro GYRO_CONFIG nos permite configurar la sensibilidad del giroscopio.
En nuestro caso, lo hemos configurado a una escala de 1000 dps (degrees per second: grados
por segundo). Su dirección en memoria es el 0x1B.
Gráfico 92. Registro para la configuración de la sensibilidad del giroscopio.
El registro ACCEL_CONFIG nos permite configurar la sensibilidad del

acelerómetro. En nuestro caso, lo hemos configurado a una escala de +/- 8g. Su dirección en
memoria es el 0x1C.
Gráfico 93. Registro para la configuración de la sensibilidad del acelerómetro.
Una vez que hayamos configurado la sensibilidad de nuestro acelerómetro y

giroscopio, procedemos a realizar la calibración del MPU-6050. Esta calibración es
importante realizarla, ya que elimina el offset y nos permite así obtener medidas más
precisas. Para ello, tomamos 3000 muestras del acelerómetro y giroscopio y calculamos el
valor medio. Este valor medio es el offset de nuestro dispositivo.
Ahora bien, previamente hemos declarado una variable llamada “motores_off” y la
hemos inicializado en verdadero. Esta variable actúa como bandera y la utilizaremos de la
siguiente manera:
while(motores_off == true)
{
leer_app();
}
Este bloque de instrucción se ejecutará indefinidamente hasta que la condición sea

falsa. La única manera en que esta condición se vuelva falsa es que a través de la llamada a
la función leer_app(), desde el dispositivo presionemos el botón de ON, transmitiendo un
81
carácter al microcontrolador y dándole a entender que queremos iniciar el programa

principal.
Una vez que presionamos el botón de ON en la app, salimos del bucle de control, y
procedemos a asignar los pines 3 y 5 como nuestras salidas PWM para los motores. Mediante
la función writeMicroseconds, perteneciente a la clase Servo, enviamos 1000 microsegundos
a cada motor, el cual representa el valor del ancho de pulso de la señal PWM, preparando a
los motores para girar.
Debido a que tenemos que medir el tiempo transcurrido entre cada iteración,
utilizamos la función propia del arduino (millis), el cual calcula el tiempo desde que se ha
encendido el microcontrolador. También establecemos un retardo de 10 segundos para poder
conectar la batería una vez enviada la señal PWM de 1000 microsegundos.
En la función loop, comenzamos con el cálculo del tiempo transcurrido entre cada
iteración. Este tiempo lo usaremos para las fórmulas de aplicación del filtro complementario
y del control derivativo de nuestro PID. Dado que este tiempo calculado está en unidades de
milisegundos, y nos interesa el valor en segundos, lo dividimos entre 1000.
Una vez calculado el valor del tiempo transcurrido en unidades de segundos,
procedemos al llamado de la función de leerMPU, el cual se encarga de leer los valores sin
refinar del acelerómetro o del giroscopio. Esta función recibe 4 parámetros, el cual
pasaremos a describir a continuación.
Address_firstRegister: Corresponde a la dirección del primer registro donde se aloja
la información, ya sea del giroscopio o del acelerómetro. Si queremos leer los valores del
acelerómetro, la dirección de memoria del primer registro que debemos enviar es el 0x3B.
Mientras que, si queremos realizar la lectura del giroscopio, la dirección de memoria a enviar
será el 0x43.
- Vx: Es la variable donde alojaremos, o bien la aceleración medida en el
eje X, o bien la velocidad angular del eje X. Depende de la dirección de
memoria que hayamos enviado previamente. Pasamos esta variable por
referencia.
- Vy: Es la variable donde alojaremos, o bien la aceleración medida en el
eje Y, o bien la velocidad angular del eje Y. Depende de la dirección de
referencia.
- Vz: Es la variable donde alojaremos, o bien la aceleración medida en el
eje Z, o bien la velocidad angular del eje Z. Depende de la dirección de
referencia.
En nuestro programa, comenzamos primero leyendo las aceleraciones de los tres ejes
(X, Y, Z). Luego, llamamos a la función calculate_angle, donde calculamos los ángulos de
inclinación del módulo MPU-6050 con respecto a los ejes X e Y. Para el cálculo de estos
ángulos, utilizamos las fórmulas (1) y (2). Cabe destacar que estos ángulos los almacenamos
temporalmente para implementarlos luego en la función correspondiente a la del filtro
complementario.
Ahora procedemos a llamar nuevamente a la función leerMPU, pero con la intención
ahora de obtener las velocidades angulares de los 3 ejes. Una vez que hayamos terminado
82
de obtener las lecturas del giroscopio, hacemos el llamado a la función filtro

complementario.
Esta función aplica la fórmula número (7), combinando el ángulo de inclinación
calculado de los ejes X e Y, y las velocidades angulares (ya refinadas) también de los ejes X
e Y. Con esta fórmula, obtenemos el ángulo final de rotación los ejes X e Y. Uno de estos
ángulos se utilizará en la función PID. Como se ha comentado anteriormente, el propósito
de aplicar este filtro es la de resolver la problemática del ruido y de la deriva presentes en
nuestras medidas.
Es aquí donde ahora llamamos la función de leerApp. Esta función realiza diversas
tareas, dependiendo del carácter recibido que se leerá a través de la instrucción Serial.read,
tenemos:
- Si recibimos el carácter 1: Disminuimos en intervalos de “0.80” el ángulo
de referencia que hayamos establecido previamente. Esto hará que el
balancín se incline hacia la izquierda. Llamamos también a la función
mapear_valores para garantizar que el nuevo ángulo de referencia no
sobrepase los límites. Si no hemos presionado la tecla de girar hacia la
izquierda, entonces el valor de referencia seguirá siendo 0º.
- Si recibimos el carácter 2: Aumentamos en intervalos de “0.80” el ángulo

de referencia que hayamos establecido previamente. Esto hará que el
balancín se incline hacia la derecha. Llamamos también a la función
mapear_valores para garantizar que el nuevo ángulo de referencia no
sobrepase los límites. Si no hemos presionado la tecla de girar hacia la
derecha, entonces el valor de referencia seguirá siendo 0º.
- Si recibimos el carácter 3: Apagamos los motores de manera rápida.
- Si recibimos el carácter 4: Modificamos el valor de la variable

“motores_off” a verdadero, con tal de poder salir del bucle de control
antes mencionado.
Ahora es cuando llamamos a la función Control PID. Para saber qué acciones
debemos aplicar con nuestro controlador, debemos primero conocer el error en nuestro
sistema, por lo que procedemos a calcular el error. Este error no es más que la diferencia
entre el ángulo real calculado y el valor de referencia (la consigna). Como nuestro balancín
solo trabaja a lo largo del eje X, es importante que el mismo se encuentre alineado con este
eje. Sin embargo, el ángulo de rotación a utilizar será el del Roll, el cual corresponde con el
eje Y.
Una vez que tenemos la señal de error calculada, procedemos a aplicar el control
proporcional. Este control resulta de multiplicar la constante Kp (anteriormente inicializado
con un valor arbitrario) con el error. En pocas palabras, la finalidad de este controlador es la
de eliminar el error del sistema.
Luego, para el control integral, como sabemos que este se caracteriza por actuar sólo
si estamos cerca de la consigna, creamos una sentencia if condicional en la que establecemos
los límites que debe valer el error. (Entre -3 y 3). Para realizar la integración, sumamos el
valor de la integral anterior con el error multiplicado por la constante Ki. Este control se
83
encargará de reducir el valor final de la acción integral en cada iteración hasta que
alcancemos el valor de 0. En pocas palabras, la finalidad de este controlador es la eliminar
el error residual que queda del controlador proporcional.
En cuanto al control derivativo, sabemos que la derivada de la señal representa la
velocidad de variación de esta señal de error. Por lo tanto, este control procederá a actuar
cuando exista una desviación entre el error actual y el error anterior. Es por esta razón que
creamos una variable llamada “error_ant”. Para la aplicación de este control, hacemos la
diferencia entre el error actual y el error anterior, y este resultado lo dividimos entre el tiempo
que ha transcurrido entre cada llamada a este control derivativo. Todo esto multiplicado por
nuestra constante Kd, En pocas palabras, la finalidad de este controlador es la de eliminar
las oscilaciones generando una corrección en la señal de control proporcional a la derivada
de la señal de error e(t).
Finalmente, procedemos a sumar el resultado de cada control (proporcional, integral
y derivativo) para así obtener el control PID. Por último, debemos de aplicar las acciones
con las correcciones pertinentes en nuestro sistema actuador, los cuales lo conforman los
ESC y los motores. Para ello, llamamos a la función actuador.
Esta función realiza diversas acciones. La primera de ellas, es garantizar que el valor
de salida del controlador PID esté entre un rango aceptable. En otras palabras, Los valores
PID oscilará entre -1000 y 1000, ya que cuando el mínimo valor del PWM se encuentre en
1000 µs, el máximo valor que se le puede añadir es +1000 µs, y debemos cerciorarnos de no
sobrepasarnos de este valor. Por otra parte, cuando estemos en el máximo valor del PWM,
el cual es 2000 µs, el máximo valor que podemos substraer es de -1000 µs, y así alcanzar el
punto mínimo de 1000 µs. Debemos asegurarnos de no sobrepasarnos de estos rangos.
La segunda acción que realiza nuestra función, es la de crear el ancho de pulso de la
señal con que alimentaremos a nuestros ESC, (que a su vez controlarán a nuestros motores).
Para ello, simplemente sumamos la aceleración inicial que tienen estos motores más la salida
del controlador PID.
Nuevamente, tenemos que asegurarnos de que los valores no sobrepasen los límites
de trabajo: (1000 µs < valor final < 2000 µs). Por ende, debemos volver a mapear los valores
finales PWM para nuestros 2 motores y asegurarnos de que el valor final que enviaremos a
nuestros ESC esté dentro del rango correcto.
Una vez que hayamos mapeado los valores, procedemos a enviar los valores PWM
finales a nuestros 2 motores, mediante la función WriteMicroseconds perteneciente a la clase
Servo. Por último, guardamos en la variable “error_ant” el error actual.
84
3.4.5 Sistema Drone
3.4.5.1 Efectos de un controlador PID en un drone
Ya hemos visto cómo obtener las constantes P, I, D de nuestro sistema balancín.

Ahora es momento de enfocar nuestra atención en el drone mismo. Es momento de sintonizar
sus parámetros PID. No obstante, es importante entender primero cómo afectarán las
ganancias proporcionales, integrales y derivativas a nuestro drone basándonos únicamente
en la variación de altura del drone, sin entrar en detalles con los ejes Yaw, Pitch y Roll.
Para empezar, supongamos que sólo utilizamos un control proporcional para elevar
el drone desde el suelo y que se mantenga estable a una altura de 3 metros. En este caso, la
posición inicial del drone será el nivel del suelo (0 metros), y la posición que queremos
alcanzar será la consigna. Inicialmente, tenemos un error de 3 metros (3 – 0 = 3). Para una
comprensión, observemos el siguiente gráfico.
Gráfico 94. Comportamiento del drone aplicando un controlador proporcional
Recordemos que a la salida de nuestro bloque controlador será la velocidad de giro

de los motores. Una vez que el lazo de control comience a ejecutarse, (y dependiendo de la
ganancia Kp), el drone comenzará a elevarse (Situación A), y llegará un momento en que el
mismo alcance una velocidad que cree una fuerza de empuje que sea igual al peso del drone,
provocando que el drone flote en el aire y no continúe elevándose (Situación B).
Si la ganancia Kp es lo suficientemente alta, llegará un momento en que el drone se
acercará a la posición deseada. Sin embargo, los motores se apagarán (puesto que el error es
0), y el drone se caerá. En su caída, los motores volverán a activarse (el error se ha
incrementado), y el drone se volverá a elevar. Este comportamiento no es deseable en nuestro
sistema.
Por ejemplo, asumamos que la velocidad para la cual el drone flota es de 30 rpm. Y
comenzamos a ir variando la ganancia Kp, tenemos:
85
Gráfico 95. Relación entre la variación de la ganancia y el valor que toma el error
Como podemos observar en la imagen, a medida que vamos incrementando la

ganancia, el error nunca se irá (sólo se va haciendo más pequeño). Este error recibe el nombre
de Steady state error (Brian, 2018).
Con tal de deshacernos de este error, debemos dejar que el drone utilice información
de los errores que se han ido acumulando en el pasado. Es aquí donde entra en juego la parte
integral. Veamos cuál será el comportamiento del drone aplicando un controlador PI.
Gráfico 96. Comportamiento del drone aplicando un controlador PI
Una vez iniciado el proceso, el drone comenzará a elevarse (Situación A). Cuando
llegue al punto donde ocurre el steady state error (por debajo de la posición deseada), la parte
integral realizará la siguiente acción:
86
Gráfico 97. Ejemplo de cómo funciona la parte integral
Como hemos mencionado anteriormente, la parte integral representa la acumulación

de la señal de error. A medida que transcurra el tiempo, pequeños errores se van sumando
de manera que la acción de este control aumente, consiguiendo reducir el error del sistema
en régimen estacionario (steady state error). En otras palabras, el error en estado estacionario
se integrará y el valor en la salida del controlador se incrementará, y, por ende, la velocidad
de las hélices aumentará y el drone podrá seguir elevándose para alcanzar la altura deseada;
el error irá disminuyendo.
No obstante, puede darse el caso de que mientras el drone se encuentre muy cerca a
la posición deseada, la parte integral haya acumulado un valor superior a la velocidad de
flote del drone, provocando que el drone se eleve por encima de la posición deseada
(Situación B). Esto acarrea las siguientes consecuencias:
- Debido a que el drone sigue elevándose por encima de la posición
deseada, el error se vuelve negativo. Al integrar un error negativo, la
salida del controlador será una velocidad inferior para hacer que el drone
descienda y llegue al nivel de estabilización (Situación C).
- Entre más alto se eleve el drone, más tiempo le tomará al sistema en

conseguir la estabilización.
Para solucionar este problema, simplemente debemos añadir un elemento en nuestro
controlador de manera que pueda “predecir el futuro”, es decir, de manera que responda a
qué tan rápido nos estamos acercando a nuestra referencia (Brian, 2018). Este elemento es
la parte derivativa.
La parte derivativa es la velocidad con que varía la señal de error. Para mayor
comprensión, veamos el siguiente ejemplo:
Gráfico 98. Ejemplo de cómo funciona la parte derivativa
87
Por ejemplo, si nuestro drone se está aproximando a nuestra referencia de manera

rápida, el error irá también disminuyendo rápidamente, creándose una tasa de cambio
negativa. Al derivarlo, tendremos un valor negativo en la salida de nuestro controlador,
provocando que las velocidades de las hélices de nuestro motor vayan disminuyendo de
manera prematura para evitar que el drone se sobrepase de la referencia, evitando la
situación B de la figura 96.
Si juntamos las 3 partes (Proporcional, Integral y Derivativa), y si hemos sintonizado
las constantes Kp, Ki, Kd correctamente, el comportamiento de nuestro drone (siguiendo el
ejemplo de las figuras 94 y 96), sería el siguiente:
Gráfico 99. Comportamiento del drone aplicando un controlador PID
El drone comenzará a elevarse (Situación A) y lo seguirá haciendo mientras se

encuentre por debajo de la referencia. La acción integral tratará de eliminar el error residual
que queda del controlador proporcional con la intención de reducirlo a cero, evitando que el
drone termine flotando por debajo de los 3 metros. A medida que se vaya aproximando, la
acción derivativa reducirá la velocidad de las hélices para que el drone no sobrepase la
referencia debido a su propia inercia, consiguiendo finalmente lo que queríamos; que el
drone se mantenga flotando a los 3 metros (Situación B).
Una vez entendido cómo actúan las distintas partes de nuestro controlador PID,
debemos también saber que existen estrategias de control de vuelo en el mundo del
aeromodelismo. Entre las más comunes, se encuentran el modo acrobático y el modo estable.
En el modo acrobático, el drone no vuelve a su posición inicial tras una rotación a
causa de alguna fuerza externa (como la fuerza del viento), sino que sólo trata de
contrarrestar el efecto de la perturbación que ha causado esta fuerza externa en el drone,
hasta que consigamos detenerlo. (ArduProject.es, 2018).
Mientras que, en el modo estable, el drone vuelve a su posición inicial tras una
rotación a causa de alguna fuerza externa. A pesar de que en este modo es más fácil de
controlar al drone, también resulta ser el más complejo al momento de programar los PID’s.
88
Es por ello que nos centramos en desarrollar el modo acrobático primero, con la posibilidad
de incluir también el modo estable en un futuro.
3.4.5.2 Descripción del problema
La manera de proceder con la programación del drone es distinta a la forma con que
se ha programado el sistema balancín. Esto se debe a que en el sistema balancín se utiliza
solamente uno de los 3 ejes (el eje Roll). Mientras que el drone utiliza los 3 ejes del espacio
(Yaw, Pitch, Roll).
En base a los posibles movimientos del drone, debemos de enviar a los 4 motores las
velocidades que permitan que el sistema se mantenga estable en el aire. Además, también
queremos que acate las órdenes que recibe del mando de control. Esta información que recibe
del exterior será captada por la IMU 6050.
De momento, tenemos un lazo de realimentación como la mostrada a continuación:
Gráfico 100. Posible lazo de realimentación de nuestro sistema drone
Lo que debemos plantearnos ahora es cómo conseguimos enviarles a los 4 actuadores

las velocidades correctas para poder controlar al drone de manera estable. Para ello, debemos
centrarnos en el bloque cuya salida es la velocidad que tendrán los actuadores; Controlador
PID.
Para el desarrollo de un algoritmo correcto de nuestro controlador PID, debemos
tener en cuenta todos los posibles movimientos que puede realizar nuestro drone; los 6
grados de libertad.
En otras palabras, tenemos 4 motores para 6 grados de libertad.
- Movimientos traslacionales: arriba, abajo, izquierda, derecha, hacia
adelante, hacia atrás.
- Movimientos rotacionales: Yaw, Pitch, Roll.
Sin embargo, es fácil darse cuenta que algunos de estos movimientos están
relacionados entre ellos. Por ejemplo, para desplazarnos hacia la izquierda, primero debemos
aplicar un roll donde las velocidades de los motores laterales derechos sean mayores que las
velocidades de los otros motores.
89
Y si por ejemplo, deseamos movernos hacia adelante, basta con aplicar un pitch,
donde las velocidades de los motores delanteros sean superiores que las velocidades de los
motores traseros.
Por tanto, podemos resumir nuestros movimientos en 4: Pitch, Yaw, Roll, y el
Throttle (altitud). Ahora debemos de ser capaces de producir estos 4 movimientos en nuestro
drone con los 4 motores.
Con tal de poder controlar el pitch, yaw, roll y la altitud de manera independiente, la
dirección de las hélices de los motores deben estar dispuestos de la siguiente manera:
Gráfico 101. Dirección de giro correcta de las hélices del drone
En un primer inicio, podemos variar por ejemplo el pitch sin afectar el roll, la altitud
ni el yaw. Sin embargo, en espacios abiertos donde hay turbulencias y vientos fuertes, los
movimientos del uno del otro se acoplan y se combinan, por lo que resultaría difícil variar
el movimiento de uno de los ejes sin afectar a los otros. No obstante, resaltamos que el
propósito de nuestro drone es hacerlo volar en espacios cerrados y pequeños.
Mediante esta configuración, tenemos un control directo sobre los 4 movimientos.
Además, es lógico pensar que la variación de alguno de estos 4 movimientos va a cambiar
la estabilidad inicial del drone. Por ende, las señales a enviar a nuestros 4 actuadores serán
una combinación del Pitch, Yaw, Roll y la altitud.
Recordemos cómo producir estos movimientos en nuestro drone.
- Yaw: Si deseamos que el drone se mueva en el sentido de giro de las
manecillas del reloj, debemos de aumentar la velocidad de las hélices del
motor frontal izquierdo y del motor trasero derecho. Si deseamos el efecto
contrario, debemos aumentar la velocidad de los otros 2 motores.
- Roll: Si deseamos que el drone se desplace hacia la izquierda, debemos

de aumentar la velocidad de las hélices del motor frontal derecho y del
motor trasero derecho. Si deseamos desplazarnos hacia la derecha,
debemos aumentar la velocidad de los otros 2 motores.
- Pitch: Si deseamos que el drone se desplace hacia adelante, debemos de

aumentar la velocidad de las hélices del motor frontal derecho y del motor
frontal izquierdo. Si deseamos desplazarnos hacia atrás, debemos
aumentar la velocidad de los otros 2 motores.
90
- Altitud: Si deseamos elevar el drone, debemos de aumentar en la misma

proporción la velocidad a los 4 motores. Si queremos que el drone
descienda, basta con reducir la velocidad de estos 4 motores en la misma
proporción.
En base a esta información, podemos realizar el algoritmo de las señales a enviar para
cada motor. Un posible algoritmo podría ser el siguiente:
𝑀𝑜𝑡𝑜𝑟𝑓𝑟𝑜𝑛𝑡 𝑟𝑖𝑔ℎ𝑡 = 𝐴𝑙𝑡𝑖𝑡𝑢𝑑 − 𝑌𝑎𝑤 + 𝑃𝑖𝑡𝑐ℎ − 𝑅𝑜𝑙𝑙
𝑀𝑜𝑡𝑜𝑟𝑓𝑟𝑜𝑛𝑡 𝑙𝑒𝑓𝑡 = 𝐴𝑙𝑡𝑖𝑡𝑢𝑑 + 𝑌𝑎𝑤 + 𝑃𝑖𝑡𝑐ℎ + 𝑅𝑜𝑙𝑙
𝑀𝑜𝑡𝑜𝑟𝑏𝑎𝑐𝑘 𝑟𝑖𝑔ℎ𝑡 = 𝐴𝑙𝑡𝑖𝑡𝑢𝑑 + 𝑌𝑎𝑤 − 𝑃𝑖𝑡𝑐ℎ − 𝑅𝑜𝑙𝑙
𝑀𝑜𝑡𝑜𝑟𝑏𝑎𝑐𝑘 𝑙𝑒𝑓𝑡 = 𝐴𝑙𝑡𝑖𝑡𝑢𝑑 − 𝑌𝑎𝑤 − 𝑃𝑖𝑡𝑐ℎ + 𝑅𝑜𝑙𝑙
El procedimiento a utilizar es similar al empleado en el sistema balancín, con la

diferencia de que se deben de programar los controladores PID adicionales para los ejes pitch
y yaw.
Gráfico 102. Estrategia de control del modo Acrobático
Para realizar la programación de nuestro drone, empleamos 3 controladores PID, uno

por cada eje. Para la elevación en vertical del drone (throttle), no es necesario aplicar un
controlador.
3.4.5.3 Descripción de la solución
La estrategia de control a utilizar es el modo acrobático, con la funcionalidad extra

de poder estabilizar el drone a una posición de 0º cuando la persona así lo requiera. Para
91
poder incorporar esta funcionalidad extra, es necesario utilizar 2 PID adicionales (para los
ejes Pitch y Roll).
- Un primer PID (lazo de inclinación), que compara la consigna de
inclinación que enviamos desde el mando con el ángulo de inclinación
actual del drone. Este controlador generará una salida que será la consigna
de velocidad para el siguiente PID.
- Un segundo PID (lazo de velocidad), que compara la velocidad recibida

desde el primer PID, junto con la velocidad de rotación del drone actual.
Este controlador generará una salida que serán las velocidades que
deberán girar los motores para contrarrestar la inclinación y así el drone
pueda posicionarse en 0º.
Esta funcionalidad se activará desde el mando y se desactivará cuando el usuario

envíe otra orden al drone. Tras ello, el microcontrolador volverá a ejecutar únicamente los
lazos de velocidad (modo acrobático) para mantener estable el drone.
Gráfico 103. Estrategia de control del modo Acrobático con la posibilidad de posicionar el drone a 0º
No obstante, nos enfocamos primero en conseguir mantener estable al drone

utilizando únicamente los lazos de velocidad (gráfico 102) antes de incluir la opción de auto
estabilidad (gráfico 103).
Señal PWM a enviar a los motores
En nuestro balancín hay sólo 3 parámetros PID a controlar (Kp, Ki, Kd)
pertenecientes al eje Roll. Sin embargo, el drone utiliza 9 parámetros PID a controlar en el
lazo de velocidad, 3 por cada eje, complicando más la programación del sistema.
Una posible secuencia de instrucciones a ejecutar en este modo de control sería:
1- Leeremos las velocidades angulares del sensor MPU-6050 de los ejes
Pitch, Roll y Yaw.
92
2- Recibimos las consignas correspondientes desde el mando de control,

dependiendo de la opción escogida por el usuario.
3- Comparamos estas lecturas con las consignas correspondientes que
recibimos desde el mando de control. El PID de cada eje calculará el error
y decidirá qué tanto habrá que acelerar o desacelerar los motores para
compensar este error y minimizarlo.
4- Volvemos al paso 1.
Tras la realización de varias mediciones, el tiempo medio de ejecución de las
instrucciones anteriores es de aproximadamente unos 6 ms, con retardos puntuales que llegan
a veces hasta los 7 ms. Para garantizar que el ciclo de ejecución sea siempre la misma, hemos
decidido que el periodo con que los controladores PID actuarán será de 8 ms.
Por tanto, debemos de enviar las señales pwm (velocidad de giro de los motores) con
el mismo periodo que el lazo de control. El tiempo de ejecución de ambos procesos debe de
estar sincronizados.
Ahora bien, uno de los inconvenientes de utilizar la función WriteMicroseconds para
la generación de señales PWM (de la librería servo), es que se ejecuta a una frecuencia de
50 Hz (cada 20 ms), siendo un periodo de ejecución muy lento para el lazo de control del
drone.
Una alternativa para generar una señal PWM sincronizada es la siguiente:
Gráfico 104. Creación de la señal PWM sincronizada con el lazo de control
Del gráfico anterior, tenemos 3 aspectos importantes a resaltar:

1) Momento A: Es el tiempo en el cual el pulso está en estado HIGH. Esta
puede variar entre 1 ~ 2 ms. (A modo de ejemplo, se decidió escoger 1.8
ms). Dependiendo del tiempo en que la señal está en estado HIGH, la
velocidad de los motores irá variando.
2) Momento B: Es un tiempo “muerto” en la que arduino no hará nada, solo

esperar. Con esto garantizamos que la lectura del sensor MPU y del
mando ocurra siempre en el mismo instante, independientemente del
tiempo en que el pulso esté en estado HIGH.
93
3) Momento C: Es el tiempo en la que arduino procede a realizar las

siguientes tareas:
- Lectura del sensor MPU-6050: cálculo de los ángulos de inclinación y de

las velocidades angulares en los 3 ejes.
- Lectura del mando (app).
- Ejecución del lazo de velocidad (los 3 PID, uno para cada eje),
actualizando la velocidad con que los motores deberán girar para el
siguiente ciclo.
Una vez realizada las tareas en el momento C, procedemos a crear la señal PWM
para el siguiente ciclo. Para crear los flancos de subida y de bajada de la señal PWM,
utilizamos la función integrada en el arduino llamada digitalWrite. Esta función recibe dos
parámetros:
- Número de pin: le especificamos el pin el cual el motor está asociado.
- Estado de la señal: HIGH para flancos de subida, LOW para flancos de

bajada.
El hecho de generar un PWM sincronizado con la frecuencia de los lazos de control
garantiza una mayor rapidez en la actualización de las velocidades de los 4 motores, y por
ende, garantiza también un mayor control del cuadricóptero.
3.4.5.4 Las vibraciones (ruido)
Un aspecto importante a tener en cuenta es el tema de las vibraciones. El 100 % de

las vibraciones provienen de las hélices, las cuales sustentan el peso del drone en pleno aire.
Si las hélices no están bien calibradas, en combinación con la gran velocidad de giro,
provocarán pequeños tambaleos e irregularidades en su movimiento. Esto se traduce en
vibraciones que pueden afectar en la estimación de la inclinación (y de las velocidades
angulares). (ArduProject, 2018). Como consecuencia, el drone nunca será estable (sin
importar la sintonización de los parámetros PID que hayamos realizado).
Existen varias técnicas para reducir las vibraciones. Las que hemos utilizado son:
- Calibración de las hélices.
- Aislamiento físico del microcontrolador y sensor MPU-6050.
- Uso de filtros digitales paso bajo (Digital Low Pass Filter).
94
Calibración de las hélices
Dentro del mundo del aeromodelismo, es bien sabido que no todas las hélices que
vienen de fábrica están calibradas. Para saber si las hélices adquiridas están calibradas,
podemos utilizar un artefacto llamado calibrador de hélices. En nuestro caso, el equilibrador
de hélices se compone de 2 vasos de igual tamaño. Entre estos 2 vasos, reposa un tornillo
envuelto con cinta aislante por donde entra el eje de la hélice.
Este proceso de calibración consiste en conseguir el punto de equilibrio de las hélices.
Gráfico 105. Hélice sin calibrar
En la imagen anterior, la pala izquierda de la hélice tiene más peso que la de la

derecha. No está calibrada. La consecuencia de hacer girar una hélice sin calibrar es la
mostrada a continuación.
Gráfico 106. Velocidad del motor izquierdo trasero sin haber calibrado su hélice
95
Como podemos observar en el gráfico, hay una gran cantidad de ruido presente en la
velocidad a enviar al motor izquierdo trasero. Un mal balanceo de la hélice, provocará que,
cuando el motor gire a grandes revoluciones, una pala tienda a elevarse un poco por encima
de la otra pala, y por ende, la hélice temblará; creándose las vibraciones.
Gráfico 107. Origen de las vibraciones en nuestro sistema
Debemos de buscar la manera de reducir lo máximo posible las vibraciones que

ocurren en la hélice de este motor.
Una solución para conseguir su equilibrio es cortar un trozo rectangular de cinta
adhesiva transparente y pegarlo en el borde de ataque de la pala derecha. Si observamos que
la pala derecha se vuelve ahora más pesado que el izquierdo, debemos repetir el proceso
hasta conseguir el total equilibrio de la hélice.
Gráfico 108. Hélice ya calibrado
96
Gráfico 109. Velocidad del motor izquierdo trasero con su hélice calibrada
Al realizar la comparación de los gráficos 106 y 109, podemos observar una gran
disminución de las vibraciones. Procedemos a realizar esta calibración para todas las hélices
de nuestro cuadricóptero, en caso de que haga falta.
Aislamiento físico del microcontrolador y sensor MPU-6050
Una técnica simple pero muy poderosa a la hora de reducir (e incluso eliminar) el
ruido de nuestras mediciones, es “aislar” aquellos componentes que puedan verse afectados
por las vibraciones remanentes de las hélices. Este componente es el sensor MPU-6050.
Para aislar nuestro único sensor, simplemente debemos de utilizar un material en
concreto que separe físicamente el sensor del frame de nuestro drone. El material escogido
ha sido de goma espuma, el cual reduce en buena parte las vibraciones.
97
Gráfico 110. Aislamiento del sensor MPU-6050 del frame utilizando goma espuma
Al aislar nuestro sensor y realizar las pruebas, nos hemos percatado de que seguía
existiendo ruido que afectaba nuestras mediciones. El drone no respondía a los comandos
enviados desde la app.
La explicación del por qué el sensor continuaba recibiendo ruido de las hélices, es
porque no habíamos aislado el microcontrolador arduino del chasis, y por tanto, las
vibraciones viajaban a través de los cables que conectan al sensor con el arduino.
Gráfico 111. Aislamiento del microcontrolador del frame utilizando goma espuma
El hecho de aislar el microcontrolador y el sensor del chasis nos ha permitido tener

un mayor control y maniobrabilidad de nuestro drone. Esto se debe a que gran parte de las
vibraciones remanentes de las hélices son absorbidas por la goma espuma, y no afectarán
por tanto al sensor mpu.
Sin embargo, para una mayor disminución de ruido, hemos decidido optar por la
implementación de filtros digitales paso bajo.
98
Uso de filtros digitales paso bajo (Digital Low Pass Filter)
Un filtro paso bajo es un filtro que se caracteriza por permitir el paso de las
frecuencias que estén por debajo de una frecuencia en específico, llamado frecuencia de
corte. Pueden ser recreados a través de circuitos analógicos, o mediante circuitos digitales
y/o programas informáticos (filtro digital).
Gráfico 112. Ejemplo de una señal atenuada por un filtro digital paso bajo
En nuestro sistema, el filtro digital paso bajo se encargará de separar aquellas señales
de interés que han sido contaminadas con las interferencias remanentes de las hélices (ruido).
Filtro digital paso-bajo que incorpora el sensor MPU-6050
Este dispositivo incorpora un filtro LPF (Low Pass Filter) con distintas frecuencias
de corte. Sin embargo, cuanto más bajo sea la frecuencia de corte, más retardo habrá en
nuestras medidas (incluso superando el periodo de ejecución que hemos establecido
previamente: 8 ms). La siguiente tabla muestra las distintas frecuencias de corte con su
correspondiente retardo.
Gráfico 113. Configuración del filtro digital paso-bajo, de acuerdo al datasheet del MPU-6050
Para seleccionar qué frecuencia de corte deseamos utilizar, basta con escribir en el
registro DLPF_CFG el valor al cual está asociado dicha frecuencia de corte. En nuestro
sistema, hemos optado por una frecuencia de corte 44 Hz (para el acelerómetro) y de 42 Hz
(para el giroscopio), por tanto escribimos en el registro DLPF_CFG el valor de 0x03.
Como podemos observar en el gráfico 112, para la frecuencia de corte escogida,
tenemos un retardo aproximadamente de 4.9 milisegundos. Este retardo es inferior a nuestro
periodo de ejecución que hemos escogido, por tanto es aceptable.
99
Gráfico 114. Filtro digitales paso-bajo del acelerómetro y giroscopio respectivamente
Para saber si la frecuencia de corte escogida nos ayudará a reducir el ruido de nuestras
mediciones, basta con calcular la frecuencia de las vibraciones de las hélices. Para ello,
debemos conocer la cantidad de revoluciones por minuto a la que nuestras hélices giran.
Los motores adquiridos son del modelo A2212 con una constante 1000 KV. Esta
constante representa el número de revoluciones por minuto que será capaz de ofrecer al
aplicar 1 voltio de tensión. Al alimentarlo con una batería 3 S de 11.1 voltios, nuestro motor
podrá llegar a girar a una velocidad de 11100 rpm sin carga (con una señal PWM en estado
alto de 2000 microsegundos; 100 % Throttle).
Sin embargo, el drone no girará a esta velocidad durante todo el vuelo. El valor de la
velocidad a enviar a los motores irán variando de acuerdo a los controladores PID y del
usuario.
Debido a que el mecanismo de control se activa cuando el acelerador (variable que
modifica el usuario) está por encima de 1200, podemos asumir que las velocidades de
nuestro drone variarán entre 20 % del valor de la aceleración (1200 microsegundos) y 100
%, correspondiente a 2000 microsegundos. Es decir:
- 11100 𝑟𝑝𝑚 ∙ 20 % = 2220 𝑟𝑝𝑚
- 11100 𝑟𝑝𝑚 ∙ 100 % = 11100 𝑟𝑝𝑚

Por tanto, para el cálculo de la frecuencia de las vibraciones:
- Un motor que gira a una velocidad de 2220 rpm:
𝑟𝑒𝑣
2220 𝑟𝑝𝑚 = 2220
min
𝑟𝑒𝑣 1 𝑚𝑖𝑛
2220 ∙ = 37 𝑠 −1 = 37 𝐻𝑧
min 60 𝑠
- Un motor que gira a una velocidad de 11100 rpm:
𝑟𝑒𝑣
11100 𝑟𝑝𝑚 = 11100
min
𝑟𝑒𝑣 1 𝑚𝑖𝑛
11100 ∙ = 185 𝑠 −1 = 185 𝐻𝑧
min 60 𝑠
100
Nuestro sistema se enfrentará a vibraciones que podrán oscilar entre 37 Hz y 185 Hz.
Para la frecuencia de corte que hemos escogido, 44 Hz (para el acelerómetro) y de 42 Hz
(para el giroscopio), resulta ser entonces un buen filtro.
Cabe resaltar que estos cálculos son aproximaciones rápidas para tener una idea de
la cantidad de ruido teórica que puede afectar nuestras mediciones. No obstante, la
calibración de hélices, en combinación con el proceso de aislar nuestros dispositivos del
cuerpo del drone, reducirá la frecuencia de las vibraciones producidas.
A modo de ejemplo, encendemos los cuatro motores e incrementamos la velocidad
hasta 1357 rpm (11.6 % de aceleración). Luego, procedemos a medir las velocidades
angulares en los 3 ejes (pitch, roll, yaw) en 2 condiciones.
1) Sin utilizar el filtro digital paso-bajo del sensor MPU-6050.
2) Utilizando el filtro.
Los resultados:
Gráfico 115. Comparación en la lectura de las velocidades angulares sin emplear filtro (izq) y empleando filtro (der)
Podemos observar una gran disminución de ruido en el gráfico derecho en

comparación con el gráfico izquierdo. Por tanto concluimos que el uso del filtro digital paso-
bajo que incorpora el sensor es necesario en nuestro sistema. No obstante, el ruido aún
persiste; es entonces cuando debemos buscar otras técnicas de reducción de estas frecuencias
no deseadas.
Filtro exponencial EMA
Se trata de un filtro utilizado para suavizar la salida ante una serie de lecturas de
datos. El valor filtrado será el promedio de todas las mediciones anteriores, ponderadas por
un factor llamado alfa.
La expresión del cual se rige el filtro EMA:
𝐴𝑛 = 𝛼 ∙ 𝑀 + (1 − 𝛼 ) ∙ 𝐴𝑛−1
Donde:
- 𝐴𝑛 : El valor filtrado.
101
- 𝛼: Es un factor comprendido entre 0 y 1. Su valor rige el comportamiento

del filtro.
- M: Es el valor muestreado de la señal.
- 𝐴𝑛−1 : Valor filtrado anterior.

El filtro EMA presenta un aporte de información "nueva" a través de la medición M,
y un efecto de suavizado basado en la memoria que aporta el valor filtrado anterior An-1. El
resultado de un filtro exponencial EMA es una señal suavizada donde la cantidad de
suavizado depende del factor alfa. (Llamas, FILTRO PASO BAJO Y PASO ALTO
EXPONENCIAL (EMA) EN ARDUINO, 2017).
El filtro EMA puede ser usado ya sea como un filtro paso-bajo o un filtro paso-alto.
Para nuestros fines, haremos uso del filtro paso-bajo.
Para que nuestro filtro EMA paso-bajo nos ayude a reducir lo máximo posible las
vibraciones del gráfico 115, debemos de elegir un factor alfa adecuado. Este factor alfa es
un valor comprendido entre 0 y 1, el cual está relacionado con la frecuencia de corte del
filtro.
- Cuando alfa tiene un valor de 0, significa que la frecuencia de corte es
0 Hz, por tanto, el filtro ignorará las señales de interés y obtendremos en
la salida siempre un valor filtrado de cero.
- Cuando alfa tiene un valor de 1, el filtro no realizará ningún filtrado a

la señal muestreada.
Tras varias mediciones y pruebas con nuestro drone, un valor alfa igual a 0.55 nos
ayuda a reducir parte del ruido.
Gráfico 116. Comparación entre la velocidad angular Roll sin filtrar y la filtrada (Filtro EMA)
Para la obtención del gráfico anterior, movemos el drone con la mano a lo largo del
eje Roll, y observamos el comportamiento; de la señal muestreada (color azul), y de la señal
filtrada (color rojo). Para esta prueba, dejamos los motores apagados.
102
Como podemos contemplar, el filtro EMA elimina el ruido de alta frecuencia que se
encontraba superpuesto en nuestra señal de interés (la velocidad angular en el eje Roll).
Ahora veamos el efecto positivo de utilizar el filtro para eliminar las fluctuaciones en la
consigna de velocidad enviada a los motores.
Gráfico 117. Filtro EMA: Velocidad del motor sin emplear filtro (izq) y empleando filtro (der)
Tras analizar los gráficos 116 y 117, podemos concluir que el uso del filtro EMA
resulta indispensable dentro de nuestro sistema. Haremos uso de este filtro únicamente para
filtrar las velocidades angulares de los ejes Pitch, Roll y Yaw.
En cuanto al filtrado de los valores que mide el acelerómetro, utilizaremos el filtro
complementario (en combinación con los valores del giroscopio sin filtrar). La descripción
y explicación de este filtro fue tratado en el apartado de Inicialización del sensor MPU-
6050 (pág. 41).
Emplear cada una de estas técnicas para eliminar las vibraciones nos ayudarán a
mejorar la comunicación entre nuestro controlador de vuelo y el drone, evitando que
aparezcan ciertas situaciones no deseadas como los tambaleos y las oscilaciones.
3.4.5.5 Sintonización PID
Procedemos con encontrar los 9 parámetros P, I, D de los lazos de velocidad de cada

eje. Una vez que el drone se mantenga estable y podamos controlarlo sin problema en modo
acrobático, pasamos a la sintonización de los parámetros P, I, D de los lazos de aceleración
para los ejes Pitch y Roll.
Sin embargo, existen ciertas situaciones indeseables que se pueden dar durante las
primeras pruebas de nuestro cuadricóptero. Antes de proceder con la sintonización de
nuestros controladores, debemos evitar que el efecto “windup” aparezca en nuestro sistema.
El efecto windup se da cuando el actuador de nuestro sistema se satura, provocando
que el propio sistema tarde mucho tiempo en reaccionar ante las perturbaciones o cambios
de referencias que se hayan producido durante la saturación.
A continuación, utilizaremos un ejemplo para una mayor comprensión de las
consecuencias del efecto windup en nuestros sistemas.
103
El drone se encuentra amarrado con unas cuerdas a nivel del suelo (posición actual)
y la consigna o la posición deseada es a la altura de 3 metros. Al momento de encender los
motores, el comportamiento de la señal de error y de velocidad a enviar a los motores son
las siguientes:
Gráfico 118. Efecto “windup”
Del gráfico anterior, tenemos 5 aspectos importantes a resaltar:

A) Como el drone se encuentra amarrado a nivel de suelo, sigue estando
presente el error de 3 metros, por tanto, el controlador aumenta la
velocidad a enviar a los motores con tal de alcanzar la posición deseada
(identificado con color rojo). La componente integral del PID acumula el
error existente con el paso del tiempo y crece (identificado con color
verde).
B) Alcanzamos el límite máximo de velocidad de los motores (2000

microsegundos). El drone permanece amarrado en el suelo y el error de 3
metros sigue presente. Por tanto, la componente integral del PID continúa
acumulando el error existente con el paso del tiempo.
C) Cortamos las cuerdas y el drone despega súbitamente. La señal de error

(identificado con color azul) comienza a decrecer. La componente integral
comienza a acumular cada vez errores más pequeños. Sin embargo, la
señal integral sigue estando por encima del límite físico de los actuadores.
Como consecuencia, la velocidad de los motores no disminuye y continúa
siendo 2000 𝜇s.
D) El drone alcanza la posición deseada y continúa subiendo. La señal de

error se vuelve negativa, provocando que la componente integral
comience a decrecer. La velocidad de los actuadores no cambia y sigue
siendo de 2000 𝜇s.
E) El valor decreciente de la componente integral alcanza el límite físico de

los actuadores, disminuyendo finalmente la velocidad de los actuadores.
104
Para este punto, el drone se habrá elevado muchos metros por encima de
su referencia; la señal de error habrá crecido mucho más negativamente.
Existen muchas alternativas para evitar que aparezca el efecto windup, describiremos
la que hemos decidido utilizar, llamada limitación del término integral.
Gráfico 119. Técnica antiwindup por limitación del término integral
La solución es bastante simple. Limitamos la acción integral entre dos límites

previamente establecidos. Esto evitará que la acción integral continúe sumando los errores
anteriores cuando el actuador esté en saturación. Adicionalmente, limitamos la salida una
vez aplicado el algoritmo de control de los motores antes de enviar la señal a los motores.
En nuestro sistema balancín, sin embargo, empleamos otra técnica antiwindup:
Integración condicional.
Gráfico 120. Técnica antiwindup por integración condicional
Esta técnica consiste en integrar la señal de error siempre y cuando el valor absoluto
del error se encuentre dentro de un determinado rango. Desde un inicio, hemos optado por
utilizar este método antiwindup para nuestro drone. No obstante, tras repetidas pruebas,
hemos observado mejores resultados con la técnica de limitación del término integral.
105
Pruebas para la búsqueda de los parámetros PID
Como bien sabemos, la variación de los parámetros PID que conforman nuestros
lazos de velocidad y aceleración influye en la estabilización de nuestro cuadricóptero. Para
conseguir estos parámetros, realizaremos el ajuste a prueba y error en un “banco de
pruebas”.
La razón principal por la que no realizamos el ajuste mediante simulación, es que
sería necesario conocer el modelo matemático completo que rige el drone, resultando ser
complejo su implementación.
Por tanto, hemos optado por montar un “banco de pruebas”, donde realizaremos los
testeos y analizaremos el comportamiento que toma el sistema.
Gráfico 121. Banco de pruebas para la sintonización PID del drone
Para analizar el comportamiento de las distintas señales, utilizaremos el Serial

monitor.
El Serial monitor es una herramienta disponible en el IDE de arduino que nos permite
ver los valores de nuestras variables. Consiste en una consola de entrada y salida donde
podremos mostrar datos enviados por nuestra placa arduino, así como también podremos
enviar datos a nuestro microcontrolador (Rodríguez, 2019). Para interactuar con él, basta
con enviar dicho valor a través de la función Serial.println, y luego acceder al menú
herramientas, y escoger la opción de Serial monitor.
En el código principal, hemos añadido una función llamada display_data con la
finalidad de ver en tiempo real la manera que nuestro sistema responde ante ciertas entradas
106
(perturbaciones externas y comandos recibidos desde la app). Además, el usuario podrá

escoger qué señal estudiar desde el código principal.
Para la sintonización de los parámetros PID, no existe un método en particular que
nos garantice la estabilidad del sistema. Sin embargo, podemos seguir unas reglas sencillas
para la sintonización manual (prueba y error).
A modo de ejemplo, mostraremos el proceso de ajuste de los parámetros PID para
el eje Pitch del lazo de velocidad. Este proceso se deberá realizar también para el eje Roll.
Para un mejor análisis de las señales, guardaremos en una hoja de cálculo los datos recibidos
por la consola y las graficaremos.
Ajuste de la ganancia Proporcional
Comenzamos con colocar en cero los parámetros integral y derivativo. Este ajuste
consiste en aumentar poco a poco la ganancia Kp para disminuir el error y aumentar la
velocidad de respuesta. Partimos con una ganancia proporcional de Kp = 2.
kp =2 ki = 0 kd = 0
60
40
Velocidad angular (º/s)
20
-20
-40
-60
-80
0 1 2 3 4 5 6 7 8 9 10 11 12
Tiempo (s)
Gráfico 122. Velocidad angular del eje pitch (sintonización de Kp) – Prueba I
Utilizando el banco de pruebas, aceleramos los cuatro motores y con la mano le

damos 2 golpes al chasis del cuadricóptero. Esto se hace con el fin de introducir
perturbaciones al sistema y observar cómo reacciona éste ante los mismos.
En la gráfica, podemos observar que el sistema presenta oscilaciones antes de
alcanzar la estabilidad tras recibir una perturbación externa. El tiempo de establecimiento es
de:
𝑇𝑠 = 6.704 𝑠 − 4.264 𝑠 = 2.44 𝑠
Procedemos a disminuir la ganancia proporcional para aumentar la velocidad del
sistema. Para un Kp = 1.7.
107
kp = 1.7 ki = 0 kd = 0
60
Velocidad angular (º/s) 40
20
-20
-40
-60
-80
0 1 2 3 4 5 6 7 8 9 10 11 12 13
Tiempo (s)
Gráfico 123. Velocidad angular del eje pitch (sintonización de Kp) – Prueba II
Tras introducir perturbaciones con la mano, observamos que el sistema sigue

presentando oscilaciones considerables. En la tercera perturbación, el tiempo de
establecimiento es de:
𝑇𝑠 = 12.016 𝑠 − 9.944 𝑠 = 2.072 𝑠
Procedemos a disminuir la ganancia proporcional para aumentar la velocidad del
sistema. Para un Kp = 1.275
kp = 1.275 ki = 0 kd = 0
100
80
60
40
20
0
-20
-40
-60
-80
-100
0 1 2 3 4 5 6 7 8 9 10 11 12 13
Tiempo (s)
Gráfico 124. Velocidad angular del eje pitch (sintonización de Kp) – Prueba III
Tras varias pruebas, conseguimos disminuir las oscilaciones. Además, conseguimos

una reacción más rápida en cuanto a la estabilización de la velocidad ante las perturbaciones
introducidas. En la primera perturbación, el tiempo de establecimiento es de:
𝑇𝑠 = 7.096 𝑠 − 5.376 𝑠 = 1.72 𝑠
108
Como observamos, hemos logrado aumentar la velocidad de respuesta del sistema

al reducir la ganancia proporcional. Esto quiere decir que, en las ganancias Kp anteriores, el
sistema presentaba ya inestabilidad, provocando que la velocidad angular medida tarde en
alcanzar la posición final deseada (0 º/s).
Con tal de conseguir aún más estabilidad en nuestro sistema, procedemos al ajuste
de la ganancia derivativa.
Ajuste de la ganancia Derivativa
Dejamos en cero el parámetro integral e incrementamos el parámetro derivativo. Este
ajuste consiste en aumentar poco a poco la ganancia Kd para conseguir de nuevo la
estabilidad del sistema. Cabe destacar que esta acción de control no nos ayudará a reducir el
error permanente. Eso lo realizará la acción integral. Partimos con una ganancia proporcional
de Kd = 1.
kp = 1.275 ki = 0 kd = 1
40
20
-20
-40
-60
-80
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
Tiempo (s)
Gráfico 125. Velocidad angular del eje pitch (sintonización de Kd) – Prueba I
Tras introducir perturbaciones con la mano, observamos que el sistema sigue

presentando oscilaciones considerables. En la primera perturbación, el tiempo de
establecimiento es de:
𝑇𝑠 = 8.064 𝑠 − 6.088 𝑠 = 1.976 𝑠
Al comparar este tiempo de establecimiento con el gráfico anterior. Podemos
observar un incremento del mismo. Este es uno de los efectos no deseados cuando
incrementamos la constante derivativa; disminuye un poco la velocidad del sistema. No
obstante, debemos seguir aumentando la ganancia derivativa con tal de conseguir una
respuesta más estable.
Para la siguiente medición, optamos por incrementar un poco la ganancia
proporcional Kp para aumentar la velocidad de respuesta.
Prueba para Kp = 1,3 y un Kd = 8.
109
kp = 1.3 ki = 0 kd = 8
40
30
Velocidad angular (º/s) 20
10
0
-10
-20
-30
-40
-50
0 1 2 3 4 5 6 7 8 9 10 11
Tiempo (s)
Gráfico 126. Velocidad angular del eje pitch (sintonización de Kd) – Prueba II
Procedemos a calcular el tiempo de establecimiento del gráfico anterior de la primera

perturbación.
𝑇𝑠 = 4.952 𝑠 − 3.328 𝑠 = 1.624 𝑠
Observamos una reducción del tiempo de establecimiento en comparación con el
gráfico de la ganancia Kd = 1. Sin embargo, el sistema continúa presentando pequeñas
oscilaciones. Prueba para Kp = 1,3 y un Kd = 22.
Kp = 1.3 Ki = 0 Kd = 22
60
40
20
-20
-40
-60
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
Tiempo (s)
Gráfico 127. Velocidad angular del eje pitch (sintonización de Kd) – Prueba III
𝑇𝑠 = 10.872 𝑠 − 9.072 𝑠 = 1.8 𝑠

El tiempo de establecimiento ha incrementado en 0.176 segundos en comparación
con la gráfica anterior. No obstante, notamos una mayor estabilidad. Pasamos ahora al ajuste
de la ganancia integral.
110
Ajuste de la ganancia Integral

Este ajuste consiste en aumentar poco a poco la ganancia Ki hasta que el error en
régimen permanente se minimice con la rapidez deseada. Cabe destacar que esta acción de
control aumenta la inestabilidad del sistema, por lo que no debemos excedernos en su ajuste.
Partimos con una ganancia integral de Ki = 0,01.
Kp = 1.3 Ki = 0.01 Kd = 22
60
40
20
-20
-40
-60
-80
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14
Tiempo (s)
Gráfico 128. Velocidad angular del eje pitch (sintonización de Ki) – Prueba I
Tras introducir perturbaciones con la mano, observamos que el sistema presenta

oscilaciones. En la primera perturbación, el tiempo de establecimiento es de:
𝑇𝑠 = 7 𝑠 − 5.648 𝑠 = 1.352 𝑠
Observamos una reducción del tiempo de establecimiento en comparación con el
gráfico 127. Si queremos una velocidad de respuesta más rápida, entonces continuamos
incrementando Ki.
Kp = 1.3 Ki = 0.02 Kd = 22
80
60
40
20
0
-20
-40
-60
-80
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
Tiempo (s)
Gráfico 129. Velocidad angular del eje pitch (sintonización de Ki) – Prueba II
111
Volvemos a introducir perturbaciones con la mano y calculamos el tiempo de

establecimiento.
𝑇𝑠 = 9.712 𝑠 − 8.544 𝑠 = 1.168 𝑠
Observamos una reducción del tiempo de establecimiento de 0,184 segundos en
comparación con el gráfico anterior. Como contrapartida, las oscilaciones han crecido. Si el
sistema se torna inestable antes de conseguir la respuesta deseada, procedemos a aumentar
la ganancia derivativa.
Aplicamos estas reglas de sintonización también para el eje roll y el lazo de
aceleración. En cuanto al eje Yaw, simplemente aumentamos la ganancia proporcional y
testeamos que el drone efectivamente responda bien a los comandos de giro sobre este eje.
La razón de no realizar un proceso de sintonización PID sobre este eje, se debe a que la
lectura de su velocidad angular no tiene ningún efecto sobre la estabilidad horizontal de
nuestro cuadricóptero.
Finalmente, adjuntamos los valores finales PID obtenidos durante la fase de prueba
para cada eje. Sin embargo, es importante comentar que para un mejor comportamiento y
estabilidad del cuadricóptero, es necesario realizar el ajuste mediante pruebas de vuelo y
control.
Lazo de velocidad angular (w)

Pitch Roll Yaw
Kp Ki Kd Kp Ki Kd Kp Ki Kd
1.3 0.02 22 1.3 0.02 22 3 0.02 0
Tabla 14. Parámetros PID del lazo de velocidad angular.
Lazo de aceleración
Pitch Roll
Kp Ki Kd Kp Ki Kd
2 0.04 4 1.7 0.04 4
Tabla 15. Parámetros PID del lazo de aceleración.
3.4.5.6 Explicación del código del sistema drone
La estructura del algoritmo que rige nuestro sistema drone guarda muchas similitudes
con la de nuestro sistema balancín. Por tanto, en esta sección sólo explicaremos aquellas
nuevas secciones de código que hemos incluido.
En nuestro archivo principal, comenzamos con la definición de la única librería que
utilizaremos, Wire.h, para la comunicación con nuestro módulo sensor MPU-6050. Luego,
procedemos con la declaración y definición de las variables en general.
A diferencia del código de nuestro sistema balancín, ahora el usuario podrá:
112
- Escoger qué señal(es) visualizar y/o analizar durante la ejecución del

programa. Así mismo, se podrá elegir entre graficar la señal directamente
a través del serial plotter, o bien enviar los datos a través del serial
monitor para su posterior representación gráfica mediante hojas de
cálculo.
- Escoger qué motores activar. Esta opción la hemos decidido añadir con la
finalidad de analizar el ruido que produce cada motor por separado,
facilitando el proceso de la calibración de las hélices.
Función setup
En la función setup del arduino, comenzamos con la inicialización del sensor MPU-
6050; configuramos la sensibilidad de nuestro acelerómetro y giroscopio. Además,
incluimos la configuración del filtro digital paso bajo que incorpora el sensor, eligiendo una
frecuencia de corte de 44 Hz.
Una vez hayamos finalizado la calibración y corrección del offset de nuestro
dispositivo sensor, procedemos con la inicialización de los motores. En nuestro sistema
drone no hacemos uso de la librería servo.h, por tanto, la manera de inicializar los motores
se lleva a cabo de manera diferente.
Gráfico 130. Función inicializar motores del sistema drone
En la función inicializar_motores, establecemos como salida digital aquellos pines

que están asociados a los motores. Enviamos un nivel de tensión bajo a esos pines y
esperamos 4 segundos. A continuación, comenzamos con el periodo de inicialización.
113
Los motores brushless necesitan recibir pulsos de 1000 microsegundos por una cierta
cantidad de tiempo para prepararlos antes de que comiencen a girar. Cuando los motores ya
están armados y listos para arrancar, emitirán unos pitidos. A través del bucle principal,
mientras la variable esc_calibrado sea falso, estaremos enviando pulsos de 1000
microsegundos a los motores. Luego, procedemos a leer los posibles comandos de la
aplicación recibidos por el módulo HC-06. Si los motores aún no han emitido dichos pitidos,
no leeremos nada.
Todo este proceso se realizará en ciclos de 8 milisegundos. Cuando los motores
emitan los pitidos, presionamos el botón “soltar stick” en nuestra app, y por tanto, la variable
esc_calibrado se cambiará a verdadero, y saldremos del bucle.
Salimos de la función, y antes de entrar en el bucle principal, comenzamos con la
definición de 2 variables para almacenar el tiempo transcurrido.
- “Time”. Debido a que tenemos que medir el tiempo transcurrido entre
cada iteración, utilizamos la función propia del arduino (millis), el cual
calcula el tiempo en milisegundos desde que se ha encendido el
microcontrolador. Utilizaremos esta variable para el cálculo de los
ángulos y del control derivativo.
- “pwm_ciclo”. Utilizamos la función propia del arduino (micros), el cual

calcula el tiempo en microsegundos desde que se ha encendido el
microcontrolador. Esta variable nos ayudará a llevar el control del ciclo
de ejecución de nuestro sistema.
Función loop
En la función loop, realizamos el mismo proceso de lectura y cálculo de las
velocidades angulares y las aceleraciones que llevamos a cabo en el sistema balancín, con la
diferencia que hemos incluido el filtro EMA durante la obtención de las velocidades
angulares.
Gráfico 131. Cálculo de la velocidad angular y aplicación del filtro EMA
114
Gráfico 132. Filtro EMA expresado mediante código
Una vez que hayamos refinado las lecturas de las velocidades angulares, realizamos
el llamado a la función low_passFilter (filtro EMA), donde filtraremos la velocidad obtenida
en cada eje (pitch, roll, yaw). Luego, guardamos estos valores filtrados para la siguiente
iteración.
Cuando hayamos filtrados los valores, procedemos a llamar a la función leer_app.
Donde podremos:
- Encender el drone.
- Cambiar la velocidad de giro de los motores al incrementar el throttle.
- Indicarle al drone los desplazamientos o movimientos que queremos que
haga.
- Auto-estabilizar el drone.
- Apagar los motores.
Ahora procedemos a llamar a la función más importante de nuestro sistema; el
sistema actuador. En esta función:
- Ejecutamos los lazos de velocidad y/o de aceleración, donde llamamos a
las funciones PID de cada eje.
- Limitamos las salidas PID de cada eje entre -400 y 400.
- Aplicamos el algoritmo de control de las señales a enviar para cada motor.
- Limitamos las salidas a enviar de cada motor entre 1100 y 2000
microsegundos.
- Actualizamos los errores anteriores de las velocidades angulares.
- Iniciamos un nuevo conteo para comenzar un nuevo ciclo de ejecución, e
inmediatamente llamamos a la función crear_pwm.
Gráfico 133. Algoritmo de control de los motores del sistema drone
115
Gráfico 134. Función para crear la señal PWM a enviar a los actuadores
Dentro de la función crear_pwm, enviamos un pulso alto (HIGH) a los cuatro pines
asociados con los motores. Luego, sumamos el tiempo de las señales de los cuatro motores
(calculado por el controlador automático) con el tiempo total transcurrido desde el inicio del
nuevo ciclo. Esto tiene la finalidad de llevar el control de las señales en estado alto de los
actuadores.
Finalmente, con el siguiente bucle while, nos encargamos de pasar de flanco alto a
flanco bajo para cada motor, siempre y cuando se cumpla la condición.
Si la variable perteneciente al motor es menor o igual al tiempo total transcurrido,
apagamos el motor correspondiente. Una vez apagados todos los motores, arduino saldrá del
bucle while.
Después de enviar la señal LOW a todos los pines, procedemos con la visualización
de las señales que haya escogido el usuario previamente, llamando a la función display_data.
Esta función enviará un valor a través del serial monitor o serial plotter por cada iteración
del programa principal. Una vez se termine de ejecutar la función, comenzamos nuevamente
el proceso de lectura de datos.
116
3.5 Controladora de Vuelo (App Android)
Este apartado corresponde con el diseño de la aplicación Android. Nos hemos

decantado por el uso de la plataforma gratuita de “MIT App Inventor” para el desarrollo de
la interfaz gráfica y de la programación de la controladora de vuelo. Las ventajas que ofrece
esta plataforma es que cualquier persona con poco o nulo conocimiento de programar
aplicaciones puede hacerlo, además de que es gratuito y que solamente se requiere que
tengamos una cuenta en google.
3.5.1 Desarrollo del módulo controlador del sistema balancín
A continuación, describiremos paso a paso todo el proceso relacionado con el diseño

y programación de la aplicación que utilizaremos en nuestro sistema balancín.
1- En primer lugar, debemos de dirigirnos a la página principal:
https://appinventor.mit.edu/. Una vez dentro, debemos de hacer clic al botón que
dice “Create Apps”.
2- Se abrirá una nueva ventana donde debemos iniciar sesión con una cuenta de
google. Una vez hecho esto, se refrescará la página y hacemos clic al botón “Start
new Project”. Le damos un nombre a nuestro proyecto y clicamos en aceptar.
3- Observaremos una interfaz como la mostrada a continuación:
Gráfico 135. Interfaz inicial para el desarrollo de una nueva aplicación en Mit App Inventor
La plataforma nos ofrece muchas pestañas y funcionalidades interesantes para añadir

a la aplicación. Sin embargo, para nuestros propósitos, sólo nos concierne la pestaña
“Connectivity” (no apreciable en la imagen), y las pestañas señaladas por las flechas en rojo:
“User Interface” y “Layout”.
117
4- El siguiente paso a realizar es entrar en la pestaña de “Connectivity” y arrastrar

la funcionalidad de “BluetoothClient” y soltarla sobre el icono del móvil. Esto
nos permitirá conectar nuestra app con otros dispositivos bluetooth.
Gráfico 136. Incorporación de la funcionalidad bluetooth a la aplicación (Mit App Inventor)
5- Ahora debemos de acceder a la pestaña Layout y empezar a poner capas

horizontales. Estas capas no serán visibles en nuestra app final, sino que ayudan
a establecer un orden y hacer que los distintos elementos que deseemos colocar
sobre la app no se solapen entre ellos.
Gráfico 137. Ejemplo sobre cómo insertar capas para establecer orden en la aplicación (Mit App Inventor)
En este punto debemos de ir arrastrando las capas horizontales en primer lugar de

manera que cubran la parte inferior de la pantalla. Podemos ajustar la altura y anchura de
estas capas en el panel derecho de la interfaz.
También podemos colocar separadores verticales dentro de estas capas antes de
empezar a colocar los botones, esto evitará que los botones estén muy juntos el uno del otro.
118
6- Para colocar botones, debemos de dirigirnos a la pestaña de “User Interface” y

hacemos clic y arrastramos el icono que dice “Button” y lo soltamos donde
deseemos que exista el botón en la app. Por otra parte, cabe destacar que podemos
crear los botones de manera simple (añadiendo texto y cambiando el color del
mismo), o también podemos adjuntarle una imagen que represente al botón, que
es lo que nosotros hemos hecho.
Para adjuntar una imagen al botón, hacemos clic en el panel derecho y

seleccionamos “Image”.
7- Para poder añadir un botón que nos permita activar el bluetooth de nuestro
android y que busque otros dispositivos, clicamos en “User Interface”
“ListPicker”, y arrastramos el elemento sobre la pantalla. El resultado final de la
programación del diseño de nuestra app de control del sistema balancín es el
siguiente:
Gráfico 138. Diseño final de nuestra app de control del sistema balancín
119
Donde:
- La flecha que gira hacia la izquierda: Disminuimos en intervalos de
“0.80” el ángulo de referencia que hayamos establecido previamente. Esto
hará que el balancín se incline hacia la izquierda. La plataforma lo
representa mediante la etiqueta “Button 1”.
- La flecha que gira hacia la derecha: Aumentamos en intervalos de “0.80”

el ángulo de referencia que hayamos establecido previamente. Esto hará
que el balancín se incline hacia la derecha. La plataforma lo representa
mediante la etiqueta “Button 2”.
- El icono de Bluetooth: Permite comunicarnos con otros dispositivos

bluetooth, en nuestro caso, con el módulo HC-06. La plataforma lo
representa mediante la etiqueta “ListPicker”.
- El botón ON: Permite poder iniciar el programa principal “loop”. La razón

de incluir este botón ha sido para darle tiempo al MPU-6050 de calibrarse
y eliminar el offset. Además, así también dispondríamos de un tiempo
para conectar la batería. La plataforma lo representa mediante la etiqueta
“Button 4”.
- El botón OFF: Permite apagar los motores de manera inmediata ante

cualquier problema y/o imprevisto. Hay que recordar que estamos
trabajando con hélices que se mueven a gran velocidad, por lo que resulta
indispensable incluir un botón que apague los motores de manera rápida
(en lugar de desconectar la batería, por razones de seguridad). La
plataforma lo representa mediante la etiqueta “Button 3”.
8- Una vez que hayamos terminado con la parte estética de la aplicación, es

momento de programarla. Para acceder a la interfaz de programación, hacemos
clic en “Blocks”, el cual se encuentra en la parte derecha de la plataforma.
Esta programación se hace a través de bloques. A continuación, adjuntamos la

programación de nuestro controlador del sistema balancín.
120
Gráfico 139. Programación en bloques de nuestra app controladora para el sistema balancín
Donde:
- El bloque A: Antes de que hagamos clic en el icono bluetooth, la
instrucción de color verde llamado “Set Listpicker1” nos enlista todos
aquellos dispositivos bluetooth que alguna vez el teléfono móvil ha estado
conectado. Por lo tanto, es importante que ya hayamos apareado el móvil
con el módulo bluetooth previamente.
- El bloque B: Después de que hagamos clic en el icono bluetooth, y una

vez que hayamos seleccionado el dispositivo con el cual nos queramos
comunicar (HC-06), la instrucción de color verde llamado “Set
Listpicker1” procederá a tratar de comunicarse con dicho dispositivo y
guardará la dirección del mismo. A este punto, ya existe comunicación
entre el móvil y el módulo HC-06.
- Button1: Este botón es la flecha de girar hacia la izquierda. Cada vez que
hagamos clic en él, enviaremos un carácter, en este caso, el número 3. El
envío de caracteres de parte de la app hacia el microcontrolador nos
servirá para que arduino pueda reconocer qué botón ha sido presionado,
puesto que a través del comando Serial.read, arduino recibirá este
carácter.
- Button2: Este botón es la flecha de girar hacia la derecha. Cada vez que
hagamos clic en él, enviaremos un carácter, en este caso, el número 2.
121
- Button3: Este botón es la apagar los motores de manera rápida. Cada vez
que hagamos clic en él, enviaremos un carácter, en este caso, el número
4.
- Button4: Este botón es la de inicio, donde le hacemos saber al arduino que
queremos comenzar el programa principal. Es importante destacar que al
presionar este botón, los motores NO se encenderán de inmediato, sino
que tendremos un margen de 10 segundos para poder conectar la batería.
Cada vez que hagamos clic en él, enviaremos un carácter, en este caso, el
número 1.
Una vez que hayamos terminado con el diseño y la programación de nuestra

aplicación, procedemos a descargarlo para poder guardarlo en nuestro teléfono móvil.
Gráfico 140. Descarga de la aplicación en (Mit App Inventor)
Una vez que hayamos descargado la aplicación en formato apk, procedemos a

conectar nuestro teléfono mediante el cable USB, y enviar el archivo a alguna de las carpetas
del teléfono. Luego, desde nuestro móvil, abrimos la aplicación, la instalamos, y listo. El
resultado final será el siguiente:
Gráfico 141. Versión final de la app controladora del sistema balancín
122
3.5.2 Desarrollo del módulo controlador del sistema drone
El diseño y programación en bloques de la app que controlará nuestro drone se realiza

de la misma manera que la app de control de nuestro sistema balancín. A continuación, se
adjunta el interfaz gráfico final visto desde la pantalla interactiva de MIT App Inventor, así
como de su programación en bloques.
Gráfico 142. Diseño final de nuestra app de control del sistema drone
Gráfico 143. Programación en bloques de nuestra app controladora para el sistema drone (Parte I)
123
Gráfico 144. Programación en bloques de nuestra app controladora para el sistema drone (Parte II)
Cada uno de estos caracteres que enviamos nos servirá para que el arduino pueda
reconocer qué botón ha sido presionado. A través del comando Serial.read, arduino recibirá
estos caracteres.
Gráfico 145. Versión final de la app controladora del sistema drone
A continuación, explicaremos la función de cada botón:

- El botón B: Es el que debemos pulsar inicialmente para establecer una
comunicación Bluetooth entre el drone y el teléfono. Cuando pulsemos,
se desplegará una lista con todos los dispositivos que tengan el bluetooth
activado y que se encuentren cerca.
124
- ON: Este botón lo presionaremos luego de conectar la batería LiPo, para

que así el arduino pueda comenzar a armar los motores (periodo de
inicialización).
- OFF: Apaga todos los motores.
- Soltar stick: Este botón tiene dos funciones. La primera de ellas, es que
durante el periodo de armado de los motores, cuando estos emitan los
pitidos, debemos presionar este botón para poder entrar en el programa
principal. La segunda, para actualizar la consigna de velocidad angular a
0 en los 3 ejes, (este botón simula la acción de soltar el joystick de un
mando RC).
- T: Incrementamos la velocidad de los motores un 5 % con respecto a la

velocidad actual.
- T -: Reducimos la velocidad de los motores un 5 % con respecto a la

velocidad actual.
- Y -: Le indicamos al drone a que gire en el sentido de las agujas del reloj.
- Y: Le indicamos al drone a que gire en el sentido contrario de las agujas

del reloj.
- R -: Le indicamos al drone a que gire hacia la izquierda.
- R: Le indicamos al drone a que gire hacia la derecha.
- P: Le indicamos al drone a que se desplace hacia adelante.
- P -: Le indicamos al drone a que se desplace hacia atrás.
- 0º: Es el botón de auto-nivelado. Cuando el drone se encuentre inclinado,

se activa el lazo de aceleración y velocidad, corrigiendo los ángulos de
inclinación.
125
4 Resultados
A continuación, adjuntaremos los gráficos obtenidos durante la fase de prueba y

visualizaremos aquellas variables que hemos tratado para conseguir el control del
cuadricóptero.
Eje Pitch
Ángulo de inclinación en el eje Pitch

15
10
5
Grados (º)
-5
-10
-15
0 2.5 5 7.5 10 12.5 15 17.5 20 22.5
Tiempo (segundos)
Gráfico 146. Ángulo de inclinación del eje pitch tras recibir comandos de la app
Como podemos observar en el gráfico de la inclinación, el sistema responde de

manera progresiva ante los cambios de orientación enviadas desde la aplicación. Al presionar
el botón de auto-estabilización, el drone entra en el modo “estable” y trata de mantenerse
nivelado (0º). Luego, aproximadamente en el segundo 11.5, le indicamos que gire hacia
adelante sobre su propio eje por unos segundos y volvemos a presionar la opción de auto-
estabilización. Al hacerlo, el lazo de aceleración nos indica la desviación en grados y
generará una referencia de velocidad para el siguiente lazo y así contrarrestar la inclinación.
126
Velocidad angular en el eje Pitch

40
30
20
10
0
-10
-20
-30
-40
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
Tiempo (segundos)
Gráfico 147. Velocidad angular del eje pitch tras recibir comandos de la app
En la representación de la velocidad angular del eje pitch, a medida que

incrementamos la velocidad de los motores, la cantidad de vibraciones también comienzan
a crecer. En el segundo 11, le indicamos al drone que gire hacia atrás 30 º/s, provocando un
pico que alcanza el valor de 30 en el gráfico.
En el segundo 13.5, le ordenamos al drone que gire ahora hacia adelante -30 º/s. Esta
acción provoca igualmente un pico que alcanza el valor de -30 en el gráfico. Repetimos estas
acciones en el segundo 18 y 23, donde conseguimos el mismo efecto. Por ende, podemos
concluir que nuestro controlador responde adecuadamente a los comandos recibidos desde
la aplicación.
Eje Roll
Ángulo de inclinación en el eje Roll

20
15
10
5
Grados (º)
0
-5
-10
-15
-20
-25
0 2.5 5 7.5 10 12.5 15 17.5 20 22.5
Tiempo (segundos)
Gráfico 148. Ángulo de inclinación del eje roll tras recibir comandos de la app
127
De igual forma como observamos en el gráfico de inclinación del eje pitch, el sistema
responde de manera progresiva ante los cambios de orientación enviadas desde la aplicación.
Al presionar el botón de auto-estabilización, el drone entra en el modo “estable” y trata de
mantenerse nivelado (0º). Luego, le indicamos que gire hacia la izquierda sobre su propio
eje por unos segundos, le ordenamos que se detenga en esa posición inclinada, y después
volvemos a presionar la opción de auto-estabilización.
Velocidad angular en el eje Roll

40
30
20
10
0
-10
-20
-30
-40
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
Tiempo (s)
Gráfico 149. Velocidad angular del eje roll tras recibir comandos de la app
En la representación de la velocidad angular del eje roll, a medida que incrementamos

la velocidad de los motores, la cantidad de vibraciones aumentan, pero no de manera tan
significativa como en el eje pitch. En el segundo 4.71, le indicamos al drone que gire hacia
la izquierda - 30 º/s, provocando un pico que alcanza el valor de -30 en el gráfico.
Aproximadamente en el segundo 6, la velocidad trata de alcanzar el valor de 0 luego de
haberle indicado al drone que detenga la rotación, (consigna de velocidad igual a 0).
En el segundo 10, presionamos el botón de auto-estabilización. Esta acción provoca
que el drone presente un pico que alcanza el valor de 30 en el gráfico, con tal de poder
alcanzar el nivel de 0 º.
Aproximadamente en el segundo 12.5, le ordenamos al drone que gire ahora hacia la
derecha 30 º/s, presentando un pico que alcanza nuevamente el valor de 30. Un segundo
después, le indicamos al drone que deje de girar, es decir, actualizamos la consigna de
velocidad al valor de 0, provocando que la velocidad medida intente alcanzar esta velocidad.
Por ende, podemos concluir que nuestro controlador responde adecuadamente a los
comandos recibidos desde la aplicación.
128
5 Conclusiones
Los resultados conseguidos tras la realización de estos proyectos han sido

satisfactorios. Hemos cumplido con los objetivos que nos hemos planteados desde el inicio,
los cuales han sido; el desarrollo de un algoritmo de control que le permita al drone
mantenerse estable en todo momento, así como el diseño de una app Android que se
comunique con nuestro cuadricóptero y nos permita controlarlo.
Para poder llevar a cabo este proyecto, hemos intentado abarcar la mayor cantidad
de áreas posibles que estén relacionados con nuestra carrera. Hemos puesto en práctica
aquellos conocimientos relacionados con el control automático, programación, y de
electrónica en general. Esto nos ha permitido obtener un correcto funcionamiento y control
de nuestro sistema cuadricóptero.
Antes de proceder con el cumplimiento del primer objetivo, hemos optado por la
construcción de un sistema balancín que simule el eje roll de nuestro drone. El propósito de
este balancín es la de mantenerlo estable en un ángulo de 0º en todo momento, aun así reciba
perturbaciones del medio externo. De esta manera, podemos adquirir una mejor noción sobre
el funcionamiento de un controlador PID digital y de la efectividad que tendrá el mismo.
Durante el desarrollo del algoritmo de control, tanto del cuadricóptero como del
balancín, nos hemos percatado de la dificultad de conseguir la estabilidad de un sistema
mediante la sintonización PID por el método de ensayo y error. Existen otras alternativas
mejores de sintonización como; el uso del criterio de Ziegler-Nichols, o bien ya sea mediante
el modelo matemático del sistema para su posterior simulación a través de ciertos programas
informáticos (Simulink). Sin embargo, como ya hemos explicado en su respectivo apartado,
el criterio de Ziegler-Nichols no puede ser aplicado en nuestro sistema balancín, y su
utilización en nuestro drone resulta peligroso y poco aconsejable.
Por otra parte, obtener el modelo matemático del balancín es posible, pero no se trata
del sistema original de estudio, finalmente optando por la sintonización manual. En cuanto
a la representación matemática de nuestro sistema drone, el mismo se hace complicado. Por
tanto, la mejor alternativa que deducimos para la sintonización PID es probándolo
directamente en el cuadricóptero, (dentro de un banco de pruebas, para mayor seguridad).
En relación a los puntos positivos y negativos que hemos observado durante la
realización del proyecto, procederemos a explicar cada uno de ellos.
En primer lugar, cabe señalar la parte positiva. Los algoritmos de control
desarrollados para nuestros sistemas balancín y drone funcionan según lo esperado. El
diseño, programación y posterior implementación de la app resultó ser también satisfactoria,
vinculándose con nuestro módulo Bluetooth HC-06 sin problema y permitiéndonos tener un
control tanto del drone como del balancín de manera remota, como era lo planteado.
Además, a medida que avanzábamos en la realización del presente trabajo, hemos
podido descubrir el gran potencial de nuestro microcontrolador Arduino y el abanico de
posibilidades que presenta a la hora de llevar a cabo cualquier tipo de proyecto relacionado
con la electrónica. Su versatilidad y facilidad a la hora de conectarse con otros dispositivos
tales como el MPU-6050 y HC-06, nos ofrecen una infinidad de opciones para la creación
de distintos proyectos. Donde no solamente podamos poner en práctica nuestros
129
conocimientos en los campos de software y hardware, sino que también podamos hacer uso
de la imaginación y del ingenio para desarrollar proyectos de carácter innovador.
En cuanto a la parte negativa durante la ejecución del trabajo, destacamos la gran
cantidad de tiempo invertido para conseguir mantener estable nuestro drone durante la fase
de sintonización PID. Esto se debe a que nuestro sensor MPU-6050 es muy sensible al ruido,
y no habíamos realizado desde un inicio el proceso de calibración de hélices
correspondientes. Por tanto, señalamos que unas hélices mal ajustadas, o un mal aislamiento
entre los dispositivos sensibles al ruido y el cuerpo que recibe las vibraciones, provocarán
mediciones imprecisas y nuestro sistema nunca sería estable, independientemente del tipo
de ajuste PID empleado.
Como último punto negativo, nos centramos en el dispositivo que funciona como
radiocontrol dentro de nuestro sistema; el móvil con la app Android. De acuerdo a lo que
hemos podido aprender del mundo del aeromodelismo durante la consecución del presente
trabajo, destacamos lo imprescindible de utilizar un mando radio control (RC) con su
respectivo receptor. Estos dispositivos funcionan por interrupciones hardware, consiguiendo
una respuesta rápida del sistema ante el envío de nuevas órdenes por parte del mando RC sin
afectar el ciclo de ejecución del microcontrolador. Sin embargo, en nuestro caso, las órdenes
que enviemos desde la app no serán tratadas de manera inmediata como ocurren con las
interrupciones, sino que quedarán almacenadas en el buffer del HC-06 hasta que el punto
actual de ejecución del programa llame a nuestra función leerApp, donde leemos los datos
del buffer. Esto provoca un ligero retraso que puede afectar la maniobrabilidad de nuestro
drone en pleno vuelo.
Como mejora de nuestro sistema, consideramos la inclusión del mando radio control
RC como hemos mencionado anteriormente. Así como el uso de una placa de montaje, (en
sustitución de la protoboard), para soldar los pines del microcontrolador y los pines de los
distintos componentes que conforman nuestro sistema drone. De esta manera, aseguramos
que ninguna de estas conexiones vaya a soltarse en pleno vuelo. Además, podemos añadir
nuevos sensores; sensor de ultrasonidos, GPS, entre otros, con tal de conseguir un control de
vuelo más preciso y autónomo.
En general, concluimos que el proceso de desarrollo del proyecto ha sido gratificante.
Ha servido no sólo para poner en práctica algunos de los conocimientos adquiridos en la
carrera, sino que también nos ha permitido una mejor compresión de aquellos conceptos que
solo se ven en clase. En lo personal, considero que el presente trabajo es una buena manera
de enlazar conocimientos prácticos-teóricos, y así darnos una idea del futuro trabajo como
ingenieros que podemos llegar a tener.
130
6 Bibliografia
ACLAV. (16 de Agosto de 2017). ¿Cuál es el funcionamiento de un motor brushless?

Obtenido de ACLAV: https://www.aclav.com.ar/cual-es-el-funcionamiento-de-un-
motor-brushless/
Aprendiendo arduino. (14 de Noviembre de 2016). IMU (Inertial Measurement Unit).
Obtenido de Aprendiendo arduino:
https://aprendiendoarduino.wordpress.com/2016/11/14/bus-i2ctwi/
aprendiendo arduino. (21 de Diciembre de 2016). Proyectos sencillos con Arduino. Obtenido
de Aprendiendo Arduino: https://aprendiendoarduino.wordpress.com/tag/imu/
ArduProject. (10 de Julio de 2018). Calibración de hélices y motores Brushless para drones
(sketch). Obtenido de ArduProject.es: https://arduproject.es/calibracion-de-helices-
y-motores-sketch/
ArduProject.es. (5 de Julio de 2018). Control de estabilidad y PID para drones. Obtenido
de ArduProject.es: https://arduproject.es/control-de-estabilidad-y-pid/
Blog de Recursos para Tecnología en Enseñanza Secundaria. (Sin fecha). Sistemas de
Control. Obtenido de Tecnoblogph:
http://tecnoblogph.blogspot.com/2018/02/sistemas-de-control.html
Brian, D. (22 de Mayo de 2018). Understanding PID Control, Part 1: What is PID control?
Obtenido de https://www.youtube.com/watch?v=wkfEZmsQqiA
Canalés, L. (12 de Julio de 2014). Acciones básicas de control. Obtenido de SlideShare:
https://es.slideshare.net/wilmermedrano5/acciones-basicas-de-control
Compañía Levantina de Reductores. (S.f). Diferencias entre motores con escobillas y
brushless. Obtenido de CLR: https://clr.es/blog/es/diferencias-motores-con-
escobillas-brushless/
Dejan. (2019). Arduino Brushless Motor Control Tutorial | ESC | BLDC. Obtenido de How
to Mechatronics: https://howtomechatronics.com/tutorials/arduino/arduino-
brushless-motor-control-tutorial-esc-bldc/
ELECTRONOOBS. (2016). ESC - control electrónico de velocidad. Obtenido de
ELECTRONOOBS: http://www.electronoobs.com/circuitos_tut4.php
facilelectro. (1 de Enero de 2019). Que es el PWM y como funciona. Obtenido de facilelectro:
https://www.facilelectro.es/que-es-el-pwm-y-como-funciona/
García, P. (09 de Mayo de 2013). ¿Qué es el control PID? Obtenido de Franklin Electric:
https://franklinelinkmx.wordpress.com/2013/09/05/que-es-el-control-pid/
García, V. (9 de Septiembre de 2015). Sensor MPU6050. Obtenido de Electrónica Práctica
Aplicada: https://www.diarioelectronicohoy.com/blog/sensor-mpu6050
Inquietum Natura. (26 de Abril de 2017). Como elegir un variador o ESC correcto para
nuestro drone o avión. Obtenido de Inquietum Natura:
https://www.loslocostambientienenblog.com/como-elegir-un-variador-o-esc-
correcto-para-nuestro-drone-o-avion/
131
Jadiaz. (21 de Enero de 2016). PLACA ARDUINO UNO. Obtenido de Iescamp:

http://www.iescamp.es/miarduino/2016/01/21/placa-arduino-uno/
Llamas, L. (1 de Septiembre de 2016). CÓMO USAR UN ACELERÓMETRO EN
NUESTROS PROYECTOS DE ARDUINO. Obtenido de Luis Llamas:
https://www.luisllamas.es/como-usar-un-acelerometro-arduino/
Llamas, L. (24 de Marzo de 2017). FILTRO PASO BAJO Y PASO ALTO EXPONENCIAL
(EMA) EN ARDUINO. Obtenido de Luis Llamas: https://www.luisllamas.es/arduino-
paso-bajo-exponencial/
Marmolejo, R. (31 de Octubre de 2017). Arduino Serial Read. Obtenido de Hetpro:
https://hetpro-store.com/TUTORIALES/arduino-serial-read/
Mi Drone de Carreras. (27 de Enero de 2018). ¿QUE SIGNIFICA LA CLASIFICACIÓN C
DE LAS BATERÍAS LIPO? Obtenido de Mi Drone de Carreras:
https://www.midronedecarreras.com/bateria-lipo/que-significa-la-clasificacion-c-
de-las-baterias-lipo/
Naylamp Mechatronics. (2016). Tutorial MPU6050, Acelerómetro y Giroscopio. Obtenido
de Naylamp Mechatronics: https://naylampmechatronics.com/blog/45_Tutorial-
MPU6050-Aceler%C3%B3metro-y-Giroscopio.html
Pardo, C. (2013). Método de Ziegler-Nichols. Obtenido de Picuino:
https://www.picuino.com/es/arduprog/control-ziegler-nichols.html
Pardos, C. (Septiembre de 2019). Picuino. Obtenido de Controlador PID:
https://www.picuino.com/es/arduprog/control-pid.html
Quadcopters | Drone Flyers. (21 de Febrero de 2015). Quadcopters Yaw Roll and Pitch
Defined. Obtenido de Quadcopters | Drone Flyers:
https://www.quadcopterflyers.com/2015/02/quadcopters-yaw-roll-and-pitch-
defined.html
Roberto. (S.f). Funcionamiento de un Drone – Cuadricóptero. Obtenido de Muy Drones:
https://www.muydrones.com/funcionamiento-del-cuadricoptero/
Robologs. (15 de Octubre de 2014). Tutorial de Arduino y MPU-6050. Obtenido de
Robologs: https://robologs.net/2014/10/15/tutorial-de-arduino-y-mpu-6050/
Rodríguez, F. (16 de Junio de 2019). Como usar el monitor serie y el serial plotter en
Arduino. Obtenido de Fidias Rodríguez: https://fidiasrodriguez.com/como-usar-el-
monitor-serie-y-el-serial-plotter/
Serrudo, R. D. (20 de Abril de 2017). SlideShare. Obtenido de Filtro digital pasa bajos:
https://es.slideshare.net/rodrigodavidserrudo/filtro-digital-pasa-bajos
TºBem. (3 de Mayo de 2017). Baterías LiPo – ¿Cómo usar y cuidar una batería LiPo?
Obtenido de TºBem: https://teslabem.com/blog/como-usar-y-cuidar-las-baterias-
lipo/
Wikipedia. (Sin fecha). Controlador PID. Recollit de Wikipedia:
https://es.wikipedia.org/wiki/Controlador_PID
132
Wikipedia. (Sin fecha). Vehículo aéreo no tripulado. Obtenido de Wikipedia:

https://es.wikipedia.org/wiki/Veh%C3%ADculo_a%C3%A9reo_no_tripulado
6.1 Lista de referencias de las imágenes
Gráfico 1. Lumenier. (2019). Qav-x charpu fpv Racing quadcopter. [figura]. Recuperado
de: https://www.lumenier.com/consumer/qav-x
Gráfico 2. Horizon Hobby. (2019). [figura]. Recuperado de:

https://www.horizonhobby.com/product/storefronts/horizon-hobby-best-
brands/bladebrand/blade-mqx-bnf-blh7580
Gráfico 3. Recuperado de:

https://charliedeets.com/turnigy-micro-xquadcopter-from-hobby-king/
Gráfico 4. Etigowni Sriharsha. (2018). Crystal (ball): I look at Physics and Predict
Control Flow! Just-Ahead-of-Time Controller Receiver. [figura]. Recuperado de
https://www.researchgate.net/figure/Drones-pitch-roll-andyaw_fig2_329521700
Gráfico 5. Translators café. (2017). Drone Lipo Battery calculator. [figura]. Recuperado
de: https://www.translatorscafe.com/unit-converter/ro-RO/calculator/multicopter-
lipo-battery/
lipo-battery/
lipo-battery/
lipo-battery/
Gráfico 9. Fuente propia.
Gráfico 12. Naylamp Mechatronics SAC. (2016). Tutorial MPU6050, Acelerómetro y

Giroscopio. [figura]. Recuperado de:
https://naylampmechatronics.com/blog/45_Tutorial-MPU6050-
Aceler%C3%B3metro-y-Giroscopio.html
133
Gráfico 13. Naylamp Mechatronics SAC. (2016). Tutorial MPU6050, Acelerómetro y

Giroscopio. [figura]. Recuperado de:
https://naylampmechatronics.com/blog/45_Tutorial-MPU6050-
Aceler%C3%B3metro-y-Giroscopio.html
Gráfico 14. García, Vicente. (2016). Sensor MPU-6050. [figura]. Recuperado de

https://www.diarioelectronicohoy.com/blog/sensor-mpu6050
Gráfico 15. Jadiaz. (2016). Placa Arduino Uno. [figura]. Recuperado de
http://www.iescamp.es/miarduino/2016/01/21/placa-arduino-uno/
Gráfico 16. Infootec. (2018). Arduino UNO R3. [figura]. Recuperado de
https://www.infootec.net/arduino/
Gráfico 17. Aniakea. (2019). Motor Brushless A2212 KV1000, SIN ESCOBILLAS,
PARA DRONES. [figura]. Recuperado de: https://laniakea.mx/motor-A2212
Gráfico 18. Dejan. (2019). How Brushless Motor and ESC Work. [figura]. Recuperado
de: https://howtomechatronics.com/how-it-works/how-brushless-motor-and-esc-
work/.
Gráfico 19. Prometec. (s.f). Lo que hay que saber para elegir los ESC para un
cuadracóptero. [figura]. Recuperado de: https://www.prometec.net/esc-para-drones/
Gráfico 20. Oliveira, Mario & Fernandes, Marcos & Souto, Rafael. (2017).
Implementation of a Low-cost Prototype of Twin Rotor for Academic Studies in
Identification, Optimal Control and Stochastic Filtering.
10.1109/ICoSC.2017.7958718. [figura]. Recuperado de
https://www.researchgate.net/figure/PWM-Signal-for-brushless-motor-speed-
control_fig4_317084889
Gráfico 21. Electronoobs. (2019). ESC – Control Electrónico de Velocidad. [figura].

Recuperado de: http://www.electronoobs.com/circuitos_tut4.php
Gráfico 22. Tecneu. (2019). Módulo Bluetooth HC-06 para Arduino PIC Raspberry.
[figura]. Recuperado de: https://www.tecneu.com/products/modulo-bluetooth-hc-06
Gráfico 23. HP Modelismo. (2019). Gens Ace Batería Lipo 25C 2200 mAh 3S1P 11.1 V.
[figura]. Recuperado de: https://www.hpmodelismo.com/pt/lipo/12150-bateria-lipo-
gens-ace-25c-2200mah-3s1p-111vphantom.html
134
Gráfico 31. Wood, Steve. (2013). Spyda 500 Quadcopter. [figura]. Recuperado de:
https://www.thingiverse.com/thing:160607/files
Gráfico 47. IvenSense. (2013). MPU-6000 and MPU-6050 Register Map and
Descriptions Revision 4.2. [figura]. Recuperado de: https://www.invensense.com/wp-
content/uploads/2015/02/MPU-6000-Register-Map1.pdf
135
Descriptions Revision 4.2. [figura]. Recuperado de: https://www.invensense.com/wp-
content/uploads/2015/02/MPU-6000-Register-Map1.pdf
Gráfico 60. Durán Rocha, Andrés. (2015). Bluetooth HC-06 y HC-05 Android Arduino.
[figura]. Recuperado de: https://hetpro-store.com/TUTORIALES/bluetooth-hc-06-
app-arduino/
Gráfico 65. Pardos, Carlos. (2013). Controlador PID. [figura]. Recuperado de:
https://www.picuino.com/es/arduprog/control-pid.html
136
Gráfico 72. No especificado. (s/f). Diseño de sistemas de control. [figura]. Recuperado

de: https://ocw.ehu.eus/file.php/83/capitulo10_html/capitulo10.html
Descriptions Revision 4.2. [figura]. Recuperado de:
https://www.invensense.com/wp-content/uploads/2015/02/MPU-6000-Register-
Map1.pdf
137
Map1.pdf
Map1.pdf
Gráfico 112. Llamas, Luis. (2017). Filtro paso bajo y paso alto exponencial (EMA) en
Arduino. [figura]. Recuperado de: https://www.luisllamas.es/arduino-paso-bajo-
exponencial/
138
Map1.pdf
139
6.2 Lista de referencias de las tablas
Tabla 1. Naylamp Mechatronics SAC. (s/f). Módulo MPU6050 Acelerómetro,

Giroscopio I2C. [tabla]. Recuperado de: https://naylampmechatronics.com/sensores-
posicion-inerciales-gps/33-modulo-mpu6050-acelerometro-giroscopio-i2c.html
Tabla 2. Descubre Arduino (equipo). (2019). Arduino UNO, partes, componentes, para
qué sirve y donde comprar. [tabla]. Recuperado de:
https://descubrearduino.com/arduino-uno/
Tabla 3. Fuente propia.
Tabla 4. Heptro-store (tienda online). (s/f). Motor Brushless A2212/13T 1000 KV.
[tabla]. Recuperado de: https://hetpro-store.com/motor-brushless-a2212-13t-1000-
kv/
Tabla 5. Amazon (tienda online). (2018). Ulable Little Bee Mini 20 A 2 – 4S LiPo batería
OPTO PRO ESC sin escobillas para QAV250. [tabla]. Recuperado de:
https://www.amazon.es/Ulable-Little-Bee-Mini-escobillas/dp/B07CKST3PP
140
Tabla 6. HP Modelismo. (2019). Gens Ace Batería Lipo 25C 2200 mAh 3S1P 11.1 V.
[tabla]. Recuperado de: https://www.hpmodelismo.com/pt/lipo/12150-bateria-lipo-
gens-ace-25c-2200mah-3s1p-111vphantom.html
Tabla 9. Equipo técnico de Mateksys. (s/f). PDB-XT60 w/BEC 5 V & 12 V. [tabla].

Recuperado de: http://www.mateksys.com/?portfolio=pdb-xt60#tab-id-3
Tabla 13. Pardos, Carlos. (2020). Método de Ziegler-Nichols. [tabla]. Recuperado de:
https://www.picuino.com/es/arduprog/control-ziegler-nichols.html
7 Anexos
A continuación, adjuntamos el código desarrollado y utilizado tanto en el

cuadricóptero como en el balancín. Cabe resaltar que hay ciertas funciones que utilizamos
en ambos sistemas. Estas son:
- Función que inicializa el sensor MPU-6050.
- Funciones para calibrar el giroscopio y acelerómetro.
- Función lectura de datos sin refinar del MPU-6050.
- Función filtro complementario.
- Función mapear valores.
Por lo tanto, para no repetir código, aquellas funciones en común serán descritas
solamente en el apartado del sistema balancín.
7.2 Código del control del sistema balancín
7.2.1 Programa principal
#include <Wire.h> // Esta librería permite comunicarnos con el módulo

MPU-6050 (utilizando protocolo I2C)
#include <Servo.h> // Esta librería permite controlar y comunicarnos
con los ESC
141
#define A_C 4096.0 // Constante de conversión para el acelerómetro

(obtenido del datasheet del MPU6050)
#define G_C 32.8 // Constante de conversión para el giroscopio
#define RAD_G 57.295 // Ratio de conversión de radianes a grados
#define MIN_angle -2.5 // Mínimo ángulo a girar en nuestro balancín
#define MAX_angle 2.5 // Máximo ángulo a girar en nuestro balancín
//* CREACIÓN DE LOS OBJETOS DE LOS MOTORES PERTENECIENTES A LA CLASE

SERVO *//
Servo left_motor; // Motor izquierdo
Servo right_motor; // Motor derecho
//* VARIABLE(S) GENERALES DEL PROGRAMA

int dato_enviado=0; // Variable que se enviará desde la app android
boolean motores_off = true; // Variable bandera que nos indicará si
los motores están off o on
float GyroRoll_cal, GyroPitch_cal, GyroYaw_cal; // Variables
utilizadas para la calibración del mpu del giroscopio
float AccRoll_cal, AccPitch_cal, AccYaw_cal; // Variables
utilizadas para la calibración del mpu del acelerómetro
//* DEFINICIÓN Y DECLARACIÓN DE LAS VARIABLES RELACIONADAS AL MPU6050

*//
const int MPU_address = 0x68; // Si el pin AD0 está a nivel bajo, la
dirección es 0x68
int16_t ax, ay, az; // Variables para almacenar la lectura de las
aceleraciones
int16_t gx, gy, gz; // Variables para almacenar la lectura del
giroscopio
float Ac[2]; // Almacenamos los ángulos de inclinación calculados de
los ejes X e Y
float Gc[2]; // Almacenamos temporalmente las velocidades angulares
float Final_angle[2]; // Almacenamos los ángulos de rotación finales
de los ejes X e Y
float angleX, angleY;
String valores; // A través de esta variable representaremos todas
las variables en fila
//* DEFINICIÓN Y DECLARACIÓN DE LAS VARIABLES DEL PID *//
142
float previous_time, time, dt; // Variables auxiliares para el cálculo

del tiempo transcurrido
float acelerador=1300; // aceleración inicial de los motores
float roll_angulo_deseado=0; // angulo que nosotros queremos conseguir
(consigna)
//* ROLL (One axis)*//

float Roll_PID, Roll_error, Roll_error_ant, pwm_left, pwm_right;
float RollPID_p=0, RollPID_i=0, RollPID_d=0;
// CONSTANTES DEL CONTROLADOR PID (Aplicados SOLO para el ROLL)!!

double Roll_Kp=1.1; // Estos valores debemos irlos cambiando hasta
conseguir el comportamiento deseado
double Roll_Ki=0.007; // Estos valores debemos irlos cambiando hasta
double Roll_Kd=0.15; // Estos valores debemos irlos cambiando hasta
void setup()
{
Wire.begin(); // La comunicación I2C comienza..
inicializaciones(MPU_address, 0x6B, 0x00); // Despertamos al módulo
MPU (sleepmode)
inicializaciones(MPU_address, 0x1B, 0x10); // Configuración escala
giroscopio a +/- 1000 º/s
inicializaciones(MPU_address, 0x1C, 0x10); // Configuración escala
acelerómetro a +/- 8g
Serial.begin(9600);
calibracionMPU_gyr(); // Calibramos el MPU para corregir los offsets
del giroscopio
calibracionMPU_acc(); // Calibramos el MPU para corregir los offsets
del acelerómetro
while(motores_off == true)
{
leer_app();
}
inicializar_motores();
143
delay(10000); // Para conectar la bateria
void loop()
{
///// * LECTURA DE DATOS MPU-6050 Y APLICACIÓN DEL FILTRO * /////
// Comenzamos a contar el tiempo para aplicarlo en el filtro
complementario
previous_time = time; // El tiempo anterior la almacenamos antes del
tiempo actual
time = millis();
dt = (time - previous_time) / 1000; // Conversión de milisegundos a
segundos
// Procedemos a leer los valores sin refinar del acelerómetro

leerMPU(0x3B, ax, ay, az);
// Guardamos los ángulos de inclinación temporalmente para luego

usarlos en el filtro complementario
calculate_angle();
// Procedemos a leer los valores sin refinar del giroscopio

leerMPU(0x43, gx, gy, gz);
// Aplicamos el filtro, utilizando ambos valores del acelerómetro y

del giroscopio
filtro_complementario();
// Analizamos el valor recibido por la app android

leer_app();
if(motores_off == false) // Si los motores no están apagados,

entonces ..
{
// Control PID
Control_PID();
144
// Actuador del sistema

actuador();
}
}
7.2.2 Función inicializadora del MPU-6050
Función que nos permitirá configurar el rango de escala del acelerómetro y

giroscopio.
void inicializaciones(const int mpu_dir, int value_towrite, int
bit_toset)
{
Wire.beginTransmission(mpu_dir);
// Le hacemos saber al módulo MPU-6050 en qué registro estamos
escribiendo..
Wire.write(value_towrite);
Wire.write(bit_toset);
Wire.endTransmission(true);
}
7.2.3 Función inicializadora de los motores
Función donde asociamos los pines a los 2 motores. Además, también enviamos
pulsos de 1000 microsegundos con tal de entrar al modo de inicialización. De esta manera,
comenzarán a girar en la función loop.
void inicializar_motores()
{
left_motor.attach(3); // El pin 3 está conectado al motor de la

izquierda
right_motor.attach(5); // El pin 5 está conectado al motor de la
derecha
time = millis(); // Comienza el conteo en milisegundos
// Inicializamos los motores

left_motor.writeMicroseconds(1000);
right_motor.writeMicroseconds(1000);
}
145
7.2.4 Función calibración del giroscopio
Función donde tomamos 3000 lecturas de las velocidades angulares en cada uno de
sus ejes, para luego realizar el promedio. El promedio es el offset. Haciendo la resta entre
los valores medidos y el offset, obtendremos mediciones más precisas.
void calibracionMPU_gyr()
{
int i;
for(i=0; i<3000; i++)
{
leerMPU(MPU_address, gx, gy, gz); // Leemos los
valores del giroscopio
GyroPitch_cal = GyroPitch_cal + gx; // Almacenamos la
lectura SIN REFINAR del giroscopio en el eje X (PITCH)
GyroRoll_cal = GyroRoll_cal + gy; // Almacenamos la
lectura SIN REFINAR del giroscopio en el eje Y (ROLL)
GyroYaw_cal = GyroYaw_cal + gz; //
Almacenamos la lectura SIN REFINAR del giroscopio en el eje Z (YAW)
delayMicroseconds(1000);
}
GyroPitch_cal = GyroPitch_cal/3000;
GyroRoll_cal = GyroRoll_cal/3000;
GyroYaw_cal = GyroYaw_cal/3000;
}
7.2.5 Función calibración del acelerómetro
Función donde tomamos 3000 lecturas de las aceleraciones en cada uno de sus ejes,
para luego realizar el promedio. El promedio es el offset. Haciendo la resta entre los valores
medidos y el offset, obtendremos mediciones más precisas.
void calibracionMPU_acc()
{
int i;
for(i=0; i<3000; i++)
{
leerMPU(MPU_address, ax, ay, az); // Leemos los
valores del acelerómetro
146
AccPitch_cal = AccPitch_cal + ax; // Almacenamos la

lectura SIN REFINAR del acelerómetro en el eje X (PITCH)
AccRoll_cal = AccRoll_cal + ay; // Almacenamos la
lectura SIN REFINAR del acelerómetro en el eje Y (ROLL)
AccYaw_cal = AccYaw_cal + az; // Almacenamos la
lectura SIN REFINAR del acelerómetro en el eje Z (YAW)
delayMicroseconds(1000);
}
AccPitch_cal = AccPitch_cal/3000;
AccRoll_cal = AccRoll_cal/3000;
AccYaw_cal = AccYaw_cal/3000;
}
7.2.6 Función para la lectura de datos sin procesar del MPU-6050
Función donde leeremos los valores sin refinar, tanto del acelerómetro como del
giroscopio.
void leerMPU(const int address_firstRegister, int16_t &vx, int16_t &vy,
int16_t &vz)
{
Wire.beginTransmission(MPU_address);
Wire.write(address_firstRegister); // Pedimos la lectura del primer
registro ya sea del acelerómetro o del giroscopio (según sea el caso)
Wire.endTransmission(false); // Esto mantendrá la conexión
activa
Wire.requestFrom(MPU_address, 6, true); // Pedimos la lectura de 6
registros a partir de la dirección "address_firstRegister"
vx = Wire.read()<<8 | Wire.read(); // Se leen los registros del byte
alto y bajo y se almacena el valor sin refinar
vy = Wire.read()<<8 | Wire.read();
vz = Wire.read()<<8 | Wire.read();
}
7.2.7 Función para el cálculo del ángulo de inclinación
void calculate_angle()
{
ax -= AccPitch_cal;
ay -= AccRoll_cal;
az -= AccYaw_cal;
147
Ac[0]= atan((ay/A_C)/sqrt(pow((ax/A_C),2) +
pow((az/A_C),2)))*RAD_G; // Ángulo de inclinación del ángulo X
Ac[1]= atan(-1*(ax/A_C)/sqrt(pow((ay/A_C),2) +
pow((az/A_C),2)))*RAD_G; // Ángulo de inclinación del ángulo Y
}
7.2.8 Función filtro complementario
Función en donde aplicamos la fórmula del filtro complementario.

void filtro_complementario()
{
// Comenzamos con la refinación de los valores del giroscopio
Gc[0] = (gx - GyroPitch_cal)/G_C; // Lectura de la velocidad
angular del eje Pitch
Gc[1] = (gy - GyroRoll_cal)/G_C; // Lectura de la velocidad
angular del eje Roll
// Aplicamos el filtro
Final_angle[0] = 0.98 *(Final_angle[0] + Gc[0]*dt) + 0.02*Ac[0]; //
Cálculo del ángulo de rotación del ángulo X
Final_angle[1] = 0.98 *(Final_angle[1] + Gc[1]*dt) + 0.02*Ac[1]; //
Cálculo del ángulo de rotación del ángulo Y
angleX = Final_angle[0];
angleY = Final_angle[1];
}
7.2.9 Función mapear valores
Mediante esta función, nos aseguramos que la variable a tratar (value) no supere los
límites mínimos o máximos.
void mapear_valores(float &value, int valor_min, int valor_max)
{
if(value < valor_min)
{
value = valor_min;
}
if(value > valor_max)
148
{
value = valor_max;
}
}
7.2.10 Función lectura de datos bluetooth
Función que se encargará de interpretar los distintos comandos recibidos desde el

Android.
void leer_app()
{
if(Serial.available()>0)
{
dato_enviado = Serial.read(); // Leemos el caracter enviado desde
la app
if(dato_enviado == '1') // Girar hacia la izquierda

{
if(motores_off == false)
{
if(angleY > MIN_angle) return; // Si se ha alcanzado el máximo
ángulo X a girar, no se hará nada
else
{
roll_angulo_deseado = roll_angulo_deseado - 0.80;
mapear_valores(roll_angulo_deseado, MIN_angle, MAX_angle); //
Delimitamos el valor
}
}
}
if(dato_enviado == '2') // Girar hacia la derecha
{
{
if(angleY > MAX_angle) return; // Si se ha alcanzado el máximo
ángulo X a girar, no se hará nada
else
{
149
roll_angulo_deseado = roll_angulo_deseado + 0.80;

mapear_valores(roll_angulo_deseado, MIN_angle, MAX_angle); //
Delimitamos el valor
}
}
}
if(dato_enviado == '3') // Apagar los motores (SOLO BALANCÍN,
NO EXISTIRÁ EN EL DRONE)
{
{
left_motor.writeMicroseconds(1000);
right_motor.writeMicroseconds(1000);
acelerador = 1050.0; // Reseteamos el valor del acelerador
a su valor inicial
roll_angulo_deseado= 0;
motores_off = true;
}
}
if(dato_enviado == '4') // Comenzar con el programa principal:
Encender los motores
{
if(motores_off == true) motores_off = false;
}
}
}
7.2.11 Función PID
Función que aplica el control PID de nuestro sistema.

void Control_PID()
{
Roll_error = Final_angle[1] - roll_angulo_deseado;
/* Procedemos a aplicar el control proporcional */

RollPID_p = Roll_Kp*Roll_error;
/* Procedemos a aplicar el control integral */
150
if(-3 < Roll_error < 3)

{
RollPID_i = RollPID_i + (Roll_Ki*Roll_error);
}
/* Procedemos a aplicar el control derivativo:

La acción derivativa se manifiesta cuando
hay un cambio en el valor absoluto del error.
Esta derivada de la señal de error representa
la velocidad de variación de esta señal de error.
*/
RollPID_d = Roll_Kd*((Roll_error - Roll_error_ant)/dt);
Roll_PID = RollPID_p + RollPID_i + RollPID_d;
}
7.2.12 Actuador del sistema
void actuador()
{
/* Los valores PID oscilará entre -1000 y 1000, ya que cuando el
mínimo valor del PWM
se encuentre en 1000us, el máximo valor que se le puede añadir es
+1000us, y debemos
cerciorarnos de no sobrepasarnos de este valor. Por otra parte,
cuando estemos en el
máximo valor del PWM, el cual es 2000us, el máximo valor que
podemos substraer es de
-1000us, y así alcanzar el punto mínimo de 1000us. Debemos
asegurarnos de no sobre-
pasarnos de estos rangos */
// Llamada a la función de mapear valores, que realiza la función

antes mencionada
mapear_valores(Roll_PID, -500, 500);
// Pasamos a calcular el ancho de pulso PWM de ambos motores

pwm_left = acelerador - Roll_PID;
pwm_right = acelerador + Roll_PID;
151
/* Debido a que estamos sumando el PID más la aceleración inicial que

hemos
previamente establecido, tenemos que asegurarnos nuevamente de
que los
valores no sobrepasen los límites de trabajo
(1000 us < valor final < 2000 us) */
// motor izquierdo
mapear_valores(pwm_left, 1000, 1800);
// motor derecho
mapear_valores(pwm_right, 1000, 1800);
left_motor.writeMicroseconds(pwm_left);
right_motor.writeMicroseconds(pwm_right);
// Guardamos en "error_anterior" el error actual

Roll_error_ant = Roll_error;
}
7.3 Código para el cuadricóptero
7.3.1 Programa principal
#include <Wire.h> // Esta librería permite comunicarnos con

el módulo MPU-6050 (utilizando protocolo I2C)
#include <Servo.h> // Esta librería permite controlar y
comunicarnos con los ESC
#define A_C 4096.0 // Constante de conversión para el
acelerómetro (obtenido del datasheet del MPU6050)
#define G_C 32.8 // Constante de conversión para el giroscopio
#define RAD_G 57.29577951 // Ratio de conversión de radianes a grados
#define MIN_PWM 1000 // Mínimo valor de PWM que se le puede enviar
a los variadores ESC
#define MAX_PWM 2000 // Máximo valor de PWM que se le puede enviar
a los variadores ESC
#define acc_address 0x3B // Dirección en memoria del acelerómetro
#define gyro_address 0x43 // Dirección en memoria del giroscopio
#define MAX_OFFSET 2500
#define MIN_ANGLE -40.0
152
#define MAX_ANGLE 40.0

#define MAXlooptime_us 8000
//* MOTORES *//

float pwm_leftfrontside, pwm_rightfrontside, pwm_leftbackside,
pwm_rightbackside; // Señales PWM finales a enviar a los motores
//* DEFINICIÓN Y DECLARACIÓN DE LAS VARIABLES RELACIONADAS AL MPU6050

*//
const int MPU_address = 0x68; // Si el pin AD0 está a nivel bajo, la
dirección es 0x68
int16_t ax, ay, az, gx, gy, gz; // Variables donde se guardan los
valores SIN REFINAR
/* CREACIÓN DE LAS VARIABLES GENERALES DEL PID */

// ROLL PID VARIABLES GYRO //
float Roll_PIDw, Roll_errorw, Roll_error_antw=0, Roll_readSpeedw;
float RollPID_pw=0.0, RollPID_iw=0.0, RollPID_dw=0.0;
float Roll_desiredSpeedw=0.0, lastRoll_desiredSpeedw;
// ------------------------------------------------------------------
---// ACC
float Roll_PIDacc, Roll_erroracc, Roll_error_antacc,
Roll_readAngleacc;
float RollPID_pacc=0.0, RollPID_iacc=0.0, RollPID_dacc=0.0;
float Roll_desiredAngle=0.0;
// PITCH PID VARIABLES GYRO //

float Pitch_PIDw, Pitch_errorw, Pitch_error_antw=0, Pitch_readSpeedw;
float PitchPID_pw=0.0, PitchPID_iw=0.0, PitchPID_dw=0.0;
float Pitch_desiredSpeedw=0.0, lastPitch_desiredSpeedw;
// ------------------------------------------------------------------
---// ACC
float Pitch_PIDacc, Pitch_erroracc, Pitch_error_antacc,
Pitch_readAngleacc;
float PitchPID_pacc=0.0, PitchPID_iacc=0.0, PitchPID_dacc=0.0;
float Pitch_desiredAngle=0.0;
// YAW PID VARIABLES GYRO //
153
float Yaw_PIDw, Yaw_errorw, Yaw_error_antw=0, Yaw_readSpeedw;

float YawPID_pw=0.0, YawPID_iw=0.0, YawPID_dw=0.0;
float Yaw_desiredSpeedw=0.0, lastYaw_desiredSpeedw;
////// VARIABLES GENERALES DEL PROGRAMA ////

int dato_enviado=0; // Variable que se enviará desde la app android
int plot_counter=0;
boolean bateria_conectada = false;
boolean esc_calibrado = false;
boolean activar_pidangle; //
Variable bandera que nos ayudará a saber si el usuario desea estabilizar
el drone
float GyroRoll_cal, GyroPitch_cal, GyroYaw_cal; // Variables
utilizadas para la calibración del mpu del giroscopio
float AccRoll_cal, AccPitch_cal, AccYaw_cal; // Variables
utilizadas para la calibración del mpu del acelerómetro
unsigned long pwm_counter, pwm_ciclo;
float previous_time, time, dt; // Variables auxiliares para
el cálculo del tiempo transcurrido
float antes, proc2, dif;
// Vectores para guardar los resultados
float Ac[2]; // Almacenamos los
ángulos de inclinación calculados de los ejes X e Y
float Gc[2]; // Almacenamos
temporalmente las velocidades angulares
float Angulo[2]; // Almacenamos los
ángulos de rotación finales de los ejes X e Y
float last_pitchw, last_rollw, last_yaw = 0; // Necesario para el
filtro EMA
float valuepitch, valueroll, valueyaw;
// VARIABLES PID A MODIFICAR PARA HACER LAS PRUEBAS //

/* Lazo velocidad */
float Roll_Kpw=1.3; // Estos valores debemos irlos cambiando
hasta conseguir el comportamiento deseado
float Roll_Kiw=0.02; // Estos valores debemos irlos cambiando
float Roll_Kdw=22; // Estos valores debemos irlos cambiando
154
float Pitch_Kpw=1.3; // Estos valores debemos irlos cambiando

hasta conseguir el comportamiento deseado2.16
float Pitch_Kiw=0.01; // Estos valores debemos irlos cambiando
float Pitch_Kdw=22; // Estos valores debemos irlos cambiando
float Yaw_Kpw=3; // Estos valores debemos irlos cambiando

float Yaw_Kiw=0.02; // Estos valores debemos irlos cambiando
float Yaw_Kdw=0; // Estos valores debemos irlos cambiando
/* Lazo aceleración */
float Roll_Kpacc=1.7; // Estos valores debemos irlos cambiando
float Roll_Kiacc=0.04; // Estos valores debemos irlos cambiando
float Roll_Kdacc=4; // Estos valores debemos irlos cambiando
float Pitch_Kpacc=2; // Estos valores debemos irlos cambiando

float Pitch_Kiacc=0.04; // Estos valores debemos irlos cambiando
float Pitch_Kdacc=4; // Estos valores debemos irlos cambiando
// VARIABLES A MODIFICAR PARA VISUALIZAR LAS SEÑALES //

float throttle=1060;
// Filtro EMA 0.75

float Ema_alpha = 0.4; // 0: el valor filtrado será siempre 0 || 1:
la señal no se filtrará 0.55
/* Para seleccionar el motor que queremos testear, colocamos en true

ese motor y los demás lo ponemos en false */
bool left_f = true;
bool right_f = true;
bool left_b = true;
155
bool right_b = true;
/* Visualizacion: variable que podemos modificar según lo que queramos

realizar */
/*
int visualizacion = 14;
bool serial_plotter = false; // true: usar el serial.plotter ||
false: usar el serial.monitor
/// SETUP ///

void setup()
{
Wire.begin();
inicializar_mpu(MPU_address, 0x6B, 0x00); // Despertamos al módulo
MPU (sleepmode)
inicializar_mpu(MPU_address, 0x1B, 0x10); // Configuración escala
giroscopio a +/- 1000 º/s
inicializar_mpu(MPU_address, 0x1C, 0x10); // Configuración escala
acelerómetro a +/- 8g (0x10)
inicializar_mpu(MPU_address, 0x1A, 0x03); // Activación y
configuración del DLPF incorporado en la IMU (Filtro paso bajo digital)
0x02
pinMode(12, OUTPUT); // Pin para el led rojo
que nos avisará cuando ha finalizado la calibración y llevar el control
del loop
digitalWrite(12, LOW); // Apagamos el led para usarlo para llevar

el control del bucle
Serial.begin(9600); // Establecemos en 9600 como la velocidad de
datos en bits por segundos
calibracionMPU_gyr(); // Calibramos el MPU para corregir los offsets
del giroscopio
calibracionMPU_acc(); // Calibramos el MPU para corregir los offsets
del acelerómetro
digitalWrite(12, HIGH);
delay(2000);
digitalWrite(12, LOW); // Apagamos el led
while(bateria_conectada == false) // Mientras no envíemos la

señal de que queremos comenzar el programa, no haremos nada
156
{
leer_app();
}
digitalWrite(12, HIGH); // Encendemos el led para

indicar que estamos listos para inicializar los motores
escribir_leyenda(visualizacion, serial_plotter);
actualizar_consignas(0.0, 0.0, 0.0); // Al iniciar el programa, no
queremos que el drone gire
inicializar_motores();
digitalWrite(12, LOW); // Apagamos el led
time = millis(); // Comenzamos conteo del tiempo
pwm_ciclo = micros(); // Utilizado para llevar el
control del pwm a generar en los motores
antes = millis(); // Utilizado para ver que tanto
dura una tarea a ejecutarse
}
/// LOOP ///

void loop()
{
// Comenzamos a contar el tiempo para aplicarlo en el controlador
PID
contar_tiempo();
// Procedemos a leer los valores sin refinar del acelerómetro

leerMPU(acc_address, ax, ay, az);
// Guardamos los ángulos de inclinación temporalmente para luego

usarlos en el filtro complementario
calculate_angle();
// Procedemos a leer los valores sin refinar del giroscopio

leerMPU(gyro_address, gx, gy, gz);
// Calculamos la velocidad angular de los 3 ejes

calcular_velocidadAngular(gx, gy, gz);
157
// Aplicamos el filtro
filtro_complementario();
// Función que leemos el valor recibido desde la app (flight

controller)
leer_app();
actuador(); // Función actuador del sistema
while(micros() - pwm_ciclo < 2100); // Hasta que no hayan

transcurrido 2 ms, esperamos para leer valores serial plotter / monitor
turn_offallmotors();
// Función que muestra las velocidades PWM a enviar a los cuatro

motores y las velocidades angulares
if(serial_plotter == true)
{
plot_counter++;
if(plot_counter == 3) // Envíamos datos cada
(MAXlooptime_us * 5) us
{
display_data(visualizacion);
plot_counter = 0;
}
}
else display_data(visualizacion);
}
7.3.2 Función mostrar leyenda
Función que envía a través del serial plotter la leyenda de las variables dependiendo
de la opción escogida por el usuario.
void escribir_leyenda(int opcion, bool opc_plotter)
{
if(opcion >= 4 && opcion <= 8) turn_offKi();
if(opc_plotter == true)
158
{
switch(opcion)
{
case 1:
Serial.println("anglePitch angleRoll");
break;
case 2:
Serial.println("Pitch_pid Roll_pid Yaw_pid");
break;
case 3:
Serial.println("Pitch_readSpeedw Roll_readSpeedw
Yaw_readSpeedw");
break;
case 4:
Serial.println("l_f r_f l_b r_b");
break;
case 5:
Serial.println("lf");
break;
case 6:
Serial.println("rf");
break;
case 7:
Serial.println("lb");
break;
case 8:
Serial.println("rb");
break;
case 9:
Serial.println("pitch_w filtered_value");
break;
case 10:
Serial.println("roll_w filtered_value");
break;
case 11:
Serial.println("yaw_w filtered_value");
159
break;
case 12:
Serial.println("anglePitch");
break;
case 13:
Serial.println("angleRoll");
break;
case 14:
Serial.println("Pitch_readSpeedw");
break;
case 15:
Serial.println("Roll_readSpeedw");
break;
case 16:
Serial.println("Yaw_readSpeedw");
break;
case 17:
Serial.println("Pitch_desiredSpeedw Pitch_readSpeedw");
break;
case 18:
Serial.println("Roll_desiredSpeedw Roll_readSpeedw");
break;
}
}
}
7.3.3 Función inicializadora de los motores
Función que nos permitirá inicializar los motores con la velocidad mínima, y nos
permite asociar los pines correspondientes.
void inicializar_motores()
{
pinMode(3, OUTPUT); // motor_leftfrontside
pinMode(5, OUTPUT); // motor_rightfrontside
pinMode(6, OUTPUT); // motor_leftbackside
pinMode(9, OUTPUT); // motor_rightbackside
160
turn_offallmotors();
delay(4000);
pwm_ciclo = micros(); // Utilizado para

llevar el control del pwm a generar en los motores
while(esc_calibrado == false) // Hasta que los ESC's
no emitan los sonidos de armado, no salimos del bucle
{
while(micros() - pwm_ciclo < MAXlooptime_us); // Hasta que no hayan
transcurrido 8ms, esperamos para comenzar un nuevo periodo
pwm_ciclo = micros(); // Utilizado para
llevar el control del pwm a generar en los motores
turn_onallmotors(); // Flanco alto pwm
delayMicroseconds(MIN_PWM); // Señal mínima
turn_offallmotors(); // Flanco bajo pwm
while(micros() - pwm_ciclo < 2000); // Hasta que no hayan
transcurrido 2 ms, esperamos a leer el mando app al mismo tiempo
leer_app(); // Actualizamos la
consigna de control si los esc's se han armado
}
turn_offallmotors(); // Por seguridad
}
7.3.4 Función contar tiempo
Función para contar el tiempo transcurrido entre cada iteración. Este tiempo será
utilizado para el cálculo del filtro complementario y durante el control derivativo.
void contar_tiempo()
{
previous_time = time; // El tiempo anterior la almacenamos antes del
tiempo actual
time = millis();
dt = (time - previous_time) / 1000; // Conversión de milisegundos a
segundos
}
7.3.5 Función calcular ángulo
Función para calcular el ángulo de inclinación con los datos recopilados del
acelerómetro. Hacemos uso de la fórmula en el caso de que el módulo esté en un plano 3D.
161
void calculate_angle()
{
ax -= AccPitch_cal;
ay -= AccRoll_cal;
az -= AccYaw_cal;
az = az + A_C;
Ac[0] = atan((ay/A_C)/sqrt(pow((ax/A_C),2) + pow((az/A_C),2)))*RAD_G;

// Ángulo de inclinación del ángulo X
Ac[1] = atan(-1*(ax/A_C)/sqrt(pow((ay/A_C),2) + pow((az/A_C),2)))*RAD_G;
// Ángulo de inclinación del ángulo Y
}
7.3.6 Función lectura de las velocidades angulares
void calcular_velocidadAngular(int16_t GirX, int16_t GirY, int16_t GirZ)

{
/* Corregimos el offset y obtenemos las lecturas que cierran el lazo de
realimentación */
Pitch_readSpeedw = (GirX - GyroPitch_cal)/G_C;
Roll_readSpeedw = (GirY - GyroRoll_cal)/G_C;
Yaw_readSpeedw = (GirZ - GyroYaw_cal)/G_C;
valuepitch = Pitch_readSpeedw;
valueroll = Roll_readSpeedw;
valueyaw = Yaw_readSpeedw;
Pitch_readSpeedw = low_passFilter(valuepitch, last_pitchw);

Roll_readSpeedw = low_passFilter(valueroll, last_rollw);
Yaw_readSpeedw = low_passFilter(valueyaw, last_yaw);
last_pitchw = Pitch_readSpeedw;
last_rollw = Roll_readSpeedw;
last_yaw = Yaw_readSpeedw;
}
7.3.7 Función filtro paso bajo (EMA)
162
Función en la que empleamos un filtro para filtrar el ruido de nuestras mediciones de

velocidad angular.
float low_passFilter(float medicion, float medicion_anterior)
{
float valor_filtrado;
valor_filtrado = Ema_alpha * medicion + (1 - Ema_alpha) *

medicion_anterior;
return valor_filtrado;
}
7.3.8 Función lectura de datos bluetooth
Función que se encargará de interpretar los distintos comandos recibidos desde el

Android.
void leer_app()
{
if(Serial.available()>0)
{
dato_enviado = Serial.read();
if(dato_enviado == '1') // Aumentamos el throttle (altura del

drone)
{
throttle = throttle + 50.0;
mapear_valores(throttle, 1100, 1700); // Nos aseguramos que la
altura del drone no exceda los valores máximos ni mínimos
actualizar_consignas(0.0, 0.0, 0.0); // Actualizamos las consignas
de los 3 ejes (el drone no girará)
activar_pidangle = false;
}
if(dato_enviado == '2') // Girando el drone en el sentido de las
agujas del reloj Yaw (-)
{
Yaw_desiredSpeedw = -30; // Fijamos a una
velocidad de -2 º/s
actualizar_consignas(0.0, 0.0, -30); // Actualizamos las
consignas de los 3 ejes (el drone sólo girará en el eje Yaw)
163
}
if(dato_enviado == '4') // Girando el drone en el sentido opuesto al
de las agujas del reloj Yaw (+)
{
Yaw_desiredSpeedw = 30; // Fijamos a una
velocidad de 2 º/s
actualizar_consignas(0.0, 0.0, 30); // Actualizamos las
consignas de los 3 ejes (el drone sólo girará en el eje Yaw)
}
if(dato_enviado == '5') // Girando hacia la izquierda: Roll (-)
{
Roll_desiredSpeedw = -30; // Fijamos a una
velocidad de -2 º/s
actualizar_consignas(0.0, -30, 0.0); // Actualizamos las
consignas de los 3 ejes (el drone sólo girará en el eje Roll)
}
if(dato_enviado == '6') // Posicionamos el drone a 0º (ángulo
pitch y roll a 0º)
{
actualizar_consignas(0.0, 0.0, 0.0); // Actualizamos las
consignas de los 3 ejes (el drone no girará)
activar_pidangle = true;
}
if(dato_enviado == '7') // Girando hacia la derecha: Roll (+)
{
Roll_desiredSpeedw = 30; // Fijamos a una velocidad de
2 º/s
actualizar_consignas(0.0, 30, 0.0); // Actualizamos las consignas
de los 3 ejes (el drone sólo girará en el eje Roll)
}
if(dato_enviado == '8') // Desplazandonos hacia adelante: Pitch (-)
{
Pitch_desiredSpeedw = -45; // Fijamos a una velocidad
de -2 º/
actualizar_consignas(-45, 0.0, 0.0); // Actualizamos las consignas
de los 3 ejes (el drone sólo girará en el eje Pitch)
164
}
if(dato_enviado == '9') // Disminuimos el throttle (altura del
drone)
{
throttle = throttle - 50.0;
mapear_valores(throttle, 1030, 1700); // Nos aseguramos que la
altura del drone no exceda los valores máximos ni mínimos
actualizar_consignas(0.0, 0.0, 0.0); // Actualizamos las
consignas de los 3 ejes (el drone no girará)
}
if(dato_enviado == 'a') // Desplazandonos hacia atrás: Pitch (+)
{
Pitch_desiredSpeedw = 45; // Fijamos a una velocidad de
2 º/s
actualizar_consignas(45, 0.0, 0.0); // Actualizamos las consignas
de los 3 ejes (el drone sólo girará en el eje Pitch)
}
if(dato_enviado == 'v') // Soltamos el stick y la consigna de
velocidad vuelve a ser 0
{
if(esc_calibrado == true) actualizar_consignas(0.0, 0.0, 0.0); //
Reseteamos los valores de las consignas
esc_calibrado = true;
}
if(dato_enviado == 't') // Empezamos el programa
{
bateria_conectada = true;
}
if(dato_enviado == 'u') // Apagamos los motores
{
left_f = false;
right_f = false;
left_b = false;
right_b = false;
165
actualizar_consignas(0.0, 0.0, 0.0); // Reseteamos los valores de

las consignas
}
}
/* Actualizamos las consignas en caso de producirse o no cambios */
Roll_desiredSpeedw = lastRoll_desiredSpeedw;
Pitch_desiredSpeedw = lastPitch_desiredSpeedw;
Yaw_desiredSpeedw = lastYaw_desiredSpeedw;
}
7.3.9 Función actualizar consignas
Función que actualiza los valores anteriores de las consignas del Pitch, Yaw y Roll
(GYRO velocidad).
void actualizar_consignas(float last_pich, float last_roll, float
last_yaw)
{
lastPitch_desiredSpeedw = last_pich;
lastRoll_desiredSpeedw = last_roll;
lastYaw_desiredSpeedw = last_yaw;
}
7.3.10 Funciones PID
Incluimos las funciones PID de los lazos de velocidad y de aceleración.

//////////// Lazo velocidad /////////////
// ROLL GYR //
// Función controlador PID en el eje Roll
float PID_RollGyr()
{
float salidaPID;
Roll_errorw = Roll_desiredSpeedw - Roll_readSpeedw; // Calculamos el
error del sistema

RollPID_pw = Roll_Kpw*Roll_errorw;

RollPID_iw = RollPID_iw + (Roll_Kiw*Roll_errorw);
166
mapear_valores(RollPID_iw, -400, 400); // Limitación del

término integral

*/
RollPID_dw = Roll_Kdw*((Roll_errorw - Roll_error_antw)/dt);
/* Obtenemos finalmente la salida PID */

salidaPID = RollPID_pw + RollPID_iw + RollPID_dw;
return salidaPID;
}
// PITCH GYR //
// Función controlador PID en el eje Pitch
float PID_PitchGyr()
{
float salidaPID;
Pitch_errorw = Pitch_desiredSpeedw - Pitch_readSpeedw; // Calculamos el
error del sistema

PitchPID_pw = Pitch_Kpw*Pitch_errorw;

PitchPID_iw = Pitch_Kiw + (Pitch_Kiw*Pitch_errorw);
mapear_valores(PitchPID_iw, -400, 400); // Limitación del
término integral

167

*/
PitchPID_dw = Pitch_Kdw*((Pitch_errorw - Pitch_error_antw)/dt);

salidaPID = PitchPID_pw + PitchPID_iw + PitchPID_dw;
return salidaPID;
}
// YAW GYR //
// Función controlador PID en el eje Yaw
float PID_YawGyr()
{
float salidaPID;
Yaw_errorw = Yaw_desiredSpeedw - Yaw_readSpeedw; // Calculamos el error
del sistema

YawPID_pw = Yaw_Kpw*Yaw_errorw;

YawPID_iw = Yaw_Kiw + (Yaw_Kiw*Yaw_errorw);
mapear_valores(YawPID_iw, -400, 400); // Limitación del
término integral

Esta derivada de la señal de error represen a
*/
YawPID_dw = Yaw_Kdw*((Yaw_errorw - Yaw_error_antw)/dt);

salidaPID = YawPID_pw + YawPID_iw + YawPID_dw;
return salidaPID;
}
168
//////////// Lazo aceleración /////////////

// PITCH ACC //
// Función controlador PID para el cálculo de la inclinación para el eje
PITCH
void PID_PITCHangle()
{
Pitch_erroracc = Pitch_desiredAngle - Pitch_readAngleacc; //
Calculamos el error del sistema

PitchPID_pacc = Pitch_Kpacc*Pitch_erroracc;
/* Procedemos a aplicar el control integral:

La parte integral se caracteriza por actuar si estamos
cerca de la consiga. Con esta acción nos encargamos de
eliminar el error residual que queda del controlador
proporcional */
PitchPID_iacc = Pitch_Kiacc + (Pitch_Kiacc*Pitch_erroracc);
mapear_valores(PitchPID_iacc, -100, 100); // Limitación
del término integral

*/
PitchPID_dacc = Pitch_Kdacc*((Pitch_erroracc -
Pitch_error_antacc)/dt);

Pitch_PIDacc = PitchPID_pacc + PitchPID_iacc + PitchPID_dacc;
}
// ROLL ACC //
// Función controlador PID para el cálculo de la inclinación para el eje
ROLL
169
void PID_ROLLangle()
{
Roll_erroracc = Roll_desiredAngle - Roll_readAngleacc; //
Calculamos el error del sistema

RollPID_pacc = Roll_Kpacc*Roll_erroracc;
/* Procedemos a aplicar el control integral:

La parte integral se caracteriza por actuar si estamos
cerca de la consiga. Con esta acción nos encargamos de
eliminar el error residual que queda del controlador
proporcional */
RollPID_iacc = Roll_Kiacc + (Roll_Kiacc*Roll_erroracc);

mapear_valores(RollPID_iacc, -100, 100); // Limitación
del término integral

*/
RollPID_dacc = Roll_Kdacc*((Roll_erroracc - Roll_error_antacc)/dt);

Roll_PIDacc = RollPID_pacc + RollPID_iacc + RollPID_dacc;
}
7.3.11 Actuador del sistema
void actuador()
{
dt = dt*1000; // Conversión de segundos a milisegundos
///// LAZO DE ACELERACIÓN /////
170
if(activar_pidangle == true)
{
/* Llamamos a las funciones para calcular el grado de
inclinación de los ejes ROLL y PITCH */
PID_PITCHangle();
PID_ROLLangle();
/* Preparamos las consignas para el lazo de velocidad */

Roll_desiredSpeedw = Roll_PIDacc;
Pitch_desiredSpeedw = Pitch_PIDacc;
/* Actualizamos los valores de los errores anteriores */

Pitch_error_antacc = Pitch_erroracc;
Roll_error_antacc = Roll_erroracc;
}
///// LAZO DE VELOCIDAD /////
/* Llamamos a las funciones PID de cada eje */
Roll_PIDw = PID_RollGyr(); // Función PID del giroscopio del eje
Roll
Pitch_PIDw = PID_PitchGyr(); // Función PID del giroscopio del eje
Pitch
Yaw_PIDw = PID_YawGyr(); // Función PID del giroscopio del eje
Yaw
if(throttle < 1200)

{
pwm_leftfrontside = throttle;
pwm_rightfrontside = throttle;
pwm_leftbackside = throttle;
pwm_rightbackside = throttle;
}
else
{
/* Los valores PID oscilará entre -1000 y 1000, ya que cuando el
mínimo valor del PWM
se encuentre en 1000us, el máximo valor que se le puede añadir es
+1000us, y debemos
171
cerciorarnos de no sobrepasarnos de este valor. Por otra parte,

cuando estemos en el
máximo valor del PWM, el cual es 2000us, el máximo valor que podemos
substraer es de
-1000us, y así alcanzar el punto mínimo de 1000us. Sin embargo,
ajustamos estos valores
entre -400 y +400 para que los actuadores tengan un margen de acción
sobre los motores.
Debemos asegurarnos de no sobrepasarnos de estos rangos */
mapear_valores(Roll_PIDw, -400, 400); // Control de rango del

eje Roll
mapear_valores(Pitch_PIDw, -400, 400); // Control de rango del
eje Pitch
mapear_valores(Yaw_PIDw, -400, 400); // Control de rango del
eje Yaw
/* Actualizamos las velocidades de los motores*/

pwm_leftfrontside = throttle + Yaw_PIDw + Pitch_PIDw + Roll_PIDw;
pwm_rightfrontside = throttle - Yaw_PIDw + Pitch_PIDw - Roll_PIDw;
pwm_leftbackside = throttle - Yaw_PIDw - Pitch_PIDw + Roll_PIDw;
pwm_rightbackside = throttle + Yaw_PIDw - Pitch_PIDw - Roll_PIDw;
/* Debido a que estamos sumando el PID más la aceleración inicial

que hemos
previamente establecido, tenemos que asegurarnos nuevamente de que
los
valores no sobrepasen los límites de trabajo
(1100 us < valor final < 2000 us) */
mapear_valores(pwm_leftfrontside, 1100, MAX_PWM); // Motor

izquierdo frontal
mapear_valores(pwm_rightfrontside, 1100, MAX_PWM); // Motor
derecho frontal
mapear_valores(pwm_leftbackside, 1100, MAX_PWM); // Motor
izquierdo trasero
mapear_valores(pwm_rightbackside, 1100, MAX_PWM); // Motor
derecho trasero
}
/* Actualizamos los valores de los errores anteriores de las
velocidades angulares */
172
Roll_error_antw = Roll_errorw;
Pitch_error_antw = Pitch_errorw;
Yaw_error_antw = Yaw_errorw;
/* Si se ha dado la orden de apagar los 4 motores, los apagamos */

update_speedmotor(left_f, pwm_leftfrontside);
update_speedmotor(right_f, pwm_rightfrontside);
update_speedmotor(left_b, pwm_leftbackside);
update_speedmotor(right_b, pwm_rightbackside);
if(micros() - pwm_ciclo > MAXlooptime_us) digitalWrite(12, HIGH);

// Encendemos el led si el tiempo se excede al estipulado en MAXlooptime_us
while(micros() - pwm_ciclo < MAXlooptime_us); // Hasta que no hayan

transcurrido 7ms, esperamos para comenzar un nuevo periodo
pwm_ciclo = micros();
/* Procedemos a actuar sobre los motores */

crear_pwm(pwm_leftfrontside, pwm_rightfrontside, pwm_leftbackside,
pwm_rightbackside);
}
7.3.12 Función crear señal PWM
Función que procede a crear la señal PWM para los 4 motores en función de los
valores PID calculados.
void crear_pwm(float l_f, float r_f, float l_b, float r_b)
{
/* Comenzamos con un pulso HIGH */
turn_onallmotors();
izq_f = true;
der_f = true;
izq_b = true;
der_b = true;
antes = millis();
/* Actualización de las consignas a enviar a los motores */
173
izquierda_f = l_f + pwm_ciclo;

derecha_f = r_f + pwm_ciclo;
izquierda_b = l_b + pwm_ciclo;
derecha_b = r_b + pwm_ciclo;
while(izq_f == true || der_f == true || izq_b == true || der_b == true)

{
pwm_counter = micros();
if(derecha_f <= pwm_counter) falling_edgemotor(der_f, 5); //
motor_rightfrontside
if(izquierda_f <= pwm_counter) falling_edgemotor(izq_f, 3); //
motor_leftfrontside
if(derecha_b <= pwm_counter) falling_edgemotor(der_b, 9); //
motor_rightbackside
if(izquierda_b <= pwm_counter) falling_edgemotor(izq_b, 6); //
motor_leftbackside
}
}
7.3.13 Función crear flanco alto/bajo (PWM)
A continuación, adjuntaremos las funciones que crean el flanco alto y bajo

respectivamente.
void turn_onallmotors()
{
digitalWrite(3, HIGH); // motor_leftfrontside
digitalWrite(5, HIGH); // motor_rightfrontside
digitalWrite(6, HIGH); // motor_leftbackside
digitalWrite(9, HIGH); // motor_rightbackside
}
void turn_offallmotors()
{
digitalWrite(3, LOW); // motor_leftfrontside
digitalWrite(5, LOW); // motor_rightfrontside
digitalWrite(6, LOW); // motor_leftbackside
174
digitalWrite(9, LOW); // motor_rightbackside

}
7.3.14 Función actualizar velocidad del motor
Esta función es llamada desde el actuador de nuestro sistema. Si la variable motor es

falso, entonces la velocidad (speedmotor) se actualiza al mínimo valor de ancho de pulso
(1000 microsegundos; MIN_PWM).
void update_speedmotor(bool motor, float &speedmotor)
{
if(motor == false) speedmotor = MIN_PWM;
}
7.3.15 Función bajar flanco PWM
Función que pone en LOW los pines asociados a los 4 motores.

void falling_edgemotor(boolean &motor, int pinmotor)
{
digitalWrite(pinmotor, LOW);
motor = false;
}
7.3.16 Función para visualizar las variables
Función para visualizar las variables que deseemos. Para ello, el usuario deberá
inicializar el valor de la variable “visualizar” en alguno de estos valores, según la variable
que desee observar.
0- Nada.
1- Visualizar los ángulos de inclinación pitch y roll.
2- Visualizar las salidas PID del lazo de velocidad de los 3 ejes.
3- Visualizar las velocidades angulares gyro del roll, pitch y yaw.
4- Visualizar las velocidades PWM a enviar a los 4 motores.
5- Visualizar únicamente la velocidad del motor izquierdo frontal.
6- Visualizar únicamente la velocidad del motor derecho frontal.
7- Visualizar únicamente la velocidad del motor izquierdo trasero.
8- Visualizar únicamente la velocidad del motor derecho trasero.
9- Comparar gráficamente la velocidad angular filtrada del eje pitch con la medición
sin filtrar.
10- Comparar gráficamente la velocidad angular filtrada del eje roll con la medición sin
filtrar.
11- Comparar gráficamente la velocidad angular filtrada del eje yaw con la medición sin
filtrar.
12- Visualizar únicamente el ángulo pitch.
13- Visualizar únicamente el ángulo roll.
175
14- Visualizar únicamente la velocidad angular pitch.

15- Visualizar únicamente la velocidad angular roll.
16- Visualizar únicamente la velocidad angular yaw.
17- Comparar la referencia de la velocidad del eje pitch con la velocidad real.
18- Comparar la referencia de la velocidad del eje roll con la velocidad real.
void display_data(int visualizar)
{
static int num_conteo=0; // Variable que nos servirá para la
visualización de las variables
switch(visualizar)
{
case 1:
visualizar_angles(num_conteo, 3);
break;
//-------------------------------------------------------------------
-------- //
case 2:
envio_datos(num_conteo, 5, Pitch_PIDw, Roll_PIDw, Yaw_PIDw);
break;
//-------------------------------------------------------------------
-------- //
case 3:
envio_datos(num_conteo, 5, Pitch_readSpeedw, Roll_readSpeedw,
Yaw_readSpeedw);
break;
//-------------------------------------------------------------------
-------- //
case 4:
visualizar_pwm(num_conteo, 7);
break;
//-------------------------------------------------------------------
-------- //
case 5:
Serial.println(pwm_leftfrontside);
break;
//-------------------------------------------------------------------
-------- //
case 6:
176
Serial.println(pwm_rightfrontside);
break;
//-------------------------------------------------------------------
-------- //
case 7:
Serial.println(pwm_leftbackside);
break;
//-------------------------------------------------------------------
-------- //
case 8:
Serial.println(pwm_rightbackside);
break;
//-------------------------------------------------------------------
-------- //
case 9:
visualizar_valoresfiltrados(num_conteo, 3, valuepitch,
Pitch_readSpeedw);
break;
//-------------------------------------------------------------------
-------- //
case 10:
visualizar_valoresfiltrados(num_conteo, 3, valueroll,
Roll_readSpeedw);
break;
//-------------------------------------------------------------------
-------- //
case 11:
visualizar_valoresfiltrados(num_conteo, 3, valueyaw,
Yaw_readSpeedw);
break;
//-------------------------------------------------------------------
-------- //
case 12:
Serial.println(Pitch_readAngleacc);
break;
//-------------------------------------------------------------------
-------- //
case 13:
Serial.println(Roll_readAngleacc);
177
break;
//-------------------------------------------------------------------
-------- //
case 14:
Serial.println(Pitch_readSpeedw);
break;
//-------------------------------------------------------------------
-------- //
case 15:
Serial.println(Roll_readSpeedw);
break;
//-------------------------------------------------------------------
-------- //
case 16:
Serial.println(Yaw_readSpeedw);
break;
//-------------------------------------------------------------------
-------- //
case 17:
comparar_valores(num_conteo, 3, Pitch_desiredSpeedw,
Pitch_readSpeedw);
break;
//-------------------------------------------------------------------
-------- //
case 18:
comparar_valores(num_conteo, 3, Roll_desiredSpeedw,
Roll_readSpeedw);
break;
}
}
7.3.17 Funciones relacionadas con la visualización de datos
// Función que envía al puerto serie las velocidades de los 4 motores

void visualizar_angles(int &i, int maximo)
{
if(i == 0) Serial.print(Pitch_readAngleacc);
if(i == 1) Serial.print("\t");
if(i == 2) Serial.println(Roll_readAngleacc);
178
i++;
if(i == maximo) i=0;
}
// Función que envía al puerto serie las velocidades de los 4 motores
void visualizar_pwm(int &j, int maximo)
{
if(j == 0) Serial.print(pwm_leftfrontside);
if(j == 1) Serial.print("\t");
if(j == 2) Serial.print(pwm_rightfrontside);
if(j == 4) Serial.print(pwm_leftbackside);
if(j == 6) Serial.println(pwm_rightbackside);
j++;
if(j == maximo) j=0;
}
// Función que permite el envío de datos (velocidades angulares, pid,

etc) por el puerto serial
void envio_datos(int &k, int maximo, float dato1, float dato2, float
dato3)
{
if(k == 0) Serial.print(dato1);
if(k == 1) Serial.print("\t");
if(k == 2) Serial.print(dato2);
if(k == 3) Serial.print("\t");
if(k == 4) Serial.println(dato3);
k++;
if(k == maximo) k=0;
}
// Función que envía al puerto serie las velocidades angulares filtradas
y las compara con las no filtradas
void visualizar_valoresfiltrados(int &w, int maximo, float value, float
filteredvalue)
{
if(w == 0) Serial.print(value);
if(w == 1) Serial.print("\t");
179
if(w == 2) Serial.println(filteredvalue);
w++;
if(w == maximo) w=0;
}
// Función que envía al puerto serie las velocidades angulares filtradas
y las compara con las no filtradas
void comparar_valores(int &x, int maximo, float referencia, float
posicion)
{
if(x == 0) Serial.print(referencia);
if(x == 1) Serial.print("\t");
if(x == 2) Serial.println(posicion);
x++;
if(x == maximo) x=0;
}
7.3.18 Función apagar constantes Ki
Función que reinicializa las constantes integrales a 0, para una mejor visualización
de las señales PWM.
void turn_offKi()
{
Roll_Kiw=0;
Pitch_Kiw=0;
Yaw_Kiw=0;
Roll_Kiacc=0;
Pitch_Kiacc=0;
}
180

2711 Pub

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

2711 Pub

Cargado por

Copyright:

Formatos disponibles

Ayrton Jesús Hernández Casas

Diseño e implementación de un cuadricóptero basado en

TRABAJO FINAL DE GRADO

Dirigido por José Luis Ramírez Falo

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

de 4 motores controlado por el microntrolador ARDUINO Ayrton Jesús Hernández Casas

Gráfico 1. Drone en configuración en X ..........................................................................10

de 4 motores controlado por el microcontrolador ARDUINO Ayrton Jesús Hernández Casas

Gráfico 46. Estructura de 2 registros contiguos. ............................................................... 46

de 4 motores controlado por el microcontrolador ARDUINO Ayrton Jesús Hernández Casas

de 4 motores controlado por el microcontrolador ARDUINO Ayrton Jesús Hernández Casas

de 4 motores controlado por el microcontrolador ARDUINO Ayrton Jesús Hernández Casas

Tabla 1. Características del sensor MPU-6050................................................................. 18

de 4 motores controlado por el microcontrolador ARDUINO Ayrton Jesús Hernández Casas

de 4 motores controlado por el microcontrolador ARDUINO Ayrton Jesús Hernández Casas

3.4.5.4 Las vibraciones (ruido) ........................................................................ 94

de 4 motores controlado por el microcontrolador ARDUINO Ayrton Jesús Hernández Casas

7.3.11 Actuador del sistema ................................................................................. 170

de 4 motores controlado por el microcontrolador ARDUINO Ayrton Jesús Hernández Casas

Con el pasar de los años, y gracias al continuo avance en el campo de la electrónica,

de 4 motores controlado por el microcontrolador ARDUINO Ayrton Jesús Hernández Casas

3era parte (Resultados y conclusiones): Finalizaremos mostrando los

2 Estructura y componentes del Cuadricóptero

Como bien se mencionó anteriormente, el quadcopter (o cuadricóptero) es un drone

Gráfico 1. Drone en configuración en X

Gráfico 2. Drone en configuración en +

de 4 motores controlado por el microcontrolador ARDUINO Ayrton Jesús Hernández Casas

Gráfico 3. Drone en configuración en H

Gráfico 4. Movimientos que puede realizar un drone

Guiñada (Yaw): Corresponde a la rotación en el sentido contrario (o no) de

de 4 motores controlado por el microcontrolador ARDUINO Ayrton Jesús Hernández Casas

Gráfico 5. Explicación del movimiento Guiñada (Yaw)

Alabeo (Roll): Corresponde al movimiento hacia la izquierda o hacia la

Gráfico 6. Explicación del movimiento Alabeo (Roll)

Cabeceo (Pitch): Corresponde a la rotación hacia adelante o hacia atrás con

Gráfico 7. Explicación del movimiento Cabeceo (Pitch)

Altitud (Throttle): Corresponde al movimiento hacia arriba o hacia abajo

de 4 motores controlado por el microcontrolador ARDUINO Ayrton Jesús Hernández Casas

Gráfico 8. Explicación del movimiento Altitud (Throttle)

Gráfico 9. Dinámica Alabeo / Cabeceo (I)

Nota: Azul: Velocidad normal, Naranja: Alta velocidad

Gráfico 10. Dinámica Alabeo / Cabeceo (II)

2.2 Mecanismo funcional

Una vez que se ha visto cómo el cuadricóptero logra moverse y desplazarse en la

de 4 motores controlado por el microcontrolador ARDUINO Ayrton Jesús Hernández Casas

2.2.1 Control Automático

Un sistema automático de control es un conjunto de componentes físicos conectados

El controlador: Es el dispositivo encargado de evaluar y procesar la señal de

de 4 motores controlado por el microcontrolador ARDUINO Ayrton Jesús Hernández Casas

Actuador: Es el elemento que recibe la orden del controlador, y en función

Planta: Es el sistema sobre el que se pretende actuar o aplicar el control.

A continuación, se muestra un diagrama de bloques de un sistema de control

Gráfico 11. Sistema automático de control de Lazo Cerrado

Como bien se ha mencionado anteriormente, el sensor será el MPU-6050. Este

de 4 motores controlado por el microcontrolador ARDUINO Ayrton Jesús Hernández Casas

2.3 Descripción de los componentes

A continuación, se procederá a describir los distintos componentes que conforman el

Se trata de una unidad de medición inercial que combina un acelerómetro de 3 ejes y

Gráfico 12. Sensor MPU-6050

Gráfico 13. Dirección de los ejes X, Y y Z del sensor MPU-6050

El sensor acelerómetro mide la aceleración en las tres dimensiones del espacio; X, Y

de 4 motores controlado por el microcontrolador ARDUINO Ayrton Jesús Hernández Casas

En cuanto al ángulo con respecto al eje Z, se necesitaría de otro componente llamado

Gráfico 14. Sensor MPU-6050 y sus pines de conexión