UNIVERSIDAD TÉCNICA PARTICULAR DE LOJA

DEPARTAMENTO DE CIENCIAS DE LA COMPUTACIÓN Y ELECTRÓNICA

ÁREA TÉCNICA
“ELECTRÓNICA Y TELECOMUNICACIONES”

INTEGRANTES: Carol Villavicencio, Karol Quezada, Joffre Ríos

DOCENTE RESPONSABLE: Ing. Carlos Calderón Córdova.
COMPONENTE: Teoría de Control Automático.
Tema

• Control automático de un prototipo gimbal.

Objetivo General:

• Desarrollo de un sistema hardware-software para censar y controlar la estabilidad de la

plataforma del gimbal.

Objetivos Específicos:

• Desarrollo de un prototipo que controle a través de sensores y servomotores una exacta

estabilización de la plataforma a través de sensores y servomotores.
• Manipular los ángulos de los servos para tener una mayor exactitud en el movimiento del
gimbal.
Introducción
Te ha pasado que al tomar o grabar un video tu mano está en constante movimiento y hace que
el video salgo temblándose, o que por lo general la foto salga un poco borrosa porque tu mano se
sacudía. Gimbal es la solución a este problema que la mayoría de personas tiene pero que en
ocasiones más formales como a los fotógrafos o los amantes de los videos les ocurre muy a
menudo. Tal vez esta palabra les suene conocida en especial si eres amante a los drones o a la
fotografía les parezca un término más común.
Un gimbal es una plataforma motorizada y controlada mediante una placa con varios sensores,
generalmente acelerómetros, giroscopios y compás magnético que se encarga mediante el uso de
algoritmos de control y PIDs de mantener un objeto, normalmente una cámara estabilizada, de
modo que independientemente del movimiento que realice el portador de la misma, ésta quede
estable permitiendo tomar buenas capturas. [1]
En la actualidad hay muchos tipos de gimbal disponibles. De distintos tamaños y formatos.
Principalmente porque hay algunos modelos que están pensados para ser usados con un
smartphone, mientras que otros son para usarse con cámaras para rodar cine o para un drone.
También son compatibles con cámaras como la GoPro. Podéis ver que tienen muchos usos
posibles. Por lo que en función del dispositivo que se vaya a usar, el tamaño y formato del gimbal
en cuestión es diferente.[2]
El coste de esta tecnología ha sufrido un abaratamiento y miniaturización muy importantes,
para ser fácilmente portados en drones y siendo rápidamente adaptables a casi todo tipo de
cámaras de acción (gopro) o fotografía.[1] sin embargo los gimbals de menor costo solo se
encuentran de dos ejes y no son muy precisos, un gimbal semiprfesional tiene un precio mínimo
de 150 dólares a uno profesional que esta de 300 a 400 dólares.
 El siguiente proyecto se basa en crear un prototipo gimbal y controlarlo mediante sensores y
servomotores, se utilizará acelerómetros, giroscopios y manómetros que serán controlados a
través de un arduino generando que los ángulos sean correctos y precisos para que la persona
pueda manipular el prototipo de una manera rápida y confiada, realizaremos varios cálculos para
obtener la mejor eficiencia y eficacia en el siguiente prototipo, teniendo como modelo los gimbals
que están en el mercado.

Planteamiento

Haremos una plataforma de estabilización de camara simple o un cardán de bricolaje (gimbal)

basado en la orientación de la MPO 6050 en sus puntos de vista del acelerómetro y los datos del
giroscopio controlaremos 3 servo motores que mantendrán el nivel de plataforma.
Materiales

• MPU 6050 procesador de movimiento digital 6 ejes

 MC5883L manómetro 3 ejes
 ADXL345 acelerómetro 3 ejes
 L3G4200D giroscopio 3 ejes
 BNO055 sensor 9 ejes
• Arduino NANO
• 3 Servo motores
• Base de prototipo Gimbal.
Componentes del circuito

• MPO 6050 procesador de movimiento digital 6 ejes

Dispositivo de control de movimiento MPU-6050, 6 ejes, InvenSense

