Upload
others
View
0
Download
0
Embed Size (px)
Citation preview
TREBAJO FIN DE GRADO
Grado en Ingeniería Electrónica Industrial i Automática
CONSTRUCCIÓN Y PROGRAMACIÓN DEL CONTROL DE UN
BRAZO MECÁNICO CON STM32
Volumen I
Memoria y Anexos
Autores: Carrasco González, Raquel Molera Aliseda, Ismael Director: Calomarde Palomino, Antonio Departamento: ESAII – Ingeniería de sistemas, automática e informática
industrial. Convocatoria: Octubre 2020
Construcción y programación del control de un brazo mecánico con STM32
1
Memoria
2
Resum
Aquest document recull el procés de disseny, construcció i programació d’un braç mecànic de sis eixos
de llibertat mitjançant un microprocessador de 32 bytes, per realitzar la seva lògica de control, i una
APP (Aplicació informàtica), pel seu control remot. Amb aquest objectiu s’ha realitzar estudis sobre el
control de motors de continua amb encoder incrementals, la capacitat de càrrega dels motors sobre
l’estructura, les equacions del moviment dinàmics i cinemàtic del robot i les bases de programació
d’una APP en l’entorn d’Unity amb C#.
El prototip final dissenyat s’ha realitzat sobre una estructura d’open source d’Autodesk, i s’ha imprès
mitjançant una impressora 3D a més, a aquesta estructura se li ha afegit una pinça pneumàtica com a
element terminal. El sistema es controla mitjançant una APP compatible amb els sistemes operatius
d’Android i IOS, presents a la majoria dels dispositius mòbils. Mitjançant aquesta APP, es pot moure el
robot eix a eix, o donar-li indicant la posició desitjada del element terminal, es a dir, la pinça, mitjançant
comunicació Bluetooth. Finalment, s’han elaborat estudis econòmics y mediambientals.
Braç robòtic, microcontrolador, encoder, controlador PID, PWM, STM32, C, C#.
Resumen
Este documento recoge el proceso de diseño, construcción y programación de un brazo mecánico de
seis ejes de libertad mediante un microprocesador de 32 bytes, para realizar su lógica de control, y una
APP (Aplicación informática), para su control remoto. Con este objetivo se han realizado estudios sobre
el control de motores de continua con encoder incrementales, la capacidad de carga de los motores
sobre la estructura, las ecuaciones del movimiento dinámicos y cinemático del robot y las bases de
programación de una APP en el entorno de Unity mediante C#.
El prototipo final diseñado se ha realizado sobre una estructura open source de Autodesk, y se ha
impreso con una impresora 3D, además, a esta estructura se le ha añadido una pinza neumática como
elemento terminal. El sistema se controla mediante una APP compatible con los sistemas operativos
de Android y IOS, presentes en la mayoría de los dispositivos móviles. Mediante esta APP, se puede
mover el robot eje a eje, o indicarle la posición deseada del elemento terminal, es decir, la pinza,
mediante comunicación Bluetooth. Finalmente, se han elaborado estudios económicos y
medioambientales.
Brazo robótico, microcontrolador, encoder, controlador PID, PWM, STM32, C, C#.
Construcción y programación del control de un brazo mecánico con STM32
3
Abstract
This document covers the process of designing, constructing, and programming a six-axis mechanical
arm using a 32-byte microprocessor, for its logic control, and an APP (Application), for its remote
control. To this end, studies have been carried out on the control of continuous motors with
incremental encoders, the load capacity of the motors on the structure, the equations of the dynamic
and kinematic movement of the robot and the programming bases of an APP in the Unity environment
with C#.
The final prototype designed was made on an open source mechanical structure from Autodesk, and
was printed using a 3D printer, in addition to this structure a pneumatic clamp was added as a terminal
element. The system is controlled by an APP compatible with Android and IOS operating systems,
present in most mobile devices. Using this APP, you can move the robot axis to axis, or give it by
indicating the desired position of the terminal element, the clamp, via Bluetooth communication.
Finally, economic and environmental studies have been carried out on the prototype.
Robot Arm, microcontroler, encoder, PID controlar, PWM, STM32, C, C#.
Memoria
4
Agradecimientos
En la elaboración de este proyecto han sido determinantes muchas personas a las que es justo
agradecer su esfuerzo y dedicación.
En primer lugar, es necesario agradecer al director del proyecto Antonio Calomarde Palomino y la
confianza que nos depositó al firmar un proyecto que no estaba incluido en las ofertas de TFG de la
EEBE. Los correos electrónicos enviados en uno y otro sentido que han ayudado a redirigir el rumbo
del proyecto. Así como la ayuda brindada sobre todo en la selección de la marca de los componentes
motores.
Así mismo, también queremos agradecerles a nuestras familias, las cuales nos han acompañado en el
proceso, apoyándonos, y aguantando el ruido de la impresora 3D sin quejarse. Por todo ello, les
estamos muy agradecidos.
Construcción y programación del control de un brazo mecánico con STM32
5
Índice
RESUM _____________________________________________________________ 2
RESUMEN __________________________________________________________ 2
ABSTRACT __________________________________________________________ 3
AGRADECIMIENTOS __________________________________________________ 4
1. PREFACIO ______________________________________________________ 8
1.1. Origen del trabajo y motivación .............................................................................. 8
1.2. Requerimientos previos ........................................................................................... 8
2. INTRODUCCIÓN ________________________________________________ 11
2.1. Objetivos del trabajo .............................................................................................. 11
3. ANTECEDENTES ________________________________________________ 12
3.1. Los robots ............................................................................................................... 12
3.1.1. Historia .................................................................................................................. 13
3.1.2. Tipos de brazos robóticos ..................................................................................... 13
3.2. Los encoder ............................................................................................................ 14
3.2.1. Tipos de encoder................................................................................................... 14
3.3. El microcontrolador ............................................................................................... 16
3.3.1. Historia .................................................................................................................. 16
3.3.2. Características....................................................................................................... 16
3.3.3. Tipos de tecnologías ............................................................................................. 17
3.3.4. Tecnología ARM ..................................................................................................... 18
3.4. Motores para brazos robóticos ............................................................................. 20
3.4.1. Motores DC ........................................................................................................... 20
3.4.2. Motores paso a paso ............................................................................................ 20
3.4.3. Servomotores ....................................................................................................... 21
3.5. Tipos de materiales para el brazo robótico ........................................................... 22
3.5.1. Aleaciones metálicas ............................................................................................ 22
3.5.2. Plásticos aptos para la impresión 3D ................................................................... 22
3.5.3. Impresoras 3D ........................................................................................................ 24
3.6. Regulación automática y sistemas de control. ...................................................... 26
Memoria
6
3.6.1. Técnicas de control para sistemas lineales ........................................................... 28
3.6.2. Control para sistemas no lineales.......................................................................... 33
3.7. Base de programación de microcontroladores en C ............................................ 33
3.8. Base de programación de aplicaciones informáticas en C# ................................. 35
3.9. Protocolos de comunicación inalámbricos ........................................................... 37
3.9.1. Bluetooth ............................................................................................................... 37
3.9.2. WIFI ........................................................................................................................ 38
3.10. Plataformas de diseño de APP............................................................................... 39
3.10.1. Android Studio ........................................................................................... 39
3.10.2. XCode ......................................................................................................... 40
3.10.3. Unity .......................................................................................................... 41
3.11. Localización espacial y cinemática del brazo robótico.......................................... 42
3.11.1. Sistema cartesiano. Representación de la posición y orientación. .......... 42
3.11.2. Matrices de transformada homogénea .................................................... 43
3.11.3. Cinemática del Robot ................................................................................ 44
4. ESPECIFICACIONES BÁSICAS ______________________________________ 46
4.1. Posibles soluciones ................................................................................................ 46
4.1.1. Estructura metálica ............................................................................................... 46
4.1.2. Estructura plástica mediante impresora 3D ......................................................... 47
4.1.3. Accionamiento mediante servomotores .............................................................. 47
4.1.4. Accionamiento mediante motores DC ................................................................. 48
4.1.5. Placa de desarrollo ................................................................................................ 48
4.2. Solución adoptada ................................................................................................. 48
4.2.1. Estructura .............................................................................................................. 48
4.2.2. Motores y encoder ................................................................................................ 50
4.2.3. Placa de desarrollo ................................................................................................ 50
5. DISEÑO MECÁNICO DEL BRAZO ROBÓTICO __________________________ 51
5.1. Componentes que conforman de brazo robótico ................................................ 51
5.1.1. Estructura ............................................................................................................... 51
5.1.2. Motores.................................................................................................................. 58
6. DISEÑO DE HARDWARE DEL BRAZO ROBÓTICO _______________________ 60
6.1. Primera solución. Direccionamiento del PWM mediante multiplexores. ............ 60
6.2. Segunda solución. Control con PWM individuales ............................................... 62
6.3. Alimentación del sistema. ..................................................................................... 64
Construcción y programación del control de un brazo mecánico con STM32
7
6.4. Módulo Bluetooth .................................................................................................. 65
7. DISEÑO DE SOFTWARE DEL BRAZO ROBÓTICO _______________________ 66
7.1. Programación del microcontrolador de la placa de desarrollo STM32F4 Discovery
(STM32F407VGTx) ................................................................................................. 66
7.1.1. Programación para el primer diseño de hardware ............................................... 66
7.1.1.1. Programación de los encoder .................................................................... 66
7.1.1.2. Selección del motor mediante multiplexores ........................................... 72
7.1.1.3. Comunicación Bluetooth de la placa de desarrollo .................................. 75
7.1.1.4. Programación del PWM ............................................................................ 76
7.1.1.5. Programación del controlador PID ....................................................................... 80
7.1.2. Programación para el segundo diseño de hardware ............................................ 93
7.1.2.1. Programación de los encoder .................................................................... 93
7.1.2.2. Programación del PWM ............................................................................ 95
7.1.2.3. Programación del controlador PID ............................................................ 98
7.1.2.4. Comunicación Bluetooth de la placa de desarrollo ................................ 102
7.1.2.5. Programación del ADC ............................................................................. 103
7.2. Programación de la aplicación móvil ................................................................... 108
7.2.1. Programación para realizar la conexión Bluetooth. (Front end) ....................... 110
7.2.2. Programación para realizar la conexión Bluetooth. (Back end) ........................ 114
7.2.3. Compilar la APP para poderla instalar en el Smartphone ................................... 126
7.3. Programación de los algo ..................................................................................... 130
7.4. ritmos o matrices de posicionamiento del robot. Representación de Denavit-
Hartenberg (D-H). ................................................................................................ 130
7.4. ANÁLISIS DEL IMPACTO AMBIENTAL _______________________________ 139
7.5. CONCLUSIONES _______________________________________________ 140
ANÁLISIS ECONÓMICA ______________________________________________ 141
BIBLIOGRAFÍA _____________________________________________________ 145
ANEXO 0. EXPLICACIÓN DEL FUNCIONAMIENTO DE LOS ANEXOS ____________ 151
ANEXO 1. ESTRUCTURA MECÁNICA ____________________________________ 151
ANEXO 2. CÓDIGO DEL PROYECTO EN STM32 ____________________________ 151
ANEXO 3. CÓDIGO DEL PROYECTO DE UNITY DE LA APP ___________________ 151
Memoria
8
ANEXO 4. DATASHEETS DE LOS COMPONENTES UTILIZADOS _______________ 152
ANEXO 5. CÁLCULOS PARA EL DISEÑO DEL PROGRAMA ___________________ 152
1. Prefacio
1.1. Origen del trabajo y motivación
El origen del trabajo nace de la motivación e inquietud de combinar los diferentes campos estudiados
durante el grado de “Ingeniería Electrónica Industrial y Automática”, especialmente a partir del
proyecto realizado en la asignatura de “Informática Industrial”. Dicha asignatura, impartida por
nuestro director de TFE (Antonio Calomarde) mostró el potencial de la programación de
microcontroladores y de su versatilidad para poderla aplicar a distintos campos. Por ello, se deseó
combinar diferentes competencias obtenidas durante nuestros estudios universitarios para realizar el
control de los motores en un robot de seis ejes de libertad.
Además, al haber realizado cursos de desarrollo de aplicaciones móviles en Android y en Unity, se quiso
realizar una aplicación móvil para la comunicación del usuario con el microcontrolador mediante
Bluetooth, facilitando la interactuación del usuario con el sistema. Y la implementación de los
algoritmos de Denavit–Hartenberg para obtener la posición de los diferentes ejes dependiendo de la
posición del elemento terminar deseada.
Finalmente, debido a dificultades presentadas por la pandemia del CoVid-19 durante el transcurso del
trabajo, nos surgió la necesidad de producirnos nuestra propia estructura del brazo robótico, por ello,
al disponer de estructuras de código abierto decidimos adentrarnos en el mundo de la impresión 3D y
realizar nuestra propia estructura.
1.2. Requerimientos previos
Para realizar este proyecto, es necesario tener una experiencia en programación orientada a objetos
con el lenguaje de programación C# y de programación de microprocesadores con el lenguaje de
programación C.
En cuanto al set-up técnico, aparte de la electrónica diseñada en el trabajo que se describirá en esta
memoria, a nivel hardware se ha contado con:
• Equipos: MSI GS65 Stealth 8SE\ MACBOOK PRO (2019)\ Iphone XR
Construcción y programación del control de un brazo mecánico con STM32
9
• Sistemas operativos: Windows 10 Home 64 bits\ MAC OS Catalina 10.15.6\ iOS 13.7
• Procesadores: Intel® Core™ i7-8750H CPU @ 2.20 GHz\ Intel® Core i9 -8 @ 2,3 GHz\ Apple A12
• Memoria RAM: 16,0 GB\ 64,0 GB\ 3GB
• Tarjetas gráficas: NVIDIA GeForce RTX 2060\ Intel UHD Graphics 630 1536 MB\ 1100 MHz
En cuanto al set-up técnico a nivel software se ha contado con:
• Keil uVusion5; Versión 5.31.0.0
• STM32CubeMX; Versión 5.6.1
• Unity Hub; Versión 2.3.2
• Unity; Versión 2017.4.40f1
• Ultimaker Cura; Versión 4.6.1
• MATLAB R2019b; Versión 9.7
• XCODE, Versión 12.0
• Autodesk Fusión 360; Versión 2.0.8816
• Arduino IDE; Versión 1.8.42.0
• Proteus; Versión 8.10.2903
Construcción y programación del control de un brazo mecánico con STM32
11
2. Introducción
El presente documento expone la memoria técnica y los anexos del Trabajo de Fin de Estudios (TFE)
del Grado en Ingeniería Electrónica Industrial y Automática, realizado por Ismael Molera Aliseda y
Raquel carrasco González y tutorizado por Antonio Calomarde Palomino.
El documento recoge el estudio y procedimiento del diseño de un bazo mecánico de seis ejes de
libertad, el diseño e implementación de una APP (Aplicación Informática) con comunicación bluetooth
para el control de la posición del robot y, finalmente, el montaje del prototipo.
2.1. Objetivos del trabajo
• Bloque 1. Programación de los controles de los motores mediante la placa de desarrollo
En primer lugar, se ha de diseñar e implementar la placa de pruebas para el control de los motores que
accionaran el brazo robótico, además se ha de programar la placa de desarrollo que contiene el
microprocesador, configurando las entradas y salidas necesarias, así como elaborando el programa en
C que controlará los motores
• Bloque 2. Diseño App
Para la comunicación a distancia con el brazo robótico es necesario elaborar una APP que transmita
mediante el protocolo Bluetooth las posiciones deseadas de cada motor.
Además, una vez completada la anterior acción, se desea mostrar una simulación de la posición del
motor a través de la APP, por lo que se necesita también recibir los datos de la posición desde la placa
de desarrollo, para que así sea real.
• Bloque 3. Montaje e impresión 3D.
Una vez los dos programas estén realizados y funcionando, se ha de elaborar el prototipo. Para ello es
necesario la impresión de las distintas piezas mediante una impresora 3D, su montaje y el
acoplamiento de los motores junto con la placa de desarrollo.
• Bloque 4. Realización de pruebas con el brazo robótico y limitación del área del trabajo.
Una vez el prototipo esté montado, se han de realizar las pruebas necesarias para comprobar su
funcionamiento, repetitividad y precisión. Además, se han de realizar los cambios necesarios para
asegurar la máxima eficiencia de este.
Memoria
12
3. Antecedentes
Debido al amplio abaste de temáticas del proyecto en campos de la ingeniería en este apartado se
exponen brevemente los conceptos básicos en los que se fundamenta el proyecto, con ello se pretende
poner al alcance del lector los conceptos necesarios para la comprensión del texto sin la necesidad de
tener conocimientos previos en robótica, microprocesadores, diseño de aplicaciones móviles o
estructuras mecánicas de los brazos robóticos.
3.1. Los robots
Los robots, en la actualidad son un conjunto de máquinas muy amplia que realizan tareas para las
personas, sustituyéndolas en el trabajo. Su definición según algunos diccionarios es la siguiente:
Enciclopedia Británica
Máquina operada automáticamente que sustituye el esfuerzo de los humanos, aunque no tiene por qué tener apariencia
humana o desarrollar sus actividades a la manara de los humanos.
Diccionario de la Real Academia Española
Máquina o ingenio electrónico programable, capaz de manipular objetos y realizar operaciones antes reservadas sólo a las
personas.
Tabla 1. Definición de robot según la enciclopedia británica [1] y la Real Academia Española [2]
Pero como se puede comprobar en la tabla 1, la definición es muy amplia, por lo que sería necesaria
una definición más escueta para definir la concepción de robot (industrial) actual. Para ello, se han
incluido las definiciones de robot industrial manipulador.
La primera definición que se realizó en el 1979 por la RIA (Robot Institute of America, actualmente
Robotic Industries Association [3]), fue la siguiente:
Robot (RIA): Un robot industrial es un manipulador multifuncional reprogramable, capaz de mover materias,
piezas, herramientas o dispositivos especiales, según trayectorias variables, programadas para realizar tareas
diversas.
Pero la definición más acotada es la actual, establecida por la Asociación Internacional de Estándares
(ISO). Ésta en su norma ISO 8373 [4] en España corresponde a la UNE EN ISO 8373:1998. «Robots
Manipuladores Industriales. Vocabulario»), define al Robot manipulador industrial como:
Robot manipulador industrial (ISO): Manipulador de 3 o más ejes, con control automático, reprogramable,
multiplicación, móvil o no, destinado a ser utilizado en aplicaciones de automatización industrial. Incluye al
manipulador (sistema mecánico y accionadores) y al sistema de control (software y hardware de control y
potencia).
Aunque actualmente esta se encuentra bajo revisión, y será reemplazada por la norma ISO/DIS 8373.
Construcción y programación del control de un brazo mecánico con STM32
13
3.1.1. Historia
Aunque pueda parecer que los brazos robóticos son relativamente modernos, lo cierto es que tienen
siglos de historia. Un claro ejemplo son los autómatas de Grecia, estatuas capaces de moverse por
energía hidráulica que quedaron plasmados en el libro Autómata, escrito por Herón de Alejandría
donde se detallan los mecanismos basados fundamentalmente en los principios de Filón o Arquímedes.
Pero no fue hasta el año 1948 cuando George Devol realizó la primera incorporación del robot en la
industria cuando patentó lo que acabaría evolucionando en los robots industriales modernos y en el
1960 instaló el primer brazo robótico, el Unimate, en la fábrica de general Motors en Trenton, Nueva
Jersey.
Por lo que respecta a los brazos robóticos de bajo coste, utilizados mayormente en el ámbito docente
y recreativo, han aumentado desde los años 2000 gracias al abaratamiento de los componentes, como
a la aparición de nuevas tecnologías.
3.1.2. Tipos de brazos robóticos
La variedad de aplicaciones para los que se pueden utilizar los brazos robóticos produce una amplia
variedad de tipos, por lo que en este apartado se expondrán los pertinentes al ámbito industrial y se
eludirán otros tipos de brazos robóticos como prótesis para humanos o animales.
Dependiendo de la finalidad con la que se desee utilizar el brazo robótico y de su estructura o
características, se pueden distinguir principalmente los siguientes tipos de brazos robóticos
industriales.
• Robot cartesiano, consta de tres articulaciones prismáticas con ejes coincidentes con los ejes
cartesianos, principalmente utilizados para aplicaciones de “pick and place”, ensamblado,
soladura por arco, etc.
• Robot cilíndrico, sus ejes forman un sistema de coordenadas cilíndricas, principalmente
utilizados para aplicaciones de ensamblaje, soldadura por punto, etc.
• Robot polar, sus ejes forman un sistema polar de coordenadas, principalmente utilizados para
aplicaciones de soldadura por punto, por gas y por arco, fundición a presión, etc.
• Robot SCARA, consta de dos articulaciones rotatorias paralelas que permiten la manipulación
en un plano, principalmente sutilizados para aplicaciones de “pick and place”, ensamblado,
etc.
• Robot articulado, costa de como mínimo de tres articulaciones rotatorias, principalmente
utilizados para aplicaciones de ensamblaje, fundición a presión, máquinas de desbarbado, etc.
Memoria
14
• Robot paralelo, consta de articulaciones prismáticas o rotatorias concurrentes,
principalmente utilizados para aplicaciones de “pick and place”, etc.
3.2. Los encoder
El encoder, también llamado codificador o generador de pulsos, es un dispositivo electromecánico que
hace de nexo de comunicación entre un dispositivo mecánico móvil y un controlador que permite
codificar el movimiento mecánico en distintos tipos de impulsos eléctricos: digitales binarias,
analógicos en función de una onda, pulsos, etc.
3.2.1. Tipos de encoder
Los encoder se pueden clasificar según el tipo de tecnología o sensor que utilizan, el tipo de movimiento
que permiten o la forma de establecer la posición.
3.2.1.1. Tipos de encoder según la tecnología utilizada para la medición
En la fabricación de un encoder se pueden utilizar diferentes tipos de sensores que permitan registrar
el movimiento o desplazamiento del objeto en cuestión, estos pueden ser:
• Sensor magnético, se fundamenta en una cinta magnetizada o una cinta fabricada con
materiales de reluctancia magnética variable que determinan la posición mediante cabezales
de lectura magneto-resistivos o con solenoides. Tienen una lectura muy fiable y son
relativamente económicos, pero son altamente susceptibles a campos magnéticos intensos,
por lo que no pueden ser empleados en ámbitos donde existan fuerzas electromotrices
elevadas.
• Sensor óptico, se fundamenta en registrar los cambios en una cinta, la cual puede estar
codificada con patrones de Moiré o holográficos, entre otros. Tienen una gran precisión y no
necesitan de contacto físico entre las artes, pero por otro lado son muy susceptibles a la
suciedad por lo que deben de estar hermetizados.
• Sensor capacitivo, su funcionamiento se basa en la medición de capacitancia entre la escala y
el cabezal lector, permite una medición sin contacto físico, por lo que es altamente
recomendable para medir calibres, pero por otro lado son muy susceptibles a la suciedad en
el cabezal o el lector por lo que deben de estar hermetizados.
• Sensor inductivo, se fundamenta en un devanado interno que cuando una corriente circula
por el mismo, un campo magnético se genera, el cual atrae o detecta los objetos ferrosos.
Puede utilizarse sin hermetizarse en ambientes donde hay presentes agentes como líquidos o
partículas de suciedad, pero su precisión no es tan elevada como en los otros casos.
Construcción y programación del control de un brazo mecánico con STM32
15
• Sensor de corrientes de Eddy, es un modelo patentado que consta de una escala en la que se
intercalan materiales no magnéticos de alta y baja susceptibilidad, los cuales permiten la
detección mediante el análisis de la variación en la inductancia dentro de un circuito de
corriente alterna.
3.2.1.2. Tipos de encoder según el movimiento permitido a medir
El tipo de movimiento que un encoder puede medir se divide en dos, en encoder lineales y encoder
rotatorios.
• Encoder lineal, es el tipo más sencillo de encoder, usualmente capacitivo, el cual lee por
interpolación la distancia recorrida desde el cero de una pieza móvil. Por lo que usualmente
se compone de un módulo fijo, donde se encuentra el sensor, y una parte móvil, unido a la
parte móvil a medir.
• Encoder rotatorio, la lectura en este tipo de encoder se realiza sobre un disco rotatorio en el
cual se ha marcado una codificación que permite saber la posición angular de este con gran
precisión.
3.2.1.3. Tipos de encoder según la metodología para determinar la posición
Indistintamente de la tecnología emprada o el tipo de movimiento registrado, los encoder pueden
proporcionar una posición que es relativa o absoluta.
• Detección incremental, la posición que proporciona es relativa, debido a que el encoder
detecta el movimiento gracias a la detección diferencial de dos valores codificados en la
superficie detectables, pero siempre se inicializa en cero.
• Detección absoluta, la posición que proporciona, como su nombre indica, es absoluta, en la
superficie de la pieza móvil se encuentra codificada la posición real desde el punto cero de la
estala, por lo que, al inicializarse, el encoder conoce la posición real del objeto, sin necesidad
de moverse.
Memoria
16
Figura 1. Diagramas de disco del codificador o encoder. El diagrama de la izquierda muestra un ejemplo simplificado de un disco codificador de cuadratura incremental, con pistas separadas para los canales A y B. El diagrama de la derecha es una representación simplificada de un disco codificador de código gris absoluto. [5]
3.3. El microcontrolador
El microcontrolador es un CI (Circuito Integrado) digital programable, compuesto por una unidad
central de proceso CPU, memoria ROM y RAM y líneas de entrada y salida (periféricos).
3.3.1. Historia
El primer microprocesador fue lanzado en el 1971 por Intel, el cual tenía una capacidad de sólo 4 bits.
Además, necesitaba de circuitos adicionales para poder funcionar, lo que implicaba un elevado costo
del sistema. Y en el 1977, Intel, comercializó lo que sería el primer microcontrolador, combinando
memoria RAM y ROM en un mismo chip, optimizado para aplicaciones de control, el Intel 8048.
Desde entonces, la capacidad de los microcontroladores ha augmentado exponencialmente, y su costo
de fabricación descendido de igual manera. Pudiendo obtener, en 2009, un microcontrolador de 8 bits
por menos de 0,25 dólares y algunos microcontroladores de 32 bits a 1 dólar en compras de grandes
cantidades.
3.3.2. Características
El microcontrolador es un circuito integrad que contiene un sistema para controlar elementos de
entrada / salida. También incluye un procesador, memoria y periféricos. Su principal función es
automatizar el proceso y procesar la información.
3.3.2.1. Elementos internos de un microcontrolador
El microprocesador estará formado por al menos tres elementos.
Construcción y programación del control de un brazo mecánico con STM32
17
- ALU (Unidad Aritmética y Lógica): Unidad lógica de realizar las operaciones matemáticas, entre
las que se comprenden las operaciones lógicas, como la suma lógica (OR), multiplicaciones
lógicas (AND), diferencia lógica (XOR) o la negación (NOT); las operaciones aritméticas como
la suma, resta, multiplicación o división; y las operaciones misceláneas, en las que se incluyen
las operaciones de transferencia de bits.
- Unidad de control: Conjunto de sistemas digitales secuenciales que permiten distribuir la
lógica de las señales.
- Registros: Espacio de memoria principal constituida por Flip-Flops, que son circuitos digitales
secuenciales.
La memoria del microcontrolador está dividida en tres. La memoria para el programa (Flash), la
memoria para los datos (RAM) y la memoria no volátil para la configuración (EEPROM).
Y finalmente, los periféricos, que permiten la interacción con los elementos externos al
microcontrolador.
- Puertos de entrada/salida.
- Puertos seriales.
- Periféricos analógicos.
Figura 2. Configuración interna de un microcontrolador [6]
3.3.3. Tipos de tecnologías
Los microcontroladores pueden estar diseñados con dos tipos de arquitecturas distintas, arquitectura
Von Neuman y arquitectura de Hardvard.
Memoria
18
- Arquitectura Von Neuman. Son bastante costosas, pero permiten ahorrarse líneas de entrada
y salidas debido a que utiliza la misma memoria para almacenar las instrucciones y los datos.
- Arquitectura de Hardvard. Es la utilizada en los microcontroladores, el cual incluye buses de
comunicación para cada tipo de memoria, un bus de datos, un bus de direcciones y un bus de
control. Permitiendo adecuar el tamaño de estos a los requerimientos de cada memoria.
Figura 3. Esquema de funcionamiento de la arquitectura de Von Neuman y de Hardvard [7]
3.3.4. Tecnología ARM
ARM diseña los núcleos de los procesadores, pero solo vende las licencias de software de diseño. ARM
ha diseñado distintos tipos de procesadores, englobados en las familias de Cortex-A, Cortex-R y Cortex-
M.
Figura 4. Tipo de procesadores diseñados por ARM [7]
Construcción y programación del control de un brazo mecánico con STM32
19
Figura 5. Comparativa de las prestaciones y capacidades de los distintos procesadores diseñados por ARM [7]
La familia de procesadores que se utilizarán son los de la familia de los Cortex-M. Por ello serán los que
se expliquen a continuación.
Todos los procesadores de Cortex-M, tienen muchas similitudes entre sí, compartiendo el mismo
modelo de referencia del programador, el controlador de interrupciones vectoriales anidadas (NVIC)
que gestionan las interrupciones, modos de reposos definidos, las características para el soporte de
sistemas operativos y un soporte de depuración.
Además, la arquitectura de ARM es de 32 bits, con palabras, por lo tanto, de 32 bits, medias palabras
de 16 bits y byte de 8 bits. Siendo por ende de 32 bits el tamaño de las instrucciones. Y son capaces de
ejecutar las funciones que se muestran en la figura 6 según al modelo que pertenezcan.
Figura 6. Instrucciones disponibles según el modelo de procesador ARM [7]
Memoria
20
3.4. Motores para brazos robóticos
Los brazos mecánicos necesitan de un sistema capaz de producir movimiento, para ello se suelen
utilizar motores eléctricos para producirlo. En el siguiente apartado se exponen los más utilizados, con
la aclaración que el uso de estos engloba tanto a brazos robóticos industriales y no industriales,
pudiendo englobar también los docentes o lúdicos. Entre los motores eléctricos los más utilizados son
los motores de corriente continua (DC), los motores paso a paso y los servos motores o servos.
3.4.1. Motores DC
El motor de corriente continua es una máquina capaz de convertir energía eléctrica en movimiento
mecánico rotatorio mediante la acción de un campo magnético.
Este se compone principalmente de dos partes, el estátor, que contiene los polos magnéticos de la
máquina que da soporte a la estructura, y el rotor, que generalmente tiene una forma cilíndrica que se
alimenta de la corriente continua por el colector. Otro de los componentes también son las escobillas,
pero no presentes en todos los motores por el enorme desgaste de estas cuando entran en contacto
con las delgas que forman el colector.
Suelen utilizarse en robótica industrial debido a la facilidad para invertir el sentido de giro, pudiendo
estos funcionar en ambas direcciones y su fácil aplicación. Aun así, su posición no es fácil de determinar
por sí solos, por lo que necesitan de un encoder que codifique la posición angular del eje del motor.
Figura 7. Motor DC con reductor 70:1 y encoder de cuadratura incremental integrado con funcionamiento a 12V. [8]
3.4.2. Motores paso a paso
El motor paso a paso es una máquina capaz de convertir una serie de impulsos eléctricos en
desplazamientos angulares discretos, por lo que es capaz de girar unos grados determinados por paso.
Es especialmente útil aplicado en sistemas digitales, debido a que puede ser controlado mediante
impulsos producidos por estos. Tiene una gran precisión y repetitividad de posicionamiento, ya que su
Construcción y programación del control de un brazo mecánico con STM32
21
movimiento se divide en pasos equitativos pudiendo controlar la parada en estos pasos, siendo más
precisos cuanto menor es el paso.
Suelen utilizarse en aplicaciones que requieran una gran precisión de posicionamiento, un excelente
control de velocidad, como impresoras 3D o el cabezal de lectura/escritura de algunas unidades de
disco. Además, a diferencia de los motores DC, el motor paso a paso tiene el par máximo a bajas
velocidades.
Aun así, el principal problema que presentan es su baja eficiencia, debido a que el consumo de
corriente del motor paso a paso es independiente al de la carga. Además, trabajan en lazo abierto, no
pudiendo trabajar con realimentación presentando problemas de seguridad y control y su par en altas
velocidades es muy limitado.
Figura 8. Motor paso a paso: bipolar, 200 pasos / rev, 20x30 mm, 3,9 V, 600 mA (SY20STH30-0604A) [9]
3.4.3. Servomotores
El servomotor es un motor eléctrico, similar al motor de corriente continua, que lleva incorporado un
sistema de regulación que permite el control de velocidad y posición. En los servos es muy fácil
controlar la posición del motor, históricamente solían estar restringidos a 180 grados, en este caso son
los servos de rotación continua, o de rotación libre, servos de rotación continua, que permite girar en
ambas direcciones, pero a menor velocidad y par motor que los motores DC.
Tiene un consumo de corriente reducido, el cual depende del tamaño del servomotor y del par motor
que puede proporcionar, pero que suele ser reducido.
Figura 9. Power HD servo submicro digital de alta velocidad DSP33 [10]
Memoria
22
3.5. Tipos de materiales para el brazo robótico
3.5.1. Aleaciones metálicas
Las aleaciones metálicas están formadas por la combinación de dos o más metales, o también, por
metales y no-metales, con propiedades mixtas de los elementos que lo conforman.
Las aleaciones metálicas se pueden diferenciar por su estructura cristalina y el mecanismo que se utilizó
para formarla, la cual puede ser una aleación por sustitución o una aleación intersticial. La primera, se
compone de un metal base al cual se le añade un segundo metal, el cual suele ser de tamaño y posición
en la tabla periódica cercano, y los átomos del material añadido sustituyen átomos del metal base,
como el Latón formado por la unión de cobre y zinc, con números atómicos 29 y 30 correlativamente.
La aleación intersticial, mezcla metales con átomos de distintos tamaños, donde los átomos del
material de menor tamaño pueden introducirse en la red cristalina del metal con átomos de mayor
tamaño, un claro ejemplo es el acero, en el cual átomos de carbono se sitúan dentro de la red cristalina
del hierro, el cual tiene átomos de mayor tamaño.
Las propiedades de las aleaciones metálicas, por lo tanto, dependen de los metales o no metales que
las conforman, aun así, entre todas suelen mantener características propias de los metales, como la
resistencia a deformación o impactos y un punto de fusión elevado. En algunas aleaciones, además se
puede obtener propiedades muy útiles dependiendo del ambiente donde se quiera situar el o jeto
como la resistencia a la corrosión, la apariencia y color de la aleación y de la capacidad que tiene a
conducir el calor.
3.5.2. Plásticos aptos para la impresión 3D
Como se podrá observar en los siguientes subapartados la variedad de plásticos que existen para la
impresión mediante impresoras 3D es muy amplia, además existen otros materiales no plásticos aptos
para la impresión como las resinas, pero estos últimos no se han incluido debido a la complejidad que
presenta su utilización además de postprocesos necesarios para su utilización, como del coste
económico tanto de la impresora 3D capaz de procesarlos como de los materiales.
A continuación, se exponen brevemente los materiales plásticos más comunes con sus principales
características.
Acrilonitrilo Butadieno Estireno (ABS): El ABS es el más utilizado en la impresión 3D, es flexible y
resistente a los golpes a la vez que resistente, siendo capaz de soportar temperaturas de -20ºC a 80ºC.
Tiene una temperatura de extrusión de entre 230ºC a 260ºC, aunque al contraerse al contacto con el
aire necesita de una plataforma calefactada en la impresión para evitar deformaciones. Además, está
Construcción y programación del control de un brazo mecánico con STM32
23
compuesto por termoplásticos con una base de elastómeros a base de polibutadieno, por lo que es
reutilizable, aunque no biodegradable y se recomienda su uso en una impresora 3D con cámara
cerrada por las emisiones de partículas al imprimir con este material.
Poliácido Láctico (PLA): El PLA es uno de los materiales de más fácil impresión 3D, aunque puede
reducirse en tamaño después de esta y tiene una alta velocidad de enfriamiento y solidificación, lo que
puede dificultar la impresión. Tiene una temperatura de extrusión de entre 190ºC a 230ºC y no necesita
de una cama calefactada al imprimirse. Además, está fabricado con materias primas renovales como
el almidón de maíz por lo que tiene la ventaja de ser un material renovable, por eso, es sensible al
contacto con el agua, pudiéndose deteriorar.
Acrilonitrilo estireno acrilato (ASA): El ASA es un material con una gran resistencia a la intemperie,
manteniendo su color y resistencia al impacto por largos periodos de tiempo al aire libre, esto es debido
a que es altamente resistente a los rayos UV. Además, este es un termoplástico constituido por
acrilonitrilo, estireno y acrilato, diferenciándose del ABS por el elastómero utilizado.
Tereftalato de polietileno (PET): El PET es un material muy utilizado en la industria para la producción
de botellas y envases alimenticios, debido a su buena resistencia al impacto, su transparencia y su
estabilidad dimensional. Al imprimirse no necesita de cama calefactada y tiene una temperatura de
extrusión de entre 75ºC a 90ºC, lo que dificulta su impresión 3D al sobrecalentarse. Aun así, presenta
la ventaja de que es un material 100% reciclable.
Poliéster glicolizado (PETG): El PETG es un derivado del PET con la misma composición química que
este, pero con glicol añadido, lo que reduce su fragilidad y aumenta su resistencia. Tiene una
temperatura de extrusión de entre 220ºC y 260ºC y suele imprimir con una cama calefactada que no
supere los 80ºC, debido a que es un material pegajoso que dificulta su extracción de esta.
Policarbonato (PC): EL PC es un material de alta resistencia y transparente. Tiene una temperatura de
extrusión de entre 260ºC y 310ºC y necesita de una plataforma calefactada de entre 80ºC y 120ºC,
temperaturas bastante elevadas. El PC puede liberar partículas de bisfenol A, por lo que en Europa su
uso está prohibido en biberones y en cualquier recipiente destinado a contener alimentos para niños
desde el 1 de junio de 2011 siendo efectivo en España desde el 17 de junio mediante el Real Decreto
847/2011 [11], pero si se puede encontrar en multitud de objetos cotidianos como las bolsas de
plástico.
Polímeros de alto rendimiento (poliariletercetonas PEEK, Poliétercetonacetona PEKK): Los polímeros
de alto rendimiento han sido desarrollados con el objetivo de obtener características mecánicas
similares a las de los metales, tienen una resistencia mecánica y térmica muy alta, y muchas veces son
más resistentes y ligeros que muchos metales. Por sus características, suelen tener una elevada
Memoria
24
temperatura de extrusión, de hasta 350ºC, y necesitan igualmente de una cama calefactada de al
menos 230ºC y necesitar de una cámara cerrada, por lo que no es posible imprimir con este material
en todas las máquinas FDM (Fused Deposition Modeling) del mercado.
Polipropileno (PP): El PP es un termoplástico es altamente resistente a la abrasión y tiene una gran
capacidad en la absorción de impactos, además de tener una rigidez y flexibilidad moderada. Aun así,
es sensible a los rayos UV y la temperatura.
Poliamidas (Nylon): Las poliamidas suele crearse a partir de un polvo blanco con tecnología SLS
(Sinterización selectiva por láser). Sin embargo, existen variantes de nylon que también se encuentran
en filamentos aptos para el modelado por deposición fundida (FDM). Las poliamidas tienen un buen
equilibrio de características químicas y mecánicas ofreciendo una elevada estabilidad, rigidez,
flexibilidad y resistencia a los golpes, siendo utilizadas en fabricación de una amplia gama de productos.
El filamento de nylon apto para la impresión 3D suele disponer de 6 átomos de carbono, comúnmente
llamado PA6. El PA6 es un filamento de gran flexibilidad, resistencia al impacto y a la abrasión. Tiene
una temperatura de extrusión de entre 220ºC a 250ºC y necesita de una plataforma calefactada de al
menos 80ºC debido a sus dificultades de adhesión, además, el material absorbe con facilidad la
humedad, por lo que deberá cuidarse las características del espacio donde se almacena.
3.5.3. Impresoras 3D
En la descripción de los materiales, han aparecido las dos tecnologías principales que se utilizan en la
impresión 3D, la impresión 3 D por deposición fundida, FDM, y la impresión 3D de sinterización
selectiva por láser, SLA.
La primera tecnología utilizada fue la SLA en 1986 al registrarse la primera patente de impresión 3D
por 3D Systems. A partir del año 1988, la compañía Stratasys, lanza al mercado las primeras impresoras
que utilizan tecnología FMD.
Si se comparan ambas, la resolución tecnología SLA está limitada por el punto óptico del láser, y como
en la impresión se utiliza la luz para su polimerización y no intervienen fuerzas, se obtiene una
superficie lisa con grosores de capa de hasta 0,05 mm a 0,01 mm. Mientras que en la tecnología FMD,
su resolución depende del tamaño de la boquilla de extrusión y la precisión de movimiento de esta, así
como de su calibración. Al utilizar, por tanto, en método físico donde intervienen distintas fuerzas para
depositar el material, el tamaño de capa mínimo va desde 0,5 mm a 0,127 mm.
Aun así, aunque en primera instancia puede parecer que la tecnología SLA supera con creces a la FDM,
se ha de considerar el posprocesamiento de la pieza. En la tecnología FMD, es bastante sencillo, donde
se basta con retirar la pieza de la plataforma de impresión. Mientras que, en la SLA, retirar la resina de
Construcción y programación del control de un brazo mecánico con STM32
25
la base puede ser más complicado, al imprimir con resinas. Además, una vez se ha retirado el modelo,
de este se han de retirar los restos que han quedado de la resina colocando el modelo en un baño de
alcohol isopropílico y después remover los soportes manualmente.
Y, si a ello le sumamos los precios de las impresoras y los materiales aptos para imprimir en estas, la
SLA supera en costo con creces a la FDM. Mientras puedes obtener una impresora FDM desde 200 € y
filamentos desde 20 €/kg, las impresoras SLA más económicas tienen un costo a partir de 3.000 € y las
resinas pueden costar un mínimo de 70 €/kg. Por ello, a continuación, solo se mostrará las partes de la
impresora 3D con tecnología FDM.
La impresora 3D con tecnología FDM, se fundamenta el extrusor, el cabezal, la bobina, el chasis y la
cama.
Figura 10. Esquema de las partes de una impresora 3D de tecnología FDM. [12]
Por tanto, las partes de la figura 10 son las siguientes:
- Cama. Superficie, que puede estar calefactada, que se utiliza como superficie donde imprimir
la pieza.
- Cabezal. Es el elemento que funde el filamento calentando el plástico a la temperatura
correcta.
- Bobina. Conjunto de filamento del material apto para la impresión 3D enrollado.
- Extrusor. Controla la deposición de material en la impresión.
Memoria
26
- Chasis. Estructura que mantiene las distintas partes de la impresora, así como la encargada de
mover el extrusor para posicionar el material en la posición necesaria.
- Componentes electrónicos. Además, la impresora para su funcionamiento incluye una serie
de hardware y software. Como la fuente de alimentación, la toma de corriente, un lector de
tarjeta SD para poder introducir los diseños, una pantalla LCD donde muestra la configuración
y los procesadores necesarios para el control de la máquina.
3.6. Regulación automática y sistemas de control.
Para poder entender la memoria del proyecto y comprender las soluciones aplicadas, es necesario
también la explicación de conceptos básicos de la regulación automática.
La regulación automática o teoría de control, en ingeniería, es el control sobre un proceso que se
encuentra en un estado determinado. En el caso del proyecto es el proceso de controlar el giro del
motor para posicionarlo en la posición angular deseada.
En primer lugar, es necesario el estudio del sistema que se desea controlar, que son sistemas dinámicos
cuyo estado cambia con el tiempo. Estos sistemas se representan mediante bloques en los cuales se
introduce una entrada, usualmente una señal digital o analógica, y proporcionan una salida. En el
sistema el sistema, puede hallarse más de un bloque, y este puede representar distintas acciones del
sistema, así como perturbaciones, rozamientos en los actuadores o elementos de control. Siendo, por
tanto, una combinación de bloques o elementos que actúan sobre un proceso, o planta, variando el
valor de alguno de los parámetros iniciales.
Como se había comentado, la representación de estos sistemas se realiza mediante bloques, llamados
diagrama de bloques, representando cada elemento mediante un rectángulo que se comunican
mediante flechas que indican el sentido de la información. Estos diagramas de bloques se componen
básicamente de tres operaciones, la medida, la decisión y la acción. La medida es la variable para
controlar, la cual es proporcionada usualmente por un sensor; la decisión se realiza por el controlador,
cuando al obtener el valor de la medida ha de discernir que ha de aplicar para obtener el valor deseado
de salida; y la acción es el proceso o conjunto de operaciones matemáticas que se aplica sobre el valor
inicial, cuando el controlador lo ha decidido, para obtener en la salida el valor deseado.
Figura 11. Diagrama de bloques de un sistema cualquiera de lazo abierto.
Construcción y programación del control de un brazo mecánico con STM32
27
En esencia, existen dos tipos de sistemas de control, control de lazo abierto y control de lazo cerrado.
En el control de lazo abierto, la señal medida entra en al controlador, donde se realiza el control de la
señal, sobre la que se aplicarán las acciones pertinentes, una vez se ha actuado sobre la señal, esta se
transmite a la salida. En este proceso, no se realiza ningún de comprobación que de señal de salida es
realmente la deseada después de pasar por el sistema.
Mientras que un sistema de lazo cerrado se diferencia del sistema de lazo abierto, en que la señal de
salida realimenta el sistema para controlar el estado y salida del sistema dinámico. Es decir, la entrada
del sistema afecta a su salida, esta salida se mide y una vez comparada con una referencia o consigna
se procesa mediante el controlador, el resultado de la señal se reenvía, por la realimentación, a la
entrada del proceso.
Figura 12. Diagrama de bloques de un sistema cualquiera de lazo cerrado.
El sistema de lazo cerrado presenta las ventajas, sobre el sistema de lazo abierto, de permitir la
corrección de perturbaciones no esperadas, pudiendo proporcionar un buen resultado aun con
incertidumbre en el sistema, por lo que es capaz de estabilizar procesos inestables y tiene tolerancia a
variaciones sobre los parámetros involuntarias. Pero, presenta la desventaja de reducir la ganancia del
sistema. Por lo que se suelen utilizar ambos sistemas conjuntamente.
Para realizar el control en lazo cerrado, existen diversas técnicas, mediante las cuales se ha de
garantizar la estabilidad en el comportamiento del lazo cerrado, pero se ha de distinguir si el proceso
o planta es un sistema lineal o un sistema no lineal. A continuación, se exponen ambos sistemas con
sus distintas técnicas de control.
Memoria
28
3.6.1. Técnicas de control para sistemas lineales
Los sistemas lineales, son aquellos que se pueden representar por un sistema matemático basado en
el uso de operadores lineales, estos permiten realizar una abstracción matemática del sistema y su
idealización, lo que su manipulación es significativamente más simple que con los sistemas no lineales.
Las técnicas de control más habituales para los sistemas lineales se exponen a continuación.
3.6.1.1. Control de dos posiciones o todo-nada
El control sobre la señal se aplica cuando esta supera o rebasa la consigna. La acción que se aplica sobre
la salida es de actuar o dejar de actuar sobre ella, moviéndose entre dos variables fijas para un solo
valor de la variable a controlar.
Esta técnica de control permite oscilar el valor de la salida en valores cercanos a la consigna establecida,
pero no mantenerse en el valor exacto de la consigna establemente, debido a que se ve muy limitada
por la velocidad de cambio del controlador.
Figura 13. Control todo-nada [13]
3.6.1.2. Control todo-nada con banda diferencial
El control todo o nada con banda diferencial funciona prácticamente igual que el control todo o nada,
con la diferencia que tiene dos consignas distintas, una que activa el sistema si el valor es inferior a
esta, y otra que apaga el sistema cuando el valor es superior a esta. Por lo que el valor, nunca alcanza
el valor de consigna, sino que oscila en un margen superior e inferior a la consigna.
Construcción y programación del control de un brazo mecánico con STM32
29
Esto es extremadamente útil para sistemas lentos que no requieren una gran exactitud, debido a que
permite al controlador no estar actuando constantemente. Como, por ejemplo, en un sistema de
regulación de temperatura de una casa particular, donde el termostato fija una consigna, y en el
controlador hay un margen aceptable, 2 ºC o 3 ºC, que permiten que no se esté encendiendo y
apagando constantemente la calefacción, la cual, al estar formada por muchos componentes
mecánicos, podría fácilmente averiarse por el desgaste. Sin error significativo para el usuario, el cual
no percibe la diferencia entre la consigna y el valor real.
Figura 14. Control todo-nada con banda diferencial [13]
Figura 15. Diferencial estático y diferencial dinámico[13]
Memoria
30
3.6.1.3. Control proporcional (P)
El controlador P, o proporcional, regula la señal proporcionalmente, como indica su nombre, al error
de esta respecto a la consigna. Lo que significa que cuanto mayor sea la desviación mayor será la
corrección que aplique. Por lo que la señal se irá equilibrando por pequeños cambios en la variable
controlada, por lo que no pasa bruscamente de un todo a un nada.
∆𝑦 = 𝐾 · ∆𝑥 [1]
Pero, entre el valor de consigna y el real siempre se mantiene un error residual, u offset, siendo menor
cuanto menor es la banda proporcional, y mayor cuanto mayor es esta, pero si la banda proporcional
se intenta acotar demasiado el sistema puede resultar inestable.
Figura 16. Resultado del control según la amplitud de la Banda Proporcional (Xp) [13]
Como se puede ver en la figura 8, con una banda proporcional demasiado amplia la señal a regular
tarda mucho en llegar a su nuevo punto de equilibro, y además la desviación respecto a la consigna
será notoria. Cuando se tiene una banda proporcional demasiado pequeña, el controlador P se
comporta como un todo o nada por lo que no estabilizará. Mientras que cuando se ajusta la banda
proporcional, se llega rápidamente al punto de equilibrio y la desviación respecto de la consigna será
menor.
Además, en un sistema real, no un único valor, debido a que tiene una cierta tolerancia de ajuste, que
se puede calcular a partir de la ganancia (K) o coeficiente de proporcionalidad y la Banda proporcional
(Xp).
Construcción y programación del control de un brazo mecánico con STM32
31
𝐾 = 𝑌
𝑋𝑝 [2]
3.6.1.4. Control integral (I)
El controlador integral es independiente a la carga. Su funcionamiento se basa en la relación entre el
error y la velocidad de variación de la magnitud de salida. Anulándose la velocidad de ajuste a cero
cuando la señal coincide con la consigna, estabilizándose.
𝑑𝑌 = 𝐾𝑖 · ∫ 𝑋𝑑 · 𝑑𝑡𝑡
0 [3]
Siendo en la ecuación 3, dY la variación de la magnitud de ajuste, Ki la ganancia o coeficiente de acción
integral, el Xd el error y dt el intervalo de tiempo. Para hallar la magnitud de ajuste Y, se puede igualar
la variación de la magnitud al producto del coeficiente de integración con el error, ecuación 4.
𝑑𝑌
𝑑𝑡= 𝐾𝑖 · 𝑋𝑑 [4]
Integrando la ecuación, se obtendrá el valor de Y. Por lo que el regulador dará una señal variable hasta
que la desviación sea nula y posteriormente será nula. El problema que presenta es que la acción
integral es lenta, aunque muy precisa, debido a que al comparar la función con su integral la variación
es mucho más lenta. Por lo que no suele emplearse.
Figura 17. Evolución de las variables controlada y operada ante una perturbación. [13]
Memoria
32
3.6.1.5. Control derivativo
El control derivativo, a nivel industrial, no es muy utilizado por su dificultad de sintonizar, este se
fundamenta en prevenir el valor futuro que va a tener la señal de error recibida por el PID. La
predicción se realiza calculando la derivada del error constante en el instante de tiempo en estudio.
Para calcularlo, básicamente aproxima la curva de error a una recta tangencial al punto de estudio, que
se puede calcular por aproximación por series de Taylor.
𝑑𝑌 = 𝐾𝑑 ·𝑑𝑥
𝑑𝑡 [5]
3.6.1.6. Control proporcional-integral-derivativo (PID)
Aunque también se pueden utilizar controles PI y PD, estos no se han explicado, debido a que el
controlador utilizado en el proyecto se trataba de un controlador PID, el cual integra ambos.
El regulador PID se basa en los tres términos que operan sobre la señal de error para generar la señal
de control, que son el proporcional, integral y derivativo, siendo este probablemente el más utilizado.
En la ecuación 6, se pueden observar cómo se compone de la suma de las ecuaciones 5, 3 y 1.
𝑑𝑌 = 𝐾 · ∆𝑥 + 𝐾𝑖 · ∫ 𝑋𝑑 · 𝑑𝑡𝑡
0 + 𝐾𝑑 ·
𝑑𝑥
𝑑𝑡 [6]
Esta combinación, la acción proporcional estabiliza la oscilación de la variable controlada corrigiendo
el error proporcionalmente, la acción integral elimina el offset de la acción proporcional corrigiendo la
posición a una velocidad proporcional al error y la acción derivativa corrige la posición de la variable
manipulada en proporción a la tasa de cambio del error, de modo que después de que cambia la carga,
la variable controlada vuelve a su valor establecido lo antes posible, obteniendo entre los tres una
respuesta rápida.
Figura 18. Diagrama de bloques del controlador PID [13]
Construcción y programación del control de un brazo mecánico con STM32
33
3.6.2. Control para sistemas no lineales
Los no sistemas lineales, como indica su nombre, están formados por ecuaciones no lineales, que
pueden incluir por ejemplo ecuaciones diferenciales con coeficientes que son función de la variable
dependiente.
Estos son mucho más difíciles de controlar, pero con el avance de la tecnología se han hecho cada vez
más comunes debido al comportamiento no lineal de muchos CI. Aun así, es viable estabilizarlos,
aunque no se profundizará en la teoría, debido a que no es relevante al proyecto realizado.
Si la ecuación está formada de una parte, lineal y otra no lineal, si la no lineal no es significativa, esta
se puede obviar y tratar el sistema como lineal realizando una aproximación. Si no es el caso, se puede
realizar un control por ganancia tabulada, la cual consiste en la linealización del sistema alrededor de
un conjunto de puntos de equilibrio deseados, realizando un control lineal para cada punto y se realiza
una conmutación entre estos.
3.7. Base de programación de microcontroladores en C
El lenguaje de programación C de propósito general, esencialmente para sistemas operativos
(especialmente Unix). Aunque el lenguaje C también se puede utilizar para crear aplicaciones, el código
generado por el lenguaje C es muy eficiente y es el lenguaje de programación más popular utilizado
para crear software de sistema. Fue desarrollado originalmente por Dennis Ritchie en Bell Labs entre
1969 y 1972.
Este es un lenguaje de tipos de datos estáticos de nivel medio, el cual está débilmente tipado porque
tiene la estructura típica de un lenguaje de alto nivel, pero al mismo tiempo tiene una estructura de
lenguaje que permite el control a un nivel muy bajo. Los compiladores suelen proporcionar extensiones
al lenguaje, que pueden mezclar código ensamblador con código C o acceder directamente a la
memoria o periféricos.
Al empezar a utilizar C para programar microcontroladores, se ha de tratar la gestión de la memoria
con precaución. En lenguaje C, los programadores deben reservar y liberar memoria explícitamente.
En otros lenguajes (como C # o Java), la memoria se administra de forma transparente para el
programador. Esto reduce la carga de trabajo y evita errores, pero priva a la flexibilidad del lenguaje
de escribir controladores de hardware. Por lo tanto, para los principiantes, se deben adoptar buenas
prácticas al escribir y manejar la memoria en lenguaje C, como el uso extensivo de sangría y una
comprensión profunda de todo lo relacionado con el manejo de punteros y direcciones de memoria,
que son muy importantes.
Memoria
34
A continuación, se explicarán las variables y comandos para del lenguaje C; hay algunos caracteres
especiales que se utilizan con frecuencia. Estos personajes tienen una representación especial.
Código Significado Valor ASCII Valor ASCII
(decimal) (hexadecimal)
'\n' nueva línea 10 0x0A
'\r' retorno de carro 13 0x0D
'\f' nueva página (form feed) 2 x0C
'\t' tabulador horizontal 9 0x09
'\b' retroceso (backspace) 8 0x08
'\'' comilla simple 39 0x27
'\"' comillas 4 0x22
'\\ ' barra invertida 92 0x5C
'\? ' interrogación 63 0x3F
'\nnn' cualquier carácter (donde nnn es el código ASCII expresado en octal)
'\xnn' cualquier carácter (donde nn es el código ASCII expresado en hexadecimal) Tabla 2. Caracteres especiales de texto del lenguaje de programación C
Los tipos de datos definidos por C son los caracteres, números enteros y números en coma flotante.
Siendo los números enteros probablemente los más importante, los cuales permiten realizar las
operaciones aritméticas como la suma o la multiplicación, siendo este por lo tanto el tipo de dato por
defecto. Los números en coma flotante, utilizados para las calculadoras científicas, permiten operar
con decimales, aun así, no todos los microcontroladores tienen unidad de coma flotante, por lo que se
ha de tener en cuenta las propiedades de cada CI. Como se muestra en la tabla 3 los caracteres se
representan mediante char, los números enteros mediante short, int, long y los de coma flotante con
float y double. Las cuales podrán ser locales, actuando solo en dentro de la función, o globales
Variable Tipo bits Intervalo
char Carácter 8 -128 a 127
unsigned char Carácter sin signo 8 0 a 255
signed char Carácter con signo 8 -128 a 127
int Entero con signo 16 -32 768 a 32 767
unsigned int Entero sin signo 16 0 a 65535
signed int Entero con signo 16 igual que int
short int Entero con signo 8 -128 a 127
unsigned short int Entero sin signo 8 0 a 255
signed short int Entero con signo 8 igual que short int
long int Entero con signo 32 -2 147 483 648 a 2147 483 647
signed long int Entero con signo 32 -2 147 483 648 a 2 147 483 647
unsigned long int Entero sin signo 32 0 a 4 294 967 296
float Flotante simple 8 De 0 a 255
float Flotante doble
32 3.4E-38 a 3.4E+38
double 64 1.7E-308 a 1.7E+308
long double Flotante doble 128 3.4E-4932 a 3.4E+4932
(aprox. 24 dígitos de precisión)
bool Booleano 1 sin valor
void Generico funciones 0 sin valor Tabla 3. Tipo de variables, tamaño e intervalo en lenguaje C.
Construcción y programación del control de un brazo mecánico con STM32
35
Además, en el caso de la programación de microcontroladores, es muy útil el uso de punteros. El
puntero, como indica su nombre, apunta a variables o direcciones de almacenamiento de datos. Por
lo tanto, la variable puntera apunta al espacio físico donde se encuentran los datos o la variable. Al
poder este apuntar a cualquier tipo de estructura, objeto o función. Son extremadamente útiles para
referenciar y manipular estructuras de datos, bloques de memoria y realizar llamadas a funciones
pasándole parámetros.
Como se había comentado un puntero es una variable que almacena la dirección de memoria de otra
variable, esto es muy lógico, decimos que un puntero se declara igual que cualquier otra variable, pero
con un * (asterisco) antes del nombre de la variable.
Siendo la sintaxis: tipo * PointerName = NULL; configurándose en NULL para no asignar ninguna
dirección.
Donde tipo es el tipo de datos al que hará referencia este puntero, es decir, si necesita una dirección
de memoria para almacenar datos int, necesita un puntero de tipo int.
3.8. Base de programación de aplicaciones informáticas en C#
El lenguaje de programación "C#" es un lenguaje de programación multiparadigma desarrollado y
estandarizado por Microsoft como parte de su plataforma .NET, que luego fue aprobado como
estándar por ECMA (ECMA-334) e ISO (ISO/IEC 23270:2018) [14]. Durante el desarrollo de la
plataforma .NET, la biblioteca de clases se escribió originalmente utilizando un sistema de código
administrado llamado Simple Managed C (SMC). En abril de 1999, Anders Hejlsberg formó un equipo
cuya tarea era desarrollar un nuevo lenguaje orientado a objetos. El cual se cambiaria posteriormente
de nombre a C#.
Su sintaxis básica se deriva de C / C ++ y utiliza un modelo de objetos de plataforma .NET similar a Java,
aunque incluye mejoras derivadas de otros lenguajes. Siendo C # uno de los lenguajes de programación
diseñados para la infraestructura de lenguaje común.
Como se ha comentado, al ser un lenguaje desarrollado por Microsoft, se pueden encontrar guías muy
extensas, teniendo una Guía de C# en la plataforma Microsoft Ignite, en la cual se encuentra toda la
información necesaria para poder aprender a programar en este lenguaje. La guía en cuestión se trata
de la Documentación de C# [15].
A continuación, se explicarán los tipos de variables y comandos para del lenguaje C#; hay algunos
caracteres especiales que se utilizan con frecuencia. En primer lugar, se muestran en la tabla 5 los tipos
de datos enterios, mientras que en la tabla 4 se muestran los tipos de datos flotantes.
Memoria
36
Tipo de datos de enteros
Tipo Equivalencia Tamaño Rango Significado
byte System.Byte 8-bit (1-
byte) 0 a 255 Entero sin signo
sbyte System.SByte 8-bit (1-
byte) -128 a 127 Entero con signo
short System.Int16 16-bit (2-
byte) -32.768 a 32.767 Entero corto con signo
ushort System.UInt16 16-bit (2-
byte) 0 a 65.535 Entero corto sin signo
int System.Int32 32-bit (4-
byte) -2.147.483.648 a
2.147.483.647 Entero medio con signo
uint System.UInt32 32-bit (4-
byte) 0 a 4.294.967.295 Entero medio sin signo
long System.Int64 64-bit (8-
byte)
-9.223.372.036.854.775.808 a
9.223.372.036.854.775.807 Entero largo con signo
ulong System.UInt64 64-bit (8-
byte) 0 a
18.446.744.073.709.551.615 Entero largo sin signo
Tabla 4. Tipo de datos enteros en el lenguaje de programación C# [16]
Tipo de datos de coma flotante
Tipo Equivalencia Tamaño Rango Significado
float System.Single 32-bit (4-byte) ±1.401298E−45 a ±3.402823E+38 Coma flotante corto
double System.Double 64-bit (8-byte) ±4.94065645841246E−324 a
Coma flotante largo ±1.79769313486232E+308
decimal System.Decimal 128-bit (16-byte)
−7.9228162514264337593543950335 a Coma flotante monetario 79.228.162.514.264.300.000.000.000.000
Tabla 5. Tipo de datos flotantes en el lenguaje de programació C# [16]
Además, aparte de los caracteres numéricos, se puede trabajar con caracteres, booleanos, secuencias
de escape, así como de la declaración de funciones y variables locales y globales. Estas están
representadas en la tabla 6.
Tipo Equivalencia Tamaño Rango Significado
Tipo caracteres char System.Char 16-bit (2-byte) '\u0000' a '\uFFFF' Carácter unicode
Tipo lógicos bool System.Boolean 8-bit (1-byte) true o false Verdadero o falso
Tipo función void 0 0 0 Declaración función
Secuencias escape
\a 0 0 0 Alerta (timbre)
\b 0 0 0 Retroceso
\f 0 0 0 Avance de página
\n 0 0 0 Nueva línea
\r 0 0 0 Retorno de carro
\t 0 0 0 Tabulador horizontal
\v 0 0 0 Tabulador vertical
\0 0 0 0 Nulo
\' 0 0 0 Comilla simple
\" 0 0 0 Comilla doble
\\ 0 0 0 Barra inversa Tabla 6. Tipo caracteres, booleanos, secuancias de escape y funciones en el lenguaje de programación C#.
Construcción y programación del control de un brazo mecánico con STM32
37
3.9. Protocolos de comunicación inalámbricos
En la actualidad existen distintos protocolos de comunicación, muchos de ellos se realizan mediante
cable, aun así, estos no se expondrán debido a que el objetivo del trabajo es realizar una comunicación
inalámbrica entre el dispositivo móvil de control y el brazo robótico. A continuación, se exponen los
distintos tipos de comunicaciones inalámbricas más utilizadas en la actualidad.
3.9.1. Bluetooth
Bluetooth es un estándar que permite desplegar redes de área personal inalámbricas (PAN). En otras
palabras, conectar de forma inalámbrica varios dispositivos dentro de un rango cercano. El estándar
nació en Ericsson a mediados de la década de 1990 y ahora se ha establecido como una de las
conexiones universales entre dispositivos móviles y PC. Desde su aprobación, ha facilitado la conexión
y el intercambio de datos de varios dispositivos periféricos. Como el estándar IEEE 802.15 en 2002.
Hoy en día, se ha normalizado el uso de los teclados Bluetooth para computadoras personales y
tabletas, dispositivos manos libres para teléfonos inteligentes e incluso dispositivos GPS externos (que
fueron ampliamente utilizados en la edad de oro de las PDA hace unos años). Sin embargo, se ha
incrementado la tasa de transferencia de datos (hemos pasado de 1 Mbps a 24 Mbps) en el Bluetooth,
este tipo de conexiones perjudican gravemente la autonomía de los terminales. De hecho, esto puede
agotar la Batería del smartphone.
Por ello en el 2001 se imaginó futuro de los hogares como un entorno inteligente lleno de sensores
que pudieran enviar información de forma inalámbrica a los dispositivos móviles personales o sistemas
de control instalados en la casa. Esta idea fue propuesta por Nokia y también forma parte del proyecto
MIMOSA del sexto plan MARCO de la UE. Antes del proyecto MIMOSA, Nokia desarrolló la primera
versión, la llamada extensión Bluetooth Low End Extension, que se convirtió a Wibree después del
proyecto de investigación europeo. Los resultados de desarrollo de Wibree se integraron en la
especificación de baja energía de Bluetooth en 2007, y Bluetooth LE se integró en la pila de protocolos
Bluetooth 4.0 en 2010.
La base de Bluetooth LE es reducir el consumo, por lo tanto, minimizar la potencia de transmisión y el
radio de cobertura de la señal de radio utilizada. Bajo estas premisas, con una velocidad de conexión
de 1 Mbps, utilizando conexiones encriptadas AES de 128 bits y códigos redundantes para minimizar
la transmisión de errores. No considerando la reducción de alcance importante debido a que si se
desea utilizar un dispositivo manos libres que se encuentra a tan solo 20 cm del terminal, no tiene
sentido en muchos casos irradiar una señal de potencia de 100 mW (Bluetooth Tipo 1, distancia
Memoria
38
superior a 30 metros). Y si la transmisión de datos no es continua, no necesitamos establecer una
conexión continua y persistente.
Entre las oportunidades que brinda esta tecnología, una de sus mayores ventajas radica en su
aceptación y compatibilidad con las grandes plataformas actuales (como IO, Android, Microsoft o
Linux, etc.). Cabe mencionar que también tiene algunas otras características básicas, como la
interoperabilidad con los fabricantes de chipsets, tamaño pequeño, requisitos de consumo de energía
muy bajos y rango de comunicación aceptable.
3.9.2. WIFI
WiFi proviene de "Wireless Fidelity", es decir, "fidelidad inalámbrica". Es una tecnología de transmisión
de datos inalámbrica que se utiliza principalmente en Internet y se basa en el estándar IEEE 802.11
(Instituto de Ingenieros Eléctricos y Electrónicos).
El WiFi se basa en ondas de radio, pero esta tecnología de conexión inalámbrica utiliza diferentes
frecuencias, especialmente 2.4 GHz (el estándar 802.11n más alto) y 5 GHz (802.11 ac). Actualmente,
aunque 5 GHz proporciona un excelente rendimiento, se utilizan dos frecuencias al mismo tiempo.
Además, en los dispositivos de mayor rendimiento, también se combinan la transmisión de datos en
las dos bandas de frecuencia. Pero hay distintos tipos de WIFI, siendo los estándares más importantes
los siguientes:
- IEEE 802.11 a. Ancho de banda de trabajo de 5GHz y 52 subportadoras de multiplexación por
división de frecuencias otorgadas (Orthogonal Frequency-Division Multiplexing, OFDM) con
una velocidad máxima de 54 Mbit/s, lo que lo hace un estándar práctico para redes
inalámbricas con velocidades reales de aproximadamente 20 Mbit/s. La velocidad de datos se
reduce a 48, 36, 24, 18, 12, 9 o 6 Mbit/s en caso necesario. Tiene un alcance de 20 km con
radios especiales.
- IEEE 802.11 b. Ancho de banda de trabajo de 2.3 GHz, velocidad máxima de transmisión con
este estándar es de aproximadamente 5,9 Mbit/s sobre TCP y 7,1 Mbit/s sobre UDP.
- IEEE 802.11 g. Ancho de banda de 2,4GHz, igualaba en lo que a la velocidad de transmisión
máxima teórica se refiere de 54 Mbit/seg al estándar IEE 802.11a, y mejoraba bastante la
cobertura en interiores y exteriores con respecto al estándar IEE 802.11b.
- IEEE 802.11 n. También conocido como WiFi4, gracias a la realización de la red MIMO en el
estándar WiFi, marcando un antes y después de la conexión inalámbrica. Si bien estas antenas
existen en dispositivos que utilizan el estándar IEEE 802.11g, lo cierto es que por las ventajas
de esta tecnología se pueden estandarizar. Además de ser compatible con estándares
Construcción y programación del control de un brazo mecánico con STM32
39
anteriores, la tecnología también alcanza un rango de 150 a 600 velocidad de transferencia.
Además, la cobertura interior y exterior alcanza los 120 metros y 300 metros respectivamente.
- IEEE 802.11 ac. También conocido como WiFi 5 o Gigabit WiFi, es una mejora del estándar IEEE
802.11n aprobada en 2014. El estándar puede lograr una transmisión de alta velocidad de
hasta 1,3 Gbit / s puediendo utilizar hasta cuatro antenas.
- IEEE 802.11 ah. Esta revisión también se conoce como HaLow y mejora el WiFi al trabajar en
el espectro de frecuencia por debajo de 1 GHz para proporcionar un mayor alcance y un menor
consumo de energía. Ideales para dispositivos IoT, que requieren un gran alcance, pero no una
velocidad inalámbrica muy alta.
- IEEE 802.11 ax. También conocido como WiFi 6, está diseñado para espectro de 2,4 y 5 GHz.
Además de utilizar MIMO y MU-MIMO, este nuevo estándar también introduce OFDMA para
mejorar la eficiencia del espectro global y proporcionar un mayor rendimiento. Es compatible
con los protocolos antes mencionados y teóricamente proporciona una velocidad máxima de
10 Gbps.
3.10. Plataformas de diseño de APP
En la última década, con la aparición del SmartPhone, se han multiplicado exponencialmente las tareas
que se pueden realizar desde una APP, apareciendo en el mercado infinidad de plataformas que
facilitan y permiten el diseño de APP. Por ello, no se pueden estudiar todas ellas en este apartado. Aun
así, se ha querido incluir una selección de plataformas que facilitan el desarrollo de APP y son
ampliamente utilizadas por los usuarios y desarrolladores en la actualidad.
3.10.1. Android Studio
Android Studio es un entorno de desarrollo integrado para la plataforma Android. Se anunció en la
conferencia Google I / O el 16 de mayo de 2013 reemplazando a Eclipse como el IDE (entorno de
desarrollo integrado) oficial para el desarrollo de aplicaciones de Android.
La plataforma integra un sistema de compilación flexible basado en Gradle, con función de
autocompletado, simulador funcional rápido y de carga, un entorno unificado en el que se puede
desarrollar para todos los dispositivos Android, y cambia la aplicación para insertar cambios de código
y recursos en la aplicación en ejecución. El programa no necesita reiniciar la aplicación, la integración
con GitHub y las plantillas de código pueden ayudarlo a compilar funciones comunes de la aplicación e
importar código de muestra, varios marcos y herramientas de prueba, herramientas Lint para
identificar problemas de rendimiento, usabilidad y compatibilidad. Versiones, incluidas y la
Memoria
40
compatibilidad con C ++ y NDK además de la compatibilidad integrada para Google Cloud Platform, que
ayuda a integrarse con Google Cloud Messaging y App Engine.
Figura 19. Ventana principal de Android Studio. 1. Barra de herramientas; 2. Barra de navegación; 3. Ventana del editor; 4. Barra de la ventana de herramientas; 5. Ventana de herramientas; 6. Barra de estado. [17]
3.10.2. XCode
Xcode es el entorno de desarrollo integrado (IDE) de Apple. Utiliza Xcode para crear aplicaciones para
productos de Apple (incluidos iPads, iPhone, Apple Watch, Apple TV y Mac). Xcode proporciona
herramientas para administrar todo el proceso de desarrollo, desde la creación de aplicaciones hasta
las pruebas, la optimización y el envío a la App Store.
El proyecto mantiene los archivos y recursos necesarios para organizar el desarrollo de la aplicación en
orden. Para crear un proyecto, se puede comenzar con una de las plantillas y modificarla según sea
necesario. Las plantillas son adecuadas para todas las plataformas (iOS, watchOS, tvOS y macOS) y tipos
comunes de aplicaciones, marcos y bibliotecas. Cada plantilla está preconfigurada con la configuración
predeterminada y se puede construir y ejecutar. Para ver una vista previa interactiva al diseñar la
Construcción y programación del control de un brazo mecánico con STM32
41
interfaz y editar el código, se ha de seleccionar Swift como lenguaje de programación y SwiftUI como
interfaz de usuario.
Una vez creado el proyecto, se mostrará la ventana principal. Esta ventana es la interfaz principal para
ver, editar y administrar todas las partes del proyecto. Es flexible y configurable, se adapta a las
necesidades de la tarea en cuestión y te permite configurarlo para que se adapte a tu estilo de trabajo.
Figura 20. Ventana principal XCode [18]
3.10.3. Unity
Unity es un motor de videojuegos multiplataforma creado por Unity Technologies. Unity se puede
utilizar como plataforma de desarrollo en Microsoft Windows, Mac OS y Linux. La plataforma de
desarrollo tiene soporte de compilación para diferentes tipos de plataformas y lenguajes de
programación. Además, permite crear juegos 2D y 3D, además de aplicaciones y experiencias.
En la web oficial de Unity, se puede encontrar un manual “Manual de Unity” [19] que explica con
detalle el funcionamiento y componentes que lo conforman.
Memoria
42
3.11. Localización espacial y cinemática del brazo robótico
En este apartado se pretende brindar las bases necesarias para que el robot pueda realizar las tareas
que le son encomendadas, necesitando por lo tanto de un conocimiento de la posición y la orientación
respecto a la base del brazo robótico.
En primer lugar, se expondrán en apartados distintos la representación de la posición y de la
orientación del brazo. Además, se expondrán herramientas matemáticas para el cálculo de estas en los
apartados contiguos.
3.11.1. Sistema cartesiano. Representación de la posición y orientación.
En primer lugar, se ha de fijar el sistema de coordenadas que servirá como referencia para fijar la
posición del brazo robótico. Para ello, es necesario conocer tanto la posición como la orientación de
las diferentes piezas.
El sistema cartesiano de referencia se fundamenta en ejes o planos perpendiculares entre sí con un
origen en común. En un espacio tridimensional, el sistema cartesiano se compone de los valores OXYZ,
individualmente definidos como OX, OY y OZ, figura X. Por lo que, una coordenada vendrá referenciada
respecto a este sistema mediante las coordenadas correspondientes a cada uno de los ejes
coordenados (x, y, z).
Figura 21. Representación de un vector en coordenadas cartesianas en 3 dimensiones. [20]
Además, para la orientación, se trabaja con matrices de rotación. Estas, en un espacio tridimensional,
se nombra al sistema OUVW, coincidentes en el origen, siendo el sistema OXYZ el sistema de referencia
Construcción y programación del control de un brazo mecánico con STM32
43
fijo, y el primero el que define la orientación del objeto. Fijando unos vectores unitarios fijos 𝑖𝑥 , 𝑗𝑦, 𝑘𝑧
para el sistema OXYZ y 𝑖𝑢, 𝑗𝑣 , 𝑘𝑤 para el sistema OUVW.
Figura 22.Sistema de referencia OXYZ y solidario al objeto OUVW. [20]
La composición de las rotaciones se puede obtener de la multiplicación de las matrices de las tres
variables, siendo estas las mostradas en la ecuación 7.
𝑇 = 𝑅𝑜𝑡𝑥(𝛼) · 𝑅𝑜𝑡𝑦(𝜙) · 𝑅𝑜𝑡𝑧(𝜃) = [1 0 00 𝐶𝛼 −𝑆𝛼0 𝑆𝛼 𝐶𝛼
] · [ 𝐶𝜙 0 𝑆𝜙0 1 0
−𝑆𝜙 0 𝐶𝜙] · [
𝐶𝜃 −𝑆𝜃 0𝑆𝜃 𝐶𝜃 00 0 1
] [7]
3.11.2. Matrices de transformada homogénea
En los dos apartados anteriores se ha mostrado como representar la posición y la orientación, pero
falta mostrar ambas unidas. Para ello, se pueden utilizar los matrices de transformación homogénea,
las cuales permiten su uso mediante álgebra matricial.
Para representar un vector p(x, y, z) se representará un una dimensión extra (n+1) siendo representado
por p(wx, wy, wz, w), donde el valor de w es aleatorio y representa un factor de escala. Siendo
representados mediante las coordenadas homogéneas mediante el vector columna:
𝑝 = [
𝑥𝑦𝑧𝑤
] = [
𝑎𝑤𝑏𝑤𝑐𝑤𝑤
] = [
𝑎𝑏𝑐1
] [8]
A partir de esta, surge la matriz de transformación homogénea T, la cual es una matriz de dimensión 4
X 4 que permite la cual permite transformar el sistema de coordenadas de un sistema a otro.
𝑇 = [𝑅3𝑥3 𝑝3𝑥1
𝑓1𝑥3 𝑤1𝑥1] = [
𝑅𝑜𝑡𝑎𝑐𝑖ó𝑛 𝑇𝑟𝑎𝑠𝑙𝑎𝑐𝑖ó𝑛𝑃𝑒𝑟𝑠𝑝𝑒𝑐𝑡𝑖𝑣𝑎 𝐸𝑠𝑐𝑎𝑙𝑎𝑑𝑜
] [9]
Memoria
44
En la ecuación X, se muestra como la matriz de transformación es una matriz homogénea compuesta
por cuatro submatrices de distinto tamaño. Además, al ser una matriz 4 X 4, esta deberá ser aplicada
sobre vectores de 4 dimensiones, que corresponderán a las coordenadas homogéneas del vector
tridimensional.
3.11.3. Cinemática del Robot
La cinemática es la ciencia que estudia el movimiento respecto al sistema de referencia sin considerar
las fuerzas que intervienen. En particular, en las relaciones entre la posición y orientación del extremo
final del robot.
Existen básicamente dos tipos de problemas a estudiar, la cinemática directa y la cinemática inversa.
3.11.3.1. Directa
La cinemática directa consiste en conocer la posición y orientación del elemento terminal del brazo
robótico conociendo la posición y orientación de cada una de sus articulaciones.
Para ello, se puede abordar de dos maneras diferentes, mediante un enfoque mediante métodos
geométricos y otro enfoque mediante métodos basados en sistemas de referencia.
Cuando solo se trabaja con unos pocos grados de libertad, hasta 3 grados, realizar los cálculos por
métodos geométricos es relativamente sencillo. Pero al augmentar el número de grados de libertad
los cálculos se complican, debido a que no son sistemáticos. Por ello, al haber mayores grados de
libertad se utiliza el método por cambio de sistema de referencia.
El caso del proyecto, por lo tanto, es necesario abordarlo mediante el método de matrices de
transformación homogéneas. Que será el que se explicará a continuación.
El método de matrices de transformación homogénea se fundamenta en el álgebra vectorial y matricial
para poder representar y describir la localización, en este caso del elemento terminal, en el espacio
tridimensional en referencia al sistema fijo.
Para ello, se considera la estructura del robot somo eslabones o elementos fijos, unidos entre sí
mediante articulaciones, situándose generalmente el sistema de referencia fijo en el la base del motor,
sobre la cual se describe la posición de cada uno de los eslabones. Por lo que, para resolver el problema
de la cinemática directa solo es necesario encontrar la matriz de transformación homogénea del
sistema. El procedimiento para hallar la matriz se explica detalladamente en el apartado 7.3, utilizando
como ejemplo la estructura utilizada en el proyecto.
Construcción y programación del control de un brazo mecánico con STM32
45
3.11.3.2. Inversa
La cinemática inversa pretende encontrar los valores para cada eslabón y articulación para posicionar
el elemento terminal del robot en la posición y orientación deseada en el sistema de coordenadas.
El principal problema que presenta es que, a diferencia de la cinemática directa, no existe un método
sistemático independiente a la configuración del motor, en este caso, las ecuaciones dependen de la
configuración del robot.
Aun así, se han desarrollado diversos procedimientos, de modo a poder ser resueltos mediante
computadora conociendo la cinemática del robot. Para ello, se utiliza el modelo de parámetros de
Denavit-Hartenberg. El procedimiento para hallar los parámetros se explica detalladamente en el
apartado 7.3, utilizando como ejemplo la estructura utilizada en el proyecto.
Memoria
46
4. Especificaciones básicas
En el siguiente apartado se plantean las posibles soluciones al proyecto propuesto. En estas soluciones
se tienen en consideración los beneficios y hándicaps, así como de la inversión económica que
requieren.
4.1. Posibles soluciones
En este apartado se plantean las diferentes soluciones para el proyecto como las características de
estas, además se incluyen diferentes variantes que surgieron durante el desarrollo del proyecto,
provocadas por impedimentos o contratiempos originados por los recursos disponibles a causa de la
pandemia del CoVid-19.
4.1.1. Estructura metálica
Por lo que respecta a la estructura, la solución que inicialmente se planteó fue una estructura metálica
de bajo coste de dimensiones reducidas como la de la figura 23.
Figura 23. Ejemplo de brazo robótico metálico de bajo coste, con 6 grados de libertad y servomotores acoplados [21]
Estas estructuras elaboradas de aleaciones de metal aportan la sujeción necesaria para los motores a
la estructura, además de la rigidez que requiere el sistema para poder asegurar una repetibilidad y una
precisión de posicionamiento en el sistema.
Construcción y programación del control de un brazo mecánico con STM32
47
El principal problema que presentaba era el anclaje de los motores en la estructura, debido a que estas
estaban diseñadas únicamente para servomotores, por lo que requerirían de modificaciones para
poder utilizar cualquier otro tipo de motor.
Lo que se planteó para solventar el problema con motores de continua, fue la utilización de
acoplamientos de brida rígida, figura 24, entre los motores y la estructura.
Figura 24. Acoplamiento de brida rígida con los tornillos de sujeción [22]
4.1.2. Estructura plástica mediante impresora 3D
Esta opción no fue la inicialmente propuesta, debido a que una estructura de plástico suele ser más
flexible que el metal, aunque esta propiedad puede ser muy beneficiosa en muchas aplicaciones, en
robótica plantea un serio problema al no asegurar la posición real del elemento terminal debido a la
deformación de las piezas. Aun así, filamentos compuestos por polímeros de alto rendimiento como el
PEEK pueden presentar las características aptas para el proyecto, pero presentan la problemática de
requerir una gran inversión económica en una impresora apta para poder procesarlos debido a las
elevadas temperaturas que necesitan en la extrusión, cuyo coste era demasiado elevado, por lo que
esta opción tuvo que ser eliminada por el coste económico.
4.1.3. Accionamiento mediante servomotores
Los servomotores son ampliamente utilizados en el mundo de la robótica, sobre todo cuando se
necesita un coste bajo y no se requiera de un par motor elevado. Por lo que, aunque presentaba la
enorme ventaja de la sencillez con la que se puede controlar su posicionamiento. Pero, presentan la
principal desventaja de trabajar en lazo abierto, por lo que no se puede obtener un feedback real del
movimiento y posición del servomotor.
Memoria
48
4.1.4. Accionamiento mediante motores DC
Los motores DC, por otro lado, pueden ejercer un elevado par motor, pero necesitan de un encoder
para el control de su posición, ya que estos por sí solos no son capaces de controlarla y el coste de
estos suele ser más elevado que el de los servomotores. Aun así, mediante un encoder, se puede
trabajar en lazo cerrado con ellos, pudiendo controlar realmente el posicionamiento de estos en el
sistema angular.
4.1.5. Placa de desarrollo
En el mercado existen diversas placas de desarrollo que permiten realizar con mayor facilidad las
conexiones con el microcontrolador ya que disponen de pines conectados a las entradas y salidas de
este. El punto más crítico que nos encontremos en las placas de desarrollo es en la disponibilidad de
temporizadores. Las opciones que se plantearon fueron las siguientes:
STM32 Núcleo 64 (STM32F446RE) [23]: La placa de desarrollo cuenta con 76 pines, dispone de 7
temporizadores de los cuales sólo 3 son aptos para utilizar en modo encoder. Además, el núcleo
dispone de una arquitectura ARM, con un Cortex-M4 de 32 bits.
STM32F4DISCOVERY (STM32F407VG) [24]: La placa de desarrollo cuenta con 100 pines, dispone de
14 temporizadores de los cuales 12 son aptos para utilizar el modo encoder. Además, el núcleo dispone
de una arquitectura ARM, con un Cortex-M4 de 32 bits
4.2. Solución adoptada
4.2.1. Estructura
En un primer lugar se decidió utilizar una estructura metálica debido a las prestaciones más aptas y el
reducido coste económico que presentaba. La estructura escogida fue un brazo robótico de seis ejes
de libertad, el modelo que se encargó se encuentra en la referencia [25].
Desafortunadamente, al realizar el pedido no fue posible su obtención debido a su importación desde
China, la cual se encontraba en festividad, el año nuevo chino, y posteriormente parada
económicamente debido a la crisis causado por la pandemia del CoVid-19, lo que provocó que no
pudiéramos obtener la estructura.
Por ello, se utilizó la segunda alternativa más viable y se planteó la opción anteriormente descrita de
imprimir una estructura mediante una impresora 3D utilizando filamento de PLA. Esto, planteaba una
segunda problemática, y era la elección o desarrollo de la estructura. Como el estudio mecánico de la
Construcción y programación del control de un brazo mecánico con STM32
49
estructura no era el objetivo original del proyecto se buscó la alternativa de utilizar un brazo mecánico
de código abierto diseñado para impresora 3D en Autodesk Fusion 360 por 泰史 田中 (Yasushi Tanaka)
[25] que se observa en la figura 7. El cual aun siendo de siete grados de libertad, al estar compuesto
por secciones modulares permitía poder adaptarlo a los grados de libertad deseados.
Figura 25. Imagen del diseño elaborado por Yasushi Tanaka [25]
Este modelo de siete ejes de libertad permitió, después de las modificaciones necesarias, obtener una
estructura viable sobre la que realizar el proyecto, pudiendo acoplar los motores sobre los que se
realizaría la lógica de control para el control de su posicionamiento.
Finalmente, el material del filamento escogido para la impresión 3D fue el PLA, por la facilidad de
impresión que presentaba, debido a que no se había trabajado con anterioridad en la impresión 3D, y
a sus propiedades siendo resistente y además biodegradable.
La impresora FDM 3D que se utilizó para la impresión fue la Predator de Anycubic [26], debido a que
su tamaño permitía elaborar piezas de dimensiones considerables y a la calidad de extrusión que
presentaba con un presupuesto reducido.
Memoria
50
Figura 26. Impresora 3D Predator de tecnología FDM de Anycubic.[26]
4.2.2. Motores y encoder
Por lo que respecta a los motores, delante la necesidad de un par motor importante, se decidió utilizar
motores de continua con encoder. Estos motores, aunque resultaban más complicados de controlar la
posición que los servomotores o los motores paso a paso, tenían unas mejores características en el
torque que podían ejercer y con el encoder se solventaba la problemática que presentaban en su
control de posición.
Los encoder se decidió por la opción de encoder de cuadratura incrementales, estos encoder son
mucho más económicos que los encoder absolutos normalmente utilizados en robots industriales
profesionales y solo presentaban la problemática de que al iniciarse empiezan desde el cero, está
problemática se decidió atacarla por software controlando la posición del motor en la parada, para
poder iniciar desde una posición conocida y así abaratar los costes significativamente.
4.2.3. Placa de desarrollo
En la elección de la placa de desarrollo priorizó que esta fuera de la gama de STM32, debido a que se
tenía experiencia previa trabajando con el software de la casa para su programación.
Debido a las características necesarias, era imperativo que el microprocesador tuviera el mayor
número de temporizadores posible y que este microprocesador se encontrada integrado en una placa
de desarrollo con el objetivo de poder realizar cambios y pruebas con agilidad. Por todo ello se eligió
la placa de desarrollo STM32F4DISCOVERY, la cual con 12 temporizadores con el modo encoder es la
placa de desarrollo con más temporizadores de la gama STM32F4.
Construcción y programación del control de un brazo mecánico con STM32
51
5. Diseño mecánico del brazo robótico
El diseño mecánico del brazo robótico se ha obtenido de un proyecto en código libre “Open-Source
Robot Arm (Prototype 01)” realizado por 泰史 田中 (Yasushi Tanaka) en 2017 [25].
Este proyecto estaba diseñado para poder ser impreso mediante una impresora 3D. Por lo que fue
adaptado a las características de las demás piezas seleccionadas que formarían la estructura, las cuales
se describirán a continuación.
5.1. Componentes que conforman de brazo robótico
El brazo robótico está compuesto por la estructura plástica que da forma al brazo y los motores que
permiten mover estas piezas según los ejes.
La estructura del brazo robótico, como se ha comentado con anterioridad, se ha obtenido del proyecto
de código libre de 泰史 田中 (Yasushi Tanaka), aun así, algunas las piezas han necesitado de
modificaciones para adaptar las sujeciones de los motores, los dientes y diámetros de los engranajes
de transmisión de los motores, así como del número de secciones del brazo para adaptarlo a los grados
de libertad del proyecto.
Y en el caso de los motores, estos se describen a continuación, el modelo y características del modelo
utilizado, como de sus especificaciones más importantes
5.1.1. Estructura
Las estructuras de los brazos robóticos suelen conformarse por las articulaciones y el elemento
terminal. Las articulaciones permiten al robot moverse en una nueva dirección, lo que le otorga al
menos un grado de libertad. Y el elemento terminal, son la herramienta colocada al final del brazo que
es capaz de realizar un tipo de tarea.
En el diseño la estructura el brazo robótico se conforma por tres diseños distinto de articulaciones,
todas ellas rotatorias, que son la base, y otras dos articulaciones distintas, que se referirán como
articulaciones 1 y 2, las cuales se pueden ir intercalando para obtener más grados de libertad. A
continuación, se describen las diferentes partes que conforman el brazo, así como de las
modificaciones que se le han realizado para la adaptación al proyecto.
Memoria
52
5.1.1.1. Parte 1. Base
La primera parte y articulación que conforman el diseño utilizado en el proyecto es la que realiza la
función de base de toda la estructura. La pieza se puede observar en la figura 27 desde una vista
superior, frontal y lateral. Los planos de la pieza se encuentran en el Anexo 1.
Esta pieza está formada por una base rectangular con los bordes redondeados sobre la que se ha
colocado la primera articulación, la sujeción de su motor y los soportes para los engranajes que realizan
la transmisión desde la rotación del motor hasta la rotación en el plano transversal a la superficie sobre
la que se coloque la base, el cual se considerará que corresponde al plano comprendido entre los ejes
de abscisas en el plano OXY. El movimiento del motor se realiza con tres engranajes, los cuales no han
sido modificados del diseño original, con una relación de transmisión de 2 que mueven una pieza
circular que hará de base para la siguiente articulación.
Figura 27. Base del brazo mecánico y primera sección del diseño. imágenes del diseño capturadas mediante Autodesk 360 Fusion. Vista desde 1. Superior, 2. Frontal, 3. Lateral.
Además, la sección se ha diseñado con una sujeción para el motor DC en la parte trasera de la pieza,
desde donde se realiza la transmisión de movimiento mediante los engranajes. Para la utilización de
los motores seleccionados, se tuvo que modificar la pieza de sujeción para ensanchar la cavidad del
motor y así adaptarla a los componentes seleccionados.
5.1.1.2. Parte 2. Articulación 1
El segundo segmento del brazo robótico está formado por una base circular que se coloca sobre la
pieza rotativa de la base. Dos sujeciones perpendiculares a la base del segundo segmento aguantan la
pieza móvil de la articulación. La pieza móvil de la articulación se mueve, considerando que la pieza de
Construcción y programación del control de un brazo mecánico con STM32
53
la base se encuentra en el plano OXY de abscisas, en el plano OZX o en el plano perpendicular al plano
de la pieza de la base o de la pieza sobre la que está. El motor está colocado en una sujeción
horizontalmente y transmite el movimiento a la pieza móvil mediante dos engranajes con una relación
de 1,8.
Esta pieza se encuentra colocada sobre la base, pero también se puede colocar sobre la Articulación 2,
pudiendo intercalar estas dos articulaciones para modular el número de grados de libertad deseados.
La pieza se puede observar en la figura 28 desde una vista superior, frontal y lateral. Los planos de la
pieza se encuentran en el Anexo 1.
Figura 28. Muñeca o segunda sección del diseño. imágenes del diseño capturadas mediante Autodesk 360 Fusion. Vista desde 1. Superior, 2. Frontal, 3. Lateral.
Para la utilización de esta sección, se realizaron diversas modificaciones. En primer lugar, en la sujeción
del motor se modificó tanto el diámetro de la cavidad del motor, como del de la salida del eje del
motor, para poder incluir acoplamientos de brida entre el eje del motor y el engranaje de transmisión.
Con esto se pretendía evitar el juego entre el eje y el engranaje, así como del desgaste del engranaje,
debido a que con el material utilizado esta tenía una cierta compresibilidad y mostraba problemas
como se explicará más adelante.
El motivo de realizar el cambio en el diámetro de los engranajes surgió en un inicio para reducir el
momento de fuerzas que recibía el motor procedente del peso de las diferentes piezas, el cual cedía
ante el peso si no se estaba actuando sobre él. Finalmente, este problema se solventó por software
como se explicará, pero se tuvieron que modificar igualmente debido a que por el material plástico con
el que estaban realizados los dientes de los engranajes patinaban por lo que se augmentó el tamaño
del engranaje pequeño, el acoplado al motor, para augmentar el área de contacto entre los dos
engranajes y así evitar el deslizamiento.
Memoria
54
Además, se cambió el diámetro y número de dientes de ambos engranajes. Se agranda el engranaje
de transmisión y se reduce el engranaje receptor. Aunque esto empeoraba el momento de fuerzas
proporcionado por el motor a la estructura, así como empeoraba el momento que fuerzas que recibía
el motor del peso de la estructura, fue necesario para evitar el deslizamiento entre ambos engranajes.
El cual, nuevamente por el material, tenía un reducido coeficiente de fricción, y junto a la flexibilidad
del material, provocaba graves errores de desplazamiento. Además, este deslizamiento se veía
empeorado al tener toda la estructura montada, dependiendo de la posición de las secciones
superiores, la flexibilidad del material de los soportes del engranaje receptor y la pieza móvil, los
soportes en rojo en la figura 10, provocaba el distanciamiento de ambos engranajes, impidiendo por
lo tanto la transmisión de movimiento. Por ello, se exageró notablemente el tamaño de los dientes,
aun del augmento de tensión percibida por estos, y el riesgo de rotura.
5.1.1.3. Parte 3. Articulación 2
El tercer segmento del brazo robótico está formado por una base cilíndrica alargada y hueca en la cual
se encuentra integrada la sujeción del motor. Esta base se puede acoplar a la pieza móvil de la
Articulación 2. La pieza móvil de la articulación se coloca con un eje en el interior del cilindro de base,
en esta pieza también se encuentra acoplado un engranaje interno que mediante la transmisión del
engranaje movido por el motor mueve la pieza móvil que es básicamente plataforma cilíndrica donde
se puede acoplar la siguiente articulación, en la cual se puede encajar una Articulación 2.
La pieza se puede observar en la figura 29 desde una vista superior, frontal y lateral. Los planos de la
pieza se encuentran en el Anexo 1.
Figura 29. Brazo o tercera sección del diseño. imágenes del diseño capturadas mediante Autodesk 360 Fusion. Vista desde 1.
Superior, 2. Frontal, 3. Lateral.
En esta estructura se tuvo que modificar la pieza principal para poderla adaptar a las dimensiones del
motor. Además, se modificó el engranaje externo, añadiéndole un tope, para que el engranaje interno,
Construcción y programación del control de un brazo mecánico con STM32
55
el cual estaba diseñado sin sujeción, no se desplazara, provocando errores en la transmisión de
movimiento. Y, después de las modificaciones realizadas la relación de transmisión de los engranajes
de la tercera sección era de 1,12.
5.1.1.4. Modificaciones realizadas de la estructura original
A continuación, se muestran las modificaciones en la estructura realizadas.
- Sujeción del motor de la base:
En el diseño, se habían utilizado otros motores, por lo que fue necesario adaptar el diámetro de la
pieza encargada de realizar la sujeción del motor.
Figura 30. Pieza de la sujeción del motor de la base modificada.
- Sujeción del motor de la sección 2:
Igual que en la base, se tuvo que adaptar el diámetro de la sujeción en la sección 2, además se
amplió el orificio de salida del eje para permitir la colocación de la brida.
Figura 31.Pieza de la sujeción del motor de la segunda sección modificada
Memoria
56
- Sujeción del motor de la sección 3:
Para poder acoplar los motores seleccionados con la brida acoplada, fue necesario modificar la
pieza principal de la sección 3. En esta, fue necesario desplazar la sujeción del motor hacia el centro
de la pieza, así como redondear parte de la base, para poder posicionar el motor verticalmente sin
que este rozara con la base de la pieza.
Figura 32. Pieza principal y encargada de la sujeción del motor de la sección 3 modificada.
- Engranajes de la sección 2:
En la sección 2 se modificó el número y paso de los dientes de los engranajes, además en el
engranaje transmisor se incluyó un tope para evitar que el engranaje receptor se desplazara de su
posición. Finalmente, se ensancho la entrada del eje del motor para poder acoplar la brida, y se
realizaron dos orificios con ejes perpendiculares entre ellos para poder introducir los tornillos que
anclaban la brida con el eje motor y el propio engranaje.
Figura 33. Engranaje transmisor y receptor de la segunda sección modificadios.
Construcción y programación del control de un brazo mecánico con STM32
57
- Engranajes de la sección 3:
En la sección 3 se modificó el número y paso de los dientes de los engranajes, además en el
engranaje transmisor se incluyó un tope para evitar que el engranaje interior, el cual iba sin
sujeción, se desplazara de su posición. Finalmente, se ensancho la entrada del eje del motor para
poder acoplar la brida, y se realizaron dos orificios con ejes perpendiculares entre ellos para poder
introducir los tornillos que anclaban la brida con el eje motor y el propio engranaje. Además, en el
engranaje interno, se modificó el número y paso de los dientes de igual manera.
Figura 34. Engranaje externo (transmisor) e interno (receptor) de la tercera sección modificados. Recuadrado en azul los orificios para los tornillos.
- Plataforma de la sección 3 (para la sujeción de la pinza):
Para poder acoplar la pinza de diseño una plataforma rectangular adaptada a esta, la cual
permitiera unir la pinza con la estructura.
Figura 35. Plataforma de sujeción de la pinza, elemento terminal.
5.1.1.5. Elemento terminal
El elemento terminal seleccionado es una pinza neumática, para su utilización se acoplo un sistema
neumático para el correcto accionamiento de la pinza.
Memoria
58
La pinza utilizada se trata del modelo PWG-S 60 del fabricante SCHUNK que es una pinza angular
metálica de dos dedos. La pinza puede trabajar en un rango de 4 bar a 8 bar, y tiene un peso de 620 g.
Los datos técnicos de la pinza se pueden encontrar en el Anexo 4.
Figura 36. Pinza neumática, modelo PWG-S 60 de SCHUNK [27]
Para el funcionamiento se ha diseñado un sistema neumático formado por un compresor de aire y una
electroválvula de doble efecto de 5/3 canales.
5.1.2. Motores
Como se había comentado, se decidió trabajar con motores DC debido al par motor que pueden
proporcionar. El motor que se escogió para las articulaciones fue el modelo #4754 de Pololu [28].
El modelo #4754 de Pololu es u n motor de continua con reductora 70:1 que puede trabajar a 12 V y 6
V con encoder incremental de cuadratura de 64 CPR. Al tener una reductora de 70:1 y un CPR de 64 se
obtiene una resolución de 4480 cuentas por revolución.
Figura 37. Motor Pololu modelo #4754 con encoder incremental de cuadratura de 64CPR y reductora de 70:1Vista desde 1. Superior, 2. Frontal, 3. Lateral. [8]
Construcción y programación del control de un brazo mecánico con STM32
59
Figura 38. Motor Pololu modelo #4754 con encoder incremental de cuadratura de 64CPR y reductora de 70:1Vista desde 1. Estructura interna del motor DC, 2. Estructura interna del encoder, 3. conexiones del encoder y motor DC. [8]
Además, al probar la estructura, en la sección 2, al haber empeorado el torque capaz de ejercer por el
motor sobre la estructura, se decidió cambiar el motor por uno con mayor torque. Aunque
teóricamente por el cálculo de fuerzas realizado, el motor seleccionado se encontraba al límite de su
funcionamiento, en el prototipo, este no era capaz de realizar el torque suficiente para desplazar la
pieza. El modelo seleccionado fue el #2828 de Pololu [28] el cual disponía de una reductora de 150:1,
un torque de 49 Kg*cm y una velocidad angular de 67 rpm.
Memoria
60
6. Diseño de hardware del brazo robótico
En este apartado se expondrá el diseño electrónico diseñado para el control de los motores que
accionan las distintas articulaciones del brazo robótico. El diseño en cuestión se compone de circuitos
integrados y una placa de desarrollo con el objetivo de reducir el ruido e interferencias entre los
componentes utilizados.
Para conectar los diferentes elementos entre si se ha utilizado una placa de topos, en la cual se han
soldado los diferentes CI y los conectores necesarios para la alimentación de los elementos del
prototipo, motores y CI.
Durante el desarrollo del proyecto y debido a las problemáticas que surgieron se desarrollaron dos
posibles soluciones, en la primera solución se utilizó una placa de desarrollo con un microprocesador
M4, dos multiplexores para la selección del motores y tres drivers para el control de los motores. En el
segundo diseño, se prescindió de los multiplexores y solo se necesitó de la placa de desarrollo y los
drivers para los motores.
6.1. Primera solución. Direccionamiento del PWM mediante multiplexores.
El microcontrolador utilizado en los dos diseños, como se comentó en el apartado 4, es el modelo
STM32F4 DISCOVERY debido al número de temporizadores que podía proporcionar.
Los drivers en el primer diseño necesitan de 2 canales de PWM para cada motor, como los
temporizadores de la placa están limitados si se sacaran directamente no se tendrían suficientes
temporizadores para todos los motores, teniendo en cuenta de que de cada temporizador se obtienen
uno, dos o cuatro canales de PWM, pero estos, independientemente de los canales en uso, solo
pueden trabajar en un solo modo.
Se necesitan 6 temporizadores para los encoder que no son compatibles con los temporizadores
utilizados para el PWM, porque si no compartirían el mismo registro, solapándose los valores. Además,
necesitabas dos canales por motor, y por lo tanto, si un temporizador se utilizaba para encoder, ya no
podía ser para una señal de PWM, aunque quedaran canales libres, por lo que se decidió utilizar una
sola salida de dos canales de PWM la cual se multiplexaba con un MUX (multiplexor) de s0 s1 s2 s3,
para controlar la dirección a la que se transmitirá el PWM, es decir la habilitación del sentido de giro.
En el primer diseño se utilizaron 26 de los pines del microprocesador, los cuales se soldaron con estaño
e hilo unifilar. Como se muestra en la figura 39, los pines el PE9, PE11, PA5, PB3, PA6, PA7, PD12, PD13,
PA0, PA1, PC6 y PC7 se utilizan para los canales A y B de los encoder de los distintos motores, los cuales
Construcción y programación del control de un brazo mecánico con STM32
61
permiten identificar la posición angular de los motores y se conectan directamente desde los motores
a la placa de desarrollo. Los pines PB14 y PB15 se utilizan para direccionar la señal de PWM, la cual
controla el movimiento del motor, en los multiplexores y los pines PE3, PE5, PC13 y PC15 son la de
control de los multiplexores Finalmente, los pines PA2 y PA3 son los utilizador para la comunicación
bluetooth entre la placa de desarrollo y el módulo Bluetooth.
Figura 39. Esquema del primer diseño de hardware, se muestran las conexiones entre la placa de desarrollo, los multiplexores, los drivers del motor, el módulo Bluetooth, los motores y la alimentación.
Por lo que el material utilizado para la elaboración de la placa de control es la siguiente:
- Placa de desarrollo STM32F407G.
- Driver motor L2298N x3
- Multiplexor Digital analógico CD74HC4067 x2
- Fuente de alimentación 12V
- Relé KY-019
- Adaptador conector terminal pin x6
- Placa perforada circuito impreso
Además de los componentes mecánicos, que conforman el brazo robótico.
Memoria
62
- Motor DC 70:1 con 64 CPR Encoder x3
- Estructura PLA brazo robótico
- Tornillos M3 10mm
- Tornillos M2,5 14 mm
- Tornillos M2,5 10 mm
- Tubo Teflón
- electroválvula 5/2
- Compresor de Aire
- Pinza neumática PSW-60
6.2. Segunda solución. Control con PWM individuales
En el segundo diseño, se utilizan 37 pines de pines del microprocesador los cuales se soldaron con
estaño e hilo unifilar. Como se muestra en la figura 40, los pines PE9, PE11, PA5, PB3, PA6, PA7 y PD12
PD13 se utilizan para los canales A y B de los encoder de los distintos motores, los cuales permiten
identificar la posición angular de los motores y se conectan directamente con estos. Los pines PB14,
PB15, PE5 y PE6 se utilizan como las salidas de PWM las cuales se conectan directamente con el motor
pertinente, además de los pines PD0, PD1, PD2, PD3, PD4, PD5, PD6 y PD7 para el direccionamiento
del sentido de rotación del motor. Los pines PB10 y PB11 son los utilizador para la comunicación
bluetooth entre la placa de desarrollo y el módulo Bluetooth. Y, finalmente, los pines PA8 y PC9 se
utilizan para la comunicación I2C con la pantalla LCD.
Aparte, en el segundo diseño, al disponer de más espacio en la placa de topos, y la capacidad de los
drivers del motor de proporcionar una corriente de salida para el cálculo de potencias del motor. Se
agregó una pantalla LCD, por la que se podía mostrar diferentes valores de los motores.
Además, el diseño está preparado solo para 4 grados de libertad, más la pinza, esto es debido a que al
realizar el prototipo se comprobó que la estructura mecánica era inviable para 6 grados de libertad.
Esto era debido al diseño de la sección 3, dónde la pieza móvil no estaba sujetada, por lo que, al
posicionarla en determinadas posiciones, esta cedía. Por lo que, además, se debió limitar los grados de
posición en los motores.
Construcción y programación del control de un brazo mecánico con STM32
63
Figura 40.Esquema del segundo diseño de hardware, se muestran las conexiones entre la placa de desarrollo, la pantalla LCD, los drivers del motor, el módulo Bluetooth, los motores y la alimentación.
Memoria
64
Por lo que el material utilizado para la elaboración de la placa de control es la siguiente:
- Placa de desarrollo STM32F407G.
- Driver motor VNH5019 x2
- Fuente de alimentación 12V
- Relé KY-019
- Adaptador conector terminal pin x4
- Pantalla LCD 16x4
- Placa perforada circuito impreso
Además de los componentes mecánicos, que conforman el brazo robótico.
- Motor DC 70:1 con 64 CPR Encoder x3
- Estructura PLA brazo robótico
- Tornillos M3 10mm
- Tornillos M2,5 14 mm
- Tornillos M2,5 10 mm
- Tubo Teflón
- electroválvula 5/2
- Compresor de Aire
- Pinza neumática PSW-60
6.3. Alimentación del sistema.
En el primer diseño, se han de alimentar los motores y los drivers a 12 V. Además, los drivers tienen
una salida de 5V, la cual se utiliza para alimentar los periféricos como los multiplexores. Además, el
Bluetooth LE, que trabaja a 3.3V se alimenta desde la salida Vdd de la placa de desarrollo. Y, la placa
de desarrollo se alimenta a 5 V desde la salida USB de un ordenador.
En el segundo diseño, se han de alimentar los motores y los drivers a 12V. Pero aparte, es necesario
alimentar entre 2.1 V y 5 V la lógica de control del driver, para ello se utiliza la salida Vdd de la placa de
desarrollo, al igual que para el módulo Bluetooth LE. Además, desde la placa de desarrollo también se
alimenta la pantalla LCD a 5V.
Construcción y programación del control de un brazo mecánico con STM32
65
6.4. Módulo Bluetooth
Para la compatibilidad del sistema y de la aplicación móvil con los tipos mayoritarios de sistemas
operativos que existen en el mercado se decidió trabajar con módulos de bajo consumo (BLE,
Bluetooth Low Energy).
La selección de un módulo BLE fue debido a la compatibilidad de este con los modelos de los
dispositivos móviles de la marca Apple, iPhone e iPad, los cuales solo son compatibles con módulos
bluetooth de bajo consumo. Estos módulos, a la vez, también eran compatibles con los dispositivos
móviles con Android como sistema operativo.
El modelo con el que se trabajó fue el módulo bluetooth HM-10, el cual está basado en los chips de
Texas Instruments CC2540 o CC2541. Las características técnicas del módulo se encuentran en el Anexo
4.
Memoria
66
7. Diseño de software del brazo robótico
El software elaborado en el proyecto se ha desarrollado principalmente sobre dos lenguajes de
programación, C y C#, utilizando el primero para la programación del microcontrolador y el segundo
para la programación de la aplicación web.
En este apartado, se describirán las diferentes partes de ambos códigos, así como los procedimientos
previos realizados para obtener los valores necesarios para la elaboración del código.
7.1. Programación del microcontrolador de la placa de desarrollo STM32F4
Discovery (STM32F407VGTx)
En la placa de desarrollo se programó la lógica necesaria para el accionamiento y control de los motores
DC con encoder, para ello fue necesario utilizar distintas funciones disponibles en el STM32CubeMX
que se describirán en los siguientes subapartados.
Debido a las dos versiones de hardware elaborados se ha debido adaptar el código para cada una, por
ello en cada subapartado se especificará las diferencias entre ambos prototipos.
7.1.1. Programación para el primer diseño de hardware
7.1.1.1. Programación de los encoder
Para el control de los motores DC, como se había comentado en los apartados anteriores, es necesario
conocer la posición angular en la que se encuentra el motor. Para conocer la posición angular del
motor, se utiliza el encoder, el cual proporciona dos señales, A y B, que permiten conocer el
desplazamiento y dirección del eje del motor mediante su incremento o decremento.
Para poder tratar las señales es necesario programar dos pines de la placa de desarrollo por encoder
como entradas, y será necesario la utilización de dos canales de temporizador, uno por cada señal que
corresponderán cada uno a un pin, para la programación de cada encoder.
En primer lugar, es necesario la configuración de los pines de la placa de desarrollo que serán utilizados
como entrada paran las señales de los encoder. La conzfiguración de los pines del microcontrolador se
puede realizar mediante el software STM32CubeMX, el que permite generar las funciones base de la
configuración de los pines, debido a que estos pueden ser inicializados de distintas maneras.
Construcción y programación del control de un brazo mecánico con STM32
67
En el primer prototipo se han utilizado 12 pines para la elaboración de los 6 encoders, con dos canales
por cada encoder. Los pines utilizados son el PE9 y PE11 que corresponden al temporizador 1 canal 1 y
canal 2 correlativamente; los pines PA5 y PB3 que corresponden al temporizador 2 canal 1 y canal 2
correlativamente; los pines PA6 y PA7 que corresponden al temporizador 3 canal 1 y canal 2
correlativamente; los pines PD12 y PD13 que corresponden al temporizador 4 canal 1 y canal 2
correlativamente; los pines PA0 y PA1 que corresponden al temporizador 5 canal 1 y canal 2
correlativamente y los pines PC6 y PC7 que corresponden al temporizador 8 canal 1 y canal 2
correlativamente. En la figura 41 se muestran los pines mencionados recuadrados en azul.
Los pines asignados han de ser configurados como temporizadores para su utilización, debido a que
estos pueden trabajar en diferentes modos de funcionamiento. Para configurarlo, es necesario
seleccionar el pin y seleccionar el modo de funcionamiento en la pantalla “Pinout&Configuration” del
STM32CuveMX como se muestra en la figura 43. También se puede inicializar los temporizadores
desde la barra vertical de opciones situada a la izquierda de la misma pantalla, en la opción “Timers”
seleccionando los que se deseen y configurándolos, como en la figura 42. Este último paso se deberá
realizar igualmente si se seleccionan los pines manualmente para configurar los temporizadores
utilizados. Para configurarlos se debe seleccionar el temporizador deseado en la barra izquierda de la
pantalla “Pinout&Configuration”, figura 44, seleccionando el temporizador deseado, en este caso el
temporizador 5, se abrirá una ventana con las opciones “Mode” y “Configuration” que permiten fijar
el modo de trabajo y la configuración del pin. En la ventana “Mode” en la opción “Combined Channels”
se deberá seleccionar la opción “Encoder Mode”, como se muestra en la figura 44.
Figura 41. Esquema de las entradsa y salidas del microcontrolador del STM32CubeMX. Recuadradas en azul, los pines utilizados para la lectura de los valores proporcionados por los encoders.
Memoria
68
Figura 42. Barra lateral "Pinout & Configuration" Figura 43. Selección manual de los pines.
Figura 44. Configuración de los temporizadores para la utilización del Encoder Mode
El modo encoder, o “Encoder Mode”, permite evaluar las transiciones de las 2 entradas TI1FP1=TI1 y
TI2FP2=TI2, figura 27, que son entradas externas filtradas digitalmente. El resultado de esto es la
generación de pulsos de conteo y una señal de dirección DIR de 1 bit, figura 45. Dependiendo de la
secuencia entre el canal A y B del encoder el contador contará hacia arriba o hacia abajo, pudiendo
determinar cuando el motor se mueve hacia una dirección o hacia la otra.
Construcción y programación del control de un brazo mecánico con STM32
69
Figura 45.Esquema interno del TIM1 para el funcionamiento del modo encoder [29]
Figura 46. Modos de contaje [29]
En el modo encoder, el contador se actualiza a la misma la velocidad y dirección en la que se encuentre
girando el codificador incremental. Según los canales que se cuenten es posible obtener el doble de
resolución como es el caso de evaluar los 2 canales a la vez. En la siguiente tabla de la figura 29 se
resumen las posibles combinaciones suponiendo que TI1 y T12 no cambian al mismo tiempo.
Figura 47.Dirección de contaje respecto a las señales del encoder [29]
A continuación, se ha de configurar el temporizador, para configurarlo se puede realizar en la pantalla
de “Configuration”, la cual está situada justo debajo de la ventana “Mode”. En ella se ha de especificar
el periodo del temporizador, el cual trabajará como contador para el encoder, donde el valor ascenderá
o descenderá según la posición que se le marque. El periodo que se ha fijado es de 65535 que es el
valor máximo que puede alcanzar el registro del contador del encoder TIM->CNT, siendo el tamaño del
Memoria
70
preescaler del temporizador de 16 bits. Además, se han dejado por el contador en modo ascendente y
no se han añadido ningún filtro a la entrada. La configuración final se puede observar en la figura 48.
Figura 48. Configuración del temporizador para la lectura de los encoder en STMCubeMX .
Una vez configurados los temporizadores en el STM32CubeMX, y los demás pines que se explicarán en
los demás subapartados, se ha de generar el código en C donde se realizará el programa. El código
generado contendrá las funciones y la inicialización de los pines en el modo seleccionado y la
configuración introducida en el STM32CubeMX como se muestra en la figura 50 en el main y las
inicializaciones necesarias presentes en el anexo 2. Además, se generarán automáticamente los
archivos necesarios para la configuración de los temporizadores y los pines, como por ejemplo el
stm32f4xx_it.c, que permiten la correcta conexión con el microcontrolador.
Por último, se ha modificado el valor inicial del registro del contador del encoder, para que el valor
“00000” del contador no coincida con el ángulo 0 del encoder, por lo que se ha introducido un valor
inicial de 1000, como se muestra en valor hexadecimal en la figura 49, para así permitir que el motor
pudiera volver a la posición inicial sin generar problemas en el algoritmo del PID, el cual no era capaz
de trabajar si ambos valores se encontraban en 0.
Construcción y programación del control de un brazo mecánico con STM32
71
Figura 49. Código en C de la Inicialización de los temporizadores utilizados para la lectura de los encoder.
Figura 50. Código en C de la configuración del temporizador 4 en modo encoder. Código autogenerado por el STM32CubeMX.
A continuación, en el primer diseño, para poder procesar los datos de los encoder, se declaran las
variables de la figura 51. Además, se ha realizado la función conversión_grados_pulsos la cual recoge
los datos recibidos mediante bluetooth y los copia a la variable GRADOS_MOTOR, seguidamente
mediante el comando atoic se convierten los datos tipo chart de GRADOS_MOTOR a una variable
GRADOS_MOTOR_ de tipo entero. Una vez se tiene el valor en el formato int, se pueden realizar
comparaciones y operaciones lógicas con este. Seguidamente, se realizan dos condicionales, para
limitar la rotación del motor entre 0 º y 360 º. En el primer condicional, dentro del intervalo deseado,
en la variable PULSOS_MOTOR se guarda la suma de 1000, valor de 0º, y el producto de la resolución
del motor, pprotation, con los grados del motor entre 360, el ángulo máximo. En el segundo
Memoria
72
condicional, la variable PULSOS_MOTOR se iguala a la suma del offset de 1000 y la resolución del
motor, pprotation, y se asigna el ángulo máximo, 360º, a GRADOS_MOTOR_.
Figura 51. Código en C de las variables necesarias para el funcionamiento de la lectura de los encoder y el tratamiento de la información.
Figura 52. Código en C de la función conversión_grados_pulsos, función encargada de realizar la conversión de los grados deseados a los pulsos.
7.1.1.2. Selección del motor mediante multiplexores
El actual apartado solo aplica al primer diseño de hardware, en el cual solo se utilizan dos canales de
PWM, por lo que era necesario seleccionar sobre que motor se deseaba actuar y leer el encoder.
Para ello se utilizaron dos multiplexores 1:16 con 4 canales de selección. Al tratarse de multiplexores
con dieciséis salidas, era necesario cuatro variables de control por cada multiplexor, por lo que se
debieron configurar cuatro salidas discretas, GPIO, del microcontrolador, S0, S1, S2 y S3 en los pines
PC15, PC13, PE5 y PE3 correlativamente. Estando estas señales de selección Al generar el código, las
variables se inicializan en la función MX_GPIO_Init, como se puede observar en la figura 53.
Construcción y programación del control de un brazo mecánico con STM32
73
Figura 53. Código en C de la función de inicialización de las entradas y salidas del microcontrolador. Función autogenerada por STM32CubeMx.
Para poder controlar la dirección de giro, se introducía como entrada un canal de PWM en cada
multiplexor, las cuales activándose una u otra, harían girar al motor en una dirección u otra. Y, por lo
tanto, introduciendo en el driver los dos canales de PWM de ambos multiplexores, conectando la
primera salida de ambos MUX con el primer motor, la segunda salida de ambos MUX con el segundo
motor y así sucesivamente.
Además, para la selección del motor, se utiliza el primer carácter recibido, el cual variará dependiendo
del motor que se desee accionar. Al recibir datos mediante el bluetooth, se activa la función
HAL_UART_RxCpltCallback, desde la cual se llama a la función selección_encoder con los datos
recibidos.
Figura 54. Código en C de la funsión HAL_UART_RxCpltCallback encargada de leer la información recibida por el módulo Bluetooth.
Memoria
74
En la función selección_encoder con el primer carácter del RX_DATO se entra en un switch case que
activa o desactiva las variables FLAG, variables booleanas que determinan el motor que se desea
accionar. Además, se fijan en SET, valor a 1, o en RESET, valor a 0, de las variables de salida S0, S1, S2 y
S3, que actúan como señales de control de los multiplexores, los encargados de direccionar la señal de
PWM al motor correcto.
Figura 55. Código en C de la función selección_encoder encargada de seleccionar el encoder que se desea leer y direccionar la
señal de PWM para accionar el motor deseado.
Una vez se activa un FLAG, se cumple la condición de la figura 56, determinando de que contador o
temporizador ha de guardar los datos en la variable ENCODER.
Figura 56. Código en C de los condicionales activador según la función seleccion_encoder que la relacionan con los temporizadores correctos.
Construcción y programación del control de un brazo mecánico con STM32
75
7.1.1.3. Comunicación Bluetooth de la placa de desarrollo
Para obtener la posición angular deseada del eje de los motores, se ha realizado una aplicación móvil
capaz de transmitir el valor deseado mediante comunicación Bluetooth. Por eso, en la placa de
desarrollo se ha incorporado un módulo Bluetooth LE para poder recibir la información.
En primer lugar, se deberán configurar los pines para la comunicación serie de TX_DATO y RX_DATO
que se utilizarán del microcontrolador, esto se realizará nuevamente desde el software
STM32CubeMX, en ambos diseños, se utilizaron los pines PB10 para el TX, y PB11 para el RX, pines que
corresponden al bus de comunicación USART3. A continuación, en la barra izquierda, en la categoría
“Connectivity” se deberá seleccionar el bus de comunicación utilizado, en este caso el USART3, para
realizar la configuración. Finalmente, en la ventana “Mode” se deberá seleccionar “Asynchronous” y
en la ventana “Configuration” se deberá habilitar el “NVIC Interrupt Table” en la ventana “NVIC
Settings” y en la ventana “Parameter Settings” se deberá fijar el ancho de banda a 9600 Bits/s. Una vez
los pines configurados, se deberá generar el código apto para editar en el uVision Keil.
Figura 57. Configuración del bus de comunicación Bluetooth con un ancho de banda configurado a 9600 Bits/s en el configurador STM32CubeMX
En el código generado, en el main, se encontrará la función de inicialización del USART3, figura 58. En
ella se deberá habilitar el reloj del USART3, para ello en el espacio destinado para la edición de código
por el usuario se introduce la instrucción _UART3_CLK_ENABLE.
Memoria
76
Figura 58. Código en C de la inicialización de la función USART3
A continuación, para recibir los datos transmitidos por el teléfono móvil, fuera del bucle principal while
se introduce la función HAL_UART_RECEIVE_IT, la cual es una interrupción que se activa al recibir
datos.
Figura 59. Código en C de la función encargada de recibir la información del módulo Bluetooth.
Para transmitir los datos recibidos de vuelta, donde se comprobarán si se han recibido correctamente,
se utiliza la función HAL_UART_TRANSMIT, al no tratarse esta de una interrupción, ha de estar dentro
del bucle while.
Figura 60. Código en C de la función encargada de enviar la información mediante el módulo Bluetooth.
7.1.1.4. Programación del PWM
Para controlar el giro de los motores se ha utilizado la modulación por ancho de pulso, o PWM (Pulse
width modulatio), la cual permite modificar el ciclo de trabajo de una señal periódica para controlar la
cantidad de energía que se dirige a los motores y por tanto su giro.
Construcción y programación del control de un brazo mecánico con STM32
77
En el primer diseño se ha utilizado sólo dos canales PWM para dirigir los 6 motores, esta se redirige a
través a dos multiplexores al motor seleccionado, como se explica en el apartado 6.1.
Al utilizarse temporizadores para generar las señales de PWM, en el primer diseño no se disponían de
suficientes temporizadores para las señales de los encoder y para los PWM individuales de cada motor,
por ello se utilizó un redireccionamiento de una única señal de PWM mediante los multiplexores. Esto
era debido a que los drivers del motor necesitaban para el accionamiento y control de dirección al
menos dos canales de PWM cada uno, como se muestra en la figura 61.
Figura 61. Vista superior del driver L298N Dual H Puente DC, recuadrado en azul y rosa las entradas de PWM del primer motor y del segundo motor respectivamente. [31]
A continuación, se explicará el procedimiento que se ha seguido para la elaboración de las señales de
salida de PWM desde el software STM32CubeMX y posteriormente su edición desde el Keil uVision5.
En primer lugar, como se ha comentado es necesario de una señal de temporizador para generar el
PWM. Para ello se ha de seleccionar, como con los encoder, los pines deseados, pin PB14 y PB15, que
puedan funcionar como temporizadores o en la barra izquierda de opciones, seleccionar la opción
“Timers” y seleccionar un temporizador que no esté en uso.
Una vez seleccionado el temporizador deseado, en la ventana “Mode” que se habrá abierto, se deberá
seleccionar la opción “PWM GenerationCH1” para en “Channel1” y “PWM Generation CH2” para en
“Channel2” como se muestra en la figura 63.
Memoria
78
Figura 62. Simulación de los pines configurados del microcontrolador en STM32CubeMX. Se remarcan en azul los pines utilizados para los canales de PWM.
Figura 63. Configuración de los dos canales del temporizador 12 como salidas de PWM en el configurador STM32CubeMX.
A continuación, en la ventana inferior de “Configuration” se deberá introducir el valor del preescaler y
periodo del PWM. Los valores del preescaler y periodo dependen de la frecuencia del temporizador
interno del microcontrolador y de la frecuencia que pueden soportar los motores. Por ello se ha de
modular la frecuencia inicial, frecuencia del reloj interno del microcontrolador, para obtener una
frecuencia de trabajo apta para los motores. Seleccionando en la barra superior la ventana “Clock
Configuration” se puede comprobar la frecuencia del reloj interno del microcontrolador, figura 64.
Construcción y programación del control de un brazo mecánico con STM32
79
Figura 64. Configuración de los relojes internos del microcontrolador STM32F407VGTx en el configurador STM32CubeMX.
Por defecto el reloj interno del microcontrolador, y por tanto los temporizadores integrados, trabajan
a una frecuencia de 168 MHz, pero los motores tienen una frecuencia de trabajo máxima de
aproximadamente 20 KHz. Para obtener los valores del preescaler y periodo que permiten obtener la
frecuencia de salida deseada se aplica la ecuación 10.
𝑈𝐸𝑉 = 𝑅𝑒𝑙𝑜𝑗 𝑖𝑛𝑡𝑒𝑟𝑛𝑜
(𝑃𝑟𝑒𝑠𝑐𝑎𝑙𝑒𝑟+1)(𝑃𝑒𝑟𝑖𝑜𝑑𝑜+1) [10]
UEV = Frecuencia de salida deseada
Cambiando el orden de los factores se puede obtener el producto de la multiplicación del preescaler y
el periodo, al substituir los valores conocidos de la frecuencia del reloj interno, frecuencia del PCLK1, y
la frecuencia de salida deseada, se obtiene la ecuación 11.
(𝑃𝑟𝑒𝑠𝑐𝑎𝑙𝑒𝑟 + 1)(𝑃𝑒𝑟𝑖𝑜𝑑𝑜 + 1) = 𝑅𝑒𝑙𝑜𝑗 𝑖𝑛𝑡𝑒𝑟𝑛𝑜
𝑈𝐸𝑉=
42 𝑀𝐻𝑧
20 𝐾𝐻𝑍= 2100 [11]
Por lo que seleccionando un valor de preescaler de 10 y un período de 199 se obtiene un producto
entre ambos de 2200, con los que se obtendría una frecuencia de salida de 19KHz, estando esta última
por debajo de la frecuencia máxima de los motores. Los valores del preescaler y del período
introducidos se pueden observar en la figura 65.
Memoria
80
Figura 65. Configuración de los dos canales del temporizador 12 con preescaler 10 y periodo de 199 en el PWM en el configurador STM32CubeMX.
7.1.1.5. Programación del controlador PID
Para el correcto funcionamiento del brazo robótico el motor se ha de posicionar en el ángulo deseado,
para ello se realiza un sistema de lazo cerrado, sistema de control simultáneo por realimentación, en
el caso del proyecto se ha utilizado un PID. Además, para poder realizar el control del sistema se ha
hecho uso de unas librerías desarrolladas por la marca ST Microelectrónics [30] y que son de uso
público general. Estas librerías están ubicadas en GitHub que es una comunidad web desarrollada para
desarrolladores de software.
Además, para poder corregir el error dentro de la rutina se han utilizado datos que facilita la librería,
para poder realizar ajustes en la función de la velocidad del microcontrolador. En la figura 66 se
muestra los diferentes errores de ciclos de cuentas según la velocidad del microcontrolador. En este
proyecto se ha decidido utilizar una velocidad de 168 MHz y se ha hecho una relación polinomial para
obtener de forma más precisa del error en la llamada de la función.
Construcción y programación del control de un brazo mecánico con STM32
81
Figura 66. Descripción de la función "DoFullPID" [30]
Figura 67. Error computado con la rutina [30]
Figura 68. Ajuste o relación polinomial de segundo grado del error dado por la función.
A continuación, para el diseñar el controlador PID apto al sistema, se ha estudiado el comportamiento
de los motores sin carga, mediante los valores de posicionamiento de salida. Con los datos
experimentales se puede obtener la función de transferencia del sistema mediante la aplicación PID
Tunner de MATLAB, la cual permite extraer el modelo de la planta del motor con el cual se elaborará
el controlador PID.
y = 0,0009x2 + 0,1042x + 45R² = 1
47
48
49
50
51
52
53
54
55
56
57
58
0 10 20 30 40 50 60 70 80
Memoria
82
En primer lugar, para obtener el modelo de planta del motor, se utilizaron los datos del anexo 5. Para
obtener los datos experimentales, se realizaron ensayos con el programa final del microcontrolador
sin el PID habilitado, comentando las líneas marcadas en la figura 69 que corresponden a los factores
Kp, Ki y Kd del controlador PID, para así poder obtener el comportamiento del sistema. Y, además, para
poder visualizar la posición del eje del motor, es necesario transmitir la posición del que proporciona
el encoder y la posición deseada, o SETPOINT. Para transmitir la posición se agrega una función
“HAL_UART_Transmit” que transmiten sólo los valores numéricos del SETPOINT y del ENCODER del
motor que se desea leer, figura 70.
Figura 69. Código en C de la función DoFullPID proporcionada por la librería de ST. Recuadrado en azul líneas de código comentadas para inhabilitar el PID.
Figura 70. Código en C de la función HAL utilizada para transmitir la información del SETPOINT y del ENCODER para obtener el modelo de la planta en lazo abierto.
Una vez hecha la modificación, se ha de cargar el programa en la placa de desarrollo y conectar el
motor, con el que se va a realizar el estudio, sin carga a la placa diseñada.
Finalmente, para leer los valores transmitidos, es necesario utilizar un módulo Bluetooth HM-05 o HM-
06, los cuales no son BLE, esto es debido a que los receptores de los equipos informáticos utilizados no
eran compatibles con módulos Bluetooth LE. A continuación, se conectó el equipo informático con el
bluetooth y se utilizó el monitor serie del software Arduino IDE para visualizar los valores transmitidos
Construcción y programación del control de un brazo mecánico con STM32
83
desde el sistema los cuales se deberán guardar en un documento EXCEL para su posterior análisis
mediante MATLAB.
Una vez se tienen los datos experimentales de la posición del motor respecto al tiempo, se procede a
analizarlos mediante MATLAB, primero se deberán importar los datos al software de MATLAB. Para
realizarlo se puede arrastrar el archivo hasta la ventana “Current Folder” o seleccionando el botón
“Import Data” en la barra superior de la ventana “Home”.
Figura 71. Pantalla inicial de MATLAB, recuadrado en azul el icono para importar los datos al programa.
Seguidamente, para obtener los valores que se procesaran, se debe hacer doble clic en el fichero
importado y se abrirá la ventana de la figura 72. En esta ventana se deberá seleccionar el tipo de salida
como “Column vectors”, poner nombre a las columnas de los datos que se quieran importar y
seleccionar los datos a importar o toda la columna. Es recomendable excluir de la importación el primer
tramo de datos, debido a que la parte de interés a analizar es la que muestra las oscilaciones que realiza
el motor hasta estabilizar, si lo hace, y no el tramo inicial que representa un desplazamiento natural
hasta en ángulo marcado. Además, es necesario conocer el valor del SETPOINT, aunque no será
necesario importar el dato. Para finalizar se importarán los datos picando en el icono verde encima
de “Import Selection”. Los diferentes vectores deberían aparecer en la ventana del “Workspace” como
se muestra en la Figura 73.
Memoria
84
Figura 72. Ventana que muestra los datos importados al programa. Recuadrado en azul el nombre otorgado a la variable y el modo en el que se desean importar.
Figura 73. Ventana del Workspace con las variables importadas.
Una vez se han obtenido los datos en el formato correcto para procesarlos, se utiliza la aplicación PID
Tuner, que pertenece al paquete de aplicaciones ControlSystem Toolbox. Para abrirla se puede realizar
desde la consola mediante el comando “pidTuner” o seleccionando el icono en la ventana “APPS”,
figura 74, y se abrirá una ventana con el interfaz de la aplicación.
Figura 74. Barra superior de la ventana APP en MATLAB. Recuadrado en azul el icono de la aplicación PID Tunner
Construcción y programación del control de un brazo mecánico con STM32
85
Figura 75.Ventana inicial de la aplicación PID Tuner
Al hacer clic izquierdo sobre el icono de PID Tuner se abrirá la ventana que se muestra en la figura 75.
En la opción “Plant” se tendrá que seleccionar “Identify New Plant” debido a que no se dispone de una
planta anterior y lo que se pretende es identificar la planta del motor en cuestión. Aparecerá la ventana
“Plant Identification” y la opción “Get I/O Data” desde donde introduciremos los datos experimentales
de los cuales obtendremos el modelo de la planta.
Figura 76. Ventana “Plant Identifyer” de la aplicación PID Tuner de MATLAB
En el caso de estudio, los datos utilizados se corresponden a un “Step Response”, donde se deberá
introducir el dato de salida con el nombre de la variable cargada como vector, la altura del escalón, que
será el SETPOINT y el intervalo de tiempo entre datos. Finalmente se deberán importar.
Memoria
86
Figura 77. Selector del tipo de dato y ventana Import Step Response. Recuadrado en azul la opción seleccionada del selector en el desplegable. En la ventana Import Step Response recuadrado en azul el nombre de la variable que se desea utilizar, la amplitud del SETPOINT y tiempo de captura de datos.
En la ventana “Plant Identification” los datos experimentales introducidos se mostrarán en verde,
mientras que la aproximación realizada por el programa se mostrará en azul. Como se muestra en la
figura 78, la aproximación que se realiza por defecto es de un sistema de primer orden. Pero, como se
observa en esta figura, no se asemeja a los datos experimentales.
Figura 78. Aproximación a la planta experimental por defecto.
Construcción y programación del control de un brazo mecánico con STM32
87
Para extraer los datos de la planta para diseñar el controlador PID se ha de aproximar lo máximo posible
la interpretación virtual a los datos reales. Para realizarlo, se disponen diversos instrumentos como la
selección de la estructura de un polo o dos polos, reales o complejos, o el “Auto Estimate” el cual ayuda
calculando mediante software la mayor coincidencia posible. Con la utilización de las herramientas que
proporciona la App y, sobre todo, el criterio y conocimientos propios del usuario que está utilizando la
aplicación se llega a una aproximación muy cercana al modelo experimental como se muestra en la
figura 79.
Figura 79. Aproximación de la planta según los datos experimentales introducidos.
Una vez se ha realizado la aproximación manual o automática, con las modificaciones necesarias, se
puede proceder a la extracción de la planta y al diseño del controlador PID. En primer lugar, se deberá
hacer clic izquierdo sobre “Apply” para extraer la planta.
Seguidamente, se puede comprobar como en la ventana “Step Plot” se puede observar una respuesta
de la planta diseñada con un controlador P, en un primer momento mostrará una respuesta que no
estabiliza debido a las características del sistema con el que se está trabajando.
Para obtener una respuesta que llegue a estabilizar se deberán modificar el tipo de controlador
deseado en la opción “Type” a PID, se podrá comprobar como la barra “Transient Behaviour” se
habilita. Finalmente, se deberán modificar el valor de las barras “Response Time” y “Transient
Behaviour” para obtener el PID deseado con la velocidad y la robustez de estabilización deseada. Se
tendrá un buen PID cuando se obtenga una figura que llega a estabilizar, como se muestra en la figura
80. En esta figura, se muestra como al inicio hay un ligero sobre pico, pero se considera que es
aceptable y que no afecta posteriormente al comportamiento del motor, pero si no fuera posible en
nuestro sistema, se debería buscar un sistema más similar a la figura 81, donde el sistema estabiliza sin
sobrepasar el valor 1, pero resultando una estabilización mucho más lenta y abrupta.
Memoria
88
Finalmente, para extraer el modelo de planta, el cual se podría utilizar posteriormente para
simulaciones con Simulink, y los valores del PID se ha se hacer clic izquierdo sobre “Export” poner
nombre a nuestro PID y seleccionar la planta que se desea exportar como se muestra en la figura 83.
Además, si se desea ver los valores del PID antes de exportar se puede realizar haciendo clic izquierdo
sobre la opción “Show Parameters” y se abrirá una ventana como la de la figura 84.
Figura 80. Sistema estable de la planta del motor con el PID diseñado, pero con un sobrepico de 1,03.
Figura 81. Mejor estabilización obtenida en el PID de la planta diseñada sin sobrepico
Construcción y programación del control de un brazo mecánico con STM32
89
Figura 82. Modelo de la planta con el PID utilizado.
Figura 83. Extracción del modelo de la planta obtenido y del PID diseñado para el modelo en cuestión.
Figura 84. Valores del PID para el modelo de la planta aproximado mediante los datos experimentales.
Memoria
90
El PID y el modelo de la planta exportada se mostrarán en el “Workspace” como se muestra en la figura
85.
Figura 85. Modelo de la planta y se su respectivo PID extraídos en el “Workspace”
El código elaborado para el control de los motores, y por lo tanto con el PID integrado, se realizó
previamente a obtener los parámetros del PID, pero se han explicado a posteriori para facilitar la
comprensión del lector.
En primer lugar, se utilizó la librería PID_C_stm32.c de STMicroelectronics [30], la librería proporciona
dos funciones que permiten calcular el error del sistema, estas funciones fueron editadas para
ajustarse a las necesidades del programa diseñado.
Por último, se mostrará cómo es la estructura del controlador PID, figura 86. Se puede observar cómo
hay 2 parámetros independiente del proceso que se pueden ajustar fuera de la rutina. Uno de ellos es
el error interno computado por la función “PrevError_C “y el otro “InTerm_C” es el error de la acción
integral (no se ha tenido en cuenta).
Construcción y programación del control de un brazo mecánico con STM32
91
Figura 86. Código en C de las funciones proporcionadas por la librería de ST para la elaboración de un control PID.
Y, desde el main del programa diseñado se ha de agregar el include stm32_dsp.h, para llamar
correctamente a las funciones de la librería utilizada, y los parámetros que se introducirán en el PID,
en la variable COEFF.
A continuación, el programa diseñado varia ligeramente dependiendo de a que diseño de hardware al
que se vaya a aplicar, debido a que en el primer diseño se utiliza un solo PID para todos los motores,
mientras que, en el segundo diseño, como se explicará en los siguientes apartados, se genera un PID
propio para cada motor.
En el primer diseño de hardware, solo se actúa sobre un motor a la vez, por lo que sólo se requiere de
tres variables y una función, control_motor. Y las variables necesarias son el INPUT, OUTPUT_PID y
SETPOINT, aparte de la variable COEFF donde se almacenan los valores de los parámetros del PID
calculado.
En primer lugar, y dentro del bucle principal, while, se guarda en la variable INPUT el resultado de la
función control_motor con la variable ENCODER introducida en esta, que representa la posición
angular del eje del motor.
Memoria
92
Figura 87. Código en C de las variables necesarias para el tratamiento del ENCODER y el PID
En la función control_motor se introduce el valor de ENCODER, donde se encuentra con una variable
interna de la función OUTPUT_PROCESS y tres condiciones. La primera condición, se cumple al arrancar
el motor, cuando la diferencia entre la posición deseada y la marcada por el encoder es superior a 199
y fijándola en 199, su valor máximo para el PID introducido en el período del temporizador utilizado
como contador. La segunda condición controla la parada del motor cuando el encoder detecta que está
en la posición que se le ha marcado. Y la tercera condición, determina la dirección que ha de girar el
motor para alcanzar la posición deseada. Al finalizar la condición, independientemente la que se haya
cumplido, devuelve el valor de la variable OUTPUT_PROCESS, a la cual se le ha asignado el valor del
ENCODER.
Figura 88. Código en C de la función control_motor
A continuación, vuelve al while, donde llama a la función del PID, anteriormente explicada, y le
introduce los valores del INPUT, SETPOINT y COEFF. Lo que generará un nuevo OUTPUT_PID, al
aplicarle el lazo cerrado, más próximo a la posición deseada.
Para poderse comprender mejor el proceso se ha añadido un diagrama de bloques, figura 89, el cual
se han utilizado las mismas variables que en la programación del código. En el diagrama salen las
variables más significantes del proceso y como se ubican dentro del algoritmo de control.
Figura 89. Sistema de funcionamiento del motor con control PID.
Construcción y programación del control de un brazo mecánico con STM32
93
7.1.2. Programación para el segundo diseño de hardware
El segundo diseño se elaboró en base a al primero. Por ello se encuentran muchas similitudes entre
ambos. Aun así, se pretende explicar extensivamente el programa con el objetivo de facilitar la
comprensión al lector.
Pero, en el segundo diseño se ha utilizado un PWM para cada motor, así evitar que los motores
cedieran por el par producido por el peso de la estructura al no actuarse sobre ellos, y así poder
mantener la posición deseada.
Esta modificación fue posible debido que, a diferencia del primer diseño, donde los drivers
seleccionados para el control de los motores necesitaban dos canales de señale de PWM para poder
accionar y direccionar los motores, los drivers del segundo diseño sólo necesitaban un solo canal de
señal de PWM para el accionamiento del motor y dos señales discretas para determinar la dirección
del movimiento.
7.1.2.1. Programación de los encoder
Como se ha comentado, el diseño del programa es sustancialmente parecido al primer diseño. Pero en
este caso sólo se han programado los pines necesarios para la lectura de 4 encoder. Tanto el segundo
diseño como su programa se realizaron después de testear el primero, por ello se comprobó como la
estructura del brazo robótico no era viable para 6 ejes de libertad, por lo tanto, se diseñó sólo para 4
motores.
En el segundo prototipo se han utilizado 8 pines para la elaboración de los 4 encoder, con dos canales
por cada encoder. Los pines utilizados son el PE9 y PE11 que corresponden al temporizador 1 canal 1 y
canal 2 correlativamente; los pines PA5 y PB3 que corresponden al temporizador 2 canal 1 y canal 2
correlativamente; los pines PA6 y PA7 que corresponden al temporizador 3 canal 1 y canal 2
correlativamente; los pines PD12 y PD13 que corresponden al temporizador 4 canal 1 y canal 2
correlativamente.
A continuación, se han de configurar los pines, para ello se ha seguido el mismo procedimiento que en
el apartado 7.1.1.1, en el cual se configuran los temporizadores que se utilizarán para la lectura de los
encoder, seleccionando el temporizador deseado en la barra izquierda de la pantalla
“Pinout&Configuration”, seleccionando el temporizador deseado, se abrirá una ventana con las
opciones “Mode” y “Configuration” que permiten fijar el modo de trabajo y la configuración del pin.
En la ventana “Mode” en la opción “Combined Channels” se deberá seleccionar la opción “Encoder
Mode”. Una vez realizados todos los pasos, en el STM32CubeMX, se mostrarán los pines configurados
Memoria
94
como en la figura 90 y en la figura 91. Si se observan, se puede comprobar como los encoder
configurados coincidían con los cuatro primeros del primer diseño. Así, como de los parámetros del
período y prescaler que se calcularon en el apartado 7.1.1.1.
Figura 90. Configuración del microcontrolador STM32F407VGTx en STM32CubeMX. Recuadrado en azul los pines utilizados para los encoder.
Figura 91. Configuración de los temporizadores de los encoder en la ventana “Pinout & Configuration” en STM32CubeMX
Construcción y programación del control de un brazo mecánico con STM32
95
Una vez se han configurado los pines, se ha de generar el código sobre el que se desarrollara el
programa, como en el caso anterior, se genera un documento Keil uVision v5.
La inicialización los temporizadores, con un offset de 20.000, pero sólo se inicializan los temporizadores
configurados, en este caso los temporizadores 1, 2, 3 y 4.
Figura 92. Código en C de la inicialización de los temporizadores utilizados para los encoder con un offset de 20.000
Además, los temporizadores se han de asociar a una variable, pero a diferencia del anterior caso, las
variables que almacenan y con las que se trabajan los datos del registro del temporizador han de ser
únicas para cada temporizador. Esto es debido, a que, en este caso, es necesario mantener la lectura
del encoder de cada motor constantemente, debido a que en ningún momento se deja de actuar sobre
los distintos motores, para evitar, que cedan delante del peso del brazo robótico. Por ello, se realizan
cuatro variables que recogen el valor del temporizador como se muestra en la figura 93.
Figura 93. Asignación de los registros de los temporizadores en variables independientes en programa del lenguaje C en uKeil v5.
7.1.2.2. Programación del PWM
En el caso del segundo diseño, se han de realizar PWM independientes para cada motor. EL objetivo,
como ya se ha comentado, es evitar la pérdida de control sobre los motores, por lo que se ha de estar
actuando sobre ellos constantemente, por eso, es necesario tener variables de PWM independientes
para cada motor. Los drivers para los motores utilizados en el segundo diseño son los Pololu Dual
VNH5019 Motor Driver [31], estos drivers solo utilizan una sola señal de PWM para controlar la
velocidad del motor, debido a que el control de dirección se realiza mediante dos señales discretas.
Memoria
96
Figura 94. Conexiones del Pololu Dual VNH5019 Motor Driver con el microcontrolador y los motores. En gris se muestran las conexiones opcionales, recuadrado en azul se muestran las conexiones de las variables discretas del primer motor y recuadrado en rojo se muestra la conexión de PWM del primer motor.
Por lo que, en primer lugar, fue necesario habilitar los pines necesarios desde el software
STM32CubeMX para los 4 canales de PWM y las 8 señales discretas necesarias. Para ello, será necesario
configurar 4 canales de temporizadores para las señales PWM, pudiendo utilizarse distintos canales de
un mismo temporizador para distintos PWM independientes. Y 8 señales GPIO, 2 para cada motor,
para el control de dirección. Finalmente, se utilizó CH1 del temporizador 12 para el PWM primer
motor, con pin PB14, el CH2 del temporizador 12 para el segundo motor, con pin PB15, el CH1 del
temporizador 9 para el tercer motor, con pin PE5, y el CH2 del temporizador 9 para el cuarto motor,
con pin PE6.
Figura 95. Configuración de los pines del microcontrolador de la placa de desarrollo STM32F4 Discovery en el software STM32CubeMX, recuadrado en azul los pines utilizados para la señal de PWM del segundo diseño.
Construcción y programación del control de un brazo mecánico con STM32
97
Además, se habilitan las señales discretas y se las nombra. Para el direccionamiento del primer motor
se utilizan los pines PD4 y PD5, los cuales se han nombrado como INA_1 y INB_1 respectivamente, para
el segundo motor se utilizan los pines PD6 y PD7, los cuales se han nombrado como INA_2 y INB_2
respectivamente, para el tercer motor se utilizan los pines PD2 y PD3, los cuales se han nombrado
INA_3 y INB_3 respectivamente, y para el cuarto motor se utilizan los pines PD0 y PD1, los cuales se
han nombrado INA_4 y INB_4 respectivamente. Los pines se muestran en la figura X, en la cual también
se puede observar cómo pines han sido configurados como GPIO_Output.
Figura 96. Configuración de los pines del microcontrolador de la placa de desarrollo STM32F4 Discovery en el software STM32CubeMX, recuadrado en azul los pines utilizados para las señales discretas utilizadas por el Driver del motor para controlar la dirección de movimiento del motor del segundo diseño.
Una vez con los pines configurados, se puede generar el archivo en C apto para la edición del programa.
Abriendo el archivo mediante el Keil uVision v.5 encontramos que se han inicializado los
temporizadores del PWM y, además, dentro de una única función, se han inicializado los pines de todos
los GPIO. Pudiéndose observar en la figura 97 la inicialización de las variables relacionadas con los pines
GPIO, y en la figura 98, la inicialización de los temporizadores de las señales de PWM.
Figura 97. Segmento de la declaración de la función MX_GPIO_Init, recuadrado en azul las variables de los pines configurados como GPIO para el control de dirección de lor motores.
Memoria
98
Figura 98. Inicialización de los temporizadores utilizados para las señales de PWM en el segundo diseño, correspondientes al temporizador 9 y 12.
7.1.2.3. Programación del controlador PID
En el caso de la programación del controlador PID, al haber agregado un nuevo motor en la sección 2,
fue necesaria la obtención del modelo de planta para este motor. Para ello, se realizó el mismo
procedimiento en MALTAB, descrito en el apartado 7.1.1.5. Con este procedimiento, se pudieron
obtener los parámetros del nuevo motor, pero surgía la complicación de tener que trabajar con dos
controladores PID diferentes.
Para solventar el problema, se decidió realizar dos vectores, cada uno con los parámetros para cada
tipo de motor, los cuales serían transmitidos a la librería del PID para trabajar con ellos dependiendo
del motor sobre el que se deseará actuar, los vectores se muestran en la figura 99. Utilizando la misma
librería para el PID que en el primer diseño.
Figura 99. Código en C de las variables utilizadas para contener los parámetros del controlador PID
Figura 100. Código en C de las variables ENCODER, INPUT y OUTPUT_PID y de la asignación de sus valores.
En primer lugar, como se ha explicado en el primer caso, y como se explicará en el siguiente apartado,
al recibir una posición mediante el módulo Bluetooth, dependiendo del primer carácter recibido, se
Construcción y programación del control de un brazo mecánico con STM32
99
llamará a una función u otra, a diferencia del primer caso, esta diferenciación se realiza desde la misma
función que se utiliza para recibir datos como se muestra en la figura 101.
Figura 101. Código en C de la función HAL_UART_RxCpltCallback encargada de recibir los datos del módulo Bluetooth.
Además, como se observa en la figura, en el los condicionales se diferencia tanto a la función a llamar,
como la variable donde se guardará el resultado devuelto por la función.
Por lo que, se han debido declarar tantas variables de ENCODER, SETPOINT y funciones de
conversión_grados_pulsos, como motores utilizados, figura 100.
Una vez en las funciones conversión_grados_pulsos, son estas muy similares estructuralmente, pero
se diferencian principalmente en las variables con las que trabajan, y almacenan la información. Estas
variables son GRADOS_MOTOR_, en la cual guardan la conversión a número entero recibido por
bluetooth, la variable PULSOS_MOTOR, la cual calcula el número de pulsos donde se desea colocar el
motor, y la variable pprotation_MOTOR, la cual se ha diferenciado dependiendo del modelo de motor
en utilización, ya que al tener diferentes reductoras, tienen diferente resolución.
Figura 102. Código en C de la función conversión_pulsos
Memoria
100
Figura 103. Código en C de las definiciones de las relaciones de los engranajes y de la resolución de los motores.
Además, desde el bucle principal del sistema, se actualizan constantemente los valores de ENCODER,
INPUT y OUTPUT_PID, figura 93, estos valores se guardan, así mismo, en variables independientes
numeradas con el motor con el que están relacionadas.
La variable ENCODER, se obtiene del temporizador encargado de guardar en su registro la posición del
encoder. La variable INPUT, se obtiene al llamar a la función control_motor_ (numerada según el
motor) con el valor de ENCODER. Una vez en la función, figura 104, se declara una interna,
OUTPUT_PROCESS y tres condicionales. La primera condición, se cumple al arrancar el motor, cuando
la diferencia entre la posición deseada y la marcada por el encoder es superior a 199 y fijándola en 199,
su valor máximo para el PID introducido en el período del temporizador utilizado como contador. La
segunda condición controla la parada del motor cuando el encoder detecta que está en la posición que
se le ha marcado. Y la tercera condición, determina la dirección que ha de girar el motor para alcanzar
la posición deseada. Al finalizar la condición, independientemente la que se haya cumplido, devuelve
el valor de la variable OUTPUT_PROCESS, a la cual se le ha asignado el valor del ENCODER. Además, en
la función, se ha agregado un margen de error de 6 en el segundo condicional, lo que permite
estabilizar el motor, con un error de 0,5 º.
Figura 104. Código en C de la función control_motor
Construcción y programación del control de un brazo mecánico con STM32
101
En el caso de la función de segundo motor, control_motor_2, la principal diferencia es el SETPOINT
utilizado, en la primera función se utilizaba el SETPOINT_1, mientras que, en la segunda, el valor
utilizado para determinar la posición deseada del motor es el SETPOINT_2, así como la variable enviada
a la función era el ENCODER_2. Además, al tener una resolución mucho más elevada, se ha agregado
un error de 10 en el segundo condicional, que equivale a 0,375 º.
Figura 105. Código en C de la función control_motor_2
Las funciones control_motor_3 y control_motor_4, con las diferencias que ambas utilizan sus propias
variables, SETPOINT_3, SETPOINT_4, ENCODER_3 y ENCODER_4, pero están estructuradas de igual
manera que la primera función, control_motor_, debido a que en estas secciones se está trabajando
con el mismo motor que en la primera sección.
Finalmente, el último “tipo” de función presente es la DoFullPID, la cual es la función presente en la
librería utilizada del PID, que calcula el error a corregir por la posición del motor mediante tres variables
introducidas. Las variables necesarias para el controlador PID son el INPUT, que corresponde a la
posición del motor actual, el SETPOINT, que corresponde a la posición del motor deseada, y el
COEF_MOTOR, que corresponde a los parámetros del PID dependiendo del motor que se quiera
regular. Finalmente, el resultado devuelto por la función se almacena en la variable OUTPUT_PID, la
cual es utilizada en la función control_motor, generando un lazo cerrado del sistema.
Memoria
102
Figura 106. Código en C de la función DoFullPID de la librería de ST [30]
7.1.2.4. Comunicación Bluetooth de la placa de desarrollo
En la realización de la comunicación Bluetooth, se ha mantenido el mismo diseño que en el caso 1. El
cual, como se comentó en el primer caso, se deberán configurar los pines para la comunicación serie
de TX_DATO y RX_DATO que se utilizarán del microcontrolador, esto se realizará nuevamente desde
el software STM32CubeM que se utilizaron los pines PB10 para el TX, y PB11 para el RX, pines que
corresponden al bus de comunicación USART3.
Una vez generado el código de Keil uVision v.5, en el main, se encontrará la función de inicialización
del USART3. En ella se deberá habilitar el reloj del USART3, para ello en el espacio destinado para la
edición de código por el usuario se introduce la instrucción _UART3_CLK_ENABLE, como se hizo en el
primer caso.
A continuación, para recibir los datos transmitidos por el teléfono móvil, fuera del bucle principal while
se introduce la función HAL_UART_RECEIVE_IT, la cual es una interrupción que se activa al recibir
datos, también como en el primer caso.
Construcción y programación del control de un brazo mecánico con STM32
103
Y finalmente, se recuerda que, para transmitir los datos recibidos de vuelta, donde se comprobarán si
se han recibido correctamente, se utiliza la función HAL_UART_TRANSMIT, al no tratarse esta de una
interrupción, ha de estar dentro del bucle while.
7.1.2.5. Programación del ADC
En el segundo diseño de hardware, se incluyó una pantalla LCD por la que se mostrarían los valores de
la corriente, potencia para los primeros 3 motores y el error en grados y la posición en grados de los 4
motores utilizados.
En el caso de los valores de corriente y potencia se obtienen gracias a la salida M1CS y M2CS del driver
VNH5019. El pin CS permite obtener la corriente consumida por el motor entregando una tensión
proporcional a la corriente consumida, variando la tensión de la salida entre 140 mV/A. Para tratar esta
señal, se han utilizado 3 pines de la placa de desarrollo. Estos pines se han configurado como ADC. Los
pines utilizados han sido, para el primer motor el pin PA1, ADC1, para el segundo motor el pin PA4,
ADC2, para el tercer motor el pin PC0, ADC3 y para el cuarto motor no se han mostrado los datos de
corriente y potencia, debido a que la placa solo disponía de 3 ADC y se consideró que el esfuerzo de la
última sección al tener menor peso era la menos significativa.
Además, para enviar los datos a la pantalla LCD se ha utilizado el protocolo de comunicación I2C, por
lo que era necesario configurar dos pines de I2C, se han utilizado los pines PA8 y PC9, para el SCL y el
SDA respectivamente, los cuales pertenecen al I2C3 de la placa. Y finalmente, como toda la información
no podía mostrarse en la pantalla LCD al mismo tiempo, y el ADC funciona como una interrupción, se
configuró el botón azul de la placa de desarrollo como GPIO_EXTI0, para generar una interrupción que
llame a mostrar la información deseada. Todos los pines mencionados se muestran recuadrados en
azul en la figura 107.
Una vez configurados los pines necesarios, se puede volver a generar el código. Y elaborar el programa
en el proyecto generado en Keil uVision v.5. Y en el proyecto, como con los demás pines configurados
anteriormente, se habrán generado las funciones de inicialización necesarias para su uso.
A continuación, se declaran las variables necesarias para trabajar los valores deseados, estas se
muestran en la figura 108.
A continuación, se introducen en la función HAL_ADC_ConvCpltCallback los valores de los distintos ADC
dentro de las variables VALOR_ADC_1, VALOR_ADC_2 y VALOR_ADC_3. Esta función trabaja como una
interrupción.
Memoria
104
Figura 107. Simulación de las entradas y salidas del microcontrolador STM32F407VGTx configuradas en el software STM32CubeMX. recuadrado en azul, los pines utilizados para el ADC, la comunicación I2C y la generación de la interrupción mediante el botón.
Figura 108. Variables declaradas para la programación de los canales ADC y para la representación de los datos obtenidos por la pantalla LCD mediante comunicación I2C, así cómo las variables necesarias para realizar los cálculos.
Figura 109. Función interrupción donde se llama al valor de los ADC.
Construcción y programación del control de un brazo mecánico con STM32
105
Además, se crea la función get_current y get_potencia las cuales se utilizarán para realizar la conversión
de la tensión subministrada por el CS a la corriente y potencia consumida por el motor. Para observar
la corriente, se declaran dos variables flotantes, tensión y corriente, las cuales se utilizarán para realizar
la conversión de la tensión recibida desde el pin CS del driver del motor. Para realizar la conversión, la
variable tensión se iguala al producto del valor recibido por la variable ADC con un valor de 3.3 (tensión
máxima entregada) y se divide por 4096, que equivale a una resolución de 12 bits, que es el rango
máximo de valores para la tensión de 3.3 V.
A continuación, la variable current, se realiza un factor de conversión entre la variable tensión,
recientemente calculada, multiplicándola por 1000 (1 V es igual a 1000 mV) y se divide entre 140 mV,
que es el valor de mV/A de la relación del driver. Finalmente, se devuelve el resultado de la corriente.
Figura 110. Función para el cálculo del valor de la corriente consumida de los motores mediante la relación de proporción proporcionada por el ADC, que recibe la señal del pin CS del controlador motor.
Además, se realiza el cálculo de la potencia consumida, este cálculo, al ya haber obtenido el valor de la
corriente, se obtiene de la multiplicación de esta con el valor del voltaje proporcionado por la fuente
de alimentación. Resultando en la función de la figura X. Se ha multiplicado por 11.4 y no por 12, debido
a que, aunque la tensión teórica de la fuente era de 12 V, a la práctica el valor máximo obtenido era de
11,4 V.
𝑃 (𝑊) = 𝑉 (𝑉) · 𝐼 (𝐴) [12]
Figura 111. Función para el cálculo del valor de la potencia consumida de los motores mediante la relación de proporción proporcionada por el ADC, que recibe la señal del pin CS del controlador motor.
Estas dos funciones, se llaman desde la función del botón. En esta función, la cual trabaja como una
interrupción, se realiza un condicional que se cumple cuando se pulsa el botón. Dentro del condicional,
se actualizan los valores de las variables que almacenan el ADC y se realiza un contado, i++, el cual cada
vez que entra en el condicional suma uno a su valor. A continuación, si el condicional ha llegado a 6, se
reinicia su valor a 0.
Memoria
106
Figura 112. Función ejecutada al realizar la interrupción con el botón. Se observa como al entrar en ella se encuantra un primer condicional, en el cual se inician los valores de los ADC.
Seguidamente, se ha diseñado un switch case de 6 casos. En el primer caso, cuando el contador es 1,
se vacía la pantalla del LCD y se calculan los valores de las corrientes, una vez estas se han obtenido, se
transforman a tipo de texto y posteriormente se muestran por la pantalla del LCD, colocando el valor
de cada motor en una línea distinta, figura 113.
Figura 113. Primer caso del switch-case, en el cual se obtiene el valor de las corrientes consumidas y estas se muestran por pantalla.
Cuando se cumple la segunda condición, por lo que el contador está a 2, por pantalla se mostrara el
valor de la potencia consumida por el motor. Para ello se llama a la función get_potencia que calcula
el valor, el valor obtenido se transforma en texto y se muestra en pantalla, con los datos de cada motor
en una línea distinta, figura 114.
Figura 114. Segundo caso del switch-case, en el cual se obtiene el valor de las potencias consumidas y estos se muestran por pantalla.
Construcción y programación del control de un brazo mecánico con STM32
107
En el tercer caso, cuando el condicional es 3, se desea mostrar el error en grados, por lo que primero
se explicará la función a la que llama, get_error_encoder, la cual es la encargada de calcular el error.
La función, si es capaz de mostrar el error para los cuatro motores, debido a que las variables que utiliza
son las del ENCODER y el SETPOINT de cada motor. Se han realizado los factores de conversión
necesarios para mostrar el valor en grados, se intentó mostrar también en porcentaje, pero generaba
problemas al mostrarlo por pantalla por el tamaño de los datos.
Figura 115. Función del cálculo del error absoluto en grados del motor.
Una vez explicada la función, se puede ver como en el tercer caso, se obtiene de esta los valores de
error de cada motor, se convierten a texto y se imprimen por pantalla, con los datos pertinentes de
cada motor en una línea de pantalla distinta.
Figura 116. Tercer caso del switch-case, en el cual se obtiene el valor de los errores absolutos de los motores y estos se muestran por pantalla.
Para el cuarto caso, no es necesario realizar ninguna función extra para calcular los datos deseados
para mostrar por pantalla, ya que se muestra la posición angular de cada motor en grados. Por ello, se
utilizan las variables que almacenan las posiciones de los motores en grados, se convierten en texto y
se imprimen por pantalla, con los datos de cada motor en una línea distinta.
Memoria
108
Figura 117. Cuarto caso del switch-case, en el cual se envían los valores de los grados para mostrarlos por pantalla.
Para el quinto caso, tampoco es necesario realizar ninguna función extra para calcular los datos
deseados a mostrar por pantalla, ya que se muestra el valor del SETPOINT y del ENCODER. Por ello, se
utilizan las variables que almacenan los distintos valores, se convierten en texto y se imprimen por
pantalla, con los datos de cada motor en una línea distinta.
Figura 118. Quinto caso del switch-case, en el cual se envían los valores de los SETPOINT y los ENCODERS para mostrarlos por pantalla.
Finalmente, hace falta aclarar que se ha utilizado la librería i2c [32], para mostrar los datos por pantalla,
con la cual ya se obtenían las funciones necesarias. Para utilizarla, como con las demás librerías, es
necesario declararla al inicio del main.
Figura 119. Código en C de la declaración de la librearía.
7.2. Programación de la aplicación móvil
Para el control manual del brazo robótico es necesario transmitirle a la placa de desarrollo la posición
angular deseada de cada motor. Por motivos de seguridad, se decidió transmitir la posición a distancia,
Construcción y programación del control de un brazo mecánico con STM32
109
debido a que realizarlo desde la placa de desarrollo comportaría estar dentro del área de trabajo del
brazo robótico, lo que podría resultar peligroso para el usuario.
Para la transmisión mediante Bluetooth de las posiciones angulares de cada robot se diseñó una
aplicación móvil, compatible con los sistemas operativos Android y IOS, capaz de conectarse al módulo
Bluetooth LE y transmitirle los ángulos deseados.
En este apartado, se describirá el proceso que se siguió en su diseño, así como de las partes, y detalles
relevantes de la aplicación móvil diseñada en la plataforma Unity, descrita anteriormente, en el
lenguaje de programación C#.
En primer lugar, se ha de crear el proyecto en Unity 3D, se ha de seleccionar la opción de 3D para poder
introducir el modelo del brazo mecánico. Además, al crear el proyecto se deberá asignar el nombre del
proyecto y la dirección donde se desea guardar, figura 120.
Figura 120. Pantalla del Unity Hub para la creación de un nuevo proyecto.
A continuación, se ha de crear el Canvas, figura 121, dentro del cual se generarán las diferentes
pantallas en dos dimensiones que contendrán los diferentes objetos para realizar la conexión
Bluetooth y el control del brazo robótico.
Memoria
110
Figura 121. Creación del Canvas en la pantalla de inicio del nuevo proyecto en Unity.
En primer lugar, se ha de programar tanto el front end, que es la parte de la aplicación que puede verse,
como el back end, que es la parte de la aplicación que realiza las operaciones para que esta funcione,
que permita realizar la conexión Bluetooth, para ello se ha utilizado la librería Bluetooth LE for iOS, tvOS
and Android de Shatalmic [33]. La librería contiene la configuración necesaria para poder realizar la
conexión desde la aplicación móvil con módulos Bluetooth LE, tanto para dispositivos con sistemas
operativas iOS y Android. La librería no se ha incluido en los anexos, debido a que esta no es de
distribución libre.
7.2.1. Programación para realizar la conexión Bluetooth. (Front end)
A continuación, se realiza el front end de la aplicación desde la interfaz de edición de Unity. Para ello
se genera un primer panel, PanelInActive, el cual se utilizará para contener los demás paneles,
delimitando por tanto el tamaño de estos. Además, se crea el panel Panel Active, el cual se mantendrá
vacío y se utilizará como una “base” sin contenido.
A continuación, dentro del panel PanelInActive, generan los paneles PanelCentralTISensorTag,
PanelTypeSelection y PanelCentral. El primer panel que se mostrará al abrir la aplicación será el
PanelTypeSelection, en el cual se podrá escoger continuar a la interfaz de búsqueda de dispositivos
mediante un botón, el ButtonCentra, figura 122.
Construcción y programación del control de un brazo mecánico con STM32
111
Figura 122. Aspecto del PanelTypeSelectio desde la APP
A continuación, se mostraría el panel PanelCentral, en la cual se realiza la búsqueda de dispositivos
haciendo clic sobre el ButtonScan. Además, dentro del panel, se encuentra el PanelPeripherals, en el
cual se mostrarán los dispositivos encontrados. Y también se ha incluido otro botón, el ButtonBack, el
cual al ser seleccionado te redirige al panel anterior. Al seleccionar uno de los dispositivos mostrados,
se redirigirá al siguiente panel, el panel PanelCentralTISensorTag.
Figura 123. Aspecto del PanelCentral antes y despues de pulsar el botón ButtonConnect
Memoria
112
En el PanelCentralTISensorTag, se ha vuelto a incluir un botón que permite volver al panel anterior,
ButtonBack, dos contenedores de texto que muestran el nombre y la dirección del dispositivo, Text
Name y TextAddress, y el botón ButtonConnect, que permite conectarse al dispositivo.
Al realizarse correctamente la conexión con el módulo Bluetooth, aparecerá otro panel,
PanelScrollView, dentro del mismo Panel, justo debajo del ButtonConnect, y se cambiará el texto del
ButtonConnect a “Desconectar”, sirviendo este, por lo tanto, para desconectarse del dispositivo.
Figura 124.Aspecto del PanelCentralTISensorTag antes y después de pulsar el botón ButtonConnect.
En el PanelScrollView, se muestran los diferentes objetos que permiten el control de la posición de los
motores. En primer lugar, un selector del número de motores que componen el brazo robótico, ya que
este es modular y puede variar en el número de secciones que componen. Una vez, el número de
motores escogido, se muestran dos botones, para sumar y restar grados, un InputText para introducir
el número de grados deseado, y un texto con el valor de los grados del motor por cada motor. Además,
se incluye un botón para cerrar y abrir la pinza y un botón para posicionar las secciones en su posición
inicial.
Y finalmente, se agregado un objeto 2D, ImageBusy, el cual se mostrará sobre los distintos paneles en
caso de que el programa se quede cargando o encallado hasta avanzar al siguiente panel deseado.
Construcción y programación del control de un brazo mecánico con STM32
113
Figura 125. Elementos del Canvas declarados que conforman los distintos paneles del front end de la aplicación.
Fuera del Canvas, se han agregado los objetos 3D. Los cuales se han extraído del diseño del brazo
robótico y el fondo del diseño de código libre [34]. Las diferentes secciones del brazo robótico se han
concatenado debido a que los objetos dentro de otro heredan los cambios realizados en el primero.
Pero ello para simular el movimiento del motor, era importante que, al rotar por ejemplo la primera
sección, rotaran las demás secciones.
Figura 126.Elementos 3D que conforman la imagen mostrada en el editor del brazo robótico.
Memoria
114
7.2.2. Programación para realizar la conexión Bluetooth. (Back end)
A continuación, se han de realizar los scripts que permitirán que la aplicación funcione y realice las
acciones deseadas. Los scripts que se mencionan se encuentran en el anexo 3.
En primer lugar, el script BLETestScript, realiza la función de mostrar los diferentes paneles. Este se
compone de una función, la cual es llamada al iniciarse el script, la cual si no se ha cargado ninguna
pantalla va a buscar el Canvas, el cual si no está vacío se vuelve a llamar la función nuevamente. En el
caso de que se haya cargado el Canvas, en la función se entra en el segundo condicional el cual permite
cargar el panel PanelActive y encima de este el panel PanelTypeSeleccion, el cual se había introducido
como variable en la función.
Figura 127. Código en C# del BLETestScript
En la pantalla de la figura 122, que pertenece al panel PanelTypeSeleccion, se puede observar se
encuentra un botón, el cual está programado para llamar a la función OnCentral del script
TypeSelectionScript. Esta acción se fija desde la interfaz del editor Unity, para ello se ha de seleccionar
el botón en la barra lateral izquierda para abrir el inspector del objeto. El Inspector del objeto se nos
abrirá como una barra lateral derecha donde se puede modificar el tamaño, la posición el nombre, el
aspecto… y también permite agregarle una acción al ser seleccionado, para ello en la opción de la
función “On Click ()” se puede seleccionar cuando se ejecutará la acción, y será necesario marcar en el
objeto o panel que se realizará la acción. Para ello se deberá arrastrar el objeto del PanelTypeSeleccion
al recuadro inferior y seguidamente se mostrarán las acciones disponibles del objeto, no se mostrará
ninguna si en el objeto del panel no se ha ligado ningún script previamente. En las figuras 128, 129 y
130 se muestra el proceso.
Construcción y programación del control de un brazo mecánico con STM32
115
Figura 128.Configuración de la función On Click () del botón para llamar la función deseada.
Memoria
116
Figura 129. Configuración de la función On Click () del botón para llamar la función deseada. En la flecha azul se marca el panel a arrastrar al recuadro de la función.
Figura 130. Configuración de la función On Click () del botón para llamar la función deseada. Se muestra el desplegable que aparece en la función, una vez arrastrado el panel que contiene el script, y las opciones que aparecen.
Este proceso permite llamar a la función OnCentral del script TypeSelectionScript. En esta función se
llama al panel PanelCentral, cambiando por tanto de ventana a la que se muestra en la figura 123.
Construcción y programación del control de un brazo mecánico con STM32
117
Figura 131. Código en C# del script TypeSelectionScript.
En el PanelCentral, se encuentran los objetos necesarios para realizar la conexión con el módulo
Bluetooth. En primer lugar, se ha de ligar el PanelCentral con el CentralScript, como se ha realizado en
el panel, figura 128, anterior para poder llamar las diferentes funciones desde los botones del panel.
En el botón ButtonBack, se llama a la función OnBack del script CentralScript. Dentro de esta función
se llama a la función RemovePeripheral, la cual cerrará el panel donde se muestran los dispositivos, y
en el condicional, si se está escaneando por dispositivos, se llamará a la función OnScan, la búsqueda
de dispositivos en caso de estarse efectuando, y a continuación se volverá a llamar al panel
PanelTypeSelection.
En el PanelCentral, también se encuentra el botón ButtonScan, el cual llama a la función OnScan del
script CentralScript. Esta función, en caso de estarse escaneando para la búsqueda de dispositivos, y
en el caso contrario llama a las funciones de la librería utilizada necesarias para la búsqueda de
dispositivos, la obtención de la dirección y nombre de los dispositivos disponibles. Además, llama a
mostrar el panel PanelScrollContents donde se mostrarán como una lista los dispositivos encontrados.
Para mostrarlos cómo una lista, se generará un GameObject por cada dispositivo encontrado,
heredando este, las características recibidas. Esta función se realiza gracias a las funciones
RemovePeripheral y AddPeripheral. Además, en la función AddPeripheral, se inicializa el objeto como
si fuera un botón, con la acción de llamar al script CentralPeripheralButtonScript. En esta función, se
heredan las características leídas anteriormente, y se comprueba si el nombre del dispositivo contiene
el nombre deseado. Si no es el dispositivo deseado, no realiza ninguna acción, mientras que, si es el
dispositivo deseado, llama al panel PanelCentralTISensorTag. El código se encuentra en el anexo 3.
Memoria
118
Al coincidir el dispositivo, se abre la ventana de la figura 124, la cual pertenece al panel
PanelCentralTISensorTag. Este, como los anteriores, se ha ligado al script CentralTISensorTagScript
para poder acceder desde los objetos del panel a las funciones que este contiene. Además, los objetos
definidos en el script se mostrarán en el Inspector del panel, como se muestra en la figura 132.
Figura 132. Ventana del Inspector en Unity donde se realiza la asignación de las variables con los objetos del PanelCentralTISensorTag.
En el CentralTISensorTagScript se han realizado las funciones que permitirán la manipulación del robot
mediante Bluetooth, estas se describirán a continuación paso a paso para poder comprender su
funcionamiento.
En primer lugar, se añadieron al panel, como ya se había comentado, dos botones, un InputField y un
TextBox por cada motor a controlar. Para poder conectar los objetos de texto con el script en cuestión,
se tenían que declarar en este como se muestra en la figura 133.
Construcción y programación del control de un brazo mecánico con STM32
119
Figura 133. Declaración de las variables asociadas a los objetos de texto de la pantalla PanelCentralTISensorTag
A continuación, como con los paneles, se debía unir la variable declarada con el objeto en cuestión.
Esta función se realiza desde el editor de Unity, Para ello se ha de volver a ir al Inspector, donde se
muestran todas las variables declaradas dentro del script al que se ha unido. Para unir, el objeto con
su definición del script se deberá seleccionar el objeto y arrastrarlo hasta el recuadro que habrá
aparecido de la variable en el Inspector.
Figura 134. Relación de las variables del script con los objetos del panel.
Además, como con los botones anteriores, se deberá configurar las funciones que llaman al ser
seleccionados. Los dos botones sirven para sumar o restar grados, siendo los botones que contienen
Plus, para sumar, y los botones que contienen, Less, para restar.
Las funciones que llamarán los botones serán las que efectúan la suma y resta de los grados. Estas
funciones se encuentran dentro del script CentralTISensorTagScripts, y se ha realizado una función para
cada botón y cada InputField. Además, por cada motor se han realizado diversas variables para el
funcionamiento interno de programa, las cuales sirven para operar y transmitir los valores deseados.
Memoria
120
Figura 135. Pantalla principal del editor de Unity. Recuadrado en azul el objeto del botón de suma del primer motor y la función que se le ha asignado.
Una vez explicadas las diferentes conexiones entre el panel, los objetos y el script, se puede explicar el
funcionamiento de este último. En primer lugar, para realizar la conexión con el módulo Bluetooth, se
declaran tres booleanos, _connecting, _connectedID y _connected. Los cuales se utilizan para poder
cambiar el texto del botón ButtonConnect, y en caso de querer desconectar, dejar de mostrar el
PanelTemperature, donde se encuentran los objetos para el control del motor.
Figura 136. Código en C# del booleano gestor de la conexión en el script CentralTISensorScript.
Construcción y programación del control de un brazo mecánico con STM32
121
Pero al entrar al script, lo primero que se ejecutará es el Script Initialize, el cual fijará los valores del
booleano Connected y el estado del PanelTemperature cómo “false” por lo que estará desactivado, y
se entrará en el booleano anterior introduciendo el valor y cambiando el estado del botón, como se
había comentado en el parágrafo anterior.
Figura 137. Código en C# de la inicialización del script CentralTISensorTagScript.
Además, al inicio del script, también se han incluido las funciones de los botones ButtonConnect, figura
138, y ButtonBack, figura 139. La primera llamando a la librería para realizar la conexión con el
dispositivo, y la segunda llamando al panel anterior y desconectando cualquier conexión establecida.
Llamando a la función disconnect para realizar la desconexión en caso de cumplir la condición, figura
140.
Figura 138.Código en C# de la función OnConnect () encargada de realizar la conexión con el módulo Bluetooth.
Memoria
122
Figura 139. Código en C# de la función OnBack encargada de volver a la pantalla anterior, PanelCentral y desconectar el Bluetooth.
Figura 140. Código en C# de la función disconnect, encargada de anular cualquier tipo de conexión
A continuación, se encuentran tres funciones aptas para la manipulación y transmisión de la posición
de los motores. En la función PlusOne, si el valor de la variable entera OneOne es inferior a 360, valor
máximo de los grados del motor, suma 10, a la variable OneOne. Luego se transforma la variable
OneOne en una cadena de caracteres apta para transmitirla mediante el bluetooth. Se agregan tres
condicionales, el primero cuando el valor de OneOne es menor a 10, significa que al transformar el
entero a char, será un solo carácter, por lo que este se introduce en el último carácter de la cadena de
caracteres OneOneString. Así mismo, se realiza la misma acción con el mismo criterio para los otros
dos condicionales y en la función LessOne.
Figura 141. Código en C# de las funciones PlusOne y LessOne, encargadas de realizar la suma y resta de los grados del primer motor.
Construcción y programación del control de un brazo mecánico con STM32
123
En el caso del Input Field, se transforma el string obtenido a entero y este se introduce de igual manera
que en las anteriores funciones en la variable OneOneString.
Figura 142. Código en C# de la función OneOneInput, encargada de leer la posición introducida manualmente en el Input text del primer motor.
En las tres funciones, al salir de los condicionales, se llama a la función SendString, la cual, mediante la
librería utilizada, envía la cadena de caracteres del motor que se desea, en el caso del ejemplo anterior,
la variable OneOneString. Al finalizar la acción, se llama a la función ReadString, la cual leerá el valor
que ha enviado el módulo Bluetooth al recibir la posición enviada, para así realizar la comprobación
que la posición ha sido transmitida correctamente.
Figura 143. Código en C# de la función SendString, encargada de enviar la posición del motor deseada.
En la posición ReadString, se utilizan funciones de la librería para leer los valores que envía el bluetooth.
Y procesarlos mediante la función ProcessText.
Memoria
124
Figura 144. Código en C# de la función ReadString, encargada de leer la posición enviada de vuelta por el prototipo.
En la función ProcessText, se reciben los datos en formato byte, estos datos se ha de comprobar que
contengan información, en cuyo caso se convierten a texto, eliminando los guiones que contienen
separando los diferentes valores y enviándolos a la función Converthex, debido a que se encuentran
en hexadecimal y es necesario convertirlos en decimal para poder tratarlos.
Figura 145. Código en C# de la función ProcessText y ConvertHex, encargadas de convertir los datos recibidos en hexadecimal
a decimal.
A continuación, en la función ConvertHex, se realizan las acciones necesarias para modificar de dos en
dos los valores a decimal, y a continuación, se llama a la función motorSeleccion con el valor
modificado.
En esta función, se lee el primer carácter de la cadena, el cual será una letra en mayúscula diferente
dependiendo del motor deseado, y dependiendo del motor en cuestión, se actualizará el valor del
cuadro de texto y de la variable entera que almacena el número de posición, debido a que si no se
hubiera efectuado el envío volviera al valor correcta. Además, se llama a la función AxisRotateX, siendo
X una letra diferente dependiendo del motor, que es la encargada de realizar el movimiento de los
objetos que representan las distintas partes del motor en la aplicación.
Construcción y programación del control de un brazo mecánico con STM32
125
Figura 146. Código en C# de las funciones MotorSeleccion y AxisRotateA, encargadas de la selección del motor sobre la que se ha recibido los datos y actuar sobre el diseño 3D del primer motor de la aplicación.
Además, en el panel también se agregó un botón de reset, el cual posicionaría a las diferentes secciones
en sus posiciones iniciales. Esto era de vital importancia debido a que, si se desea desconectar el robot
de la corriente, los encoder de este pierden la posición, debido a que son incrementales y al encenderse
volverían a contar desde 0, por ello es necesario antes de apagar el equipo o desconectarse volver a
posicionar todos los motores en su posición inicial.
Finalmente, se agregó el botón para el control de la pinza, función del cual funciona igual que los
botones de suma y resta, los cuales envían un valor, con una letra, dependiendo, en este caso, del
estado anterior de la función, con un booleano.
Memoria
126
Tambien cabe mencionar, que desde el diseño de la aplicación se limitó el movimiento de los distintos
ejes del brazo robótico, limitando el rango de funcionamiento de la primera sección a 180 º, de la
segunda sección a 30 º, de la tercera sección a 360 º y de la cualta sección a 60 º. La sección 5 y 6 no se
limitaron al no estar montadas, por lo que al seleccionar sus botones, la aplicación transmitirá los datos,
pero el brazo robótico no reaccionará al no estar configurado para ello.
7.2.3. Compilar la APP para poderla instalar en el Smartphone
Una vez hayamos finalizado el diseño de la aplicación, deberemos compilar esta para poderla instalar
en nuestro Smartphone. El procedimiento varia si este funciona con sistema operativo Android o iOS.
En el caso del sistema operativo Android, el procedimiento será mucho más simple. Lo único que
deberemos hacer, es seleccionar Build Settings en la pestaña File. Haciendo clic sobre esta opción se
abre la ventana de la figura 148.
Figura 147. Opciones del desplegable File en Unity. En azul la opción a seleccionar.
Figura 148. Ventana Build Settings de Unity
Construcción y programación del control de un brazo mecánico con STM32
127
En esta, se deberá comprobar que se ha seleccionado la escena relativa a la aplicación. Y se deberá
seleccionar para que sistema operativo se desea compilar el proyecto. En este caso se deberá
seleccionar Android y seleccionar Switch Platform en la parte inferior del selector.
Una vez realizado, se mostrará la ventana como en la figura 149, y se podrá seleccionar Build. Se deberá
seleccionar donde se desea guardar el archivo y el compilador generará un archivo tipo APK, apto para
instalar en un Smartphone con Android. Solo se deberá enviar el archivo al dispositivo, picar sobre este
y se podrá realizar la instalación.
Figura 149. Ventana de Build Settings con la configuración Android seleccionada.
En el caso de querer instalar la aplicación en un iPhone o iPad, el procedimiento es un poco más
complicado. En primer lugar se deberá seguir el mismo procedimiento que para Android, pero
seleccionando la opción iOS. Al seleccionar Build, Unity creará un documento apto para ser leido por
xCode, el compilador oficial de Apple. Por lo que deberemos enviar el proyecto generado a un MAC o
máquina virtual que contenga el sistema operativo MAC OS Catalina 10.15.6.
Figura 150. Ventana de Build Settings con la configuración iOS seleccionada.
Memoria
128
En el MAC, deberemos abrir la APP Xcode, e importar el proyecto. Una vez importado se mostrará
como en la figura 151. Se hace clic en el archivo deseado y se abrirá la pantalla de la figura 152.
Figura 151. Ventana inicial de la aplicación Xcode
En la aplicación, deberemos ir a la pestaña Signing & Capabilities, en la cual deberemos introducir
nuestro usuario de desarrollador de Apple e introduciremos el nombre de la aplicación.
Figura 152. Ventana Signing & Capabilities de Xcode. Recuadrado en azul el usuario de desarrollador de Apple y el nombre de la aplicación.
A continuación, como la librería utilizada era previa a la versión de iOS13, se debía incluir en el archivo
de plis el informe de Privacy – Bluetooth Always Usage Drecription, necesario para obtener los
permisos de conexión a él Bluetooth en los dispositivos con una versión igual o superior al iOS 13.
Además, en la figura 153, se ha remarcado en azul, las dos descripciones en plis que otorgan los
permisos para utilizar el sensor Bluetooth.
Construcción y programación del control de un brazo mecánico con STM32
129
Figura 153. Ventana del archivo plis, con los informes necesarios de permisos para los dispositivos.
Una vez realizados estos cambios, se deberá conectar por cable el dispositivo, iPhone o iPad, y
seleccionar ejecutar la compilación seleccionando el botón recuadrado en azul de la figura 154.
Figura 154. Ventana xCode, recuadrado en azul el icono para ejecutar el compilador.
Si el dispositivo es compatible, el propio programa compilará y a la vez instalará la aplicación en el
dispositivo, abriéndose en el iPhone o iPad.
Memoria
130
7.3. Programación de los algoritmos o matrices de posicionamiento del robot.
Representación de Denavit-Hartenberg (D-H).
Como se había comentado en los antecedentes, en este apartado, se describirá el procedimiento del
algoritmo de Denavit-Hartenberg (D-H) tanto para la obtención del modelo cinemático directo como
del inverso.
En el caso cinemático directo que permite conocer la posición del elemento terminal conociendo los
valores de cada eslabón, se realizará mediante la representación de Denavit-Hatenberg (D-H). Este es
un modelo matricial que fija la localización de cada sistema de coordenadas (S) según el eslabón y la
articulación del motor. Esto permite, obtener una cadena completa de las distintas ecuaciones del
sistema sistemáticamente. Lo que permitirá de un sistema al siguiente mediante 4 transformaciones
que dependen exclusivamente de las características geométricas del eslabón, si estos son rígidos y se
escogen el sistema de coordenadas correctos (mientras con la matriz de transformación homogénea
serian 6).
Las transformaciones que se realizaran son translaciones y rotaciones sucesivas que permitan
relacionar el sistema de referencia anterior, con el sistema estudiado, sobre el sistema móvil. Además,
se fijan unas condiciones para poder garantizar el resultado, los cuales son los parámetros de Denavit-
Hatenberg.
1. Rotación alrededor del eje OZ, un ángulo 𝜃𝑖
2. Translación a lo largo de 𝑧𝑖−1una distancia 𝑑𝑖; vector 𝑑𝑖(0, 0, 𝑑𝑖)
3. Translación a lo largo de 𝑥𝑖una distancia 𝑎𝑖; vector 𝑎𝑖(𝑎𝑖, 0, 0)
4. Rotación alrededor del eje 𝑥𝑖, un ángulo 𝛼𝑖.
Cabe recordar, que la multiplicación de matrices no es conmutativa, por lo que su multiplicación
deberá realizarse por orden. Por lo que la matriz, de cada eslabón, se puede obtener con la ecuación
13.
𝐴𝑖 𝑖−1 = 𝑅𝑜𝑡𝑧 (𝜃𝑖) · 𝑇(0,0, 𝑑𝑖)𝑇(𝑎𝑖, 0,0)𝑅𝑜𝑡𝑥(𝛼𝑖) [13]
Desarrollándose el producto de matrices, siendo S el seno y C el coseno, resulta:
Construcción y programación del control de un brazo mecánico con STM32
131
𝐴𝑖 𝑖−1 = [
𝐶𝜃𝑖 −𝑆𝜃𝑖 0 0𝑆𝜃𝑖 𝐶𝜃𝑖 0 000
00
10
01
] [
1 0 0 00 1 0 000
00
10
𝑑𝑖
1
] [
1 0 0 𝑎𝑖
0 1 0 000
00
10
01
] [
1 0 0 00 𝐶𝛼𝑖 −𝑆𝛼𝑖 0
00
𝑆𝛼𝑖
0𝐶𝛼𝑖
001
] =
[
𝐶𝜃𝑖 −𝐶𝛼𝑖𝑆𝜃𝑖 𝑆𝛼𝑖𝑆𝜃𝑖 𝑎𝑖𝐶𝜃𝑖
𝑆𝜃𝑖 𝐶𝛼𝑖𝐶𝜃𝑖 −𝑆𝛼𝑖𝐶𝜃𝑖 𝑎𝑖𝑆𝜃𝑖
00
𝑆𝛼𝑖
0𝐶𝛼𝑖
0𝑑𝑖
1
] [14]
Para obtener por lo tanto los parámetros D-H y obtener la matriz de transformación, se aplican las
normas establecidas por este, las cuales se han obtenido de Fundamentos de robótica [20].
Normas para la obtención de los parámetros de D-H [20]
DH 1. Numerar los eslabones comenzando con 1 (primer eslabón móvil de la cadena) y acabando con n (último eslabón móvil). Se numerará como eslabón 0 a la base fija del robot. DH 2. Numerar cada articulación comenzando por 1 (la correspondiente al primer grado de libertad) y acabando en n. DH 3. Localizar el eje de cada articulación. Si ésta es rotativa, el eje será su propio eje de giro. Si es prismática, será el eje a lo largo del cual se produce el desplazamiento. DH 4. Para i de 0 a n_1 situar el eje zi sobre el eje de la articulación i _ 1. DH 5. Situar el origen del sistema de la base {S0} en cualquier punto del eje z0. Los ejes x0 e y0 se situarán de modo que formen un sistema dextrógiro con z0. DH 6. Para i de 1 a n_1, situar el origen del sistema {Si} (solidario al eslabón i) en la intersección del eje zi con la línea normal común a zi–1 y zi. Si ambos ejes se cortasen se situaría {Si} en el punto de corte. Si fuesen paralelos {Si} se situara en la articulación i _ 1. DH 7. Situar xi en la línea normal común a zi–1 y zi. DH 8. Situar yi de modo que forme un sistema dextrógiro con xi y zi . DH 9. Situar el sistema {Sn} en el extremo del robot de modo que zn coincida con la dirección de zn–1 y xn sea normal a zn–1 y zn . DH 10. Obtener θ i como el ángulo que hay que girar en torno a zi–1 para que xi–1 y xi queden paralelos. DH 11. Obtener di como la distancia, medida a lo largo de zi–1, que habría que desplazar {Si–1} para que xi y xi–1 quedasen alineados. DH 12. Obtener ai como la distancia medida a lo largo de xi (que ahora coincidiría con xi–1) que habría que desplazar el nuevo {Si–1} para que su origen coincidiese con {Si}. DH 13. Obtener α i como el ángulo que habría que girar entorno a xi , para que el nuevo {Si–1} coincidiese totalmente con {Si}. DH 14. Obtener las matrices de transformación i–1Ai definidas en [4.10]. DH 15. Obtener la matriz de transformación que relaciona el sistema de la base con el del extremo del robot T _ 0A1 · 1A2 · n–1An. DH 16. La matriz T define la orientación (submatriz de rotación) y posición (submatriz de traslación) del extremo referido a la base, en función de las n coordenadas articulares.
Además, se definen los parámetros como, 𝜃𝑖el ángulo que forman entre los ejes OX de ambos eslabones, 𝑑𝑖 la distancia entre los ejes 0Z de ambos eslabones, 𝑎𝑖 la distancia entre los ejes OX de ambos eslabones y 𝛼𝑖 como el ángulo entre los ejes OZ.
Memoria
132
Para realizar los cálculos de la estructura, y hallar sus parámetros, en primer lugar, se deberá fijar la posición inicial del brazo en el sistema. Para ello se ha fijado todos los estabones en vertical, para poder facilitar los cálculos. Además, es la posición en la que los motores han de realizar un menor esfuerzo. Se fijan los distintos sistemas de coordenadas sobre el brazo, figura 155.
Figura 155. Esquema de los sistemas de rederencia de las distintas articulaciones del brazo robótico siguiendo lso criterios de Denavit-Hatenberg.
Conociendo las distancias, se pueden obtener los parámetros de D-H. Estos se muestran en la tabla 7.
Articulación 𝞱 (º) d (mm) a (mm) α (º)
1 𝞱1 87 0 0
2 𝞱2 60 0 -90
3 𝞱3 172 0 90
4 𝞱4 60 0 -90
5 𝞱5 172 0 90
6 𝞱6 60 0 -90
Pinza 0 80 0 0 Tabla 7. Parámetros de Denavit-Hatenberg para el brazo robótico mostrado en la figura 147.
Una vez obtenidos los parámetros se pueden elaborar las matrices de transformación para cada
eslabón.
Construcción y programación del control de un brazo mecánico con STM32
133
𝐴1 0 = [
𝐶𝜃𝑖 −𝑆𝜃𝑖 0 0𝑆𝜃𝑖 𝐶𝜃𝑖 0 000
00
10
01
] [
1 0 0 00 1 0 000
00
10
871
] [
1 0 0 00 1 0 000
00
10
01
] [
1 0 0 00 1 0 000
00
10
01
] =
[
𝐶𝜃𝑖 −(1)𝑆𝜃𝑖 0 0𝑆𝜃𝑖 (1)𝐶𝜃𝑖 0 000
00
(1)0
871
] [15]
𝐴2 1 = [
𝐶𝜃𝑖 −𝑆𝜃𝑖 0 0𝑆𝜃𝑖 𝐶𝜃𝑖 0 000
00
10
01
] [
1 0 0 00 1 0 000
00
10
601
] [
1 0 0 00 1 0 000
00
10
01
] [
1 0 0 00 0 (−1) 0
00
(−1)0
00
01
] =
[
𝐶𝜃𝑖 0 (−1)𝑆𝜃𝑖 0
𝑆𝜃𝑖 0 −(−1)𝐶𝜃𝑖 0
00
(−1)0
00
601
] [16]
𝐴3 2 = [
𝐶𝜃𝑖 −𝑆𝜃𝑖 0 0𝑆𝜃𝑖 𝐶𝜃𝑖 0 000
00
10
01
] [
1 0 0 00 1 0 000
00
10
1721
] [
1 0 0 00 1 0 000
00
10
01
] [
1 0 0 00 0 −(1) 0
00
(1)0
00
01
] =
[
𝐶𝜃𝑖 0 (1)𝑆𝜃𝑖 0
𝑆𝜃𝑖 0 −(1)𝐶𝜃𝑖 0
00
(1)0
00
1721
] [17]
𝐴4 3 = [
𝐶𝜃𝑖 −𝑆𝜃𝑖 0 0𝑆𝜃𝑖 𝐶𝜃𝑖 0 000
00
10
01
] [
1 0 0 00 1 0 000
00
10
601
] [
1 0 0 00 1 0 000
00
10
01
] [
1 0 0 00 0 (−1) 0
00
(−1)0
00
01
] =
[
𝐶𝜃𝑖 0 (−1)𝑆𝜃𝑖 0
𝑆𝜃𝑖 0 −(−1)𝐶𝜃𝑖 0
00
(−1)0
00
601
] [18]
𝐴5 4 = [
𝐶𝜃𝑖 −𝑆𝜃𝑖 0 0𝑆𝜃𝑖 𝐶𝜃𝑖 0 000
00
10
01
] [
1 0 0 00 1 0 000
00
10
1721
] [
1 0 0 00 1 0 000
00
10
01
] [
1 0 0 00 0 −(1) 0
00
(1)0
00
01
] =
[
𝐶𝜃𝑖 0 (1)𝑆𝜃𝑖 0
𝑆𝜃𝑖 0 −(1)𝐶𝜃𝑖 0
00
(1)0
00
1721
] [19]
Memoria
134
𝐴6 5 = [
𝐶𝜃𝑖 −𝑆𝜃𝑖 0 0𝑆𝜃𝑖 𝐶𝜃𝑖 0 000
00
10
01
] [
1 0 0 00 1 0 000
00
10
601
] [
1 0 0 00 1 0 000
00
10
01
] [
1 0 0 00 0 (−1) 0
00
(−1)0
00
01
] =
[
𝐶𝜃𝑖 0 (−1)𝑆𝜃𝑖 0
𝑆𝜃𝑖 0 −(−1)𝐶𝜃𝑖 0
00
(−1)0
00
601
] [20]
𝐴𝑃 4/5/6 = [
1 0 0 00 1 0 000
00
10
01
] [
1 0 0 00 1 0 000
00
10
801
] [
1 0 0 00 1 0 000
00
10
01
] [
1 0 0 00 1 0 000
00
10
01
] = [
1 0 0 00 1 0 000
00
10
801
]
[21]
Cuando el brazo robótico esté conformado por todos sus ejes de libertad, la posición del eslabón final
o elemento terminal vendrá dada por la matriz T. Como el robot utilizado es modular, este puede tener
distintos grados de libertad. Así, que, para saber la posición y orientación del elemento terminal, se
deberán seleccionar las matrices de los eslabones seleccionados más la de la pinza. Entonces, para un
brazo robótico de cuatro grados de libertad, como el prototipo final, se obtendría la siguiente matriz.
𝑇 = 𝐴4 ·.0 𝐴𝑃.
4 = 𝐴1 ·.0 𝐴2 ·
1 𝐴4 · 3 𝐴𝑃
4 [22]
Por lo que con la matriz T, se obtendría la posición del elemento terminal. Esta posición, idealmente,
puede tener un área de trabajo de una semi esfera de 459 mm de radio con cuatro grados y con seis
ejes de libertad con un radio de hasta 691mm. En el área de trabajo no se considera ninguna posición
inferior al nivel de la base, debido a que se considera que estará sobre una superficie plana regular,
como una mesa, por lo que el robot se encontraría con un impedimento físico.
Figura 156. área de trabajo ideal de brazo robótico.
Además, se realizan los cálculos necesarios para realizar la cinemática inversa del sistema. Aunque
esta puede realizarse conociendo la cinemática directa del sistema, presenta el inconveniente de la
obtención de múltiples soluciones, siendo, matemáticamente, todas ellas correctas. En primer lugar,
será necesario volver a fijar el sistema de referencia de la figura 155 y los parámetros D-H de la tabla
7.
Construcción y programación del control de un brazo mecánico con STM32
135
Los valores que se desean encontrar en el caso del brazo robótico de 6 grados de libertad son q1, q2,
q3, q4, q5 y q6, que corresponden al ángulo necesario de cada articulación para que el elemento
terminal este donde se desea, posición que vendrá dada por los vectores n, o, a y p.
Siendo T igual al vector mencionado.
𝑇 = [𝑛 𝑜 𝑎 𝑝
0 0 0 1] [23]
𝑇 = 𝐴4 ·.0 𝐴𝑃.
4 = 𝐴1 ·.0 𝐴2 ·
1 𝐴4 · 3 𝐴5 ·
4 𝐴6 · 5 𝐴𝑃
6 [24]
Se tendrá que realizar cálculos iterativos con la función 24, la cual se puede modificar a las siguientes
5 ecuaciones, para obtener un sistema de ecuaciones con solución. Para el último eslabón, no es
necesario aislar ninguna incógnita, por lo que no requiere de ecuación.
( 𝐴1.0 )(−1) · 𝑇 = 𝐴2 · 𝐴3 ·
2
1 𝐴4 · 3 𝐴5 ·
4 𝐴6 · 5 𝐴𝑃
6 [25]
( 𝐴2.1 )(−1) · ( 𝐴1.
0 )(−1) · 𝑇 = 𝐴3 · 2 𝐴4 ·
3 𝐴5 · 4 𝐴6 ·
5 𝐴𝑃 6 [26]
( 𝐴3.2 )(−1) · ( 𝐴2.
1 )(−1) · ( 𝐴1.0 )(−1) · 𝑇 = 𝐴5 ·
4 𝐴6 · 5 𝐴𝑃
6 [27]
( 𝐴4.3 )(−1) · ( 𝐴3.
2 )(−1) · ( 𝐴2.1 )(−1) · ( 𝐴1.
0 )(−1) · 𝑇 = 𝐴5 · 4 𝐴6 ·
5 𝐴𝑃 6 [28]
( 𝐴5.4 )(−1) · ( 𝐴4.
3 )(−1) · ( 𝐴3.2 )(−1) · ( 𝐴2.
1 )(−1) · ( 𝐴1.0 )(−1) · 𝑇 = 𝐴6 ·
5 𝐴𝑃 6 [29]
Con estas ecuaciones, se observa, que es un sistema determinado al tener 5 ecuaciones para 5
incógnitas, al ser un sistema relativamente simple, se puede resolver. En primer lugar, será necesario
conocer la inversa de las matrices.
( 𝐴1.0 )(−1) = [
𝐶𝜃𝑖 −𝑆𝜃𝑖 0 0𝑆𝜃𝑖 𝐶𝜃𝑖 0 000
00
(1)0
871
]
−1
=
[ −
𝐶𝜃𝑖
−𝐶𝜃𝑖2−𝑆𝜃𝑖
2 −𝑆𝜃𝑖
−𝐶𝜃𝑖2−𝑆𝜃𝑖
2 0 0
𝑆𝜃𝑖
−𝐶𝜃𝑖2−𝑆𝜃𝑖
2 −𝐶𝜃𝑖
−𝐶𝜃𝑖2−𝑆𝜃𝑖
2 0 0
00
00
10
−871 ]
=
[
𝐶𝜃𝑖 𝑆𝜃𝑖 0 0−𝑆𝜃𝑖 𝐶𝜃𝑖 0 0
00
00
10
−871
] [30]
Memoria
136
( 𝐴2.1 )(−1) = [
𝐶𝜃𝑖 0 −𝑆𝜃𝑖 0
𝑆𝜃𝑖 0 𝐶𝜃𝑖 000
−10
00
601
]
−1
=
[ −
𝐶𝜃𝑖
−𝐶𝜃𝑖2−𝑆𝜃𝑖
2 −𝑆𝜃𝑖
−𝐶𝜃𝑖2−𝑆𝜃𝑖
2 0 0
0 0 −1 60𝑆𝜃𝑖
−𝐶𝜃𝑖2−𝑆𝜃𝑖
2
0
−𝐶𝜃𝑖
−𝐶𝜃𝑖2−𝑆𝜃𝑖
2
0
00
01 ]
=
[
𝐶𝜃𝑖 𝑆𝜃𝑖 0 00 0 −1 60
−𝑆𝜃𝑖
0𝐶𝜃𝑖
000
01
] [31]
( 𝐴3.2 )(−1) = [
𝐶𝜃𝑖 0 𝑆𝜃𝑖 0
𝑆𝜃𝑖 0 −𝐶𝜃𝑖 000
10
00
1721
]
−1
=
[
𝐶𝜃𝑖
𝐶𝜃𝑖2+𝑆𝜃𝑖
2
𝑆𝜃𝑖
𝐶𝜃𝑖2+𝑆𝜃𝑖
2 0 0
0 0 1 −172𝑆𝜃𝑖
𝐶𝜃𝑖2+𝑆𝜃𝑖
2
0
−𝐶𝜃𝑖
𝐶𝜃𝑖2+𝑆𝜃𝑖
2
0
00
01 ]
=
[
𝐶𝜃𝑖 𝑆𝜃𝑖 0 00 0 1 172
𝑆𝜃𝑖
0−𝐶𝜃𝑖
000
01
] [32]
( 𝐴4.3 )(−1) = [
𝐶𝜃𝑖 0 −𝑆𝜃𝑖 0
𝑆𝜃𝑖 0 𝐶𝜃𝑖 000
−10
00
601
]
−1
=
[ −
𝐶𝜃𝑖
−𝐶𝜃𝑖2−𝑆𝜃𝑖
2 −𝑆𝜃𝑖
−𝐶𝜃𝑖2−𝑆𝜃𝑖
2 0 0
0 0 −1 60𝑆𝜃𝑖
−𝐶𝜃𝑖2−𝑆𝜃𝑖
2
0
−𝐶𝜃𝑖
−𝐶𝜃𝑖2−𝑆𝜃𝑖
2
0
00
01 ]
=
[
𝐶𝜃𝑖 𝑆𝜃𝑖 0 00 0 −1 60
−𝑆𝜃𝑖
0𝐶𝜃𝑖
000
01
] [33]
( 𝐴5.4 )(−1) = [
𝐶𝜃𝑖 0 𝑆𝜃𝑖 0
𝑆𝜃𝑖 0 −𝐶𝜃𝑖 000
10
00
1721
]
−1
=
[
𝐶𝜃𝑖
𝐶𝜃𝑖2+𝑆𝜃𝑖
2
𝑆𝜃𝑖
𝐶𝜃𝑖2+𝑆𝜃𝑖
2 0 0
0 0 1 −172𝑆𝜃𝑖
𝐶𝜃𝑖2+𝑆𝜃𝑖
2
0
−𝐶𝜃𝑖
𝐶𝜃𝑖2+𝑆𝜃𝑖
2
0
00
01 ]
=
[
𝐶𝜃𝑖 𝑆𝜃𝑖 0 00 0 1 172
𝑆𝜃𝑖
0−𝐶𝜃𝑖
000
01
] [34]
Construcción y programación del control de un brazo mecánico con STM32
137
( 𝐴6.5 )(−1) = [
𝐶𝜃𝑖 0 −𝑆𝜃𝑖 0
𝑆𝜃𝑖 0 𝐶𝜃𝑖 000
−10
00
601
]
−1
=
[ −
𝐶𝜃𝑖
−𝐶𝜃𝑖2−𝑆𝜃𝑖
2 −𝑆𝜃𝑖
−𝐶𝜃𝑖2−𝑆𝜃𝑖
2 0 0
0 0 −1 60𝑆𝜃𝑖
−𝐶𝜃𝑖2−𝑆𝜃𝑖
2
0
−𝐶𝜃𝑖
−𝐶𝜃𝑖2−𝑆𝜃𝑖
2
0
00
01 ]
=
[
𝐶𝜃𝑖 𝑆𝜃𝑖 0 00 0 −1 60
−𝑆𝜃𝑖
0𝐶𝜃𝑖
000
01
] [35]
Una vez tienen las matrices inversas, estas se pueden sustituir en el sistema de ecuaciones y hallar los
valores de q1, q2, q3, q4, q5 y q6 por sustitución.
Este procedimiento manualmente es muy laborioso, por lo que requiere de capacidad de computación
para poder resolverlo.
Construcción y programación del control de un brazo mecánico con STM32
139
7.4. Análisis del impacto ambiental
El proyecto elaborado podría presentar un impacto ambiental elevado si los materiales utilizados no
fueran correctamente reciclados una vez finalizada su vida útil. Además, se ha querido minimizar el
impacto utilizando un plástico biodegradable, PLA, el cual al imprimirse tampoco emite emisiones
tóxicas a la atmosfera para la impresión 3D de la estructura robótica.
Pero, arrojándolo a la naturaleza no es suficiente, ya que para ser compostado necesita de una planta
de compostaje industrial, debido que de otra manera tardaría al menos 80 años en ser degradado a la
intemperie. Además, actualmente no existe un sistema de recogida de residuo procedente de
filamento PLA, u otros filamentos para la impresión 3D, y no pueden ser arrojados al contenedor de
envases donde se depositan otros tipos de envases plásticos como las botellas (PET), debido a que este
dificulta su reciclado. Por lo que se debería llevar a un puto de recogida especializado.
Además, para el funcionamiento de los componentes electrónicos se utiliza energía eléctrica, siendo
esta limpia, no se puede controlar el método utilizado para generarla. Al estar consumiendo está en
España el 28% de la electricidad producida proviene de energías fósiles, y el 21% de energía nuclear.
Por lo que, aun utilizando energía eléctrica, se genera un impacto ambiental.
Para contrarrestar el impacto ambiental producido al consumir de la red eléctrica, se propone utilizar
energía proporcionada por compañías que generen electricidad mediante energías renovables, como
por ejemplo HolaLuz, la cual tiene presencia en la ciudad de Barcelona.
Y finalmente, se propone la colaboración con asociaciones que contrarresten la producción de CO2 en
la atmosfera, como por ejemplo la asociación española PLANTA ARBOLES, la cual trabaja por la
restauración y generación de espacios verdes en España.
Memoria
140
7.5. Conclusiones
Durante el diseño del proyecto, se han enfrentados múltiples problemas, tanto problemas esperados
como inesperados, los cuales han obligado a los miembros del equipo a tomar decisiones y realizar
cambios de rumbo durante la realización del proyecto.
En primer lugar, el proyecto, al ser en equipo, se vio gravemente perjudicado por el confinamiento
producido en España durante el período entre el 15 de marzo y el 21 de junio del 2020. Esto provocó
que mucho del trabajo en equipo no pudiera realizarse hasta finalizado el estado de alarma decretado.
Además, debido a que las afectaciones del CoVid-19 fueron mundiales, decretándose pandemia por la
OMS (Organización Mundial de la Salud), la adquisición del material necesario para la elaboración del
prototipo fue en el caso de la estructura metálica inviable y retrasándose los envíos significativamente
para el resto de material.
Por ello, se decidió continuar el proyecto, con una estructura que desde el principio presentaba
diversos inconvenientes debido al material con la que se elaboraría y que, además, al tratarse de un
proyecto de código abierto, no presentaba garantías. Aun así, se consiguió finalizar un prototipo
funcional, aunque con un grado de libertad menor al esperado y un error significativo en el
posicionamiento del elemento terminal. Pero, que permitía la demostración del control de los
motores.
Las piezas de plástico presentaban un cierto juego entre el eje del motor, también entre ellas, así como
de una flexibilidad, que impide asegurar la posición exacta del elemento terminal. También se observó,
como al modificar el tamaño y número de dientes de los engranajes, aunque se conseguía impedir el
deslizamiento entre estos, generaba un enorme error, debido a que entre los dos engranajes se
producía un juego que podía variar la posición del elemento móvil del motor, de aproximadamente 3
grados. Al estar formado el brazo robótico de distintas secciones, el error comentado se acumulaba,
haciendo imposible tener una buena precisión y obteniendo una repetibilidad prácticamente nula.
Además, el espíritu inicial del proyecto era realizar un prototipo con coste reducido. Pero como se
puede observar en el Informe económico, el coste del proyecto ha sido significativamente elevado.
Aunque queda lejos del precio de los brazos robóticos industriales, el coste no es asequible para una
utilidad de carácter lúdico.
Aun habiendo conseguido elaborar un prototipo, y habiendo obtenido un resultado satisfactorio del
control de los motores, se concluye que no es posible elaborar un brazo robótico de bajo coste y con
una elevada precisión y repetibilidad, así como con un elevado par motor. Aun así, como primer
prototipo, el resultado se considera satisfactorio, pero sería necesario de muchas mejoras, así como
del diseño propio de una estructura metálica, para que el prototipo fuera viable.
Construcción y programación del control de un brazo mecánico con STM32
141
Análisis Económica
En este apartado se pretende exponer el coste de la elaboración del proyecto, tanto en el valor de los
equipos utilizados, el coste los softwares y plataformas, así como los materiales necesarios para la
elaboración del prototipo.
En primer lugar, se detalla el coste de los softwares utilizados. Aunque en su mayoría son de código
libre, si que se han utilizado licencias proporcionadas por la escuela de ingeniería de Barcelona Este
(EEBE) las cuales tienen un coste. Al no conocer el coste total de estas licencias, y este no ser
significativo debido a que común entre todos los estudiantes, se ha considerado el coste como una
licencia personal, como si se hubiera querido realizar el proyecto sin esa ayuda. También cabe aclarar,
que este coste no ha tenido que ser sufragado por los miembros del equipo, los cuales, en software,
solo han tenido que hacerse cargo de la librería necesaria para Unity, la cual no tiene un coste
significativo respecto las otras dos licencias. Y, además, el software de código libre no se ha incluido al
no suponer ningún coste.
Software Unidades Precio unidad (€) Duración importe total (€)
MATLAB 1 250 1 año 250
Keil uVision v.5 1 1319,89 1 año 1319,89
Bluetooth LE 1 17 Perpetua 17
Total 1586,89 Tabla 8. Valor de las licencias de software utilizadas
A continuación, se han utilizado equipos informáticos y una impresora 3D, los cuales, aunque no fueron
adquiridos específicamente para el desarrollo del proyecto, en caso de querer realizarlo de 0, exigirían
una inversión económica considerable.
Equipos Unidades Precio por unidad (€) Importe total (€)
MSI GS65 Stealth 8SE 1 1600 1600
MACBOOK PRO 1 2699 2699
Predator 3D printer 1 446,27 446,27
Total 4745,27 Tabla 9. Valor de los equipos informáticos e impresora 3D utilizada
A continuación, para elaborar la estructura sobre la que se ha realizado el proyecto, fueron necesarios
tanto el material plástico para imprimir en 3D además de distintos elementos para unir las secciones.
Memoria
142
Material Unidades Precio por unidad (€)
Importe total (€)
ANYCUBIC 1KG Filamento de 1.75 mm PLA Impresora 3D 4 32,99 131,96
Acoplamiento de brida 2 13,3 26,6
Tornillo M3 10mm (50 PCS) 1 1,9 1,9
Tornillo M2,5 14 mm (50 PCS) 1 2,04 2,04
Tornillo M2,5 10 mm (50 PCS) 1 1,87 1,87
Tubo de Teflón (1.5m) 1 12,99 12,99
Electroválvula 5/2 1 7,84 7,84
Compresor Aire 1 39,99 39,99
Pinza neumática PSW-60 1 150 150
Total 375,19 Tabla 10. Costo del material para la elaboración de la estructura.
Finalmente, se ha de tener en consideración los elementos de la solución de hardware.
Material Unidades Precio por unidad (€)
Importe total (€)
Motor DC 150:1 con 64 CPR Encoder 2 55,155 110,31
Motor Driver VNH5019 2 59,25 118,5
Motor DC 70:1 con 64 CPR Encoder 4 45,93 183,71
Rele KY-019 2 5,49 10,98
STM32 F407g 2 39,98 79,96
Fuente alimentación 12 V 2 14,99 29,98
Tuercas y tornillos ensamblake K79 2 7,99 15,98
Adaptador conector terminal pin 2 9,88 19,76
Cables de Puente 3x40 pines 1 12,49 12,49
Alambre soldadura sin plomo 1 9,99 9,99
DSD TECH HC-06 Bluetooth 1 9,99 9,99
DSD TECH HM-10 Bluetooth 4.0 1 8,99 8,99
Placa Perforada de Circuito Impreso 2 5,1 10,2
multiplexor Digital analógico CD74HC4067 CMOS 2 7,99 15,98
Diodos Multicolor Emisores de Luz 1 7,99 7,99
Neuftech L298N Dual H Puente DC 3 5,99 17,97
Otros 50
Total 712,78 Tabla 11. Costo del material para la elaboración de las soluciones de hardware.
Construcción y programación del control de un brazo mecánico con STM32
143
Por lo que, si se suman el coste de los materiales para la estructura y los materiales del hardware, el
coste total del brazo robótico ha sido de 1087,97 €. Aun así, el coste real ha sido mayor, debido que en
la realización de pruebas se han averiado algunos componentes, donde ascendiera el coste, no del
brazo, pero si del proyecto a unos 1200 €.
Finalmente, se agrega el coste derivado de las horas de trabajo de los integrantes del grupo. Se ha
cogido una media de tiempo equiparables a los créditos cursados durante la realización del proyecto,
debido a la dificultad de calcular el tiempo dedicado. Además, se ha valorado el costo por hora de 12
€. Por lo que el coste total de mano de obra seria de 17.280 €, entre los dos integrantes, aparte del
costo material.
Construcción y programación del control de un brazo mecánico con STM32
145
Bibliografía
1. ©2020 Encyclopædia Britannica, I. Enciclopedia Britanica. A: [en línia]. [Consulta: 30 setembre 2020]. Disponible a: https://www.britannica.com/.
2. Española, © Real Academia. Real Academia Española. A: [en línia]. [Consulta: 30 setembre 2020]. Disponible a: https://www.rae.es/.
3. Association, 2008-2020 Robotic Industries. Robotics. A: [en línia]. [Consulta: 3 setembre 2020]. Disponible a: https://www.robotics.org/.
4. Robotics, I. 299. ISO 8373:2012 [en línia]. 2012. ISO,2012. Disponible a: https://www.iso.org/standard/55890.html.
5. PHIDGETS INC. ENCODER PRIMER. A: [en línia]. [Consulta: 5 abril 2020]. Disponible a: https://www.phidgets.com/docs/Encoder_Primer.
6. Calomarde Palomino, A. Estructura básica de un procesador. A: Informática industrial. 2019, p. 15.
7. Calomarde Palomino, A. Primer contacto con la arquitectura ARM. A: . 2019, p. 15.
8. Inc., P. 70:1 Gear Motor 37Dx70L mm with 64 CPR Encoder. A: [en línia]. 2020. [Consulta: 20 abril 2020]. Disponible a: https://www.pololu.com/product/4754#lightbox-picture0J10469;main-pictures.
9. Pololu Inc. Motor paso a paso. A: [en línia]. 2020. [Consulta: 20 abril 2020]. Disponible a: https://www.pololu.com/product/1204#lightbox-picture0J2280;main-pictures.
10. Pololu. Servomotor. A: [en línia]. 2020. [Consulta: 20 abril 2020]. Disponible a: https://www.pololu.com/product/2141#lightbox-picture0J2815;main-pictures.
11. Ministerio de Sanidad, P.S. e I. Real Decreto 847/2011, de 17 de junio,. A: Por El Que Se Establece La Lista Positiva De Sustancias Permitidas Para La Fabricación De Materiales Poliméricos Destinados a Entrar En Contacto Con Los Alimentos. [en línia]. 2011, p. 129855-129862. Disponible a: http://www.boe.es.
12. Llamas, L. Partes de una impresora 3D FFF. A: [en línia]. [Consulta: 30 setembre 2020]. Disponible a: https://www.luisllamas.es/partes-de-una-impresora-3d-fff/.
13. Fundación Wikimedia, I. Regulación Automática. A: [en línia]. [Consulta: 25 maig 2020]. Disponible a: https://es.wikipedia.org/wiki/Regulación_automática.
14. 22, I.J. 1/SC. ISO/IEC 23270:2018 — Information technology — Programming languages — C# [en línia]. Disponible a: https://www.iso.org/standard/75178.html.
15. Microfost. Documentación C#. A: [en línia]. Disponible a: https://docs.microsoft.com/es-es/dotnet/csharp/.
16. Fundación Wikimedia, Inc. C Sharp. A: [en línia]. 2020. [Consulta: 30 agost 2020]. Disponible a:
Memoria
146
https://es.wikipedia.org/wiki/C_Sharp.
17. Android Open Source Project. Introducción a Android Studio. A: 2020 [en línia]. [Consulta: 1 juny 2020]. Disponible a: https://developer.android.com/studio/intro?hl=es-419.
18. Inc., A. Descripcíón Xcode. A: [en línia]. 2020. [Consulta: 1 juny 2020]. Disponible a: https://help.apple.com/xcode/mac/current/#/devc8c2a6be1.
19. Technologies, U. Manual de Unity. A: [en línia]. 2016. [Consulta: 1 juny 2020]. Disponible a: https://docs.unity3d.com/es/530/Manual/UnityManual.html.
20. C, B.Ap.Lb. Fundamentos de Robótica. 2. Edificio Valrealty, 1.a planta Basauri, 17 28023 Aravaca (Madrid): McGRAW-HILL/INTERAMERICANA DE ESPAÑA, S. A. U., 2007. ISBN 9788448156367.
21. Store, S.O. Brazo robótico 6 DOF metálico. A: 2020 [en línia]. [Consulta: 24 setembre 2020]. Disponible a: https://es.aliexpress.com/item/4000483070581.html?spm=a2g0o.productlist.0.0.316d48c2wFqN1t&algo_pvid=031f7ecd-114b-45bd-a5dc-b1aebe195cc9&algo_expid=031f7ecd-114b-45bd-a5dc-b1aebe195cc9-6&btsid=0bb0624016009473636682739e9fd2&ws_ab_test=searchweb0_0,search.
22. Store, L. e. Acoplamiento de brida rígida. A: [en línia]. 2020. [Consulta: 24 setembre 2020]. Disponible a: https://latiendadelmotor.es/2019/05/15/charles-10mm-acoplamiento-de-brida-acero-rigido-brida-acoplamiento-motor-guia-eje-rodamiento-accesorio/.
23. Nucleo-, S.T.M. NUCLEO-F411RE Datasheet. A: [en línia]. 2019, núm. April. Disponible a: www.st.com.
24. Cortex, A.R.M. et al. STM32F4DISCOVERY Development toolchains. A: . 2014, núm. September, p. 1-4. DOI 022204.
25. 田中泰史. Open-Source Robot Arm (Prototype 01) [en línia]. Disponible a: https://gallery.autodesk.com/projects/110864/open-source-robot-arm-prototype-01.
26. Anycubic. Predator 3D Printer. A: [en línia]. [Consulta: 24 setembre 2020]. Disponible a: https://www.anycubic.com/collections/predator-series/products/anycubic-predator-fdm-printer.
27. Landmann. Assembly and operating manual. A: . 2012,
28. Pololu. 37D Metal Gearmotors. A: [en línia]. 2019, núm. January. Disponible a: www.pololu.com.
29. Brinkgreve, R.B.J. i Kumarswamy, S. Reference Manual RM0090. A: Technology. 2008, Vol. 1, núm. November, p. 1749. ISSN 1537-6591. DOI 10.1093/cid/ciq238.
30. Fourier, F. et al. UM0585 User manual. A: ReVision [en línia]. 2008, Vol. 7, núm. October, p. 1-23. Disponible a: https://community.st.com/s/question/0D50X00009XkhcESAR/pid-controller-stm32f10x-dsp-library-um0585.
31. Pololu Corporation. Pololu Dual VNH5019 Motor Driver Shield for Arduino. A: [en línia]. [Consulta: 8 agost 2020]. Disponible a: https://www.pololu.com/product/2507.
Construcción y programación del control de un brazo mecánico con STM32
147
32. Kurpiewski, A. I2C library. A: [en línia]. 2020. [Consulta: 12 gener 2020]. Disponible a: https://pastebin.com/kM3aFH2C.
33. Shatalmic, L. Bluetooth LE for iOS, tvOS and Android [en línia]. 2020. 2020. Disponible a: https://assetstore.unity.com/packages/tools/network/bluetooth-le-for-ios-tvos-and-android-26661.
34. Inc., S.B.A. Free 2D Adventure Beach Background [en línia]. Disponible a: https://assetstore.unity.com/packages/2d/environments/free-2d-adventure-beach-background-82090.
35. GettingStarted docs.unity3d.com [en línia]. Disponible a: https://docs.unity3d.com/es/530/Manual/GettingStarted.html.
36. Unity_(motor_de_videojuego) es.wikipedia.org [en línia]. Disponible a: https://es.wikipedia.org/wiki/Unity_(motor_de_videojuego).
37. Developers. Intro Developer.Android.Com [en línia]. 2020. 2020. Disponible a: https://developer.android.com/studio/intro.
38. Microcontrolador es.wikipedia.org [en línia]. Disponible a: https://es.wikipedia.org/wiki/Microcontrolador.
39. Arquitectura_ARM es.wikipedia.org [en línia]. Disponible a: https://es.wikipedia.org/wiki/Arquitectura_ARM#Diseño.
40. keil-mdk store.developer.arm.com [en línia]. Disponible a: https://store.developer.arm.com/store/embedded-iot-software-tools/keil-mdk.
41. Seron, M. Sistemas No Lineales. A: Proton.Ucting.Udg.Mx [en línia]. 2001, núm. 0, p. 1-6. Disponible a: http://proton.ucting.udg.mx/cye/academias/programas/programas/et409.pdf.
42. Encoder_Primer www.phidgets.com [en línia]. Disponible a: https://www.phidgets.com/docs/Encoder_Primer.
43. Regulación_automática es.wikipedia.org [en línia]. Disponible a: https://es.wikipedia.org/wiki/Regulación_automática.
44. Sistema_lineal es.wikipedia.org [en línia]. Disponible a: https://es.wikipedia.org/wiki/Sistema_lineal.
45. C_(lenguaje_de_programación) es.wikipedia.org [en línia]. Disponible a: https://es.wikipedia.org/wiki/C_%28lenguaje_de_programación%29.
46. asa tecnologiadelosplasticos.blogspot.com [en línia]. Disponible a: https://tecnologiadelosplasticos.blogspot.com/2012/05/asa.html.
47.Plástico impresión 3D www.3dnatives.com [en línia]. Disponible a: https://www.3dnatives.com/es/el-plastico-petg-en-la-impresion-3d-181220192/.
48. Aleaciones metálicas www.lifeder.com [en línia]. Disponible a:
Memoria
148
https://www.lifeder.com/aleaciones-metalicas/.
49. Tipos de plástico www.3dnatives.com [en línia]. Disponible a: https://www.3dnatives.com/es/plasticos-impresion-3d-22072015/#!
50. Motor_paso_a_paso es.wikipedia.org [en línia]. Disponible a: https://es.wikipedia.org/wiki/Motor_paso_a_paso.
51. Motor_de_corrent_continu ca.wikipedia.org [en línia]. Disponible a: https://ca.wikipedia.org/wiki/Motor_de_corrent_continu#Principi_de_funcionament_i_quantificació_de_la_força_del_motor.
52. Motores paso a paso en la industria www.pescaypuertos.com.ar [en línia]. Disponible a: http://www.pescaypuertos.com.ar/aplicaciones-de-motores-paso-a-paso-en-la-industria/.
53. Servomotor es.wikipedia.org [en línia]. Disponible a: https://es.wikipedia.org/wiki/Servomotor.
54. encoder-tipos www.demaquinasyherramientas.com [en línia]. Disponible a: https://www.demaquinasyherramientas.com/mecanizado/encoder-tipos.
55. Sensor_inductivo es.wikipedia.org [en línia]. Disponible a: https://es.wikipedia.org/wiki/Sensor_inductivo#:~:text=Cuando un metal es acercado,en el material por detectar.
56. Motores www.superrobotica.com [en línia]. Disponible a: http://www.superrobotica.com/Motores.htm.
57. Autómata_(mecánico) es.wikipedia.org [en línia]. Disponible a: https://es.wikipedia.org/wiki/Autómata_(mecánico).
58. Brazo_robótico es.wikipedia.org [en línia]. Disponible a: https://es.wikipedia.org/wiki/Brazo_robótico.
59. que-son-brazos-roboticos @ robotesfera.com [en línia]. Disponible a: https://robotesfera.com/que-son-brazos-roboticos.
60. Relación_de_transmisión es.wikipedia.org [en línia]. Disponible a: https://es.wikipedia.org/wiki/Relación_de_transmisión.
61. GUID-CAB3855A-B6B6-44AA-978F-D086217CF2B3-htm knowledge.autodesk.com [en línia]. Disponible a: https://knowledge.autodesk.com/es/support/inventor/learn-explore/caas/CloudHelp/cloudhelp/2019/ESP/Inventor-Help/files/GUID-CAB3855A-B6B6-44AA-978F-D086217CF2B3-htm.html.
62. tutorialn151 ingemecanica.com [en línia]. Disponible a: https://ingemecanica.com/tutorialsemanal/tutorialn151.html.
63. engranajes www.areatecnologia.com [en línia]. Disponible a: https://www.areatecnologia.com/mecanismos/engranajes.html.
Construcción y programación del control de un brazo mecánico con STM32
149
64. system docs.microsoft.com [en línia]. Disponible a: https://docs.microsoft.com/es-es/dotnet/api/system.text.stringbuilder?view=netcore-3.1.
65. Index apps.autodesk.com [en línia]. Disponible a: https://apps.autodesk.com/FUSION/en/Detail/Index?id=9029586664984391977&appLang=en&os=Mac&autostart=true.
66. convertir-un-string-hexadecimal-a-byte-y-viceversa es.stackoverflow.com [en línia]. Disponible a: https://es.stackoverflow.com/questions/138390/convertir-un-string-hexadecimal-a-byte-y-viceversa.
67. Codigo ASCII ascii.cl [en línia]. Disponible a: https://ascii.cl/es/.
68. c-sharp-hex-to-ascii stackoverflow.com [en línia]. Disponible a: https://stackoverflow.com/questions/5613279/c-sharp-hex-to-ascii.
69. C sharp string docs.microsoft.com [en línia]. Disponible a: https://docs.microsoft.com/es-es/dotnet/csharp/programming-guide/strings/.
70. how-to-convert-between-hexadecimal-strings-and-numeric-types @ docs.microsoft.com [en línia]. Disponible a: https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/types/how-to-convert-between-hexadecimal-strings-and-numeric-types.
71. char docs.microsoft.com [en línia]. Disponible a: https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/char.
72. introduction-to-bluetooth-low-energy learn.adafruit.com [en línia]. Disponible a: https://learn.adafruit.com/introduction-to-bluetooth-low-energy.
73. nsbluetoothperipheralusagedescription developer.apple.com [en línia]. Disponible a: https://developer.apple.com/documentation/bundleresources/information_property_list/nsbluetoothperipheralusagedescription.
Construcción y programación del control de un brazo mecánico con STM32
151
Anexo 0. Explicación del funcionamiento de los anexos
En los apartados de los anexos se ha referenciado las carpetas incluidas en la carpeta Anexos,
proporcionada junto a la memoria del proyecto.
Para poder abrir los documentos referenciados en estos correctamente, se deberá tener la carpeta
descomprimida en la misma localización que la memoria.
Anexo 1. Estructura mecánica
Los documentos respectivos a la estructura mecánica se encuentran en la carpeta Anexos\Estructura
mecánica. En esta se ha incluido el diseño original de la estructura, el diseño de las piezas modificadas
y los planos de los distintos componentes de las secciones.
Los planos de las secciones se encuentran en la carpeta Anexos\Estructura mecánica\Planos de la
estructura mecánica original y se han dividido entre las distintas secciones.
Anexo 2. Código del proyecto en STM32
El proyecto realizado para el control de los motores mediante STM32 se ha agregado en la carpeta
Anexos\Código del proyecto de STM32CubeMX. Este se ha dividido entre el primer diseño
Anexos\Código del proyecto de STM32CubeMX\Código del primer diseño, con PWM multiplexado y el
segundo diseño Anexos\Código del proyecto de STM32CubeMX\Código del segundo diseño, con PWM
individual.
Además, se ha incluido el manual de STM32 [30], Anexos\Código del proyecto de
STM32CubeMX\Reference Manual.pdf.
Anexo 3. Código del proyecto de Unity de la APP
El proyecto realizado en Unity para el control de la posición de los motores se ha agregado en la carpeta
Anexos\Código del proyecto de Unity\Aplicación_control_brazo_mecánico. Esta se ha agregado sin la
librería Bluetooth LE, debido a que esta no era de libre distribución. Por lo que si se deseara compilar
seria necesario importar dicha librería. En el anexo, se ha añadido una nota de recordatorio de este
hecho, Anexos\Código del proyecto de Unity\Nota informativa proyecto Unity.txt.
Annexos
152
Por ello, se ha agregado un archivo APK compatible con el sistema operativo Android. iOS, por otra
banda, no permite importar el tipo de archivo de la aplicación. El archivo APK se encuentra en la carpeta
Anexos\Código del proyecto de Unity\Archivo APK.
Anexo 4. Datasheets de los componentes utilizados
En el anexo 4, se han agregado los datasheets de los distintos componentes utilizados en el diseño de
hardware del proyecto. Estos pueden encontrarse en la carpeta Anexos\Datasheets.
Anexo 5. Cálculos para el diseño del programa
En el último anexo, se ha agregado el modelo de planta obtenido mediante MATLAB, Anexos\Cálculos
para el diseño del programa\MATLAB, así como cálculos realizados para la elección de los
componentes, Anexos\Cálculos para el diseño del programa\Cálculo de momentos de fuerza.
Construcción y programación del control de un brazo mecánico con STM32
153