proyectos integrados -...
TRANSCRIPT
PI01:
Alejandro Gutiérrez Vázquez,
Carmen Vivancos Porras,
Francisco José Rivero González,
Guillermo Cartes Domínguez,
Marcelo Fco. Simbaña Romero,
Mª del Carmen Delgado Venzalá y
Rubén Gómez Merchán
GRADO EN INGENIERÍA ELECTRÓNICA, ROBÓTICA Y MECATRÓNICA Escuela Técnica Superior de Ingeniería
PROYECTOS INTEGRADOS GLOVARM
12 DE JUNIO DE 2018
1
ÍNDICE
1. Introducción ...................................................................................................... 5
2. Objetivos .......................................................................................................... 5
3. Conocimientos previos ...................................................................................... 6
3.1 Objetivos .................................................................................................... 7
3.2 Requisitos ................................................................................................... 7
3.2.1 Funcionales .......................................................................................... 7
3.2.2 Prestaciones ........................................................................................ 7
3.2.3 Diseño ................................................................................................. 8
3.2.4 Operación ............................................................................................ 8
3.2.5 Optativos ............................................................................................. 8
3.2.6 Restricciones ........................................................................................ 8
4. Reparto y planificación de tareas ...................................................................... 8
5. Elementos utilizados ............................................................................................. 9
5.1 Arduino Mega ................................................................................................. 9
5.2 Servomotor MG9945 ..................................................................................... 10
5.3 Servomotor MG90S ....................................................................................... 10
5.4 Sensor de Flexión SparkFun ........................................................................... 11
5.5 Acelerómetro MPU6050 ................................................................................ 11
5.6 Motor DC 12 V. .............................................................................................. 12
5.7 Cables y elementos electrónicos. ................................................................... 12
5.8 Baterías y pilas .............................................................................................. 12
5.9 Tablero DM 3 mm y tornillería. ...................................................................... 13
6. Control de calidad y buenas prácticas ................................................................. 13
7. Análisis de problemas y soluciones .................................................................. 14
2
7.1 Alimentación de servomotores .................................................................. 14
7.2 Problemas de diseño ................................................................................. 14
7.3 Sobrecarga en articulación 3 ..................................................................... 15
7.4 Horario y festividad en FabLab .................................................................. 15
7.5 Errores de diseño ...................................................................................... 15
7.6 Uso de Raspberry PI .................................................................................. 15
7.7 Mala elección del sensor de flexibilidad..................................................... 15
8. Resultado final ................................................................................................ 16
8.1 Funcionalidad ........................................................................................... 16
8.2 Subsistema mecánico ................................................................................ 16
8.3 Subsistema software y hardware .............................................................. 22
9.3.1 Control de servos .................................................................................... 22
9.3.2 Lectura de acelerómetro ......................................................................... 22
9.3.3 Lectura del sensor de flexibilidad. ........................................................... 24
9.3.4 Modo aprende ........................................................................................ 26
9.3.5 Circuito impreso del box de precisión ...................................................... 26
9.3.6 Código principal ...................................................................................... 26
8.4 Subsistema de mando ............................................................................... 28
9.4.1 Guante de control ................................................................................... 28
9.4.2 Box de precisión ..................................................................................... 29
8.5 Subsistema de marketing .......................................................................... 29
9.5.1 Vídeos comerciales ................................................................................. 29
9.5.2 Flyer publicitario ..................................................................................... 30
9.5.3 Página Web ............................................................................................ 30
9.5.4 Guía de usuario ...................................................................................... 31
9. Campos de aplicación ...................................................................................... 32
3
9.1 Campo industrial ...................................................................................... 32
9.2 Campo lúdico ............................................................................................ 32
9.3 Campo educativo ...................................................................................... 32
9.4 Campo doméstico ..................................................................................... 32
10. Planos y programas ...................................................................................... 33
10.1 Planos de la estructura completa ........................................................... 33
10.2 Planos del box de control ....................................................................... 33
11.2 Esquemas eléctricos .................................................................................... 34
10.2.1 Acondicionamiento sensor de flexibilidad ........................................... 34
10.2.2 Box de precisión ................................................................................. 34
10.3 Esquema de conexionado (Arduino) ....................................................... 35
10.4 Programa de calibración del MPU-6050 ................................................. 35
10.5 Programa principal ................................................................................ 35
10.5.1 Variables y constantes ....................................................................... 35
10.5.2 Condiciones iniciales .......................................................................... 36
10.5.3 Función Home .................................................................................... 37
10.5.4 Función Mover_servo ......................................................................... 37
10.5.5 Interrupción del timer ........................................................................ 38
10.5.6 Lectura del acelerómetro ................................................................... 38
10.5.7 Lectura del sensor de flexibilidad y posiciones .................................... 38
10.5.8 Cambio de herramienta...................................................................... 39
10.5.9 Uso de herramienta ........................................................................... 39
10.5.10 Máquina de estado Modo Aprende ................................................. 39
10.5.11 Máquina de estado Modo Reproduce .............................................. 40
10.5.12 Actualización de posiciones de los servos ........................................ 41
10.5.13 Programa completo ........................................................................ 41
4
11. Presupuesto ................................................................................................. 47
Materiales necesarios: ........................................................................................ 47
12. Posibles mejoras .......................................................................................... 47
13. Demostración ............................................................................................... 48
14. Bibliografía .................................................................................................. 48
15. Agradecimientos .......................................................................................... 49
16. Anexos ......................................................................................................... 49
5
1. INTRODUCCIÓN
En este proyecto, ha participado un grupo formado por 7 alumnos del Grado en Ingeniería Electrónica, Robótica y Mecatrónica de la Universidad de Sevilla, para la asignatura Proyectos Integrados.
El objetivo de la asignatura es formar a los alumnos de manera que, sean capaces de planificar, organizar, dividir tareas y responsabilidades y llevar a cabo un proyecto real, desde la primera idea hasta la presentación de este frente a los profesores de la asignatura.
Tras adquirir unos conocimientos previos, se procedió a la discusión del proyecto y a la división de los roles, los cuales sufrieron una evolución durante el desarrollo, adaptándose a las necesidades del momento y a los imprevistos que fueron surgiendo.
La idea principal de la que partió todo el trabajo (y la cual también fue evolucionando) fue la realización de un brazo robótico de tres grados de libertad que imitara los movimientos de un brazo mediante un guante, pudiendo aprender una trayectoria para posteriormente reproducirla, contando con un cambio de herramienta que intercambiara el efector final sin dificultad para el usuario. Tras esta iniciativa nació el término de GlovArm (acrónimo proveniente del inglés, compuesto por Glove y Arm).
2. OBJETIVOS
En una primera instancia, nuestro objetivo era la realización de un brazo robótico funcional, económico y sencillo, que fuera controlado mediante un guante, de manera que el usuario no debiera poseer ningún tipo de conocimiento previo más que la lectura de las sugerencias de uso que se aportarán junto al producto final.
En cuanto a lo funcional, el robot debía ser capaz de reproducir de forma clara e intuitiva los movimientos del guante, existiendo la opción de almacenar la trayectoria seguida para reproducirla cuando fuera necesario.
Como se acaba de mencionar, también debe ser económico, por lo que la elección de los materiales y de los actuadores era de vital importancia, ya que debían tener la capacidad necesaria para someterse a los esfuerzos previstos y a su vez no superar un umbral de presupuesto previamente marcado.
Tras deliberarlo con todos los compañeros durante el transcurso del proyecto, se decidió dotar a nuestro robot de seis grados de libertad, de manera que no solo pudiera trasladarse en el espacio, sino que además pudiera orientar su efector final, con lo que surgió la idea del control de precisión, que añadía este objetivo extra a nuestras consignas iniciales.
6
Desde un inicio todos los integrantes coincidieron en separar las tareas en tres grandes subsistemas, añadiendo un cuarto durante el desarrollo del proyecto:
• Subsistema mecánico. Los responsables de este subsistema serían los encargados de diseñar la estructura, de manera que debían escoger el material que se utilizaría además de adaptar un diseño a todas nuestras necesidades, sobre todo el cambio de herramienta y la distribución de los actuadores. A su vez, este subsistema se divide en dos subsubsistemas: Brazo y pinza.
• Subsistema software y hardware. Dentro de este bloque,se englobaría toda la programación necesaria para la medición de las magnitudes físicas, la lectura de sensores y la interpretación de estos datos, para poder procesarlos y transformarlos finalmente en señales que se encargarán de mover el robot mediante los actuadores. Este subsistema se divide en otros dos bloques: software y hardware.
• Subsistema de control. Este subsistema se encarga del diseño y fabricación del guante de control y del box de precisión (que corresponden a los dos subsubsistemas que forman este bloque).
• Subsistema de marketing*. Tras comprobar que en la última semana se contaba con tiempo extra, se creó un nuevo subsistema encargado de la publicidad del producto.
*Nótese que este subsistema no estaba pensado inicialmente. Debido a disponer de tiempo extra tras cumplir los objetivos propuestos, se decidió llevar acabo esta iniciativa.
3. CONOCIMIENTOS PREVIOS
El grupo de trabajo fue formado con antelación a la decisión de la temática del proyecto, por lo que realmente fue esta la que se decidió conforme a nuestros conocimientos, aptitudes y alcance.
Previamente se había trabajado con Arduino, sin embargo, no se poseía un gran conocimiento de este, a pesar de ello, se contaba con un equipo adaptable en cuanto a programación se refiere, por lo que en ningún momento supuso un problema.
Para la realización del guante de control, se fueron adquiriendo conocimientos paralelamente de Instrumentación Electrónica, lo que permitía el diseño, la simulación y la fabricación de un instrumento de medida para medir los movimientos de la mano.
Por último, pero no por ello menos importante, se tuvo que investigar sobre posibles tipos de diseños y cómo modificarlos de manera que no solo cumplieran nuestras especificaciones, sino que además soportaran los esfuerzos a los que iban a ser sometidos.
7
Pliego de condiciones
3.1 Objetivos
Obj1. El brazo debe ser capaz de imitar los movimientos del guante que se encarga de su movimiento. Obj2. El brazo debe ser capaz de coger objetos de pequeño peso gracias a su pinza. Obj3. El brazo debe ser capaz de simular que está taladrando gracias al motor donde se acoplaría la broca. Obj4. El brazo debe ser capaz de memorizar una serie de movimientos y luego reproducirlos de forma autónoma. Es el llamado sistema de aprendizaje.
3.2 Requisitos
3.2.1 Funcionales
F1. El sistema debe tener un rango amplio de movimientos en cada articulación, que le permita coger objetos en una superficie óptima de trabajo.
F2. El sistema debería ser capaz de imitar los movimientos de la mano del operador de forma precisa.
F3. El sistema debe ser capaz de aprender movimientos que se le han enseñado con anterioridad.
F4. Debería poder simular que hace agujeros con el motor acoplado al efector final.
F5. El brazo debe poder coger objetos de peso no muy elevado, siendo esta su función principal.
F6. El sistema debería ser capaz de cambiar de herramienta de forma autónoma.
3.2.2 Prestaciones
P1. El sistema debería guardar 3 posiciones, como mínimo, por segundo cuando se encuentre en el estado de aprendizaje.
P2. Debería tener un rango de giro de la base (articulación 1) entre 0 y 180º.
P2. Debería tener un rango de giro del hombro (articulación 2) entre 15º y 85º.
P3. Debería tener un rango de giro del codo (articulación 3) entre 30º y 75º.
P4. Debería tener un rango de giro de la muñeca (eslabón 4) entre 0º y 180º.
8
3.2.3 Diseño
D1. El peso de cada eslabón debe ser lo suficientemente pequeño como para que, en el peor de los casos, el par que se ejerza sobre el servo que se encarga de su movimiento sea menor que el par que dicho servo puede ofrecer.
D2. Las dimensiones de los eslabones y del brazo, en general, deben ser lo suficientemente grandes para permitir el conexionado de cables y la inserción de los servos, así como el cambio de herramienta.
3.2.4 Operación
O1. El sistema debe poder ser totalmente controlado de forma remota, integrando un botón de on/off global.
O2. La herramienta debe poder controlarse mediante un botón en el guante.
O3. El cambio de herramienta se realizará mediante un interruptor de dos posiciones.
3.2.5 Optativos
Q1. El sistema podría tener una cámara en el brazo para permitir a un operador visualizar los objetos que está manipulando, en caso de que no lo pueda hacer bien desde su centro de mando.
Q2. El sistema podría tener un sensor de temperatura para que en el caso de que el objeto que vaya a manipular pueda deteriorar el mismo brazo, este decida no cogerlo.
3.2.6 Restricciones
C1. El presupuesto máximo del proyecto es de 70 euros.
C2. El uso de FabLab estará restringido a un horario de reserva, el cual hay que prever.
4. REPARTO Y PLANIFICACIÓN DE TAREAS
Las tareas se han repartido de la siguiente manera:
• Gestión y Seguimiento del proyecto o Supervisión. Rubén. o SOW Guillermo (encargado) + Aportación del resto. o Informes semanales. Mª del Carmen y Carmen + Aporte del
Resto. o Entrega final. Rubén (encargado), Marcelo (parte mecánica) +
Aporte del resto. o Tests y pruebas. Encargado de cada tarea.
9
• Subsistema Mecánico o Supervisor. Marcelo. o Diseño y fabricación de la estructura. Marcelo, Francisco y Mª del
Carmen.
• Subsistema Software y Hardware. o Supervisor. Rubén. o Diseño, simulación y fabricación de instrumentos de medida.
Rubén. o Control y lectura de acelerómetro. Francisco. o Control de servomotores. Alejandro. o Programa principal. Rubén, Alejandro y Francisco.
• Subsistema de mando o Diseño e integración del guante. Carmen y Mª del Carmen. o Diseño e integración del box precisión. Guillermo.
• Subsistema Marketing o Vídeos promocionales. Rubén. o Página Web. Mª del Carmen. o Demás elementos publicitarios. Guillermo y Carmen.
Una planificación más específica de las tareas de cada bloque puede verse en el diagrama de Gantt que aparece en el Stament of Work.
5. ELEMENTOS UTILIZADOS
5.1 Arduino Mega
Arduino Mega es un microcontrolador con múltiples pines configurables como entradas o salidas digitales/analógicas. Debido a la necesidad de un convertidor analógico/digital y la sencillez de la interfaz de Arduino, esta fue la mejor opción para utilizar como cerebro de nuestro robot.
Más concretamente cuenta con:
• 54 pines de entradas/salidas digitales (14 de las cuales pueden ser utilizadas como salidas PWM).
• 16 entradas análogas, 4 UARTs (puertos serial por hardware).
• Cristal oscilador de 16MHz.
• Conexión USB.
• Jack de alimentación.
• Conector ICSP.
• 256k de memoria flash.
Para la alimentación del dispositivo se utilizó una pila de 9V.
10
5.2 Servomotor MG9945
Con un precio muy asequible, este producto nos ofrece un par de 10kg/cm alimentados a 6 V, siendo más que suficiente para nuestra aplicación, aportando a la estructura 55g por servo.
Este servo sería necesario para girar la base, el hombro (x2), el codo (x2), el cambio de herramienta y el cabeceo de la pinza.
Tras mediciones con carga, se comprobó un consumo máximo (peor situación) de unos 0.7 A por servo, por lo que el consumo máximo (pico de corriente) que puede aparecer (siendo despreciable el del cabeceo de la pinza) es de aproximadamente 4.2 A, cosa que se tuvo en cuenta a la hora de escoger una fuente de alimentación.
Figura 5.1: Servomotor MG9945.
5.3 Servomotor MG90S
Para otras tareas tales como el cierre de la pinza, el giro de la muñeca y el cabeceo de la herramienta secundaria se optó por un servo que solo aportaba 9g a la estructura y era capaz de ofrecer un par de 2.2 kg/cm alimentados a 3.3V, suficiente para las especificaciones propuestas y colaborando al carácter económico del proyecto.
Al no ser muy elevado el consumo de estos elementos, pudieron ser alimentados mediante el propio Arduino.
Figura 5.2: Servomotor MG90S
11
5.4 Sensor de Flexión SparkFun
Este transductor está compuesto por una resistencia sensible a la flexión, variando cuando el sensor se encuentra deformado entre 30kΩ y 125kΩ aproximadamente. Para nosotros significará que la mano está completamente abierta cuando vale unos 30kΩ y que la mano está completamente cerrada cuando vale unos 75kΩ. De esta manera podíamos colocarlo en el dedo corazón del guante para que, al cerrar más o menos la mano, el robot imitara el movimiento.
Para la medida de esta variable, fue necesaria la implementación de un circuito de acondicionamiento de la señal, que nos ofreciera una salida de entre 0 y 5V lineal y sin offset (para el buen control del robot, por el contrario, el movimiento no sería intuitivo).
Figura 5.3: Sensor de flexión (SparkFun).
5.5 Acelerómetro MPU6050
Con la ayuda de este acelerómetro con giroscopio incorporado, podemos medir el ángulo de giro en cada eje del acelerómetro (eje vertical y dos ejes horizontales perpendiculares).
Basándonos en esta idea, si colocamos el acelerómetro encima del guante, podemos medir cuánto gira nuestra muñeca (roll) , cuánto la inclinamos (yaw) y cuánto la hacemos girar en el eje vertical (pitch).
Figura 5.4: Acelerómetro MPU6050.
12
5.6 Motor DC 12 V.
Debido a que en un principio la herramienta adicional iba a ser un taladro, este motor era el necesario para simularlo. Existen acoples baratos y ligeros para añadir una broca, sin embargo, por motivos de seguridad, se decidió simplemente simular que posee la broca acoplada.
Al ser una simulación, podríamos alimentar el motor a 5 V (mediante una señal digital de Arduino) a menor velocidad de la nominal (300 rpm).
Figura 5.5: Motor de continua.
5.7 Cables y elementos electrónicos.
Para la conexión de todos los elementos, se centralizó en una placa de circuito impreso donde se encontraba la botonera. Utilizamos cables de cobre y otros
elementos como resistencias, LEDs, pulsadores, interruptores y potenciómetros.
Figura 5.6: LED, pulsador y potenciómetro.
5.8 Baterías y pilas
Para la alimentación del Arduino y del instrumento de medida del sensor de flexibilidad, se utilizaron pilas de 9V.
En cuanto a los servos, como ya se comentó, era necesaria una batería de 9V que ofreciera la corriente suficiente en las peores situaciones. La mejor solución fue una batería de plomo de 6V y 4500mAh.
13
Figura 5.7: Batería utilizada.
5.9 Tablero DM 3 mm y tornillería.
Tras decidir un diseño y estudiar los esfuerzos soportados, este material fue el idóneo tanto para la robustez de la estructura como para la minimización de los costes. Se utilizaron tornillos de 1, 1.6, 2.8 y 6 mm de diámetro.
Para la elaboración de las piezas se utilizó FabLab, un servicio de mecanizado mediante cortadora láser que se ofreció a patrocinar el proyecto a cambio de los planos y la divulgación pública del producto.
6. CONTROL DE CALIDAD Y BUENAS PRÁCTICAS
Para poder maximizar los resultados, partimos de una serie de premisas que deberían respetarse y se siguieron a raja tabla:
• Organización: Las tareas serán repartidas por Rubén, de la manera más productiva posible, utilizando como criterio la disponibilidad, los conocimientos y recursos de cada uno, atendiendo a la opinión común y al desarrollo real de estas tareas.
• Trabajo en paralelo: Otro criterio de la división de las tareas es aquel que nos permite realizar el máximo avance en paralelo, de manera que las tareas se dividirán al máximo para poder trabajar independientemente e ir integrando progresivamente.
• Comunicación: Cada persona tenía el deber de comunicar el estado de su tarea, de manera que cuando se estime necesario, se redistribuirán las tareas de manera más eficiente aún.
• Estructura jerárquica: Existe una persona responsable de conocer y organizar estado del proyecto y de sus buenas prácticas. A su vez, cada subsistema posee otro responsable.
• Integración: Durante todo momento el proyecto se llevará a cabo pensando en la integración final de todos los elementos, por lo que un resultado aislado no aporta nada si no se va integrando de manera progresiva al sistema global. En cuanto al control de versiones, para evitar la pérdida y la sobreescritura
14
de estas, se utilizaron las técnicas provistas por los profesores de la asignatura.
Durante el transcurso de la activad se ha utiliza la herramienta GIT, salvo durante un pequeño período en el que un error no nos permitía modificar el repositorio donde se encontraban todos los archivos, pero tras solucionarlo y documentarnos sobre el uso de la plataforma, fue de gran utilidad.
Para la comunicación de tareas y notificaciones se utilizó un grupo de WhatsApp donde solo hablaba el administrador y todos los integrantes tenían archivado al principio de sus conversaciones, de manera que se podía llevar el control de quién se había informado y quién faltaba por estar al tanto.
7. ANÁLISIS DE PROBLEMAS Y SOLUCIONES
7.1 Alimentación de servomotores
Como se ha comentado anteriormente, al no tener datos del fabricante, se pudo medir un consumo de hasta 0.7A en los servomotores cuando el robot se encontraba en la posición más desfavorable, por lo que tras realizar estas pruebas y mediciones nos vimos en la necesidad de adquirir una batería que ofreciera tal amperaje, cosa que no fue ningún inconveniente.
Sin embargo, el tamaño de la batería no previsto impedía ser almacenada junto al Arduino en la caja de mandos, por lo que este último se encontraría en el exterior.
7.2 Problemas de diseño
El primer diseño tuvo una serie de problemas:
1. Las piezas no encajaban debido a que estaban pensadas para una plancha de 4 mm y en el último momento se cambió a 3mm.
2. Algunas guías no coincidían. 3. Al no saber con exactitud las medidas de los servos, se dejaron partes sin
diseñar con la idea de cortarlas manualmente. Se comprobó que esto no era posible.
Finalmente, ese diseño acumulaba demasiados errores, por lo que se realizó de nuevo en otra sesión de FabLab.
15
7.3 Sobrecarga en articulación 3
A pesar de las simulaciones realizadas, se observó un calentamiento fuera de lo esperado del actuador de la tercera articulación (el denominado codo). Para evitar una sobrecarga indebida y evitar un posible defecto, se decidió modificar el diseño y añadir otro servo extra (del que ya se disponía) para repartir la carga, tal y como ya se hacía en la articulación anterior.
Una vez probado el nuevo diseño, se comprobó una mayor fluidez y un aparente uso más reducido de los actuadores, pudiendo mantener posiciones incómodas repetidamente.
7.4 Horario y festividad en FabLab
Debido a la Semana de la Ciencia y demás festividades próximas, vimos limitada la fecha de fabricación del primer prototipo (que atrasaría al segundo y definitivo), lo cual incurría en nuestra política de progresiva integración. Esto supuso un retraso en el avance del proyecto, lo que podría haberse traducido como tiempo extra para realizar nuevas modificaciones y mejoras.
7.5 Errores de diseño
Como se comentará más detalladamente en el siguiente apartado, hubo una serie de errores de diseño, debido al uso de la cortadora láser y al cambio de espesor del material, se tuvo que repetir el diseño en una segunda jornada.
7.6 Uso de Raspberry PI
Tras un malentendido en el grupo, se pensaba que, aun utilizando un Arduino, el uso de Raspberry PI era obligatorio en la asignatura. Debido a que se necesitaba un convertidor analógico/digital, el Arduino era indispensable, mientras que la comunicación Arduino-Raspberry aportaba más dificultad que beneficios.
Finalmente se decidió el uso único del Arduino, se llevó a cabo una rápida reestructuración de los códigos ya realizados.
7.7 Mala elección del sensor de flexibilidad
De primeras, se partió de otro sensor de flexibilidad distinto (galga extensiométrica), que no era útil para nuestra aplicación, por lo que se desechó (era material barato) y se buscó el sensor comentado con anterioridad.
16
8. RESULTADO FINAL
8.1 Funcionalidad
GlovArm ofrece un brazo robótico económico, sencillo y funcional, de manera que cualquier usuario sin experiencia puede hacer uso del producto, ya sea a nivel industrial (desarrollo de procesos repetitivos o trabajo en entornos peligrosos, donde el ser humano debe evitar adentrarse o peligra su integridad física) o a nivel lúdico, donde los más pequeños podrán tener un primer contacto con el mundo de la robótica y la tecnología.
El producto está compuesto de los siguientes elementos:
• Un brazo robótico de seis grados de libertad, cuyas articulaciones (todas de rotación) se mueven a través de servomotores.
• Un guante de control, que posee un sensor de flexibilidad conectado en el dedo corazón, un acelerómetro en la parte superior de la mano y un botón en el lateral (accesible mediante el pulgar). Gracias a estos elementos, puede obtenerse una medida de los movimientos realizados con el guante puesto, los cuales son enviados al Arduino para que se encargue de mandar las señales correspondientes a los actuadores.
• Un box de precisión, en cuyo interior se encuentra el cableado y la alimentación. Además, posee una botonera para las acciones de aprender una trayectoria, reproducirla, cambiar de herramienta y, lo que le da su nombre, un potenciómetro que permite tener aún más precisión y poder orientar el efector final en el espacio una vez posicionado.
Aunque el control del robot es claramente sencillo e intuitivo, se aporta un manual de usuario en el anexo, donde se comenta detalladamente cómo realizar un correcto uso junta a las indicaciones y recomendaciones del fabricante.
8.2 Subsistema mecánico
Respecto a este subsistema, se intentó basar el diseño en alguno de la comunidad www.thingiverse.com. Se pretendía que el robot fuera robusto, que se realizara en madera, y que tuviera los suficientes grados de libertad.
17
En un primer momento, se buscaron distintos modelos de brazo robótico para partir de una base:
Figura 8.1: Robot “Thor” de Thingiverse. Figura 8.2: Robot de Thingiverse.
El diseño mostrado en la figura 9.1 implicaba realizarlo en una impresora 3D y simplemente con el gasto del material se iba el presupuesto.
El robot de la figura 9.2, que era posible realizar en madera, presentaba el inconveniente de que era demasiado pequeño y estaba diseñado para manejar servos de bajo par, por lo que también fue descartado.
Finalmente, el robot elegido fue el siguiente:
Figura 8.3: Robot de Thingiverse en SolidWorks.
Como puede apreciarse, este robot sí reunía las características que se requerían: podía diseñarse en madera, robusto, y cuenta con los grados de libertad necesarios. A continuación, se muestran los planos que se descargaron de www.thingiverse.com.
18
Figura 8.4: Planos del robot de Thingiverse en AutoCAD.
Pero este diseño presentaba varios inconvenientes, entre ellos:
• El diseño estaba pensado para un DM de 4mm.
• No era posible realizar un cambio de herramienta.
• Las longitudes de los eslabones y el radio de la base eran demasiado pequeños como para conseguir que el robot sea verdaderamente funcional.
• Las medidas de los servos y las uniones de las aletas a los eslabones no se ajustaban a los nuestros.
Por lo tanto, se decidió diseñar el robot partiendo de este modelo, pero ajustándose a nuestras necesidades. A continuación, se mostrarán una serie de imágenes donde se aprecien las modificaciones.
1. Se aumentaron las medidas de la base:
Figura 8.5: Parte 1 de la base en AutoCAD.
Principalmente se ha incrementado el radio de la base para obtener más distancia entre eslabones y así poder encajar el sistema del cambio de herramienta. Puede apreciarse que se aumentó el diámetro de los tornillos para que se ajusten a los que se compraron. Además, se disminuyó el radio de curvatura donde van colocados para que se ajuste al del rodamiento.
19
Figura 8.6: Pieza 2 de la base en AutoCAD.
También se aumentó el diámetro de la pieza en general y de los tornillos. Nótese que el diámetro de los tornillos esta vez es menor que el anterior debido a que los que se compraron tenían un cuello mayor.
Figura 8.7: Pieza 3 de la base en AutoCAD.
En este caso no fue necesario incrementar los tornillos donde van ancladas las aspas, pero sí disminuir el tamaño de los encajes ya que nuestro tablón DM era de 3mm.
2. Se aumentaron las medidas de los eslabones:
Figura 8.8: Eslabón 1 (izquierda) en AutoCAD.
Principalmente, se aumentó el tamaño de los eslabones en 6 cm. También se cambió el sistema de anclaje a las aspas y se aumentó el diámetro de las guías para que se ajusten a los tornillos comprados.
20
Figura 8.9: Eslabón 1 (derecha) en AutoCAD.
Las modificaciones son similares a la de la parte izquierda del eslabón.
Figura 8.10: Eslabón 2 (izquierda) en AutoCAD.
Una vez más, se aumentaron las medidas y se incorporaron guías.
Figura 8.11: Eslabón 2 (derecha) en AutoCAD.
Las modificaciones son similares al anterior.
3. Se diseño el dispositivo para el cambio de herramienta:
Figura 8.12: Sistema del cambio de herramienta en AutoCAD.
21
De forma que la parte superior corresponde a la parte derecha del eslabón y la parte inferior a la parte izquierda.
La pinza no sufrió modificaciones.
Los planos hasta el momento eran los siguientes:
Figura 8.13: Planos del primer prototipo.
Debido a lo comentado en el punto 8.2, se realizó un segundo diseño, ya que la utilización del primero era inviable y algunas piezas habrían sufrido durante el montaje:
Figura 8.14: Planos del segundo prototipo
En este segundo intento, se solventaron todos los errores, sin embargo, debido al problema comentado en el punto 8.3 se decidió hacer una última modificación, dando lugar al diseño definitivo, en el cual, se solventaba el error anterior añadiendo un servo más que se había comprado por precaución. Los planos definitivos pueden observarse en la sección planos y programas.
22
8.3 Subsistema software y hardware
Este segundo bloque, que inicialmente fue denominado simplemente “subsistema software” sufrió una evolución casi de manera natural a lo largo de la trayectoria del proyecto, debido a la necesidad de diseñar y fabricar circuitos electrónicos para la medida de las variaciones de los sensores y la botonera, necesarias para el correcto progreso del subsistema de mando.
Se comenzó en paralelo a trabajar con todos elementos que disponíamos. Mientras se llevaba a cabo el control de los servos, otros integrantes del grupo fueron programando los sensores que intervenían en el guante. También, se realizó un primer borrador del código que desembocaría en el modo aprende final.
8.3.1 Control de servos
Para el control de los servos se utilizó una librería que aporta Arduino, Servo.h, que nos facilitaba el trabajo. Para ello, se creó una función que toma como valores de entrada un objeto correspondiente al servo que queremos mover y el ángulo que queremos tomar. Se programó a su vez una función home que coloca todos los servos en su posición inicial y activa una pausa hasta que se pulse el botón del guante.
8.3.2 Lectura de acelerómetro
Para realizar las medidas de los giros en el guante se empleó el sensor MPU6050, comentado anteriormente, que permitía de una forma sencilla y barata medidas fiables de gran precisión.
Lo primero fue su calibración, ya que estos sensores suelen tener errores en los componentes debido al desnivelado que pueden sufrir durante su soldadura. Esta calibración se logró mediante un programa genérico tomado de la comunidad de Arduino (ver en planos y códigos). Antes de utilizar el programa se debe colocar el sensor en una posición considerada horizontal con las letras hacia arriba. Gracias a esta referencia y los valores por defecto del sensor, el programa indicará qué offsets se deben introducir en el programa antes de tomar los datos. La calibración solo hace falta realizarla una vez. Luego esos valores se introducen en el programa principal que mide los datos del giroscopio y acelerómetro.
Este programa incluye las librerías: Wire.h, MPU6050_6Axis_MotionApps20.h y I2Cdev.h, proporcionadas por Arduino y el fabricante. Mediante estas librerías se pueden realizar las lecturas del MPU-6050 y mejorar la comunicación I2C.
Un ejemplo del funcionamiento del programa se puede observar en la figura 9.13.
23
Figura 8.15: Calibrado del sensor MPU-6050.
Después de investigar los diferentes métodos y códigos para obtener las medidas, se decidió emplear el DMP (Digital Motion Processor) integrado en el MPU-6050, el cual combina la medición del giroscopio y el acelerómetro, lo que proporciona un mejor resultado que utilizar un filtro complementario y además libera a Arduino del proceso de cálculo.
Para el programa principal se han adaptado varios códigos de libre disposición dentro de la comunidad de Arduino. El funcionamiento de estos sensores se basa en el uso de la gravedad y relaciones de trigonometría.
Lo primero que se debe hacer es introducir los valores del calibrado y definir una serie de vectores: gravedad, cuaternios y ypt (yaw, pitch, roll). Se inicializa el sensor (si hubiese algún fallo aparecería un error) y el DMP. Además, se usa una interrupción para que cada cierto tiempo se actualicen los valores medidos. De esta manera, el sensor devuelve los valores de los ángulos de giro.
Estos datos se pueden observar por el Monitor Serie para comprobar su correcto funcionamiento, tal y como se observa en la siguiente imagen:
24
Figura 8.14: Prueba de lectura del MPU (mostrando valor erróneo en offset del eje z para ver el efecto)
8.3.3 Lectura del sensor de flexibilidad.
En cuanto a la medida del sensor de flexibilidad, lo primero era diseñar una fase de acondicionamiento de la señal para poder introducir una medida de tensión en el Arduino. Debido a que necesitábamos una relación lineal y sin offset (valor inicial nulo), se optó por utilizar un puente linealizado, que con un solo transductor (sensor de flexibilidad) nos permitía obtener la salida deseada. Lo primero fue utilizar softwares de simulación como MicroCap que corroboraban el buen funcionamiento del circuito:
Figura 8.16: Esquemático del puente lineailzado en MicroCap.
25
Figura 8.17: Simulación en MicroCap con distintos valores de resistencia.
En la figura 9.15 se puede observar como con un mismo incremento de la resistencia (en este caso, 5kΩ por línea), corresponde a un mismo incremento en tensión (de unos 0.5V aproximadamente), obteniendo así una medida lineal.
El siguiente paso fue testear el circuito en una placa de prototipado, obteniendo un resultado similar (salvo una pequeña saturación, pero manteniendo un gran amplio rango de valores intermedios). Posteriormente se diseñó la placa de circuito impreso (PCB) que habría que implementar, obteniendo el siguiente fotolito a utilizar en su fabricación:
Figura 8.18: Fotolito del puente linealizado.
Tras fabricar el circuito, se procedió a probar el circuito real, obteniendo un módulo definitivo que se conectó al Arduino y se probó la lectura del sensor, obteniendo resultados positivos tal y como se esperaban.
Figura 8.19: PCB del sensor de flexibilidad.
26
8.3.4 Modo aprende
Como se ha mencionado, el modo aprende fue desarrollado desde el comienzo de la parte software, ya que la consigna principal para implementar esta función fue que, cuando una señal se activase (proveniente de un botón externo), se almacenaran en una matriz los valores de los ángulos (posiciones), de cada servo, tomando 5 posiciones por segundo (se comprobó que eran suficientes para alcanzar una gran precisión sin sobrecargar la memoria). Conforme el código principal del programa fue avanzando, este también lo hizo.
8.3.5 Circuito impreso del box de precisión
Durante la finalización del código se diseñó y fabricó el circuito para el control de precisión (que se comentará más adelante y cuyo plano de tierra se utilizó para unificar todas las masas de los distintos elementos electrónicos).
Figura 8.20: Fotolito del box de precisión. Figura 8.21: Placa de circuito impreso del box de precisión.
8.3.6 Código principal
Una vez que se dio por finalizado la lectura de los sensores y el movimiento de los servos, se comenzó la integración, cosa que no aportó ningún problema debido a nuestra política en la que todos estos avances se enfocaron a la progresiva integración de los elementos.
El código principal consta de un fragmento denominado configuración inicial y bucle. En el primero se establecen las condiciones iniciales y en el segundo se encuentra el programa en sí. Se basó en un sistema de sucesos donde se estudiaba al estado de las entradas (botones, interruptores y sensores) y se establecía el estado de las salidas (actuadores y LEDs). En cada vuelta siempre se sigue un patrón de las acciones:
1. Lectura de posiciones. 2. Ajuste del cambio de herramienta (si procede). 3. Activar o desactivar el estado de la herramienta (pinza cerrada/abierta o
motor encendido/apagado). 4. Estudiar estado del modo aprende:
a. Reposo: No se realiza ninguna acción. Si se pulsa el botón se pasa al siguiente estado (para la siguiente vuelta).
b. Transición: Estado de espera. Cuando se suelta el botón se pasa al siguiente (para detectar un pulso del botón).
c. Aprendiendo: Se almacenan en la matriz las lecturas obtenidas (mediante el uso de temporizadores se almacenan solo 5 veces
27
por segundo). Se permanece en este estado hasta que se vuelve a pulsar el botón o se completa la matriz (se han establecido unas 100 posiciones, lo que equivale a 20 segundos como máximo, totalmente ampliable ya que no se ocupa el 10% si quiera de la memoria total).
d. Transición 2: Igual al segundo estado (para detectar pulso e irnos a reposo).
5. Estudiar estado del modo reproduce: a. Reposo: Idéntico al modo aprende. b. Transición: Idéntico al modo aprende. c. Reproduciendo: A este este estado solo se puede acceder si no se
está aprendiendo. Si estamos dentro, se cambian las posiciones leídas por las almacenadas anteriormente (de manera que no se atiende a los sensores). Una vez llegada a la última posición se vuelve a la primera y se reproduce de manera indefinida, hasta volver a pulsar el botón de reproducir.
d. Transición 2: Idéntico al modo aprende. Se ejecuta la función home para volver a la posición inicial (y por lo tanto, se activa pausa).
6. Movimiento de servos (si la pausa no está activada).
Figura 8.22: Máquina de estado del modo aprende. Figura 8.23: Máquina de estado del modo reproduce
Para mayor comprensión del programa, leer el código debidamente comentado en la sección Planos y códigos.
28
8.4 Subsistema de mando
Este bloque también sufrió una evolución durante el transcurso del trabajo. Como ya se comentó, la primera idea fue un robot de 3 grados de libertad, controlados por el guante, pero tras ver el estado del proyecto y el tiempo restante, se estudió la posibilidad de añadir otros 3 grados de libertad que nos permitían orientar el efector final, añadiendo un extra denominado control de precisión. De esta idea nació el concepto de box de precisión, componente que además de aportar los elementos de mando necesarios (ON/OFF, botón modo aprende, modo reproduce y cambio de herramienta) nos añade un potenciómetro con el que podemos ajustar la inclinación del efector final. Por ende, las tareas de este bloque se repartieron en dos subbloques, el guante y el box.
8.4.1 Guante de control
Respecto al guante, los responsables de este bloque se encargaron de buscar el guante idóneo para la tarea (sin olvidar que era necesario seguir cumpliendo el aspecto económico del proyecto). Posteriormente, se estudió el sistema y el modo de acoplamiento de los sensores y el botón al guante, teniendo en cuenta que el sensor de flexibilidad debería tener juego para poder desplazarse algo al doblarse y que el acelerómetro debía colocarse en una superficie lo más recta posible. Para ello, se optó por utilizar un fragmento de DM diseñado para atornillar el acelerómetro en él y utilizar pegamento de contacto entre la madera y el guante, formando una conexión sólida. En cuanto al sensor de flexibilidad, debido a la fragilidad de este y a no disponer de recambios (precio unitario elevado), se utilizó cinta aislante, permitiendo la holgura necesaria y manteniendo sensor y cables unidos al guante, con la opción de modificar la unión si fuera necesario. Para el botón de la herramienta se utilizó pegamento de contacto, sin presentar ningún tipo de inconveniente.
Figura 8.24: Diseño definitivo del guante.
29
8.4.2 Box de precisión
En cuanto al box de precisión, una vez se aceptó la propuesta, se creó un sencillo diseño de caja (Véase la sección Planos y códigos) a la vez que el circuito, aprovechando una sesión de FabLab para fabricarla. Al diseño se le añadió un LED que nos indica si todo el sistema está alimentado o no, cercano al interruptor de ON/OFF (interruptor de cuatro circuitos, que apaga o enciende todos los subsistemas).
Figura 8.25: Box de precisión, vista superior. Figura 8.26: Box de precisión, vista lateral.
8.5 Subsistema de marketing
Tal y como se comentó al principio, este subsistema nació tras haber finalizado los requisitos obligatorios y los opcionales que se añadieron. Se pensó en enfocar el proyecto a la venta del producto, por lo que se dividió el trabajo para realizar una serie de videos comerciales, una página web, un flyer publicitario y una guía de usuario.
8.5.1 Vídeos comerciales
Se plantearon dos tipos de vídeo comercial. Un primer vídeo (ver anexo 8), de duración 3:20 minutos, donde pueden observarse las principales características del producto, además de un enfoque llamativo y semicómico para captar la atención del posible comprador, finalizando con un tono de suspense que invita al receptor a buscar más información en la página web. El segundo vídeo (ver anexo 9) está enfocado a aparecer en distintas plataformas webs multimedia, por lo que su duración es menor (0:27 minutos) y aparecen distintos fragmentos del uso del producto, sin indagar ni explicar nada, con una melodía pegadiza que capta la atención del receptor e incita a pulsar el anuncio para obtener más información de lo que está viendo.
30
8.5.2 Flyer publicitario
Al mismo tiempo, se comenzó con el diseño del flyer, que mostraría el, desde ese momento, eslogan del producto: “Enfunda, enseña, disfruta”, haciendo referencia a la sencillez de utilización del producto.
Figura 8.25: Flyer publicitario, vista delantera.
Figura 8.28: Flyer publicitario, vista trasera.
8.5.3 Página Web
Con el fin de dar a conocer GlovArm y expandir la capacidad del negocio se inició el proyecto de una página web dedicada a la presentación del producto y la empresa al público on-line y a la preventa del propio producto. Se comenzó con la reserva de un dominio en Wordpress: https://rbtglovarm.wordpress.com
Escogido como mejor opción debido a su entorno gráfico, sencillo de manejar e intuitivo y a su uso del software libre como modelo de desarrollo, por el que se ha apostado durante el transcurso del proyecto.
La página fue diseñada de manera que constara de una página principal que enlace con el resto de entradas, proporcionando un acceso directo y sencillo al usuario.
31
Figura 9.29: Portada de la página web.
Entradas:
Robotito, la solución está en tu mano. Otorga una descripción del producto, así como sus características funcionales (grados de libertad, radio efectivo, herramientas y modos de funcionamiento).
¿Cómo funciona? Se explica brevemente, como si de un manual de uso se tratase, el funcionamiento del producto.
¿Qué es GlovArm y quiénes somos? Permite al lector conocer la empresa, quiénes la forman y qué función desempeña cada integrante, buscando cercanía con el posible cliente.
Preventa. Se habilita un cuestionario para apuntarse a la compra anticipada del producto, en la cual aparece una atractiva oferta en la que se añade una camiseta totalmente gratuita de la compañía.
Multimedia. Se encuentran disponible la visualización del folleto promocional de la empresa y el video comercial 2018, así como su descarga para los interesados.
Figura 9.30: Modelos de camiseta publicitaria, Jungle Green (izquierda) y BlueBerry (centro y derecha).
Se invita al lector a visitar la página web para conocerla con más profundidad.
8.5.4 Manual de usuario
Por último, se aporta un manual de usuario que, a pesar de que el producto es sencillo e intuitivo, ayuda a comprender perfectamente los movimientos que hay que realizar para que el robot se mueva, además del correcto uso del box de precisión. También se añadieron recomendaciones del fabricante y una serie de indicaciones para no hacer un uso indebido del producto. (Ver anexo 1 y 2).
32
9. CAMPOS DE APLICACIÓN
Desde un inicio, se comentó que GlovArm ofrecería una solución a actividades industriales repetitivas o peligrosas, además de una actividad lúdica para personas de cualquier edad. Una vez finalizado el proyecto, se hizo un análisis más detallado de estos campos:
9.1 Campo industrial
Hay que recordar que el proyecto no es más que un prototipo, modificable en un futuro dependiendo de la aplicación a la que se vaya a enfocar, pudiendo utilizar actuadores más potentes y material más resistente. Si nos adentramos a un campo industrial, podría utilizarse, gracias a su modo aprende, para realizar acciones repetitivas y sencillas (no olvidemos que se trata de un robot industrial, por lo que no se enfoca a actividades como soldadura por arco) tales como el desplazamiento de elementos no muy pesados y el taladrado de estos (ya que el prototipo incluye esta herramienta secundaria, que podría ser modificable como se comentará posteriormente). Además, no requiere que el operario tenga un conocimiento de algún lenguaje de programación, ya que simplemente debe hacer uso del guante de control y enseñarle el proceso que debe repetir al robot.
9.2 Campo lúdico
Bien sabido es que cualquier producto relacionado con la robótica es muy llamativo para el ciudadano medio, sobre todo para los más pequeños y ni hablar de ello si además imita los movimientos de tu mano si utilizas un guante, sin apenas necesitar leer el manual de instrucciones.
Por ello, es especialmente atractivo para el mundo del ocio, ya que, al no tener demasiada potencia, ni un peso elevado, no resulta peligroso para los niños de más de 10 años.
9.3 Campo educativo
Además de lo mencionado anteriormente, presentaría la oportunidad de tener un primer contacto con el mundo de la robótica y la tecnología, por lo que adquirir este producto también sería atractivo para academias que basan su contenido en el STEM (ciencia, tecnología, ingeniería y matemáticas) y donde es frecuente este tipo de actividades.
9.4 Campo doméstico
Por último, sería posible utilizar el producto para automatizar tareas domésticas como pueden ser remover un caldo constantemente o cortar patatas (cambiando la herramienta secundaria por una herramienta de corte y utilizando una plataforma específica donde se coloca siempre la patata en la misma posición) o realizar tareas en las que existe algún riesgo como puede ser introducir y sacar, por ejemplo, unos
33
pequeños muffins del horno. La ventaja de utilizar nuestro producto es que puede ser reprogramable y cambiar su función en un futuro.
10. PLANOS Y PROGRAMAS
10.1 Planos de la estructura completa
Figura 10.1 Planos definitivos de la estructura
10.2 Planos del box de control
Figura 10.2: Planos del box de control
34
10.3 Esquemas eléctricos
10.3.1 Acondicionamiento sensor de flexibilidad
Figura 10.3: Esquemático en Eagle del circuito de acondicionamiento del sensor de flexibilidad.
10.3.2 Box de precisión
Figura 10.4: Esquemático en Eagle del box de precisión.
35
10.4 Esquema de conexionado (Arduino)
Figura 10.5: Esquema de conexiones del Arduino
10.5 Programa de calibración del MPU-6050
Debido a la longitud del código, se aporta junto a esta memoria. Aun así recalcar que este código no es propiedad del grupo y se encuentra gratuitamente en la comunidad de Arduino. (Ver anexo 3).
10.6 Programa principal
10.6.1 Variables y constantes
#include "I2Cdev.h"
#include "MPU6050_6Axis_MotionApps20.h"
#include "Wire.h"
#define INTERRUPT_PIN 2 // usa el pin 2 para interrupción
Servo s1; //Articulacion 1 (base)
Servo s2; //Articulacion 2 (hombro)
Servo s3; //Articulacion 3 (codo)
Servo s4; //Articulacion 4 (muñeca pinza)
Servo s5; //Articulacion 5 (cabeceo pinza)
Servo s6; //Articulacion 6 (cierre pinza)
Servo s7; //Articulacion 7 (cambio herramienta)
Servo s8; //Articulacion 8 (cabeceo motor)
const int sensorGalga = A0; // Sensor de flexibilidad (entrada)
const int BOTON_PINZA = 11; // Botón de la herramienta (entrada)
36
const int MOTOR = 12; // Motor (salida)
const int BOTON_CAMBIO = A1; // Botón cambio de herramienta
(entrada)
const int BOTON_APRENDE = 32; // Botón aprende (entrada)
const int BOTON_REPRODUCE = 34; // Botón reproduce
const int ledPin = 48;
int q1,q2,q3,q4,q5,q6,q7,q8; // Variables de posición (ángulo) de
cada sservo
int i,j; // Variables auxiliares
para recorrer matrices
int aprendiendo=0; // Flag aprendiendo
int reproduciendo=0; // Flag reproduciendo
int Q[9][100]; // Matriz de posiciones
almacenadas (modo aprende/reproduce)
int t=0; // Contador para el timer
int estado_aprende=0; // Estado del modo aprende
int estado_reproduce=0; // Estado del modo reproduce
int index; // Número de posiciones guardadas
int pausa; // Flag de pausa
const int mpuAddress = 0x68; // Puede ser 0x68 o 0x69 (acelerómetro)
//Variables acelerometro
MPU6050 mpu(mpuAddress); // Establecemos direción del MPU
bool dmpReady = false;
uint8_t mpuIntStatus;
uint8_t devStatus;
uint16_t packetSize;
uint16_t fifoCount;
uint8_t fifoBuffer[64];
Quaternion q; // [w, x, y, z] quaternion
VectorFloat gravity; // [x, y, z] gravity vector
float ypr[3]; // [yaw, pitch, roll] yaw/pitch/roll container and
gravity vector
volatile bool mpuInterrupt = false;
void dmpDataReady()
mpuInterrupt = true;
10.6.2 Condiciones iniciales
void setup()
Timer1.initialize(100000); // Interrupcion timer cada 100ms
Timer1.attachInterrupt(contador);// Interrupcion asociada -> Contador
pinMode(ledPin,OUTPUT); // Configuracion de salidas
pinMode(MOTOR, OUTPUT);
pinMode(BOTON_PINZA, INPUT); // Configuracion de entradas
pinMode(BOTON_CAMBIO,INPUT);
pinMode(BOTON_APRENDE, INPUT);
s1.attach(3); // Asociar srvos al pin
s2.attach(4);
s3.attach(5);
s4.attach(6);
s5.attach(7);
s6.attach(8);
s7.attach(9);
s8.attach(10);
//Iinicializacion del MPU//
Wire.begin();
TWBR = 24;
Serial.begin(115200);
mpu.initialize();
37
Serial.println(mpu.testConnection() ? F("IMU iniciado correctamente") :
F("Error al iniciar IMU"));
devStatus = mpu.dmpInitialize();
// Valores de calibración
mpu.setXGyroOffset(105);
mpu.setYGyroOffset(56);
mpu.setZGyroOffset(66);
mpu.setZAccelOffset(1197);
if (devStatus == 0)
mpu.setDMPEnabled(true);
attachInterrupt(digitalPinToInterrupt(INTERRUPT_PIN), dmpDataReady,
RISING);
mpuIntStatus = mpu.getIntStatus();
dmpReady = true;
packetSize = mpu.dmpGetFIFOPacketSize();
go_home(); //Home inicial.
10.6.3 Función Home
/***************************************************************/
/* FUNCIÓN HOME */
/* */
/* LLEVA CADA SERVO A SU POSICION INICIAL */
/* */
/***************************************************************/
void go_home ()
mover_servo(90,s1);
mover_servo(85,s2);
mover_servo(70,s3);
mover_servo(90,s4);
mover_servo(40,s5);
mover_servo(5,s6);
mover_servo(5,s7);
mover_servo(125,s8);
pausa=1;
10.6.4 Función Mover_servo
/***************************************************************/
/* FUNCIÓN MOVER SERVO */
/* */
/* ARGUMENTOS DE ENTRADA: */
/* -ÁNGULO DESEADO */
/* -OBJETO DEL SERVO QUE QUERREMOS MOVER */
/***************************************************************/
int mover_servo(int angulo,Servo n)
//Saturacion
if (angulo>175)
angulo=175;
else if(angulo<5)
angulo=5;
n.write(angulo); // servo se mueve al ángulo
38
10.6.5 Interrupción del timer
/***************************************************************/
/* INTERRUPCIÓN DEL TIMER */
/* */
/* SE EJECUTA CADA 100 ms, AUMENTA LA VARIABLE t PARA ALMACENAR*/
/* O REPRODUCIR CADA 200 ms. */
/* */
/***************************************************************/
void contador ()
t++;
if (t>2)
t=0;
if(estado_aprende==2 || estado_reproduce==2)i++;
10.6.6 Lectura del acelerómetro
//*********LECTURA ACELEROMETRO************///
if (!dmpReady) return;
// Esperar a la interrupción, o mientras queden datos por leer
while (!mpuInterrupt && fifoCount < packetSize);
mpuInterrupt = false;
mpuIntStatus = mpu.getIntStatus();
fifoCount = mpu.getFIFOCount();
// Comprobar overflow
if ((mpuIntStatus & 0x10) || fifoCount == 1024)
mpu.resetFIFO();// Reset FIFO
else if (mpuIntStatus & 0x02)
// Esperar datos
while (fifoCount < packetSize) fifoCount = mpu.getFIFOCount();
// Leer paquete de FIFO
mpu.getFIFOBytes(fifoBuffer, packetSize);
fifoCount -= packetSize;
// Mostrar angulos euler
mpu.dmpGetQuaternion(&q, fifoBuffer);
mpu.dmpGetGravity(&gravity, &q);
mpu.dmpGetYawPitchRoll(ypr, &q, &gravity); //ypr[] almacena
los angulos que utilizaremos
10.6.7 Lectura del sensor de flexibilidad y posiciones
//***********LECTURA POSICIONES**************//
q1=180-(ypr[0] * 180 / M_PI+90); // base (MPU)
q2=ypr[1]*180/M_PI+90; // hombro (MPU)
if (q2>85) q2=85; //saturaciones
else if(q2<15) q2=15;
39
q3 = 0.16*analogRead(sensorGalga); // codo (sensor flex)
if (q3>77) q3=77; //saturaciones
else if(q3<28) q3=28;
if(digitalRead(BOTON_CAMBIO)==LOW) q4=ypr[2]*180/M_PI+90; //si está fuera
la pinza: muñeca pinza (MPU)
10.6.8 Cambio de herramienta
//***********CAMBIO DE HERRAMIENTA*******//
if(digitalRead(BOTON_CAMBIO)==HIGH) // Si herramienta
secundaria (motor)
q7=64; //
Colocamos el cambio de herramienta
q5=128;
q8=0.1758*analogRead(A2); // Control de prec.
(pot) para el motor
if(q8>129) q8=129; // Saturación
if(q8<18) q8=18;
else
// Si pinza
q7=5; //
Colocamos el cambio de herramienta
q8=133;
q5=0.1758*analogRead(A2); // Control de prec.
(pot) para la pinza
if(q5>83) q5=83; //Saturación
if(q5<0) q5=0;
10.6.9 Uso de herramienta //**********USO DE HERRAMIENTA********************//
if (digitalRead(BOTON_CAMBIO)==LOW)
// Si pinza
if (digitalRead(BOTON_PINZA) == HIGH) q6=38;
// Si se pulsa el botón se cierra
else q6=0;
// Si no, se abre
else
// Si motor
if (digitalRead(BOTON_PINZA) == HIGH) digitalWrite(MOTOR, HIGH);
// Encender motor
else digitalWrite(MOTOR, LOW);
// Apagar motor
10.6.10 Máquina de estado Modo Aprende
//*****************MODO APRENDE***************************//
switch (estado_aprende)
case 0: //reposo (led apagado)
if (digitalRead(BOTON_APRENDE)==HIGH && estado_reproduce==0 && pausa==0)
estado_aprende=1; //si pulsamos el boton (y no estamos reproduciendo)
pasamos a aprender
digitalWrite(ledPin,LOW); //led apagado
break;
40
case 1: // Transicion
index=0; // Reseteamos número de posiciones guardadas
i=0; // Reseteamos variable que recorre matriz
if (digitalRead(BOTON_APRENDE)==LOW) estado_aprende=2; //cambio de
estado
break;
case 2: //estado aprendiendo (led encendido)
digitalWrite(ledPin,HIGH); // encendemos led
if (t==2) // Cada 20ms almacenamos una posición
(i se incrementa en el timer)
Q[0][i]=q1;
Q[1][i]=q2;
Q[2][i]=q3;
Q[3][i]=q4;
Q[4][i]=q5;
Q[5][i]=q6;
Q[6][i]=q7;
Q[7][i]=q8;
if (digitalRead(BOTON_PINZA) == HIGH && digitalRead(BOTON_CAMBIO) ==
HIGH) Q[8][i]=1; // Si motor, almacenar estado del motor (1
encendido, 0 apagado)
else Q[8][i]=0;
if(i==100) // si hemos alcanzado el limite de posiciones
estado_aprende=0; // deja de aprender
index=100; // tenemos 100 posiciones
i=0;
if (digitalRead(BOTON_APRENDE)==HIGH) //dejar de aprender al
pulsar
index=i; // guardamos numero de posiciones
i=0;
estado_aprende=3; // nos vamos a reposo
break;
case 3: //transicion
if (digitalRead(BOTON_APRENDE)==LOW) estado_aprende=0;
break;
default:
estado_aprende=0;
break;
10.6.11 Máquina de estado Modo Reproduce
//***********MODO REPRODUCE********************************//
switch (estado_reproduce)
case 0: //reposo
if (digitalRead(BOTON_REPRODUCE)==HIGH && estado_aprende==0)
estado_reproduce=1; //si no estamos aprendiendo
break;
case 1: //transicion
if (digitalRead(BOTON_REPRODUCE)==LOW) estado_reproduce=2;
i=0;
break;
case 2: //estado reproduceiendo
41
if(i==index) i=0; // si llegamos al final, volvemos a empezar (i
varia en la interrupción)
q1=Q[0][i];
q2=Q[1][i];
q3=Q[2][i];
q4=Q[3][i];
q5=Q[4][i];
q6=Q[5][i];
q7=Q[6][i];
q8=Q[7][i];
if(Q[8][i]==1)digitalWrite(MOTOR,HIGH); // Estado del motor
else digitalWrite (MOTOR, LOW);
if (digitalRead(BOTON_REPRODUCE)==HIGH) estado_reproduce=3; // Si
pulsamos botón cambiamos de estado
break;
case 3: //transicion
if (digitalRead(BOTON_REPRODUCE)==LOW)
estado_reproduce=0;
go_home(); //nos vamos a home
break;
default: //Estado por defecto
estado_reproduce=0;
break;
10.6.12 Actualización de posiciones de los servos
//************ACTUALIZACION DE POSICIONES******************//
if (digitalRead(BOTON_PINZA)==HIGH) pausa=0; //Quitamos pausa al
pulsar pinza
if(pausa==LOW) //si venimos de un home, no
movemos
mover_servo(q1,s1); //movemos base
mover_servo(q2,s2); //movemos hombro
mover_servo(q3,s3); //movemos codo
mover_servo(q4,s4); //giro de muñeca
mover_servo(q5,s5); //cabeceo muñeca
mover_servo(q6,s6); //pinza
mover_servo(q7,s7); //cambio de herramienta
mover_servo(q8,s8); //cabezeo motor
10.6.13 Programa completo
#include <Servo.h>
#include <TimerOne.h>
//librerias acelerometro
#include "I2Cdev.h"
#include "MPU6050_6Axis_MotionApps20.h"
#include "Wire.h"
#define INTERRUPT_PIN 2 // usa el pin 2 para interrupción
Servo s1; //Articulacion 1 (base)
Servo s2; //Articulacion 2 (hombro)
Servo s3; //Articulacion 3 (codo)
Servo s4; //Articulacion 4 (muñeca pinza)
Servo s5; //Articulacion 5 (cabeceo pinza)
Servo s6; //Articulacion 6 (cierre pinza)
Servo s7; //Articulacion 7 (cambio herramienta)
Servo s8; //Articulacion 8 (cabeceo motor)
42
const int sensorGalga = A0; // Sensor de flexibilidad (entrada)
const int BOTON_PINZA = 11; // Botón de la herramienta (entrada)
const int MOTOR = 12; // Motor (salida)
const int BOTON_CAMBIO = A1; // Botón cambio de herramienta
(entrada)
const int BOTON_APRENDE = 32; // Botón aprende (entrada)
const int BOTON_REPRODUCE = 34; // Botón reproduce
const int ledPin = 48;
int q1,q2,q3,q4,q5,q6,q7,q8; // Variables de posición (ángulo) de
cada sservo
int i,j; // Variables auxiliares
para recorrer matrices
int aprendiendo=0; // Flag aprendiendo
int reproduciendo=0; // Flag reproduciendo
int Q[9][100]; // Matriz de posiciones almacenadas (modo aprende/reproduce)
int t=0; // Contador para el timer
int estado_aprende=0; // Estado del modo aprende
int estado_reproduce=0; // Estado del modo reproduce
int index; // Número de posiciones guardadas
int pausa; // Flag de pausa
const int mpuAddress = 0x68; // Puede ser 0x68 o 0x69 (acelerómetro)
//Variables acelerometro
MPU6050 mpu(mpuAddress); // Establecemos direción del MPU
bool dmpReady = false;
uint8_t mpuIntStatus;
uint8_t devStatus;
uint16_t packetSize;
uint16_t fifoCount;
uint8_t fifoBuffer[64];
Quaternion q; // [w, x, y, z] quaternion
VectorFloat gravity; // [x, y, z] gravity vector
float ypr[3]; // [yaw, pitch, roll] yaw/pitch/roll container and
gravity vector
volatile bool mpuInterrupt = false;
void dmpDataReady()
mpuInterrupt = true;
/***************************************************************/
/* FUNCIÓN MOVER SERVO */
/* */
/* ARGUMENTOS DE ENTRADA: */
/* -ÁNGULO DESEADO */
/* -OBJETO DEL SERVO QUE QUERREMOS MOVER */
/***************************************************************/
int mover_servo(int angulo,Servo n)
//Saturacion
if (angulo>175)
angulo=175;
else if(angulo<5)
angulo=5;
n.write(angulo); // servo se mueve al ángulo
/***************************************************************/
/* INTERRUPCIÓN DEL TIMER */
/* */
/* SE EJECUTA CADA 100 ms, AUMENTA LA VARIABLE t PARA ALMACENAR*/
/* O REPRODUCIR CADA 200 ms. */
/* */
/***************************************************************/
void contador ()
43
t++;
if (t>2)
t=0;
if(estado_aprende==2 || estado_reproduce==2)i++;
/***************************************************************/
/* FUNCIÓN HOME */
/* */
/* LLEVA CADA SERVO A SU POSICION INICIAL */
/* */
/***************************************************************/
void go_home ()
mover_servo(90,s1);
mover_servo(85,s2);
mover_servo(70,s3);
mover_servo(90,s4);
mover_servo(40,s5);
mover_servo(5,s6);
mover_servo(5,s7);
mover_servo(125,s8);
pausa=1;
void setup()
Timer1.initialize(100000); // Interrupcion timer cada 100ms
Timer1.attachInterrupt(contador); // Interrupcion asociada -> Contador
pinMode(ledPin,OUTPUT); // Configuracion de salidas
pinMode(MOTOR, OUTPUT);
pinMode(BOTON_PINZA, INPUT); // Configuracion de entradas
pinMode(BOTON_CAMBIO,INPUT);
pinMode(BOTON_APRENDE, INPUT);
s1.attach(3); // Asociar servos al pin
s2.attach(4);
s3.attach(5);
s4.attach(6);
s5.attach(7);
s6.attach(8);
s7.attach(9);
s8.attach(10);
//Iinicializacion del MPU//
Wire.begin();
TWBR = 24;
Serial.begin(115200);
mpu.initialize();
Serial.println(mpu.testConnection() ? F("IMU iniciado correctamente") :
F("Error al iniciar IMU"));
devStatus = mpu.dmpInitialize();
// Valores de calibración
mpu.setXGyroOffset(105);
mpu.setYGyroOffset(56);
mpu.setZGyroOffset(66);
mpu.setZAccelOffset(1197);
if (devStatus == 0)
mpu.setDMPEnabled(true);
44
attachInterrupt(digitalPinToInterrupt(INTERRUPT_PIN), dmpDataReady,
RISING);
mpuIntStatus = mpu.getIntStatus();
dmpReady = true;
packetSize = mpu.dmpGetFIFOPacketSize();
go_home(); //Home inicial.
void loop()
//*********LECTURA ACELEROMETRO************///
if (!dmpReady) return;
// Esperar a la interrupción, o mientras queden datos por leer
while (!mpuInterrupt && fifoCount < packetSize);
mpuInterrupt = false;
mpuIntStatus = mpu.getIntStatus();
fifoCount = mpu.getFIFOCount();
// Comprobar overflow
if ((mpuIntStatus & 0x10) || fifoCount == 1024)
mpu.resetFIFO();// Reset FIFO
else if (mpuIntStatus & 0x02)
// Esperar datos
while (fifoCount < packetSize) fifoCount = mpu.getFIFOCount();
// Leer paquete de FIFO
mpu.getFIFOBytes(fifoBuffer, packetSize);
fifoCount -= packetSize;
// Mostrar angulos euler
mpu.dmpGetQuaternion(&q, fifoBuffer);
mpu.dmpGetGravity(&gravity, &q);
mpu.dmpGetYawPitchRoll(ypr, &q, &gravity); //ypr[] almacena los
angulos que utilizaremos
//***********LECTURA POSICIONES**************//
q1=180-(ypr[0] * 180 / M_PI+90); // base (MPU)
q2=ypr[1]*180/M_PI+90; // hombro (MPU)
if (q2>85) q2=85; //saturaciones
else if(q2<15) q2=15;
q3 = 0.16*analogRead(sensorGalga); // codo (sensor flex)
if (q3>77) q3=77; //saturaciones
else if(q3<28) q3=28;
if(digitalRead(BOTON_CAMBIO)==LOW) q4=ypr[2]*180/M_PI+90; //si está fuera
la pinza, muñeca pinza (MPU)
//***********CAMBIO DE HERRAMIENTA*******//
if(digitalRead(BOTON_CAMBIO)==HIGH) // Si herramienta
secundaria (motor)
45
q7=64; // Colocamos el cambio de herramienta
q5=128;
q8=0.1758*analogRead(A2); // Control de prec. (pot) para el motor
if(q8>129) q8=129; // Saturación
if(q8<18) q8=18;
else
// Si pinza
q7=5; // Colocamos el cambio de herramienta
q8=133;
q5=0.1758*analogRead(A2); // Control de prec. (pot) para la pinza
if(q5>83) q5=83; //Saturación
if(q5<0) q5=0;
//**********USO DE HERRAMIENTA********************//
if (digitalRead(BOTON_CAMBIO)==LOW)
// Si pinza
if (digitalRead(BOTON_PINZA) == HIGH) q6=38;
// Si se pulsa el botón se cierra
else q6=0;
// Si no, se abre
else
// Si motor
if (digitalRead(BOTON_PINZA) == HIGH) digitalWrite(MOTOR, HIGH);
// Encender motor
else digitalWrite(MOTOR, LOW);
// Apagar motor
//*****************MODO APRENDE***************************//
switch (estado_aprende)
case 0: //reposo (led apagado)
if (digitalRead(BOTON_APRENDE)==HIGH && estado_reproduce==0 && pausa==0)
estado_aprende=1; //si pulsamos el boton (y no estamos reproduciendo)
pasamos a aprender
digitalWrite(ledPin,LOW);
//led apagado
break;
case 1: // Transicion
index=0; // Reseteamos número de posiciones guardadas
i=0; // Reseteamos variable que recorre matriz
if (digitalRead(BOTON_APRENDE)==LOW) estado_aprende=2; //cambio de
estado
break;
case 2: //estado aprendiendo (led encendido)
digitalWrite(ledPin,HIGH); // encendemos led
if (t==2)// Cada 20ms almacenamos una posición (i se incrementa en el timer)
Q[0][i]=q1;
Q[1][i]=q2;
Q[2][i]=q3;
Q[3][i]=q4;
Q[4][i]=q5;
Q[5][i]=q6;
Q[6][i]=q7;
Q[7][i]=q8;
46
if (digitalRead(BOTON_PINZA) == HIGH && digitalRead(BOTON_CAMBIO) ==
HIGH) Q[8][i]=1; // Si motor, almacenar estado del motor (1
encendido, 0 apagado)
else Q[8][i]=0;
if(i==100) // si hemos alcanzado el limite de posiciones
estado_aprende=0; // deja de aprender
index=100; // tenemos 100 posiciones
i=0;
if (digitalRead(BOTON_APRENDE)==HIGH) //dejar de aprender al pulsar
index=i; // guardamos numero de posiciones
i=0;
estado_aprende=3; // nos vamos a reposo
break;
case 3: //transicion
if (digitalRead(BOTON_APRENDE)==LOW) estado_aprende=0;
break;
default:
estado_aprende=0;
break;
//***********MODO REPRODUCE********************************//
switch (estado_reproduce)
case 0: //reposo
if (digitalRead(BOTON_REPRODUCE)==HIGH && estado_aprende==0)
estado_reproduce=1; //si no estamos aprendiendo
break;
case 1: //transicion
if (digitalRead(BOTON_REPRODUCE)==LOW) estado_reproduce=2;
i=0;
break;
case 2: //estado reproduceiendo
if(i==index) i=0; // si llegamos al final, volvemos a empezar (i
varia en la interrupción)
q1=Q[0][i];
q2=Q[1][i];
q3=Q[2][i];
q4=Q[3][i];
q5=Q[4][i];
q6=Q[5][i];
q7=Q[6][i];
q8=Q[7][i];
if(Q[8][i]==1)digitalWrite(MOTOR,HIGH); // Estado del motor
else digitalWrite (MOTOR, LOW);
if (digitalRead(BOTON_REPRODUCE)==HIGH) estado_reproduce=3; // Si
pulsamos botón cambiamos de estado
break;
case 3: //transicion
if (digitalRead(BOTON_REPRODUCE)==LOW)
estado_reproduce=0;
go_home(); //nos vamos a home
break;
default: //Estado por defecto
estado_reproduce=0;
break;
47
//************ACTUALIZACION DE POSICIONES******************//if
(digitalRead(BOTON_PINZA)==HIGH) pausa=0; //Quitamos pausa al pulsar pinza
if(pausa==LOW) //si venimos de un home, no movemos
mover_servo(q1,s1); //movemos base
mover_servo(q2,s2); //movemos hombro
mover_servo(q3,s3); //movemos codo
mover_servo(q4,s4); //giro de muñeca
mover_servo(q5,s5); //cabeceo muñeca
mover_servo(q6,s6); //pinza
mover_servo(q7,s7); //cambio de herramienta
mover_servo(q8,s8); //cabezeo motor
11. PRESUPUESTO
La realización de este proyecto parte de la limitación de los 70 euros. A continuación, se muestra una lista detallada de los materiales usados con su coste, incluyendo aquellos que se tenían a priori o han sido patrocinados.
Materiales necesarios:
• Sensor IMU MPU-6050 ----------------------------- 1.55€
• Sensor flexibilidad Sparkfun ----------------------- 9.21€
• Pilas y baterías ---------------------------------------- 3.48€ (2x9V) + 1.5€(4x1.5V)
• Servomotor MG995 Microservo ------------------ 6x3.18€
• Servomotor MG90S Microservo ------------------ 2x2.53€
• Mini motor DC ----------------------------------------- 2.96€
• DM 3 mm ------------------------------------------------ 5.19€
• Tornillería ------------------------------------------------ 8.40€
• Resistencias --------------------------------------------- 0.09€
• Pines ------------------------------------------------------ 0.84€
• Conectores pilas --------------------------------------- 3.02€
• Guante de tela ------------------------------------------ 1.2€ TOTAL ----------------------------------------------------- 61.58€
• Uso del FabLab (Patrocinador)
• Cableado y botones (Prestado)
• Arduino MEGA (Prestado)
• Placa de cobre
12. POSIBLES MEJORAS
Debido a que el tiempo de realización del proyecto estaba limitado, tuvimos que limitar el alcance del proyecto, sin embargo se han pensado una serie de mejoras para el futuro o para cualquier interesado que desee realizarlas:
48
1. Utilizar herramientas adicionales extra como por ejemplo, una herramienta de corte.
2. Rediseñar la estructura con un material más resistente y actuadores más potentes.
3. Añadir varias trayectorias almacenadas que se puedan seleccionar mediante un display.
13. DEMOSTRACIÓN
Para ver una breve demostración de todas las acciones comendadas en este documento, puede reproducirse el vídeo correspondiente al anexo 4.
Una vez visualizado el vídeo anterior, puede detallarse un movimiento más amplio del robot con el guante en el anexo 5, un ejemplo del modo reproduce en una cadena de movimientos en el anexo 6 y un uso del control de precisión detalladamente en el anexo 7.
14. BIBLIOGRAFÍA
Planos originales:
https://www.thingiverse.com/thing:2433
Tutorial MPU
https://naylampmechatronics.com/blog/45_Tutorial-MPU6050-Aceler%C3%B3metro-y-Giroscopio.html
Web realizada con:
https://wordpress.com
Guía de diseño Eagle:
https://hetpro-store.com/images/Tutoriales/pcb_eagle/hetpro_tutorial_pcb_eagle.pdf
Manual de usario de MicroCap:
http://www.spectrum-soft.com/down/ug11.pdf
Palomo Pinto, Francisco Rogelio, & Perez Vega-Leal, Alfredo, & Galván Diez, Eduardo, (2004), Problemas de Instrumentación Electrónica, Sevilla, España: Escuela Técnica Superior de Ingeniería.
Imágenes de componentes electrónicos. Sensores, servos, etc:
https://es.aliexpress.com/es_home.htm
49
15. AGRADECIMIENTOS
Agradecer en gran parte nuestros éxitos y resultados especialmente a los profesores de la asignatura Hipólito Guzmán y José Ángel Acosta así como a nuestro profesor de Instrumentación Electrónica, Alfredo Pérez, por aportar los conocimientos necesarios en muchas de las tareas realizadas, así como en la gestión de este proyecto.
También ha sido de muchísima ayuda el apoyo, el aporte de materiales y consejos de los maestros de taller de la ETSI (Universidad de Sevilla) Andrés y Agustín, así como los consejos y el patrocinio de Juan Carlos Pérez en nombre de FabLab, taller de fabricación donde se realizaron todas las piezas de este proyecto.
16. ANEXOS
Debido al carácter audiovisual o gráfico de los anexos, se ha decidido añadirlos en una carpeta adjunta a la memoria.
Anexo 1: Manual de usuario proporcionada por GlovArm. Anexo 2: Guía rápida de uso. Anexo 3: Código de calibración. Puede accederse a él mediante cualquier
herramienta de texto. Se recomienda algún editor que detecte C++. Anexo 4: Video rápido de demostración. Anexo 5: Vídeo detallado movimientos con guante. Anexo 6: Vídeo detallado modo reproduce. Anexo 7: Vídeo detallado control de precisión. Anexo 8: Vídeo comercial completo. Anexo 9: Vídeo comercial corto.