El procesador de movimiento I2C de 6 ejes MPU-6050™ con sensor inteligente de
InvenSense incorpora un giroscopio de tres ejes y un acelerómetro de tres ejes, junto con
un procesador de movimiento digital (DMP), todo en un único sistema en chip. El
dispositivo de control de movimiento MEMS cuenta con un giroscopio y un acelerómetro
programables, diseñados para un control preciso de movimiento rápido y lento. La unidad
de control de movimiento MPU-6050 incorpora algoritmos MotionFusion con acceso
también a los sensores externos y magnetómetros mediante el bus I2C maestro auxiliar.
Las aplicaciones MPU-6050 incluyen sensores portátiles, tablets y smartphones. La
plataforma MotionAppsTM de InvenSense extraerá todos los movimientos asociados y
descargará la gestión del sensor del sistema operativo para proporcionar una interfaz de
programa de aplicación (API).

 Compatible con comunicaciones I2C: hasta 400 kHz

 Giroscopio programable por el usuario de escala completa en un rango de ±250,
±500, ±1.000y ±2.000°/s (dps)
 Acelerómetro programable por el usuario de escala completa en un rango de ±2
g, ±4 g, ±8 g y ±16 g
 Plataforma MotionApps™ compatible con Android, Linux y Window
 Dimensiones: 4 mm x 4 mm x 0,9 mm
(encapsulado QFN)
VLOGIC/VDD: 1,8 V ± 5%
 Corriente de funcionamiento del giroscopio y del acelerómetro: 3,8 mA
  Conformidad con RoHS/WEEE
 Corriente de alimentación en modo de reposo de chip completo: 5 μA
 Unidades de medida inerciales (IMU), Invensense[3]

• Arduino NANO

El Arduino Nano es un tablero pequeño, completo y fácil de usar basado en el

ATmega328P (Arduino Nano 3.x). Tiene más o menos la misma funcionalidad del
Arduino Duemilanove, pero en un paquete diferente. Solo le falta un conector de
alimentación de CC y funciona con un cable USB Mini-B en lugar de uno estándar. [4]

• 3 Servo Motores

Servomotor TowerPro MG995 con alto Torque, hasta 15Kg-cm. Robusto, alto
rendimiento, compacto, con engranes de Metal, tamaño estándar, incluye accesorios y
tornillos para montarlo en cualquier proyecto. [5]

Ideal para proyectos de Electrónica, Robótica... etc.

 Product Model: MG995

 Product Size: 40.7 * 19.7 * 42.9mm
 Product weight: 55g
 Operating torque: 15KG/cm Reaction speed: 53-62R / M
 Operating Temperature: -30 ~ +60 °
 Deadband settings: 4 microseconds
 Plug Type: JR, FUTABA General
 Rotation angle: A maximum of 180 degrees
 Servo: Servo
 Operating current: 100mA
 Using the voltage: 3-7.2V
 Materials of Construction: Copper metal teeth, coreless motor, double ball
bearing
 No load operating speed: 0.17 seconds / 60 degrees (4.8V); 0.13 seconds / 60
degrees (6.0V)

DIAGRAMA

+
Controlador Actuador Proceso
Setpoint -

Sensor
 +
Arduino Servomotores Procesador de
Angulo de -
movimiento digital
Giro

Sensor
BNO055

En el siguiente diagrama tenemos una variable de setpoint la cual queremos regular que es el
ángulo de giro que seguiremos el siguiente proceso: como el controlador de nuestro prototipo
tenemos un Arduino UNO, el cual se encargara de controlar los 3 servos motores que serán los
actuadores de nuestro prototipo, el proceso estará controlado por un procesador de movimiento
digital que tendrá perturbaciones rápidas de giros, el sensor que utilizaremos es un BNO055 en el
cual estarán presentes un acelerómetro, manómetro y un giroscopio que nos ayudaran a regular
los giros de la gimbal.
Controlador
El MPU6050 IMU tiene acelerómetro de 3 ejes y giroscopio de 3 ejes integrados en un solo chip.

El giroscopio mide la velocidad de rotación o la velocidad de cambio de la posición angular a

lo largo del tiempo, a lo largo de los ejes X, Y y Z. Utiliza la tecnología MEMS y el efecto Coriolis
para la medición, pero para más detalles, puede consultar mi tutorial particular de cómo funcionan
los sensores MEMS . Las salidas del giroscopio están en grados por segundo, por lo que para
obtener la posición angular solo necesitamos integrar la velocidad angular. [6]

