construcciÓn y programaciÓn del control de un …

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#.


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.


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


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


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


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.


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.


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.


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]


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


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á


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

http://www.boe.es/boe/dias/2011/07/11/pdfs/BOE-A-2011-11828.pdf

http://www.boe.es/boe/dias/2011/07/11/pdfs/BOE-A-2011-11828.pdf

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

https://imprimakers.com/es/lo-ultimo-en-tecnologia-la-impresion-3d-en-sls-sinterizacion-selectiva-por-laser/




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.


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.


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).


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]


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.


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


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 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#.


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

https://es.wikipedia.org/wiki/Transmission_Control_Protocol

https://es.wikipedia.org/wiki/User_Datagram_Protocol


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


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


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.


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.


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


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.


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.

https://gallery.autodesk.com/users/BYFDLEHJQAMB

https://gallery.autodesk.com/users/BYFDLEHJQAMB

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


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,


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.


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]


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


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


- 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.


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



- 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.


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.


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 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.


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.


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.


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.


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.


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.


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.


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


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


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.


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


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).


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.


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 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


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.


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


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


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.


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.


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.


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,


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.


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.


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.


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.


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.


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.


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.


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.


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


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.


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:


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.


133

𝐴1 0 = [


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 = [


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 = [


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 = [


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

00

(−1)0

00

601

] [18]

𝐴5 4 = [


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 = [


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

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.


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) = [


00

(1)0

871

]

−1

=

[ −

𝐶𝜃𝑖

−𝐶𝜃𝑖2−𝑆𝜃𝑖

2 −𝑆𝜃𝑖


2 0 0

𝑆𝜃𝑖


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 0 0

0 0 −1 60𝑆𝜃𝑖


2

0

−𝐶𝜃𝑖


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 0 0

0 0 1 −172𝑆𝜃𝑖


2

0

−𝐶𝜃𝑖


2

0

00

01 ]

=

[

𝐶𝜃𝑖 𝑆𝜃𝑖 0 00 0 1 172

𝑆𝜃𝑖

0−𝐶𝜃𝑖

000

01

] [32]

( 𝐴4.3 )(−1) = [



−10

00

601

]

−1

=

[ −

𝐶𝜃𝑖


2 −𝑆𝜃𝑖


2 0 0

0 0 −1 60𝑆𝜃𝑖


2

0

−𝐶𝜃𝑖


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 0 0

0 0 1 −172𝑆𝜃𝑖


2

0

−𝐶𝜃𝑖


2

0

00

01 ]

=

[

𝐶𝜃𝑖 𝑆𝜃𝑖 0 00 0 1 172

𝑆𝜃𝑖

0−𝐶𝜃𝑖

000

01

] [34]


137

( 𝐴6.5 )(−1) = [



−10

00

601

]

−1

=

[ −

𝐶𝜃𝑖


2 −𝑆𝜃𝑖


2 0 0

0 0 −1 60𝑆𝜃𝑖


2

0

−𝐶𝜃𝑖


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.


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.


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.


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.


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.


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.


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.


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.

Anexos/Estructura%20mecánica

Anexos/Estructura%20mecánica

Anexos/Estructura%20mecánica/Planos%20de%20la%20estructura%20mecánica%20original

Anexos/Estructura%20mecánica/Planos%20de%20la%20estructura%20mecánica%20original

Anexos/Código%20del%20proyecto%20de%20STM32CubeMX

Anexos/Código%20del%20proyecto%20de%20STM32CubeMX/Código%20del%20primer%20diseño,%20con%20PWM%20multiplexado

Anexos/Código%20del%20proyecto%20de%20STM32CubeMX/Código%20del%20segundo%20diseño,%20con%20PWM%20individual

Anexos/Código%20del%20proyecto%20de%20STM32CubeMX/Código%20del%20segundo%20diseño,%20con%20PWM%20individual

Anexos/Código%20del%20proyecto%20de%20STM32CubeMX/Reference%20Manual.pdf

Anexos/Código%20del%20proyecto%20de%20STM32CubeMX/Reference%20Manual.pdf

Anexos/Código%20del%20proyecto%20de%20Unity/Aplicación_control_brazo_mecánico

Anexos/Código%20del%20proyecto%20de%20Unity/Nota%20informativa%20proyecto%20Unity.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.

Anexos/Código%20del%20proyecto%20de%20Unity/Archivo%20APK

Anexos/Datasheets

Anexos/Cálculos%20para%20el%20diseño%20del%20programa/MATLAB

Anexos/Cálculos%20para%20el%20diseño%20del%20programa/MATLAB

Anexos/Cálculos%20para%20el%20diseño%20del%20programa/Cálculo%20de%20momentos%20de%20fuerza


153

construcciÓn y programaciÓn del control de un …

Documents