Por otro lado, el acelerómetro MPU6050 mide la aceleración de la misma manera que se
explicó en el video anterior para el sensor del acelerómetro ADXL345. Brevemente, puede medir
la aceleración gravitacional a lo largo de los 3 ejes y, mediante algunos cálculos de trigonometría,
podemos calcular el ángulo en el que se coloca el sensor. Por lo tanto, si fusionamos o
combinamos los datos del acelerómetro y el giroscopio, podemos obtener información muy
precisa sobre la orientación del sensor. [7]
 La IMU MPU6050 también se denomina dispositivo de seguimiento de movimiento de seis
ejes o dispositivo de 6 DoF (seis grados de libertad), debido a sus 6 salidas, o las 3 salidas del
acelerómetro y las 3 salidas del giroscopio.

Arduino y MPU6050

Veamos cómo podemos conectar y leer los datos del sensor MPU6050 utilizando el Arduino.
Estamos utilizando el protocolo I2C para la comunicación con el Arduino, por lo que necesitamos
solo dos cables para conectarlo, más los dos cables para la alimentación.

Código Arduino MPU6050

Aquí está el código Arduino para leer los datos del sensor MPU6050. Debajo del código puedes
encontrar una descripción detallada del mismo.

1. #include <Wire.h>
2.
3. const int MPU = 0x68 ; // MPU6050 dirección I2C
4. flotar AccX, AccY, AccZ;
5. flotar GyroX, GyroY, GyroZ;
6. flotar accAngleX, accAngleY, gyroAngleX, gyroAngleY, gyroAngleZ;
7. rollo de flotación , inclinación, desvío
8. flotar AccErrorX, AccErrorY, GyroErrorX, GyroErrorY, GyroErrorZ;
9. float elapsedTime, currentTime, previousTime;
10. int c = 0 ;
11.
12. configuración vacía ( ) {
13. De serie. comienzo ( 19200 ) ;
14. Cable. comenzar ( ) ; // Inicializar comunicación
15. Cable. beginTransmission ( MPU ) ; // Iniciar la comunicación con MPU6050 // MPU = 0x68
16. Cable. escribir ( 0x6B ) ; // Habla con el registro 6B
17. Cable. escribir ( 0x00 ) ; // Restablecer - coloca un 0 en el registro 6B
18. Cable. endTransmission ( true ) ; // terminar la transmisión
19. / *
20. // Configurar la sensibilidad del acelerómetro - Rango de escala completa (valor predeterminado +/- 2g)
21. Wire.beginTransmission (MPU);
22. Wire.write (0x1C); // Habla con el registro ACCEL_CONFIG (1C hex)
23. Wire.write (0x10); // Establecer los bits de registro como 00010000 (+/- 8g rango de escala completa)
24. Wire.endTransmission (true);
25. // Configure Gyro Sensitivity - Full Scale Range (valor predeterminado +/- 250deg / s)
26. Wire.beginTransmission (MPU);
27. Wire.write (0x1B); // Habla con el registro GYRO_CONFIG (1B hex)
28. Wire.write (0x10); // Establezca los bits de registro como 00010000 (escala de 1000deg / s)
29. Wire.endTransmission (true);
30. retraso (20);
31. * /
32. // Llame a esta función si necesita obtener los valores de error de IMU para su módulo
33. calcular_IMU_error ( ) ;
34. retraso ( 20 ) ;
35. 36. } 37.
38. bucle de vacío ( ) {
39. // === Leer datos del acelerador === //
40. Cable. beginTransmission ( MPU ) ;
41. Cable. escribir ( 0x3B ) ; // Comenzar con el registro 0x3B (ACCEL_XOUT_H)
42. Cable. endTransmission ( false ) ;
43. Cable. requestFrom ( MPU, 6 , true ) ; // Leer 6 registros en total, cada valor de eje se almacena en 2
registros
44. // Para un rango de + -2g, necesitamos dividir los valores sin procesar por 16384, de acuerdo con la hoja de
datos
45. AccX = ( . Wire leer ( ) << 8 . | Alambre leer ( ) ) / 16384.0 ; // valor del eje X
46. Accy = ( . Wire leer ( ) << 8 . | Alambre leer ( ) ) / 16384.0 ; // valor del eje Y
47. AccZ = ( . Wire leer ( ) << 8 . | Alambre leer ( ) ) / 16384.0 ; // valor del eje Z
48. // Calculando Roll and Pitch a partir de los datos del acelerómetro
49. accAngleX = ( atan ( AccY / sqrt ( pow ( AccX, 2 ) + pow ( AccZ, 2 ) ) ) * 180 / PI ) - 0.58 ; // AccErrorX ~
(0.58) Consulte la función personalizada calcula_IMU_error () para obtener más detalles
50. accAngleY = ( atan ( - 1 * AccX / sqrt ( pow ( AccY, 2 ) + pow ( AccZ, 2 ) ) ) * 180 / PI ) + 1.58 ; //
AccErrorY ~ (-1.58)
51.
52. // === Leer datos del giroscopio === //
53. previousTime = currentTime; // El tiempo anterior se almacena antes del tiempo real leído
54. currentTime = millis ( ) ; // hora actual hora actual lectura
55. elapsedTime = ( currentTime - previousTime ) / 1000 ; // Divide por 1000 para obtener segundos
56. Cable. beginTransmission ( MPU ) ;
57. Cable. escribir ( 0x43 ) ; // Dirección de primer registro de datos Gyro 0x43
58. Cable. endTransmission ( false ) ;
59. Cable. requestFrom ( MPU, 6 , true ) ; // Leer 4 registros en total, cada valor de eje se almacena en 2
registros
60. GyroX = ( . Wire leer ( ) << 8 . | Alambre leer ( ) ) / 131,0 ; // Para un rango de 250deg / s tenemos que
dividir primero el valor bruto por 131.0, de acuerdo con la hoja de datos
61. GyroY = ( . Wire leer ( ) << 8 . | Alambre leer ( ) ) / 131,0 ; 62. GyroZ = ( . Wire leer ( ) << 8 . | Alambre
leer ( ) ) / 131,0 ;
63. // Corregir las salidas con los valores de error calculados.
64. GyroX = GyroX + 0,56 ; // GyroErrorX ~ (-0.56)
65. GyroY = GyroY - 2 ; // GyroErrorY ~ (2)
66. GyroZ = GyroZ + 0.79 ; // GyroErrorZ ~ (-0.8)
67.
68. // Actualmente los valores sin procesar están en grados por segundo, grados / s, por lo que necesitamos
multiplicar por sendonds (s) para obtener el ángulo en grados
69. gyroAngleX = gyroAngleX + GyroX * elapsedTime; // grado / s * s = grado
70. gyroAngleY = gyroAngleY + GyroY * elapsedTime;
71. yaw = yaw + GyroZ * elapsedTime;
72.
73. // Filtro complementario - combina valores de acelerómero y ángulo de giro
74. roll = 0.96 * gyroAngleX + 0.04 * accAngleX; 75. pitch = 0.96 * gyroAngleY
+ 0.04 * accAngleY;
76.
77. // Imprimir los valores en el monitor serie
78. De serie. impresión ( rollo ) ;
79. De serie. imprimir ( "/" ) ;
80. De serie. impresión ( tono ) ;
81. De serie. imprimir ( "/" ) ;
82. De serie. println ( guiñada ) ;
83. } 84.
85.
86. void calcula_IMU_error ( ) {
87. // Podemos llamar a esta función en la sección de configuración para calcular el error de datos del
acelerómetro y el giro. Desde aquí obtendremos los valores de error utilizados en las ecuaciones anteriores
impresas en el Monitor serie.
88. // Tenga en cuenta que debemos colocar la IMU plana para obtener los valores correctos, para que luego
podamos los valores correctos
89. // Leer los valores del acelerómetro 200 veces
90. mientras ( c < 200 ) {
91. Cable. beginTransmission ( MPU ) ;
92. Cable. escribir ( 0x3B ) ;
93. Cable. endTransmission ( false ) ;
94. Cable. requestFrom ( MPU, 6 , true ) ;
95. AccX = ( . Wire leer ( ) << 8 . | Alambre leer ( ) ) / 16384.0 ;
96. Accy = ( . Wire leer ( ) << 8 . | Alambre leer ( ) ) / 16384.0 ;
97. AccZ = ( . Wire leer ( ) << 8 . | Alambre leer ( ) ) / 16384.0 ;
98. // Suma todas las lecturas
99. AccErrorX = AccErrorX + ( ( atan ( ( AccY ) / sqrt ( pow ( ( AccX ) , 2 ) + pow ( ( AccZ ) , 2 ) ) ) * 180 /
PI
));
100. AccErrorY = AccErrorY + ( ( atan ( - 1 * ( AccX ) / sqrt ( pow ( ( AccY ) , 2 ) + pow ( ( AccZ ) , 2 ) ) ) *
180 / PI ) ) ;
101. c ++;
102. }
103. // Divide la suma por 200 para obtener el valor de error
104. AccErrorX = AccErrorX / 200 ;
105. AccErrorY = AccErrorY / 200 ;
106. c = 0 ;
107. // Leer valores de giroscopio 200 veces
108. mientras ( c < 200 ) {
109. Cable. beginTransmission ( MPU ) ;
110. Cable. escribir ( 0x43 ) ;
111. Cable. endTransmission ( false ) ;
112. Cable. requestFrom ( MPU, 6 , true ) ;
113. GyroX = Alambre. leer ( ) << 8 | Cable. leer ( ) ;
114. GyroY = Alambre. leer ( ) << 8 | Cable. leer ( ) ;
 115. GyroZ = Alambre. leer ( ) << 8 | Cable. leer ( ) ;
116. // Suma todas las lecturas
117. GyroErrorX = GyroErrorX + ( GyroX / 131,0 ) ;
118. GyroErrorY = GyroErrorY + ( GyroY / 131,0 ) ;

119. GyroErrorZ = GyroErrorZ + ( GyroZ / 131,0 ) ;

120. c ++;
121. }
122. // Divide la suma por 200 para obtener el valor de error
123. GyroErrorX = GyroErrorX / 200 ;
124. GyroErrorY = GyroErrorY / 200 ;
125. GyroErrorZ = GyroErrorZ / 200 ;
126. // Imprimir los valores de error en el Monitor de serie
127. De serie. print ( "AccErrorX:" ) ;
128. De serie. println ( AccErrorX ) ;
129. De serie. print ( "AccErrorY:" ) ;
130. De serie. println ( AccErrorY ) ;
131. De serie. imprimir ( "GyroErrorX:" ) ;
132. De serie. println ( GyroErrorX ) ;
133. De serie. print ( "GyroErrorY:" ) ;
134. De serie. println ( GyroErrorY ) ;
135. De serie. imprimir ( "GyroErrorZ:" ) ;
136. De serie. println ( GyroErrorZ ) ;
137. }

Actuador

Características técnicas de un servomotor con Arduino.

Servo

Un servo es un tipo de accionador ampliamente empleado en electrónica. A diferencia de

otros tipos de motores en los que controlamos la velocidad de giro, en un servo indicamos
directamente el ángulo deseado y el servo se encarga de posicionares en este ángulo.

Típicamente los servos disponen de un rango de movimiento de entre 0 a 180º. Es decir, no

son capaces de dar la vuelta por completo (de hecho, disponen de topes internos que limitan el
rango de movimiento). [8]

Internamente un servo frecuentemente consta de un mecanismo reductor. Por tanto,

proporcionan un alto par y un alto grado de precisión (incluso décimas de grado). Por contra, las
velocidades de giro son pequeñas frente a los motores de corriente continua.

Los servos se admiten una tensión de alimentación entre 4,8V a 7,2V, siendo el valor más
adecuado es 6V. Con tensiones inferiores el motor tiene menos fuerza y velocidad. Con tensiones
superiores a 6,5V los servos empiezan a oscilar demasiado, lo cual los hace poco útiles. [8]
MG996R

Este es el servo de tamaño «grande» que usaremos frecuentemente. Este tipo de servos es
ampliamente utilizado en proyectos de robótica. Igual que con el SG90, muchos dispositivos y
kits como brazos robóticos, hexápodos, están diseñados para instalar este tamaño de servo. [8]

• Torque: 13kg·cm (4.8V) a 15kg·cm (6V)

• Velocidad: 0.17 seg/60º (4.8V) y 0.13 seg/60º (6V)
• Dimensiones: 40 x 19 x 43mm
• Peso: 56g

Como funciona un servo

La comunicación de la posición deseada se realiza mediante la transmisión de una señal

pulsada con periodo de 20ms. El ancho del pulso determina la posición del servo.
 La relación entre el ancho del pulso y el ángulo depende del modelo del motor. Por ejemplo,
algunos modelos responden con 0º a un pulso de 500 ms, y otros a un pulso de 1000 ms

En general, en todos los modelos:

• Un pulso entre 500-1000 us corresponde con 0º

• Un pulso de 1500 ms corresponde con 90º (punto neutro)

• Un pulso entre 2000-2500us corresponde con 180º
Por tanto, variando la señal en microsegundos podemos disponer de una precisión teórica de
0.18-0.36º, siempre que la mecánica del servo acompañe.[8]

Conexionado con Arduino

Las conexiones dependerán del tipo de servomotor con Arduino que estemos utilizando.

Todos deben tener 3 cables. Uno irá a tierra, otro a la alimentación de 5 Voltios y el tercero a
un pin PWM. También puedes utilizar un shield para controlar servomotores, como el de Adafruit.

Código

Esta acción ya nos ha hecho un include en nuestro código que nos permite controlar el servo.
Os dejo a continuación un código básico para posicionar el servo en los ángulos 0º, 90º y 180º.
[9]

2 // Incluímos la librería para poder controlar el servo

 3 #include &lt;Servo.h&gt;

5 // Declaramos la variable para controlar el servo

6 Servo servoMotor;

8 void setup() {

9 // Iniciamos el monitor serie para mostrar el resultado

10 Serial.begin(9600);

11

12 // Iniciamos el servo para que empiece a trabajar con el pin 9

13 servoMotor.attach(9);

14 }

15

16 void loop() {

17

18 // Desplazamos a la posición 0º

19 servoMotor.write(0);

20 // Esperamos 1 segundo

21 delay(1000);

22

23 // Desplazamos a la posición 90º

24 servoMotor.write(90);

25 // Esperamos 1 segundo

26 delay(1000);

27

28 // Desplazamos a la posición 180º

29 servoMotor.write(180);

30 // Esperamos 1 segundo
31 delay(1000);

32 }

De la librería Servo.h hemos declarado un objeto o variable servoMotor y hacemos uso de dos
métodos. Por un lado, el attach, que nos permite indicar en que pin tenemos conectado nuestro
servo, y por otro lado el write, donde indicamos en qué ángulo queremos posicionar nuestro
servomotor. [9]

Tabla de error
ANEXOS
CÁLCULOS.
La tensión de alimentación depende del modelo del servomotor que se use. El servomotor
usado en nuestro proyecto comprende 4.5 V a 6 V.
La función de un servomotor es indicar la posición a través de una señal cuadrada de
voltaje. Su ángulo de ubicación depende del nivel alto de la señal.
Para el servomotor MG996R, los valores posibles de la señal están entre 1,0 ms / 60
grados, y 2,5 ms / 60 grados, que posicionan al motor en los extremos de giro.

Señal arrojada.
Referencias

[1] “¿Qué es un gimbal?” [Online]. Available: http://medya-audiovisual.com/que-es-

ungimbal/. [Accessed: 29-May-2019].
[2] “Qué es y para qué sirve un Gimbal.” [Online]. Available:
https://www.profesionalreview.com/2017/10/26/que-es-un-gimbal-para-que-sirve/.
[Accessed: 30-May-2019].
[3] “MPU-6050 | Sensor, MPU-6050, 6 ejes, I2C QFN 24 pines | RS Components.” [Online].
Available: https://pt.rs-online.com/web/p/sensores-de-acelerometro/8837948/.
[Accessed: 30-May-2019].
[4] “Arduino Nano.” [Online]. Available: https://store.arduino.cc/usa/arduino-nano.
[Accessed: 30-May-2019].
[5] “Servomotor TowerPro MG995 15Kg-cm. - ColdFire Electronica - Todo para Sistemas
Embebidos, Arduino, Microcontroladores, Electronica, Sensores, Libros Tecnicos,
Seminarios, Cursos.” [Online]. Available:
https://www.coldfireelectronica.com/esp/item/26/servomotor-towerpro-mg995-15kg-cm.
[Accessed: 30-May2019].
[6] J. A. Montoya, O. Javier, R. Azagra, M. Gil Martínez, and C. Académico, “TRABAJO
FIN DE GRADO Diseño y desarrollo de un gimbal con motores brushless,” 2015.
[7] “Tutorial de acelerómetro y giroscopio Arduino y MPU6050 - HowToMechatronics.”
[Online]. Available: https://howtomechatronics.com/tutorials/arduino/arduino-
andmpu6050-accelerometer-and-gyroscope-tutorial/. [Accessed: 30-May-2019].
[8] “Controlar un servo con Arduino.” [Online]. Available:
https://www.luisllamas.es/controlar-un-servo-con-arduino/. [Accessed: 30-May-2019].
[9] “Servomotor con Arduino tutorial de programación paso a paso.” [Online]. Available:
https://programarfacil.com/tutoriales/fragmentos/servomotor-con-arduino/. [Accessed:
30-May-2019].