TFG Roberto Carrasco Serrano

ESCUELA TÉCNICA SUPERIOR DE INGENIERÍA
Y SISTEMAS DE TELECOMUNICACIÓN
PROYECTO FIN DE GRADO
TÍTULO: Diseño de un controlador para motores eléctricos de

corriente continua sin escobillas.
AUTOR: Roberto Carrasco Serrano.
TITULACIÓN: Grado en Ingeniería Electrónica de Comunicaciones.
DIRECTOR: José Carlos Prieto Honorato.
TUTOR: Eduardo Barrera López de Turiso.
DEPARTAMENTO: Electrónica y Telemática.
VºBº
Miembros del Tribunal Calificador:
PRESIDENTE: Francisco Aznar Ballesta.
TUTOR: Eduardo Barrera López de Turiso.
SECRETARIO: Julián Nieto Valhondo.
Fecha de lectura:
Calificación:
El Secretario,
Diseño de un controlador para motores eléctricos de corriente continua sin escobillas
Índice de contenidos
Resumen .............................................................................................................................................iii
Abstract ............................................................................................................................................... v
Lista de acrónimos y siglas ..............................................................................................................vii
Índice de ilustraciones ...................................................................................................................... ix
Índice de tablas ................................................................................................................................xiii
Introducción. ...................................................................................................................................... 1
1.1. Motores eléctricos: tipos y principios de funcionamiento. ................................................ 2
1.1.1. Motores de corriente alterna (CA).............................................................................. 2
1.1.2. Motores de corriente continua (CC). .......................................................................... 3
1.2. Métodos de control para motores de corriente continua sin escobillas. ............................ 7
1.2.1. Control trapezoidal o Six-Steps. ................................................................................. 8
1.2.2. Control sinusoidal..................................................................................................... 10
1.2.3. FOC (Field Oriented Control). ................................................................................ 10
1.3. Soluciones en el mercado para el control de motores de CC sin escobillas. ................... 13
1.3.1. Soluciones de Maxon................................................................................................ 13
1.3.2. Soluciones de Texas Instruments. ............................................................................ 14
1.3.3. Soluciones de ST Microelectronics. ......................................................................... 15
1.4. Elección de las herramientas de desarrollo. ..................................................................... 16
Trabajos previos al diseño del controlador. .................................................................................. 19
2.1. Configuración hardware de las tarjetas de desarrollo. ..................................................... 19
2.2. Estructura del firmware generado a partir de Motor Control Workbench. ...................... 23
2.3. Generación y pruebas de una primera versión del firmware. .......................................... 24
2.3.1. Generación del perfil del motor con ST Motor Profiler. .......................................... 24
2.3.2. Personalización del firmware mediante MCWB y generación del código. .............. 26
2.3.3. Programación de las tarjetas y pruebas. ................................................................... 29
2.4. Comunicación por puerto serie con las tarjetas de desarrollo. ........................................ 31
2.4.1. Mensajes de escritura. .............................................................................................. 31
2.4.2. Mensajes de respuesta. ............................................................................................. 34
Diseño del controlador. .................................................................................................................... 37
3.1. Estructura del controlador................................................................................................ 37
3.2. Diseño del circuito electrónico. ....................................................................................... 41
3.2.1. Alimentación de la tarjeta......................................................................................... 42
3.2.2. Bloque de control. .................................................................................................... 44
3.2.3. Medida de la corriente en las fases del motor. ......................................................... 45
3.2.4. Circuito integrado controlador para motores BLDC. ............................................... 47
3.2.5. Acondicionamiento de las señales del encóder y de los sensores Hall. ................... 48
3.2.6. Interfaz CAN y puerto serie. .................................................................................... 50
3.2.7. Medida de la temperatura y de la tensión de entrada. .............................................. 51
3.2.8. Selección de componentes pasivos........................................................................... 53
3.3. Diseño de la tarjeta de circuito impreso. ......................................................................... 53
3.3.1. Definición de las capas y dimensiones de la PCB.................................................... 53
3.3.2. Colocación de los componentes y de las serigrafías. ............................................... 55
i
Índice de contenidos
3.3.3. Ruteo. ....................................................................................................................... 56

3.3.4. Diseño de los planos de cobre. ................................................................................. 58
3.4. Fabricación de la tarjeta. .................................................................................................. 61
Calibración y puesta en marcha del controlador. ......................................................................... 65
4.1. Recepción y puesta en marcha del controlador. .............................................................. 65
4.2. Calibración de los PID implementados en el firmware. .................................................. 68
4.2.1. Método de calibración de ST Microelectronics. ....................................................... 69
4.2.2. Trabajos previos a la calibración del controlador. ................................................... 72
4.2.3. Método de calibración para el controlador diseñado................................................ 75
4.3. Modificaciones en la lectura de la tensión de alimentación del controlador. .................. 79
4.4. Cálculo de la trayectoria en los cambios de posición. ..................................................... 80
4.4.1. Definición de los parámetros del movimiento. ........................................................ 81
4.4.2. Cálculo de las ecuaciones del movimiento............................................................... 83
4.4.3. Implementación en el firmware del controlador. ..................................................... 88
4.4.4. Determinación de los valores máximos del jerk, la aceleración y la velocidad. ...... 89
4.5. Pruebas para la validación del controlador. ..................................................................... 91
Conclusiones. .................................................................................................................................... 95
5.1. Líneas futuras de trabajo. ................................................................................................. 96
Anexo I: Presupuesto. ...................................................................................................................... 99
Anexo II: Referencias. ................................................................................................................... 101
ii
Resumen
Diseño de un controlador para motores eléctricos de
corriente continua sin escobillas
Los motores eléctricos de corriente continua sin escobillas (BLDC) son los motores que más ventajas
presentan para ser utilizados en aplicaciones de robótica móvil: bajo mantenimiento, alta eficiencia,
relación torque/velocidad prácticamente lineal, etcétera. Pero su control resulta bastante complejo,
por lo que se requiere de un sistema basado en microprocesador que lo realice.
Existen tres algoritmos de control para motores BLDC: trapezoidal, sinusoidal y FOC (Field Oriented
Control). El fin de todos ellos es calcular el instante óptimo para excitar cada una de las fases del
motor y durante cuánto tiempo deben ser excitadas; y sus diferencias residen en su complejidad, la
eficiencia y el rizado de torque que producen en el motor.
Así, el objetivo de este Proyecto Fin de Grado es el de diseñar un controlador para motores BLDC de
baja potencia que implemente un algoritmo de control. El resultado debe ser un dispositivo
completamente funcional, ya que formará parte de los robots diseñados por la empresa Star Robotics.
Además, su coste debe ser inferior al de los controladores comerciales que pueden encontrarse
actualmente en el mercado.
Nuestro diseño parte de la tarjeta X-NUCLEO-IHM07M1, del fabricante ST Microelectronics. Se trata
de una tarjeta de evaluación basada en el circuito integrado L6230, también diseñado por ST
Microelectronics, el cual es capaz de generar las corrientes para las tres fases del motor a partir de 3
señales PWM y 3 señales digitales. Estas señales son generadas por el microcontrolador
STM32L476RG, el cual ejecuta un firmware basado en el paquete STM32 MC SDK¸ también de ST
Microelectronics.
Para integrar el hardware del controlador, se ha diseñado una PCB (Printed Circuit Board) de
dimensiones reducidas (82x33 mm) y que consta de 4 capas conductoras. El objetivo con esta tarjeta
es conseguir una alta densidad de componentes, así como una alta disipación del calor generado por
la corriente consumida por los motores.
En la fase de puesta en marcha del proyecto debemos ajustar el controlador diseñado a las condiciones
reales de funcionamiento. Para ello, se han calibrado los reguladores PID que implementa el firmware
de control para ajustar las señales de acción que determinan las corrientes del motor, su velocidad y
su posición angular. Esta calibración se ha realizado con los controladores ya montados en el robot.
La modificación más importante realizada en el firmware ha sido el cálculo e implementación de una
nueva trayectoria en los cambios de posición del motor, debido a que la respuesta obtenida en los
desplazamientos largos es demasiado lenta. La solución pasa por recalcular los tiempos de cada una
de las fases del movimiento, a partir del jerk, la aceleración y la velocidad máxima que puede alcanzar
el motor.
Como punto final del proyecto, se han realizado todas las pruebas necesarias para la validación del
controlador diseñado y analizaremos las posibles modificaciones que puede sufrir este diseño en sus
futuras versiones.
iii
Abstract
Design of a brushless direct current motor driver.
Brushless direct current (BLDC) motors are the most commonly used in mobile robotic applications.
They have many advantages over brushed motors: more efficiency, almost-linear torque/velocity
relation, low maintenance, etcetera. But they present an important disadvantage, that is their complex
control. For that, it is indispensable a microprocessor based system which executes the control
algorithm.
There are three main algorithms for controlling BLDC motors: 6-Steps, Sinusoidal and FOC (Field
Oriented Control). All of them have a common objective: to calculate the optimal instant for
commuting the excitation of each phase of the motor. The differences between them are their
complexity, their efficiency and the torque ripple generated.
Thus, the purpose of this Final Project is to develop a driver for low power BLDC motors which
implements the FOC control algorithm. This development must generate a totally useful device which
will be part of robots designed by Star Robotics. Moreover, it must be cheaper than the commercial
drivers which can be found in the market.
We take as reference the design of the X-NUCLEO-IHM07M1 board, from ST Microelectronics. This
is an evaluation board based on the integrated circuit L6230, from the same manufacturer. It is able
to generate the proper current for each motor phase from 3 PWM and three digital signals. These
signals are generated by the microcontroller STM32L476RG, which executes a firmware based on the
STM32 MC SDK.
The designed hardware is integrated on a PCB (Printed Circuit Board), whose dimensions are really
compact (82 x 33 mm). It counts with four conducting layer and its objective is to achieve a high
components density as well as a high heat dissipation due to the consumed current by the motor.
Once the driver is available, we have to adjust its parameters for the real working conditions. That
involves calibrating the PID regulators implemented on the control firmware. That regulators are the
responsible for managing the currents of the motor, its velocity and its angular position. This
calibration is made once the driver was mounted in the robot.
The most important modification performed on the firmware is the calculus and the implementation
of a new trajectory for the position displacement of the motor. In the original trajectory implemented
by ST, the motor accelerates and decelerates too slowly, so we will recalculate the duration of each
movement stage from the maximum values of jerk, acceleration and velocity that the motor can reach.
Finally, all the validation tests were made on the designed driver for guaranteeing the correct system
operation on the robot and we present some possible modifications for the next version of the driver.
v
Lista de acrónimos y siglas

Acrónimo / Significado
Siglas
BLDC Brushless Direct Current
BEMF Back Electromotive Force
FOC Field Oriented Control
PCB Printed Circuit Board
PMSM Permanent Magnet Synchronous Motors
PID Proportional, Integral and Derivative
MOSFET Metal-Oxide-Semiconductor Field-Effect Transistor
SVPWM Space Vector Pulse Witdth Modulation
LED Light-Emiting Diode
CAD Computer-Aided Design
SMD Surface Mounted Device
THD Through Hole Device
CAN Controller Area Network
SDK Software Development Kit
CMSIS Cortex Microcontroller Software Interface Standard
MCWB MotorControl Workbench
CRC Comprobación de redundancia cíclica
ACK Acknowledgement
NACK Negative Acknowledgment
ESR Equivalent Series Resistance
UVLO Undervoltage Lockout
SWD Serial Wire Debug
GPIO General Porpouse Input/Output
NTC Negative Temperature Coeficient
MOSI Master Output Slave Input
MISO Master Input Slave Output
vii
Índice de ilustraciones
Ilustración 1: Estructura de un motor trifásico asíncrono. ................................................................... 3
Ilustración 2: Componentes de un motor CC con escobillas. .............................................................. 4
Ilustración 3: Representación simplificada de un motor CC con escobillas. ....................................... 4
Ilustración 4: Ejemplo de conexión de los devanados del estátor de un motor BLDC trifásico. ........ 5
Ilustración 5: Clasificación de los motores eléctricos. ......................................................................... 6
Ilustración 6: robot de la empresa Star Robotics en el que se integrará el controlador diseñado. ....... 7
Ilustración 7: Módulo de visión donde se ubicarán los controladores. ................................................ 7
Ilustración 8: Secuencia de activación de las fases del motor mediante control trapezoidal. [2] ........ 8
Ilustración 9: BEMF generado en las tres fases de un motor BLDC sin excitar. ................................ 9
Ilustración 10: Tabla de verdad para excitar las fases en el control 6-steps con sensores Hall. .......... 9
Ilustración 11: Relación entre el ciclo de trabajo de las señales PWM y la posición del rotor . ...... 10
Ilustración 12: Torque generado en el rotor en función del ángulo de los campos magnéticos.. ...... 10
Ilustración 13: Diagrama de bloques del algoritmo de control FOC de motores BLDC. .................. 11
Ilustración 14: Descomposición el campo magnético ejercido sobre el rotor en el control FOC. ..... 11
Ilustración 15: Imagen de la estructura de la gama IDX de Maxon Motors. ..................................... 13
Ilustración 16: Controlador EPOS2 P de Maxon. .............................................................................. 13
Ilustración 17: Circuito de aplicación de los dispositivos DRV835x de Texas Instruments. [3] ...... 14
Ilustración 18: Circuito de aplicación del circuito integrado DRV8313 de Texas Instruments. ....... 14
Ilustración 19: Esquema del hardware de desarrollo. ........................................................................ 16
Ilustración 20: Esquema de conexiones del conector CN10 en el diseño MB1136 .......................... 19
Ilustración 21: Esquema de conexiones del microcontrolador en el diseño MB1136. ...................... 20
Ilustración 22: Asignación de pines por defecto para las tarjetas de desarrollo en MCWB. ............. 20
Ilustración 23: Asignación de pines del microcontrolador. ............................................................... 21
Ilustración 24: Módulo ST-LINK/V2 incorporado en el diseño MB1136......................................... 21
Ilustración 25: Conexiones en los conectores J5 y J6 de la tarjeta X-NUCLEO-IHM07M1. ........... 22
Ilustración 26: Arquitectura del STM32 MC firmware. [4]............................................................... 23
Ilustración 27: Componentes que forman la librería PMSM FOC. ................................................... 24
Ilustración 28: Ventana de selección del hardware de desarrollo en ST Motor Profiler. .................. 25
Ilustración 29: Panel de configuración de ST Motor Profiler. ........................................................... 25
Ilustración 30: Ventana de configuración del hardware en MCWB. ................................................. 27
Ilustración 31: Ventana principal de MotorControl Workbench. ...................................................... 27
Ilustración 32: Ventana de asignación de pines de MotorControl Workbench. ................................ 28
Ilustración 33: Herramienta de generación del código de MotorControl Workbench. ...................... 29
Ilustración 34: Monitor básico de MCWB. ........................................................................................ 29
Ilustración 35: Controles para la conexión de las tarjetas al PC. ....................................................... 30
Ilustración 36: Captura de una sesión de Device Monitoring Studio. ............................................... 33
Ilustración 37: Diagrama de bloques de un controlador que ejecuta un algoritmo de control FOC. . 37
Ilustración 38: Conexión entre los tres semipuentes en H y las fases del motor. .............................. 38
Ilustración 39: Patrón de conmutación de los MOSFET que forman el inversor trifásico. ............... 39
Ilustración 40: Diagrama de bloques del controlador a diseñar. ........................................................ 40
Ilustración 41: Árbol de ficheros del proyecto en Altium Designer .................................................. 41
Ilustración 42: Divisor resistivo para programar la tensión de salida del convertidor. ..................... 43
Ilustración 43: Hardware para la medida de las corrientes en las fases del motor. ........................... 45
Ilustración 44: Amplificador no inversor para acondicionar la tensión en las resistencias de shunt . 46
Ilustración 45: Circuito típico de aplicación del circuito integrado L6230 [8] .................................. 47
Ilustración 46: Esquema de la implementación del circuito L6230 ................................................... 48
Ilustración 47: Implementación típica del circuito XR33184ESBTR en el controlador [9]. ............ 49
ix
Índice de ilustraciones
Ilustración 48:Circuito acondicionador de las señales de los sensores Hall y del encóder. .............. 50
Ilustración 49: Conexiones del circuito integrado SN65HVD232D. ................................................. 50
Ilustración 50: Conexiones en el microinterruptor CVS-08B. ........................................................... 51
Ilustración 52: Divisor resistivo para la medida de la tensión en el bus de alimentación. ................ 52
Ilustración 53: Divisor de tensión para la medida de la temperatura en la tarjeta. ............................ 52
Ilustración 54: Documento generado a partir del Layer Stack Manager de Altium Designer. .......... 54
Ilustración 55: Bordes de la tarjeta del controlador (en rosa) en Altium Designer. .......................... 54
Ilustración 56: Distribución de los bloques funcionales en la PCB del controlador.......................... 55
Ilustración 57: Ejemplo de Eurocircuits de”Clipping”. ..................................................................... 55
Ilustración 58: Ejemplo de buena colocación del identificador de un componente en la tarjeta. ...... 56
Ilustración 59: Ejemplo de desplazamiento de un componente de Altium Resources. ..................... 57
Ilustración 60: Representación de Eurocircuits de un peelabe. ......................................................... 57
Ilustración 61: Trazado correcto de dos pistas que deben conectarse al mismo pad. ........................ 57
Ilustración 62: Planos de cobre de las tensiones de alimentación en la tarjeta del controlador. ........ 59
Ilustración 63: Diseño del plano de masa de la tarjeta del controlador. ............................................ 59
Ilustración 64: Planos de cobre para conectar las fases 2 y 3 del motor al circuito L6230. .............. 60
Ilustración 65: Plano de cobre de la salida SENSE1 del circuito L6230. .......................................... 60
Ilustración 67: Fragmento del documento Pick and Place de la tarjeta del controlador. ................... 62
Ilustración 68: Captura en el microscopio del desplazamiento del conector J7. ............................... 66
Ilustración 69: Marca del pin positivo (“+”) del condensador C18. .................................................. 66
Ilustración 70: Punto que indica el pin 1 de los receptores de las señales del encóder. .................... 66
Ilustración 71: Conector de alimentación del controlador. ................................................................ 67
Ilustración 72: Interfaz gráfica del programa STM32 ST-LINK Utility. .......................................... 68
Ilustración 73: Escalón de corriente ideal para la calibración. .......................................................... 69
Ilustración 74: Configuración del escalón de corriente en la ventana “Configuration” de MCWB. . 69
Ilustración 75: Ejemplo de una respuesta lenta de la corriente en la fase A del motor. .................... 70
Ilustración 76: Ejemplo de respuesta ruidosa debido a valores demasiado altos de Kp y Ki. ........... 70
Ilustración 77: Ejemplo de un sobreimpulso en la corriente de la fase A del motor. ........................ 71
Ilustración 78: Configuración sensorless de MCWB. ........................................................................ 72
Ilustración 79: Interfaz gráfica del software de control. .................................................................... 74
Ilustración 80: Tarjeta EMCB-200U-MP10E conectada y en funcionamiento. ................................ 75
Ilustración 81: Respuesta tras la calibración de corriente. Kp = 3800, Ki = 3700. ........................... 76
Ilustración 82: Respuesta obtenida con los valores Kp = 4000, Ki = 3900 ....................................... 76
Ilustración 83: Velocidad del motor (en verde) con Kp = Ki = 100. ................................................. 77
Ilustración 82: Velocidad del motor (en verde) con Kp = 5000 y Ki =25000 ................................... 77
Ilustración 83: Velocidad del motor (en verde) con Kp = 3500 y Ki = 20000 (valores finales). ...... 77
Ilustración 84: Respuesta con los valores de la calibración: Kp = 2000, Ki = 300 y Kd = 200. ....... 78
Ilustración 85: Perfil del jerk y la aceleración calculados por el firmware STM32 MC SDK. ......... 80
Ilustración 86: Comparación entre un perfil de velocidad trapezoidal y uno S-Curve. ..................... 81
Ilustración 87: Perfil del jerk, la aceleración, la velocidad y la posición en la trayectoria S-Curve. 82
Ilustración 88: Desplazamiento de 300 grados con la trayectoria de ST. .......................................... 89
Ilustración 89: Desplazamiento de 300 grados con nuestra trayectoria. ............................................ 90
Ilustración 90: Velocidad descrita ante un desplazamiento de 300 grados con la trayectoria de ST. 90
Ilustración 91: Velocidad ante un desplazamiento de 300 grados con nuestra trayectoria. ............... 91
Ilustración 92: Controlador alimentado y programado correctamente. ............................................. 92
Ilustración 93: Lectura de la tensión del bus y del flag 4 (Undervoltage). ........................................ 93
Ilustración 94: Lectura de la tensión del bus y del flag 2 (Overvoltage). .......................................... 93
Ilustración 95: Funciones alternativas de los pines del microcontrolador STM32L476RG. ............. 96
Ilustración 96: Pines de las líneas de la interfaz SPI3 en el microcontrolador STM32L476RG. ...... 97
Ilustración 97: Pines PC10, PC11 y PC12 en los esquemáticos del controlador. .............................. 97
Ilustración 98: Pines de las líneas de la interfaz I2C2 en el microcontrolador STM32L476RG. ...... 98
Ilustración 99: Factura de Eurocircuits por la fabricación y montaje de las tarjetas. ........................ 99
x
Índice de tablas
Tabla 1: Parámetros del motor obtenidos mediante ST Motor Profiler. ............................................ 26
Tabla 2: Valores de resistencia para programar la tensión de salida del convertidor. ....................... 43
Tabla 3: Valores para el divisor resistivo que determina el UVLO del convertidor. ........................ 43
Tabla 4: Valores de las constantes de los PIDs resultantes de la calibración. ................................... 78
Tabla 5: Ecuaciones principales de la trayectoria S-Curve implementada. ....................................... 87
Tabla 6: despliegue de los costes de fabricación y montaje de 100 PCBs de nuestro controlador. ... 99
xiii
Capítulo 1
Introducción.
Gracias a la evolución de la Industria 4.0, el abanico de aplicaciones de los motores eléctricos crece
día a día. Sectores como el automovilístico están impulsando fuertemente su evolución gracias al
desarrollo de los vehículos eléctricos. Otro de los sectores que están extendiendo el uso de motores
eléctricos es la robótica, la cual está viviendo un momento de grandes avances.
En el campo de la robótica móvil, resulta especialmente importante la autonomía del sistema y de
cada una de sus partes. En lo que a los motores se refiere, los más eficientes son los de corriente
continua sin escobillas (BLDC), los cuales además presentan un bajo mantenimiento y no generan
apenas ruido.
Debido a sus múltiples ventajas, durante este Proyecto Fin de Grado se ha diseñado y puesto en
marcha un controlador para motores eléctricos BLDC de baja potencia, los cuales formarán parte de
los robots diseñados por la empresa Star Robotics S.L.
En los robots diseñados hasta la fecha, los motores eran gobernados por controladores comerciales,
cuyo coste era bastante alto. Dado que en el robot que se está desarrollando actualmente es muy
importante conseguir un coste de fabricación ajustado, se deben rediseñar y sustituir la gran mayoría
de componentes de los modelos anteriores, incluyendo los controladores de los motores.
Los controladores que se diseñan en este proyecto se encargan de mover el módulo de visión Pan &
Tilt del robot que está siendo actualmente diseñado. Deben ir alojados en el mástil y en el interior del
módulo de visión, por lo que sus dimensiones son reducidas. Al estar destinado para integrase en un
equipo real, son dispositivos completamente funcionales y aptos para formar parte de los futuros
robots diseñados.
En cuanto a esta memoria, se divide en 5 capítulos en los que se describen en profundidad el proceso
de diseño y la puesta en marcha de los controladores. En el primero de ellos se analiza el marco
tecnológico que engloba a nuestro proyecto y las soluciones existentes en el mercado referidas a
controladores de motores BLDC, con el objetivo de averiguar las diferentes funcionalidades que
puede implementar nuestro controlador.
En el Capítulo 2 se describe el trabajo realizado con el hardware de desarrollo. Dicho hardware es
imprescindible para validar el funcionamiento de los dispositivos que resultan más interesantes para
ser utilizados en nuestro controlador.
El diseño del circuito electrónico, así como de la tarjeta de circuito impreso (PCB – Printed Circuit
Board), es descrito en el Capítulo 3. Aquí se analizan el diagrama de bloques del controlador, las
partes más importantes del circuito electrónico y las reglas diseño seguidas para el diseño de la PCB,
habiendo concluido con la fase de diseño.
Posteriormente, en el Capítulo 4 se describe la puesta en marcha de los controladores, así como los
principales problemas encontrados y modificaciones realizadas en el firmware que ejecutan. También
describiremos las pruebas realizadas para validar el correcto funcionamiento y poder ser montados
en los robots.
El documento finaliza con el Capítulo 5, en el que se extraen las conclusiones de la realización de
este proyecto y se analizan las futuras líneas de trabajo sobre nuestro controlador. También se
incluyen dos anexos, donde se muestra el presupuesto del proyecto y la bibliografía consultada.
1
Introducción
1.1. Motores eléctricos: tipos y principios de funcionamiento.

Un motor eléctrico es una máquina que convierte la energía eléctrica en energía mecánica de rotación
haciendo uso de campos magnéticos. Pese a los muchos tipos que existen, todos ellos se componen
de dos partes fundamentales: el estátor (parte fija) y el rotor (parte móvil). A partir de aquí, sus
construcciones y principios de funcionamiento son muy diferentes. El primer criterio para clasificar
los motores eléctricos es el tipo de corriente con el que se alimentan, encontrando dos tipos: motores
de corriente alterna y motores de corriente continua.
1.1.1. Motores de corriente alterna (CA).

La tensión de alimentación de los motores de corriente alterna (CA) es una señal sinusoidal, cuya
frecuencia determinará la velocidad de rotación del motor. Son los más utilizados en la industria,
debido a su bajo mantenimiento. Por el contrario, no son los más adecuados para aplicaciones en las
que se deba variar la velocidad, pues resulta difícil modificar la frecuencia de la tensión de
alimentación. Se pueden clasificar según dos criterios:
 Número de fases del estátor.

 Sincronismo entre la velocidad del campo magnético del estátor y la del rotor.
En cuanto al número de fases del estátor, podemos encontrar motores CA monofásicos o trifásicos.
Los motores monofásicos son aquellos en los que todos los devanados del estátor están conectados a
la misma señal mientras que, en los trifásicos, los devanados se conectan a tres señales distintas, las
tres fases de la alimentación. A un motor trifásico se le aplicarán tres señales sinusoidales iguales
pero desfasadas entre sí.
Los motores monofásicos son más asequibles y sencillos, pero alcanzan una potencia menor que los
motores trifásicos (entre 2 kW y 3 kW como máximo). Además, los motores trifásicos presentan un
comportamiento más suave y generan menos vibraciones que los motores monofásicos. Esta
diferencia es más apreciable a velocidades bajas. Los motores trifásicos son los más utilizados en la
industria, mientras que los monofásicos suelen utilizarse en electrodomésticos, taladros y otras
aplicaciones con velocidades de giro altas.
También podemos distinguir entre motores de corriente alterna síncronos o asíncronos. En los
primeros, la velocidad de rotación del rotor es igual a la velocidad con la que gira el campo magnético
generado por el estátor; mientras que, en los motores asíncronos, estas velocidades son distintas. A la
diferencia entre estas velocidades se le denomina desplazamiento.
A los motores síncronos también se les conoce como motores de imanes permanentes, ya que éstos
forman parte de su rotor. Por otra parte, a los motores asíncronos también se les puede llamar motores
de inducción, ya que su rotor se compone de devanados similares a los del estátor.
Por características como la eficiencia, la suavidad en su respuesta y su bajo coste y mantenimiento,

los motores trifásicos asíncronos son los más comúnmente utilizados en la industria. Éstos basan su
funcionamiento en la generación de un campo magnético rotatorio mediante las bobinas del estátor,
el cual, por la ley de Faraday, hará circular una corriente inducida en los devanados del rotor. En el
caso de un inductor de N vueltas como son los devanados del estátor, podemos expresar la ley de
Faraday como:
𝑑𝜙
𝑉𝜀 = − ⃗ ∙ 𝑆 = 𝑁 ∗ 𝐵 ∗ 𝑆 ∗ cos(𝛼)
; 𝜙=𝐵
𝑑𝑡
2
Donde 𝜙 es el flujo magnético, 𝑉𝜀 es la tensión o fuerza electromotriz inducida, 𝐵

⃗ es el campo
magnético, 𝑆 la superficie de la espira inducida y 𝛼 el ángulo entre 𝐵
⃗ y 𝑆.
Al generar un campo rotativo, conseguimos variar el flujo magnético que atraviesa las espiras del
rotor, ya que variará α. Para generar ese campo magnético, nos basamos en el teorema de Ferraris, el
cual dice que: para un conjunto de bobinas separadas de forma equidistante y por las que circulan
corrientes sinusoidales desfasadas 120º en el tiempo, se obtiene una fuerza magnetomotriz (FMM)
giratoria y de amplitud y velocidad de giro constantes. [1]
Al inducir una tensión en las espiras de rotor, por ellas circulará una corriente cuyo sentido, según la
Ley de Lenz, se opondrá a la variación del flujo magnético que la indujo. Por ello, en cada tramo
infinitesimalmente pequeño de la espira se generará una fuerza de Lorentz que tendrá sentido opuesto
a la FMM generada por el estátor. Estas fuerzas tendrán sentidos opuestos, lo que quiere decir que el
rotor se verá atraído por el campo magnético del estátor y que el motor comenzará a girar.
Ilustración 1: Estructura de un motor trifásico asíncrono.
1.1.2. Motores de corriente continua (CC).
Los motores de corriente continua (CC) son alimentados mediante una tensión continua. En función
del tipo de motor CC del que estemos hablando, su principio de funcionamiento cambia
completamente. Encontramos dos grandes grupos de motores CC: con escobillas y sin escobillas.
 Motores CC con escobillas (brushed): El rotor de estos motores se compone de un bobinado,

por el que circulará una corriente cuando sus dos terminales estén en contacto con las
escobillas. Además, el estátor está formado por dos imanes permanentes, de polaridad opuesta,
los cuales generan un campo magnético constante.
3
Introducción
Ilustración 2: Componentes de un motor CC con escobillas.
Así, al hacer circular una corriente por un conductor inmerso en un campo magnético
constante, las espiras experimentarán una fuerza de Laplace, que puede expresarse como:
𝑏
⃗
𝐹 = 𝐼 ∗ ∫ 𝑑𝑙 𝑥 𝐵
𝑎
Donde I es la intensidad de corriente, 𝑑𝑙 el diferencial de longitud del conductor (cuyo sentido

coincide con el sentido de la corriente) y 𝐵
⃗ el campo magnético.
Ilustración 3: Representación simplificada de un motor CC con escobillas.
Si aplicamos la regla de la mano derecha en la Ilustración 3, entenderemos por qué se genera

una fuerza hacia abajo en el lado izquierdo de la espira. En el lado derecho también se generará
una fuerza, pero esta vez hacia arriba, por lo que aparecerá un par sobre la espira que la hará
rotar. También aplicando la regla de la mano derecha, veremos que las fuerzas generadas en
los segmentos restantes de la espira se cancelan entre sí.
Pero cuando el vector superficie de la espira se coloque de forma paralela al campo magnético
(en la Ilustración 3, cuando la espira esté paralela con respecto a los imanes), las fuerzas
generadas en los segmentos laterales se opondrán entre sí y se cancelarán. La propia inercia
conseguida en el rotor hace que este continúe girando hasta que los terminales de la espira
conmuten: el que antes estaba conectado al polo positivo de la tensión continua, ahora estará
conectada al polo negativo y viceversa.
Esto provoca que el sentido de la corriente que circula por la espira cambie, invirtiéndose el
sentido de las fuerzas generadas en los segmentos de la espira y que el rotor continúe girando.
La gran ventaja de los motores CC con escobillas es su bajo coste y la simplicidad para
manejarlos (ya que su velocidad y sentido de giro tan solo depende de la tensión de
alimentación aplicada). Por el contrario, necesitan bastante mantenimiento, ya que la fricción
generada entre el conmutador y las escobillas provoca que ambos elementos se desgasten.
4
 Motores CC sin escobillas (brushless): el principio de funcionamiento es muy parecido al de

los motores asíncronos CA estudiados, solo que en este caso las señales que excitan los
devanados del rotor son generadas electrónicamente a partir de una tensión continua.
El estátor es una pieza circular de acero que cuenta con unas columnas metálicas repartidas
por su diámetro alrededor de las cuales se enrollan los bobinados. Estos bobinados están
conectados a tres fases distintas de alimentación.
Ilustración 4: Ejemplo de conexión de los devanados del estátor de un motor BLDC trifásico.
Cuando los bobinados son atravesados por una corriente, se genera un campo magnético en
su interior, según la ley de Biot-Savart:
µ 𝐼 ∗ 𝑑𝑙 𝑥 𝑟
⃗ =
𝐵 ∗
4𝜋 𝑟3
Si aplicamos la regla de la mano derecha en la ley de Biot-Savart, veremos que el campo

magnético generado será paralelo al eje del bobinado y su sentido dependerá del sentido en el
que circula la corriente.
Por su parte, el rotor albergará una serie de imanes permanentes, colocados equidistantemente
a lo largo del diámetro del rotor y alternando su polaridad. Estos imanes serán atraídos o
repelidos por los campos magnéticos generados en los devanados del estátor.
Para conseguir un campo magnético giratorio en el estátor, es necesaria una electrónica que
se encargue de gestionar los parámetros de las corrientes que atraviesan los devanados,
principalmente su intensidad y su sentido de circulación. Esta gestión puede realizarse
mediante distintos algoritmos, los cuales serán estudiados en el próximo apartado.
También puede deducirse que la velocidad de giro del campo magnético generado en el estátor
será la misma que la del rotor, por lo que nos encontramos ante un motor síncrono. Es por ello
que a los motores brushless DC (BLDC) también se les conoce como Permanent Magnet
Synchronous Motors (PMSM).
La principal ventaja de este tipo de motores frente a los motores con escobillas es que no
requieren mantenimiento, ya que se eliminan los elementos expuestos al desgaste por fricción.
Además, el eliminar esta fricción entre las escobillas y el conmutador hace que los motores
brushless sean mucho más eficientes, más silenciosos y con una relación velocidad/torque
prácticamente lineal. Por el contrario, su principal desventaja es que su control es bastante
más complejo que el de un motor con escobillas, además de que su precio es superior.
5
Introducción
A modo de resumen, se presenta el siguiente esquema, el cual muestra la clasificación de motores

eléctricos realizada:
Ilustración 5: Clasificación de los motores eléctricos.
Al estar alimentado por una batería y al ser una aplicación en la que la eficiencia, el ruido y el
mantenimiento son claves, todos los motores que monta el robot son motores BLDC. De ahí la
motivación de desarrollar un controlador para motores BLDC propio, el cual permita ajustar el coste
de fabricación del robot que está siendo desarrollado actualmente por la empresa Star Robotics.
6
Ilustración 6: robot de la empresa Star Robotics en el que se integrará el controlador diseñado.
1.2. Métodos de control para motores de corriente continua sin

escobillas.
Existen tres algoritmos de control para motores BLDC (Brushless Direct Current): trapezoidal,
sinusoidal y FOC (Field Oriented Control). El fin de todos ellos es calcular el instante óptimo para
excitar cada una de las fases del motor y durante cuánto tiempo deben ser excitadas.
Sus diferencias residen principalmente en el nivel de complejidad de sus algoritmos, el cual es
directamente proporcional a la eficiencia y las prestaciones que se pueden conseguir con el motor. El
control trapezoidal es el método más sencillo de implementar, lo que hace que sea el método más
fiable de los tres. Por el contrario, genera un mayor rizado en las corrientes de las fases, lo que se
traduce en más vibraciones y ruido.
Por sus resultados, el método trapezoidal solo debe ser utilizado en aplicaciones de bajo coste y en
las que la eficiencia y una respuesta muy suave del motor no sean factores cruciales. Dado que los
robots en los que se montará nuestro controlador son sistemas movidos por baterías, la eficiencia es
un factor clave. Además, el movimiento del módulo de visión debe ser suave y preciso para obtener
buenas imágenes. Esto hace que el control FOC sea el método más apropiado para ser ejecutado por
nuestro controlador de motores BLDC.
Ilustración 7: Módulo de visión donde se ubicarán los controladores.

7
Introducción
1.2.1. Control trapezoidal o Six-Steps.

El método trapezoidal o Six-Steps divide un ciclo eléctrico en 6 intervalos, determinados por la
posición del rotor. En cada intervalo se excitan únicamente dos de las tres fases del estátor, haciendo
que la corriente a través del motor entre por una de las fases y retorne a tierra por otra.
En el documento AN1160 de Microchip se muestra gráficamente la secuencia de excitación en cada
una de las fases, así como la corriente que circula por cada una de ellas en cada intervalo. La rampa
de tensión que se ve en alguno de los intervalos representa la conmutación de la tensión aplicada en
esa fase.
Ilustración 8: Secuencia de activación de las fases del motor mediante control trapezoidal. [2]
Por ejemplo, en el intervalo 1, la corriente entrará al motor y atravesará los devanados de la fase roja
y los de la fase verde, a través de la cual la corriente vuelve a masa. En estos devanados se generarán
campos magnéticos de dirección opuesta (ya que la corriente recorre los devanados de fases distintas
en sentidos opuestos), los cuales atraerán a los imanes permanentes del rotor. Mientras, los devanados
de la fase azul estarán sin excitar.
En el siguiente intervalo cambiarán las fases excitadas para conseguir que el rotor siga girando. El
instante de la conmutación debe producirse cuando el campo magnético generado por los imanes
permanentes del rotor sea paralelo al campo magnético generado por los devanados del estátor, para
lo cual es necesario conocer la posición del rotor en cada instante.
La posición del rotor puede obtenerse mediante sensores (como tres sensores Hall) o sin sensores,
midiendo la fuerza electromotriz inducida por el rotor en los devanados del estátor. Por la ley de
Faraday, al tener un conductor (los devanados del estátor) sumergido en un campo magnético variable
(generado por los imanes del rotor en rotación), una fuerza electromotriz (FEM) será inducida en el
conductor. Esta fuerza electromotriz inducida se denomina Back EMF (BEMF) y responde a la
siguiente ecuación
𝐵𝐸𝑀𝐹 = 𝑁 ∗ 𝑙 ∗ 𝑟 ∗ 𝐵 ∗ 𝜔
donde:
 N es el número de vueltas de los devanados,
 l es la longitud del rotor,
 r es el radio interno del rotor,
 B es el campo magnético generado por el rotor,
 ω es la velocidad angular del rotor.
8
Entre todos estos parámetros, el único que varía es la velocidad del rotor. Por tanto, podemos
decir que el BEMF será directamente proporcional a la velocidad angular. Esto no permite utilizar
el método sensorless (sin sensores) en aplicaciones en las que la velocidad de giro es baja, ya que
el BEMF generado sería demasiado bajo.
El BEMF generado en los devanados del estátor se muestra en la Ilustración 9. Dado que siempre
hay una fase que no está excitada, la tensión medida en esa fase se corresponde con el BEMF
inducido (en las fases excitadas esta tensión se opondrá a la tensión de excitación de las fases,
debido a la Ley de Lenz). En cada uno de los 6 intervalos, el BEMF cruzará dos veces por cero.
Detectando estos instantes y sabiendo cual es la fase no excitada, podemos conocer la posición
del rotor.
Ilustración 9: BEMF generado en las tres fases de un motor BLDC sin excitar.
En aplicaciones donde la velocidad de giro del motor es demasiado baja, es imprescindible utilizar
sensores Hall. Normalmente, se utilizan 3 sensores Hall, repartidos equidistantemente por el diámetro
interno del estátor (es decir, con una separación de 120º). Por el efecto Hall, estos sensores generarán
un nivel alto de tensión cuando estén enfrentados con un imán N del rotor y un nivel bajo cuando
estén enfrentados con un imán S. Mediante una tabla de verdad que evalúa el valor entregado por
cada sensor, podemos determinar la posición del rotor y la excitación de las fases.
Ilustración 10: Tabla de verdad para la excitación de las fases en el control 6-steps con sensores Hall.
9
Introducción
1.2.2. Control sinusoidal.
El método de control sinusoidal aplica señales de tensión de forma sinusoidal a las fases del motor,
las cuales están desfasadas 120º en el tiempo entre sí. Con respecto al control trapezoidal, ofrece
mayor eficiencia, menor rizado en el par y menor ruido acústico.
Al igual que con los motores trifásicos asíncronos de corriente alterna, el objetivo es generar un
campo magnético rotativo en el estátor que, en este caso, atraerá o repelerá a los imanes permanentes
del estátor, provocando el movimiento.
Para conseguir generar estas señales a partir de la corriente continua que alimenta el controlador, un
microcontrolador generará tres señales PWM cuyo ciclo de trabajo será variado constantemente y que
serán aplicadas en las puertas de los MOSFET superiores de cada semipuente en H. Así, al variar el
ciclo de trabajo, variará el valor medio de la tensión aplicada en la puerta del MOSFET. De esta
forma, en función del ciclo de trabajo de la señal PWM la corriente que atravesará las fases del motor
serán distintas.
El ciclo de trabajo de las señales PWM estará determinado por la posición del rotor, obtenida
mediante sensores Hall como se hacía en el control trapezoidal. Esta relación puede apreciarse en la
Ilustración 11:
Ilustración 11: Relación entre el ciclo de trabajo de las señales PWM y la posición del rotor .
1.2.3. FOC (Field Oriented Control).

El método de control FOC (Field Oriented Control) excita las fases del motor de tal forma que el
ángulo entre el campo magnético generado por el estátor y el generado por los imanes permanentes
del rotor sea de 90º. Cuando los campos magnéticos están orientados de esta forma, la entrega de par
es máxima. Esto se puede apreciar de manera intuitiva en la siguiente imagen:
Ilustración 12: Torque generado en el rotor en función del ángulo de los campos magnéticos..
10
Por cada fase del estátor se hará circular una corriente sinusoidal, las cuales estarán desfasadas 120º
entre fase y fase. De esta forma, se consigue un campo magnético giratorio de la misma forma que se
estudió en los motores trifásicos asíncronos de corriente alterna.
Por tanto, la tarea de un controlador que implemente el algoritmo FOC será proporcionar estas
corrientes sinusoidales al motor a partir de una tensión continua de alimentación. Para ello, el
firmware del controlador suele implementar el siguiente diagrama de bloques, el cual representa el
algoritmo de control FOC realizando un control de velocidad:
Ilustración 13: Diagrama de bloques del algoritmo de control FOC de motores BLDC.
El campo magnético ejercido sobre el rotor puede descomponerse en dos componentes

perpendiculares entre sí: una de ellas ejercerá una fuerza perpendicular con respecto al flujo
magnético del rotor y la otra, una fuerza paralela. Esto puede apreciarse en la Ilustración 14:
Ilustración 14: Descomposición el campo magnético ejercido sobre el rotor en el control FOC.
La fuerza perpendicular es la única que ejerce un par de giro sobre el rotor y es consecuencia de una
corriente a la que llamaremos Iq. La fuerza paralela no ejerce ningún par de giro sobre el rotor, solo
consume potencia y es consecuencia de una corriente llamada Id. Por tanto, para conseguir la máxima
eficiencia, la consigna de Id será siempre cero, y la consigna de Iq será la que determine el par ejercido
sobre el rotor.
Para determinar las corrientes Iq e Id generadas por el estátor en cada instante, se toma la medida de
la corriente de dos fases y se les aplica las transformadas de Clarke y Park, en ese orden. La
transformada de Clarke convierte las corrientes de las fases, que están en un dominio trifásico, a dos
corrientes basadas en un sistema ortogonal bidimensional αβ. El resultado de esta transformada sería
el siguiente
𝑖𝜶 = 𝑖𝑎
1 2
𝑖𝛽 =∗ 𝑖𝑎 + ∗ 𝑖𝑏
√3 √3
donde ia e ib son las corrientes de dos fases del motor:
11
Introducción
𝑖𝑎 = 𝐼𝑜𝑎 ∗ 𝑠𝑒𝑛(𝜔𝑡)
2𝜋
𝑖𝑏 = 𝐼𝑜𝑏 ∗ 𝑠𝑒𝑛 (𝜔𝑡 + )
3
4𝜋
𝑖𝑐 = 𝐼𝑜𝑐 ∗ 𝑠𝑒𝑛 (𝜔𝑡 + )
3
Después, mediante la transformada de Park, obtendremos también dos corrientes basadas en un
sistema bidimensional ortogonal, pero las cuales no variarán con el tiempo. Esto se consigue
estableciendo sistema de coordenadas el cual gira de forma solidaria con el rotor. Las corrientes
obtenidas de esta transformada serán Iq e Id
𝐼𝑑 = 𝑖𝛼 ∗ 𝑐𝑜𝑠𝜃 + 𝑖𝛽 ∗ 𝑠𝑒𝑛𝜃
𝐼𝑞 = −𝑖𝛼 ∗ 𝑠𝑒𝑛𝜃 + 𝑖𝛽 ∗ 𝑐𝑜𝑠𝜃
donde θ será la posición angular del rotor. Una vez obtenidas los valores de Iq e Id, obtendremos dos
valores de tensión Vq y Vd mediante dos reguladores PI, cuyas señales de entrada serán las señales de
error producidas entre las consignas de Iq e Id y sus valores actuales.
A continuación, se aplica el proceso inverso sobre las tensiones Vq y Vd para obtener las tensiones que
debemos aplicar sobre las puertas de los MOSFET que forman los tres semipuentes en H. En primer
lugar, se aplicará la transformada inversa de Park, obteniendo dos tensiones Vα y Vβ. A partir de estas
tensiones obtendremos las señales PWM que se aplican en las puertas de los MOSFET superiores de
cada semipuente y cuyo ciclo de trabajo determinará la corriente que atraviesa el transistor y, en
consecuencia, las fases del motor.
Estas señales PWM se obtienen mediante la modulación por ancho de pulso del vector de espacio
(SVPWM - Space Vector Pulse Width Modulation1). Así obtendremos 3 señales PWM cuyo ciclo de
trabajo determinará el valor medio de la tensión aplicada en la puerta de cada MOSFET y, con ello,
la corriente que circulará por cada fase del motor.
1
Para obtener más información sobre este método, puede consultar el documento [20].
12
1.3. Soluciones en el mercado para el control de motores de CC sin

escobillas.
En el mercado, podemos encontrar distintas soluciones para el control de motores BLDC, que difieren
principalmente en su grado de integración: desde un conjunto integrado de motor y controlador hasta
circuitos integrados encargados de controlar las puertas de los MOSFET que alimentan las fases del
motor. Maxon, Texas Instruments y ST Microelectronics son los fabricantes más destacados de este
tipo de soluciones.
1.3.1. Soluciones de Maxon.

Maxon cuenta en su gama de productos con un conjunto compuesto de un motor BLDC compacto y
un controlador de posición FOC, ambos integrados bajo la misma carcasa. Esta serie de productos
recibe el nombre comercial de IDX y existen distintos modelos, que se diferencian en la potencia
consumida, el par entregado, la velocidad máxima y las interfaces de comunicación que integran
(CANopen, EtherCAT...). El principal inconveniente de esa gama de productos es su elevado precio,
el cual no baja de los 900 € en ninguno de los modelos ofrecidos.
Ilustración 15: Imagen de la estructura de la gama IDX de Maxon Motors.
También en Maxon, podemos encontrar controladores de motores BLDC. Reciben el nombre de

ECON (controladores de corriente y velocidad) y EPOS (controladores de posición). Las principales
diferencias entre los distintos modelos de cada serie son: la potencia consumida, la corriente nominal
entregada, interfaces de comunicación incluidas y su tamaño. El precio de estas soluciones es inferior
a las de la gama IDX. Aun así, sigue siendo demasiado elevado, pues está en torno a los 200 € en los
controladores menos potentes.
Ilustración 16: Controlador EPOS2 P de Maxon.
13
Introducción
1.3.2. Soluciones de Texas Instruments.

Texas Instruments ofrece una gran variedad de circuitos integrados para el control de motores BLDC,
así como diseños de referencia que los usuarios pueden utilizar como punto de partida en sus
proyectos. En cuanto a los circuitos integrados, podemos encontrar controladores para las puertas de
los MOSFET, sensores de temperatura, circuitos para la gestión de la alimentación, etcétera.
Una de las familias de dispositivos más interesantes es la DRV835x. Estos circuitos integrados
agrupan 3 controladores, cada uno de los cuales se encarga de gobernar las puertas de los dos
MOSFET que componen cada semipuente en H. Podemos encontrar un esquema simplificado de su
aplicación en la hoja de datos de esta serie:
Ilustración 17: Circuito de aplicación de la familia de dispositivos DRV835x de Texas Instruments. [3]
Como vemos, estos circuitos integrados no solo integran los controladores de los MOSFET, sino que
ofrecen 3 amplificadores que adaptan la tensión caída en las resistencias de medida de corriente a un
ADC, un convertidor reductor de tensión para alimentar a los controladores de las puertas y circuitos
de protección frente a sobrecalentamiento.
Además, son capaces de gobernar las 6 puertas de los MOSFET a partir de 1, 3 o 6 señales de entrada
PWM. Pero no todos los modelos de la serie integran el mismo hardware. Por ejemplo, los modelos
DRV8350 y DRV8350R no incorporan los amplificadores.
Un nivel superior de integración podría encontrarse en el modelo DRV8313. Este dispositivo incluye
toda la electrónica mencionada en la serie DRV835x y, además, integra los MOSFET que forman los
semipuentes en H. Este sería su circuito de aplicación:
Ilustración 18: Circuito de aplicación del circuito integrado DRV8313 de Texas Instruments.
Eso sí, como podemos observar en la Ilustración 18, perdemos los amplificadores operacionales para
la medida de la corriente en las fases. Aun así, resulta una opción muy interesante para nuestro diseño,
ya que al integrar en su interior los MOSFET, ahorraríamos bastante espacio en la tarjeta.
14
Texas Instruments también ofrece tarjetas de evaluación de los circuitos mencionados anteriormente,
las cuales son útiles tanto para comprobar el funcionamiento de estos circuitos sobre los motores del
robot como para tomar sus esquemáticos como referencia de nuestro diseño. Además, ofrece un SDK
(Software Development Kit) llamado C2000Ware MotorControl SDK, mediante el cual se agiliza el
proceso de desarrollo del firmware del controlador.
1.3.3. Soluciones de ST Microelectronics.

ST Microelectronics ofrece circuitos integrados similares a los de Texas Instruments¸ muchos de los
cuales se agrupan dentro de la familia STSPIN. Por ejemplo, un circuito muy interesante para nuestro
diseño es el STSPIN32F0.
Este circuito integra los controladores para los 3 semipuentes en H, 4 amplificadores operacionales
rail-to-rail, un comparador para programar una protección ante consumos excesivo de corriente, una
MCU STM32, basada en una arquitectura de 32 bits ARM-Cortex-M0 y muchas otras
funcionalidades. Resulta interesante un circuito integrado que agrupe tanto la MCU como los
controladores de los MOSFET, ya que puede ahorrarnos mucho espacio en la tarjeta que diseñemos.
En su hoja de datos, se observan los esquemáticos completos para implementar este circuito en un
controlador para un motor BLDC midiendo la corriente de una sola fase del motor. Con esta
configuración, no quedan pines disponibles para conectar un encóder, lo cual nos resulta
imprescindible. Además, la MCU integrada no dispone de una interfaz para poder enviar y recibir
mensajes a través de un bus CAN.
También existen otras soluciones con un menor nivel de integración, como el circuito integrado
L6230. Se trata de un circuito que agrupa los tres semipuentes en H, sus respectivos controladores,
un circuito de protección ante consumos excesivos de corriente y pines de salida para medir
independientemente las corrientes de las tres fases del motor, lo cual lo hace especialmente interesante
para implementar un algoritmo de control FOC.
Además, cuenta con un comparador para implementar una protección por consumo excesivo de
corriente programable, protección por sobrecalentamiento y una entrega de corriente de 2,8 A de pico.
Al igual que ocurría con los circuitos de Texas Instruments, ST Microelectronics ofrece tarjetas de
evaluación para los dos circuitos analizados, cuyos esquemáticos son de acceso libre y podrían
servirnos de referencia. También ofrece un conjunto de herramientas software para generar un
firmware ejecutable en sus microcontroladores STM32 y que implementa un algoritmo de control
FOC. La parte mayoritaria de este software es gratuita, si bien es cierto que algunas funcionalidades
solo están disponibles en la versión completa. El conjunto de todas estas herramientas recibe el
nombre de STM32 MC SDK.
El factor diferencial con respecto a las herramientas de Texas Instruments es que ST ofrece un mayor
número de herramientas como, por ejemplo, un software que calcula los parámetros eléctricos y
mecánicos del motor y permite ponerlo en marcha en pocos minutos. Además, se ha encontrado una
mayor cantidad de documentación, en concreto algunos documentos muy interesantes sobre el cálculo
de la trayectoria ejecutada por el motor en los cambios de posición.
Tras analizar las soluciones ofrecidas por cada uno de los fabricantes, parece que ST Microelectronics
es el que más herramientas ofrece para diseñar nuestro propio controlador de motores BLDC a partir
de su hardware. En el próximo apartado, decidiremos el hardware de desarrollo de ST
Microelectronics con el que comenzaremos nuestro diseño.
15
Introducción
1.4. Elección de las herramientas de desarrollo.

El hardware de desarrollo que más interesante puede resultar para nuestro diseño es alguna de las
tarjetas de evaluación de ST Microelectronics, la cual servirá para evaluar el funcionamiento de
alguno de los circuitos integrados vistos en el apartado anterior y así, implementarlo posteriormente
en nuestro diseño.
Antes de seleccionar el hardware de desarrollo, debemos conocer las características del motor que
debemos controlar. Éste es del fabricante Vishan Motors, en concreto, el modelo EC2240S-3016.
Sus principales características son:
 Tensión nominal de alimentación de 30 V.
 Corriente nominal de 0,8 A.
 Velocidad máxima de 16713 rpm al voltaje nominal.
 1 par de polos en el rotor.
 Sensores Hall incorporados.
 Encóder incremental adicional incorporado.
Así, centrándonos en las características de su alimentación y consumo, vemos que el circuito

integrado L6230 podría ser utilizado para controlar este motor, pues admite una tensión de
alimentación comprendida entre los 8 V y los 52 V y es capaz de entregar una corriente de 1,4 A
RMS (y hasta 2,8 A de pico).
Dicho circuito es implementado en la tarjeta de evaluación de X-NUCLEO-IHM07M1, de ST. Esta
tarjeta funciona como una tarjeta de expansión de otra tarjeta de desarrollo de la familia NUCLEO,
las cuales integran los modelos de microcontroladores de ST.
En la empresa Star Robotics se disponía de distintos modelos de estas tarjetas de control. En concreto,
se realizaron pruebas con las tarjetas NUCLEO-F302R8 y NUCLEO-L476RG, viendo que el
comportamiento del firmware generado era correcto en ambas. Dado que el procesador
STM32L476RG declara menos consumo y mayor capacidad de procesamiento, finalmente se optó por
utilizar la tarjeta de desarrollo NUCLEO-L476RG.
El hardware de desarrollo que utilizaremos para el diseño de nuestro controlador de motores BLDC
se muestra en la Ilustración 19:
Ilustración 19: Esquema del hardware de desarrollo que se utilizará en la primera fase del proyecto.
16
El PC de la Ilustración 19 será el encargado de ejecutar las herramientas software de ST

Microelectronics que utilizaremos para desarrollar el firmware ejecutado por el controlador,
agrupadas dentro del STM32 MC SDK. Estas herramientas son:
 ST Motor Profiler: será el primer software que utilicemos y se encarga de calcular los
parámetros eléctricos y mecánicos del motor. Pese a que estos datos se pueden encontrar
fácilmente en la hoja de datos del motor, esta herramienta nos permite calcular estos
parámetros bajo cualquier condición de funcionamiento: diferentes tensiones de alimentación,
límites de corriente máxima...
Además, nos permitirá poner en marcha y comprobar el correcto funcionamiento de todo el
hardware de desarrollo en un tiempo de aproximadamente veinte minutos.
Cuenta con una interfaz gráfica para seleccionar la tarjeta de control y la tarjeta de expansión
(o de potencia) utilizadas en nuestro sistema. Permite configurar una limitación de corriente
y de velocidad, que pueden resultar útiles durante las primeras pruebas, y solo se necesita
introducir el número de pares de polos del motor y la tensión de alimentación del sistema para
comenzar el cálculo de los parámetros del motor. ST Motor Profiler programará la tarjeta
NUCEO-L476RG antes de comenzar el cálculo de los parámetros y podremos probar
ligeramente el funcionamiento del sistema, variando la consigna de velocidad del motor.
Finalmente, podremos guardar un perfil del motor que agrupará los parámetros calculados
para después ser introducidos fácilmente en la siguiente herramienta del ciclo de trabajo.
 MotorControl Workbench (MCWB): utilizaremos este software para personalizar y generar
el firmware de las tarjetas de desarrollo y de nuestro controlador. Este programa ofrece una
interfaz gráfica basada en un diagrama de bloques del controlador y del motor, mediante la
cual podemos modificar fácilmente muchos parámetros del hardware del sistema. El valor de
estos parámetros del hardware determinará el valor que toman algunas de las variables del
firmware englobado en el STM32 MC SDK.
Lo primero que haremos en MCWB es seleccionar nuestro hardware de desarrollo (la tarjeta
de control y la de expansión). Esto configurará automáticamente todos los parámetros del
hardware del controlador (la asignación de pines del microcontrolador, el valor de las
resistencias de corriente, etcétera), por lo que solo deberemos añadir el perfil del motor creado
con ST Motor Profiler. Pero estos parámetros del hardware pueden ser modificados sin
problemas, lo cual resultará útil cuando generemos el firmware para nuestro controlador.
Para cuando tengamos las tarjetas de desarrollo programadas, MCWB también ofrece un
monitor con tres interfaces gráficas diferentes para controlar el motor. Estas interfaces se
diferencian en la profundidad de los ajustes que nos permiten realizar. Es decir, mientras que
la interfaz más básica tan solo nos permitirá cambiar la velocidad de consigna y nos mostrará
el valor de la potencia consumida y la temperatura de la tarjeta de expansión, existe otra
interfaz que permite modificar el valor de hasta 100 variables del firmware.
Tras configurar todos los parámetros, podemos generar fácilmente un proyecto firmware que
puede abrirse en distintos IDEs (Integrated Development Environment).
 STM32CubeIDE: se trata de un IDE de programación en C o C++ desarrollado por ST
Microelectronics. Lo utilizaremos para compilar el proyecto firmware generado y ponerlo en
marcha en las tarjetas de desarrollo. También resultará útil si se necesita depurar, modificar o
añadir funcionalidades al código.
Siguiendo este ciclo de trabajo, seremos capaces de generar el firmware tanto para las tarjetas de
desarrollo seleccionadas anteriormente como para el controlador que diseños nosotros mismos.
17
Introducción
18
Capítulo 2
Trabajos previos al diseño del
controlador.
Para comprobar si el hardware implementado en las tarjetas de desarrollo puede ser incluido en
nuestro controlador, realizaremos una serie pruebas que nos permitirán validar, entre otras cosas, si
el circuito integrado L6230 es apto para controlar los motores que incorpora el módulo de visión del
robot. Además, empezaremos a definir alguna de las restricciones del diseño, tales como la asignación
de los pines del microcontrolador.
2.1. Configuración hardware de las tarjetas de desarrollo.

Las tarjetas de desarrollo de ST Microelectronics escogidas para comenzar nuestro diseño tienen una
serie de solderbridges y jumpers que permiten configurar algunas características de su hardware,
como la interfaz de programación o la fuente de alimentación de las tarjetas.
Para decidir la colocación de estos solderbridges y jumpers, nos preocuparemos de:
 La asignación de señales para los pines del microcontrolador.
 Poder implementar un control FOC, con 3 resistencias de medida de corriente (shunt).
 Seleccionar la fuente de alimentación correcta para el microcontrolador.
Todas las tarjetas de desarrollo de ST que implementan un microcontrolador STM32 de 64 pines se
basan en el diseño de referencia MB1136. En nuestro, la tarjeta NUCLEO-L476RG implementa el
microcontrolador STM32L476RG.
Analizando los esquemáticos del diseño MB1136, vemos que la mayoría de pines del
microcontrolador están conectados a dos solderbridges. De esta forma, podemos conectar un mismo
pin del microcontrolador a distintos pines de los conectores ST Morpho que se sitúan en los laterales
de la tarjeta. A través de estos conectores, acoplaremos posteriormente la tarjeta de potencia para
control de motores BLDC X-NUCLEO-IHM07M1.
Ilustración 20: Esquema de conexiones del conector CN10 en el diseño MB1136

19
Trabajos previos al diseño del controlador
Ilustración 21: Esquema de conexiones del microcontrolador en el diseño MB1136.
Por ejemplo, en la Ilustración 21 vemos que el pin 34 del microcontrolador puede conectarse a PB13
o a PB14, en función de si se cierra el solderbridge SB27 o el SB26. Después, en función de si
soldamos el SB35 o el SB28, podremos conducir la señal del pin 34 del microcontrolador hasta el pin
28 o el pin 30 del conector ST Morpho CN10 (Ilustración 20).
A la tarjeta de potencia conectaremos el encóder del motor (en el conector J3), las fases del motor (en
el conector J2) y la alimentación del sistema (en el conector J1). Para ello, debemos modificar los
solderbridges de la tarjeta NUCLEO-L476RG para que estas señales lleguen al pin del
microcontrolador correcto.
Lo primero que debemos hacer es asignar a cada una de las señales manejadas por el microcontrolador
uno de sus pines. Podemos ayudarnos del software MotorControl Workbench y su herramienta de
asignación de pines, en la que se listan todas las señales que maneja el microcontrolador y los posibles
pines que se le pueden asignar. Para utilizarla, crearemos un proyecto en MCWB2 seleccionando las
tarjetas NUCLEO-L476RG y X-NUCLEO-IHM07M1.
Ilustración 22: Asignación de pines por defecto para las tarjetas de desarrollo en MCWB.
2
El manejo de MotorControl Workbench se explicará en profundidad en el apartado 2.3 de esta memoria.
20
En la tercera columna de la Ilustración 22 se muestran los posibles pines que se pueden asignar a cada
señal. Basándonos en la posible distribución de los componentes en la tarjeta y con el fin de facilitar
el ruteo de las señales, cambiaremos los pines asignados por defecto a dichas señales, quedando la
siguiente asignación de pines:
Ilustración 23: Asignación de pines del microcontrolador para el diseño del controlador de motores BLDC.
Ahora podemos analizar la posición de los solderbridges y jumpers y ajustarla para que la conexión
entre el microcontrolador y la tarjeta de potencia sea la correcta. Los cambios que se han realizado
son los siguientes:
 Se han soldado los solderbridges SB16, SB50 y se ha abierto el SB55. Este cambio se debe a
que, en la configuración por defecto del NUCLEO-L476RG no se utiliza ningún reloj de alta
frecuencia. Para algunas tareas del algoritmo FOC este reloj resulta imprescindible.
Configurando los solderbridges de esta forma obtendremos una señal de reloj de 8 MHz a
partir del reloj de alta frecuencia del bloque ST-LINK/V2 incluido en la tarjeta.
Ilustración 24: Módulo ST-LINK/V2 incorporado en el diseño MB1136.
21
 Se han colocado los jumpers J5 y J6 de la tarjeta X-NUCLEO-IHM07M1 en la posición 3Sh.

De esta forma, la señal SENS13 se corresponderá con la tensión medida en la primera
resistencia de shunt y a la señal SENS3 la tensión medida en la tercera resistencia de shunt.
La tensión medida en la segunda resistencia de shunt está directamente conectada a la señal
SENS2.
Ilustración 25: Conexiones en los conectores J5 y J6 de la tarjeta X-NUCLEO-IHM07M1.
Como podemos deducir de la Ilustración 25, cuando estos jumpers se encuentran en la

posición 1Sh, la tensión que cae en la segunda resistencia de shunt es aplicada en SENS1,
SENS2 y SENS3, por lo que solo se estaría midiendo la corriente que circula por una de las
fases del motor.
 Siempre trabajaremos con el jumper JP5 de la tarjeta NUCLEO-L476RG en la posición U5V.
De esta forma, el módulo ST-LINK/V2 podrá habilitar y deshabilitar la alimentación del puerto
serie de la tarjeta, evitando posibles conflictos que puedan producirse durante el arranque de
la tarjeta. Es la configuración más estable, pues en algunas de las pruebas realizadas
alimentando la tarjeta externamente (posición E5V) han existido problemas en la
comunicación por el puerto serie.
 La configuración de los solderbridges que conectan los pines del microcontrolador con los
conectores laterales de la tarjeta NUCLEO-L476RG es la misma que la existente en la tarjeta
NUCLEO-F302R8. Esta tarjeta fue probada anteriormente por Star Robotics y, al estar
también basada en el diseño MB1136, su configuración debería ser válida para la tarjeta
NUCLEO-L476RG.
Tras haber realizado estas modificaciones en el hardware de las tarjetas de desarrollo y haber definido
la asignación de pines para cada señal manejada por el microcontrolador, tenemos un hardware de
desarrollo que puede ser programado y probado. Por ello, el siguiente paso de este proyecto será la
generación de una primera versión funcional del firmware para las tarjetas de desarrollo utilizando el
software que ST Microelectronics ofrece para ello.
3
SENS1, SENS2 y SENS3 son señales de entrada al circuito L6230.
22
2.2. Estructura del firmware generado a partir de Motor Control

Workbench.
El firmware que ejecutará el control FOC es generado a partir de las herramientas software que ofrece
ST Microelectronics y recibe el nombre de STM32 MotorControl SDK (STM32 MC SDK). Este SDK
contiene una librería software que implementa el método de control FOC para motores trifásicos
síncronos de imanes permanentes PMSM, tanto de montaje superficial (SM-PMSM) como interior
(I-PMSM).
Está librería está escrita en C e implementa tanto los algoritmos principales para el control de los
motores cómo la lectura de los sensores. También implementa algoritmos para determinar la posición
instantánea del rotor sin usar ningún tipo de sensor. Podemos encontrar dos versiones de este SDK:
X-CUBE-MCSDK y X-CUBE-MCSDK-FUL. Ésta última versión añade algunas funcionalidades y
algoritmos adicionales frente a la versión limitada y gratuita, como el máximo torque por amperio
(MTPA-Maximum Torque per Amper).
La gran ventaja de este firmware es la capacidad de personalización en función de los parámetros del
sistema: características del motor, tipo de sensores utilizados, asignación de pines del
microcontrolador, parámetros de la etapa de potencia, etcétera.
El firmware de nuestro controlador estará basado en tres grandes bloques: MC API, UI API y MC
Low Level API. Como su propio nombre indica, se tratan de APIs (Application Programming
Interface) que nos permiten utilizar las funciones que codifican para desarrollar nuestro propio
software de control o modificar el generado mediante las herramientas de ST Microelectronics. El
pilar fundamental de estas APIs en la capa de abstracción hardware de ARM, CMSIS (Cortex
Microcontroller Software Interface Standard).
Ilustración 26: Arquitectura del STM32 MC firmware. [4]
 La librería PMSM FOC contiene todos los bloques software que implementan el control FOC
del motor. Cada componente cumple una de las funcionalidades involucradas y necesarias en
el algoritmo de control, como la medida de la velocidad o la detección de la posición del rotor.
Para cubrir ciertas funcionalidades, la librería ofrece varios componentes para esa misma
función con implementación diferente, lo que hace posible utilizar distintos componentes
hardware con este SDK.
23
Ilustración 27: Componentes que forman la librería PMSM FOC.
 La librería UI (User Interface) contiene el software que permite la comunicación del STM32
MC SDK a través de un puerto serie o de un conversor analógico-digital (DAC) con otras
aplicaciones, como MCWB.
 Motor Control Cockpit integra los dos anteriores bloques en un único paquete firmware e
implementa los bucles de regulación FOC y de seguridad. Su labor es la de configurar y
comunicar los componentes firmware seleccionados de la librería PMSM FOC con los de la
librería User Interface para crear el firmware del controlador. Gracias a que a través del
software MCWB configuramos y personalizamos el firmware para nuestro sistema, el
firmware ejecutado por los controladores tan solo contendrá los bloques firmware
estrictamente necesarios.
Por último, destacaremos que el STM32 MC SDK se distribuye como una expansión o funcionalidad
adicional del software STM32CubeMX, herramienta que permite configurar gráficamente los
microcontroladores de 32 bits de ST Microelectronics, así como generar fácilmente la correspondiente
inicialización del microcontrolador, configurar el árbol de relojes del sistema, los periféricos y
generar un proyecto que puede ser abierto directamente en un IDE de programación en C.
2.3. Generación y pruebas de una primera versión del firmware.

Siguiendo el ciclo de trabajo explicado en el apartado 1.4 generaremos la primera versión funcional
del firmware que se ejecutará en las tarjeta de desarrollo para controlar nuestro motor BLDC. En este
apartado describiremos el uso y el manejo de las herramientas software de ST Microelectronics para
la generación del firmware y para conseguir mover y manejar por primera vez el motor, utilizando el
hardware de desarrollo y la interfaz gráfica de control de MCWB.
2.3.1. Generación del perfil del motor con ST Motor Profiler.

El primer paso es crear un perfil del motor que vayamos a utilizar, el cual englobará las principales
características eléctricas y mecánicas del motor, como pueden ser su tensión nominal de alimentación
o su inercia, bajo unas determinadas condiciones de uso.
Este perfil lo obtendremos mediante el programa ST Motor Profiler. Tras iniciarlo, seleccionaremos
las tarjetas de desarrollo de ST Microelectronics que estamos utilizando. En nuestro caso, estas
tarjetas son la NUCLEO-L476RG y la X-NUCLEO-IHM07M1.
24
Ilustración 28: Ventana de selección del hardware de desarrollo en ST Motor Profiler.
Una vez seleccionadas las tarjetas, el programa nos pide introducir algunas de las características del
motor, como el número de pares de polos, la velocidad máxima, la corriente máxima consumida y la
tensión nominal de alimentación. Estos datos pueden encontrarse en la hoja de características del
motor. En nuestro caso, el motor utilizado es de Vishan Motors, en concreto el modelo EC2240S-
3016.
Ilustración 29: Panel de configuración de ST Motor Profiler.
En esta primera prueba, vamos a limitar la velocidad máxima a 10000 rpm, en lugar de las 16713 rpm
indicadas en la hoja de datos del motor [5]. También, limitaremos el consumo de corriente a 2 A, en
lugar de los 2,8 A que es capaz de entregar la tarjeta IHM07M1. La tensión de alimentación que
aplicaremos sí que se corresponderá con la tensión nominal de alimentación del motor (30 V).
También debemos especificar el tipo de montaje de los imanes permanentes del rotor: superficial
(SM-PMSM) o interno (I-PMSM). Los motores de Vishan de la serie EC2240 montan éstos imanes
superficialmente.
El siguiente paso es configurar el hardware de las tarjetas. Para ello, ST Motor Profiler ofrece un
archivo en el que se describe por completo la configuración de los jumpers de las tarjetas y las
conexiones a realizar. Para acceder a él, pulsamos sobre el icono de información que encontramos
debajo de las imágenes de las tarjetas.
Algunas de las modificaciones que se indican en este archivo ya se realizaron en el apartado 2.1,
como la colocación de los jumpers J5 y J6 de la tarjeta IHM07M1 en la posición 3Sh y la configuración
de los solderbridges SB16, SB50 y SB55. Algunas configuraciones que debemos revisar son:
25
 Sobre la tarjeta NUCLEO-L476RG, debemos quitar el jumper JP1, colocar el jumper JP5 en
la posición U5V y conectar los dos jumpers en CN2. Esto permitirá programar la tarjeta a
través del dispositivo ST-LINK/V2.
 Sobre la tarjeta X-NUCLEO-IHM07M1 quitamos el jumper J9 y conectamos los jumpers JP1
y JP2.
Tras esto, podemos conectar las tarjetas al puerto USB del ordenador. Para ello, utilizaremos el
conector micro-USB de la tarjeta NUCLEO-L476RG. En ST Motor Profiler, pulsamos sobre Connect
para programar las tarjetas. Alimentaremos las tarjetas a través del conector J1 y conectaremos las
fases del motor al conector J2. El proceso de cálculo de los parámetros del motor durará unos 5
minutos aproximadamente y como resultado, se obtienen los valores mostrados en la
Tabla 1. Estos valores pueden guardarse e incluirse después en el proyecto de MCWB.
Parámetro Valor
Resistencia entre fases (Rs) 5,02 Ω
Inductancia de las fases (Ls) 0,502 mH
Constante de BEMF (Ke) 1,8 Vrms/krpm
Fricción 3,965 𝑢𝑁 ∗ 𝑚 ∗ 𝑠
Inercia 0,230 𝑢𝑁 ∗ 𝑚 ∗ 𝑠 2
Velocidad máxima alcanzada 12162 rpm
Tabla 1: Parámetros del motor obtenidos mediante ST Motor Profiler para la primera versión del firmware.
2.3.2. Personalización del firmware mediante MCWB y generación del código.
El siguiente paso será utilizar el programa MCWB para ajustar el valor de algunas constantes de la
librería PMSM FOC del firmware STM32 MCSDK. Estas constantes guardan información sobre las
características del hardware utilizado, como puede ser el número de cuentas por revolución (ppr) del
encóder, la frecuencia de las señales PWM que controlan los MOSFET, etcétera. Además, con
MCWB podremos introducir la asignación de pines realizada en el apartado 2.1 y verificar que es
correcta y funcional.
El primer paso será crear un proyecto en MCWB. Esta operación generará un único fichero con
extensión “stmcx” que puede abrirse y editarse en cualquier momento. Para ello, iniciamos el
programa y pulsamos sobre la casilla New Project. Emergerá una ventana en la que introduciremos
el hardware que estamos utilizando: la tarjeta de control (NUCLEO-L476RG), la tarjeta de potencia
(X-NUCLEO-IHM07M1 3Sh) y el perfil del motor generado con ST Motor Profiler:
26
Ilustración 30: Ventana de configuración del hardware en MCWB.
Tras confirmar, se abrirá la ventana principal de MCWB, desde la que editaremos todas las
características de nuestro hardware. Se trata de una interfaz gráfica, formada por distintos bloques
que representan esquemáticamente el hardware de las tarjetas de control y de potencia. Además,
encontramos una pequeña ventana (en la esquina inferior izquierda) en la que podemos ver el valor
de las principales constantes de la librería PMSM FOC del firmware que podemos editar. Al lado,
encontramos una ventana de información sobre los distintos comandos ejecutados y los posibles
errores que pueden darse:
Ilustración 31: Ventana principal de MotorControl Workbench.
27
Al pulsar sobre cada bloque, aparecerá una ventana desde la que podremos configurar los principales
parámetros de esa parte del hardware. Con respecto a la configuración generada por defecto al crear
el proyecto, los parámetros que debemos modificar para esta primera versión del firmware son:
 Habilitaremos tanto los sensores Hall como el encóder del motor. En cuanto al encóder,
debemos modificar su número de pulsos por revolución a 1024 (tal y como se indica en la
hoja de datos del encóder).
 En el bloque de medida de velocidad (Speed Sensing) debemos definir como sensor principal
el encóder. El sensor secundario lo mantendremos deshabilitado.
 Debemos configurar la asignación de pines definida en el apartado 2.1. Esto lo haremos dentro
de los bloques Digital I/O y Analog Input and Protection, en función de si las señales a las
que se le va a asignar un determinado pin son analógicas (como la medida de las corrientes de
cada fase) o digitales (como los PWM que gobiernan las puertas de los MOSFET). Para la
asignación de los pines, nos fijaremos en la Ilustración 23 y, para cada señal, aparecerá un
desplegable en el que seleccionaremos el pin del microcontrolador correspondiente.
 Tras asignar los pines, debemos revisar que la asignación realizada es válida. Para ello,
abrimos la ventana de Pin Assigment y pulsamos en check:
Ilustración 32: Ventana de asignación de pines de MotorControl Workbench.
Tras estas modificaciones, podemos guardar el proyecto y pasar a generar el código. Para ello,
abrimos la herramienta Project Generation y configuramos el IDE de programación y la versión del
paquete firmware de STM32 MCSDK que queremos obtener. En nuestro caso, utilizaremos el IDE ST
STM32CubeIDE y utilizaremos la versión de firmware recomendada (V1.14.0). También incluiremos
la capa de abstracción hardware (HAL) que se ofrece.
Al pulsar sobre Generate, obtendremos un proyecto para STM32CubeIDE que se guarda en el mismo
directorio en el que se encuentra el proyecto de MCWB.
28
Ilustración 33: Herramienta de generación del código de MotorControl Workbench.
2.3.3. Programación de las tarjetas y pruebas.
Para compilar el proyecto y programar las tarjetas utilizaremos el IDE de programación de

STM32CubeIDE. Tras iniciar el programa, importaremos nuestro proyecto al espacio de trabajo y
compilaremos el código. Entraremos en el modo depuración para programar la tarjeta y lanzaremos
la ejecución del firmware. Si no se han producido errores, la tarjeta NUCLEO-L476RG habrá quedado
programada.
Tras este proceso, volveremos a MCWB para realizar unas simples pruebas que ayuden a verificar
tanto que el proceso de generación del firmware ha sido el correcto como que el hardware elegido es
válido para nuestra aplicación. Abriremos el fichero con extensión “stmcx” en MCWB y abriremos
la ventana de Monitor. Aparecerá una interfaz gráfica sencilla, en la que podremos iniciar y parar el
motor, establecer la velocidad de referencia, ver la potencia consumida por el sistema, la tensión real
de alimentación, la temperatura del sistema, la medida de velocidad del motor y algunos indicadores
de errores.
Ilustración 34: Monitor básico de MCWB.

29
Como podemos ver en la parte superior, existen formatos más completos de la interfaz gráfica para
monitorizar el comportamiento del motor. Se accede a ellos a través de las pestañas Advanced y
Registers. La primera de estas pestañas abre un monitor en el que podemos ver y modificar el valor
de los principales registros del microcontrolador. De esta forma, podemos variar las referencias de
torque y flujo magnético y las constantes de los distintos PIDs, algo que en la interfaz básica no se
podía hacer. La pestaña de Registers abre una interfaz en la que podemos ver y editar el valor de todos
los registros del microcontrolador.
Para probar esta primera versión del firmware utilizaremos la interfaz básica. Así, lo primero que
debemos hacer es conectar las tarjetas con el puerto serie del PC. Para ello, seleccionamos el puerto
del PC correspondiente y el régimen binario y pulsamos sobre el botón de conectar. Si todo ha
funcionado correctamente, deberá aparecer un mensaje en verde indicando que el dispositivo está
conectado:
Ilustración 35: Controles para la conexión de las tarjetas al PC.
Tras ello, podemos establecer una velocidad de referencia y comenzar a mover el motor pulsando
sobre Start Motor. Se puede observar que el motor comienza a moverse y que la medida de velocidad
coincide con la velocidad de referencia indicada. Además, la tensión de alimentación medida por
MCWB se corresponde con la indicada en la fuente de alimentación. Ni el consumo de potencia ni la
temperatura del sistema son excesivas. También probamos a cambiar la velocidad de referencia sin
parar el motor y la respuesta es correcta. Tras ello, pulsamos sobre Stop Motor y el motor deja de
moverse.
Como conclusión, podemos decir que esta primera versión del firmware es funcional y permite
verificar el correcto funcionamiento del hardware, pero no es válida para la versión final del producto.
Esto se debe a que el firmware se encarga de realizar un control de velocidad, por lo que la consigna
introducida en el sistema será una determinada velocidad. Para la función que deben cubrir nuestros
controladores, sería deseable que la consigna fuese un determinado desplazamiento, por lo que el
firmware debería ejecutar un control de posición.
Por otra parte, la respuesta de la velocidad presenta ligeros sobreimpulsos y no se alcanza la
aceleración máxima del motor. Esto se debe a que los valores de las constantes Kp, Ki y Kd de los
reguladores PID implementados en el firmware no son los correctos. Por ello, en el apartado 4.2
calibraremos correctamente estos PIDs.
La conclusión más importante que podemos extraer de estas pruebas es que tanto el hardware
seleccionado como las herramientas software para la generación del firmware del controlador son
válidas para diseñar nuestro propio controlador de motores BLDC. Por ello, ya podemos confirmar
que nuestro controlador estará basado en el circuito integrado L6230 que implementa la tarjeta X-
NUCLEO-IHM07M1 y que el proceso de generación del firmware para nuestro controlador será muy
similar al descrito en este apartado y se realizará con las mismas herramientas software.
30
2.4. Comunicación por puerto serie con las tarjetas de desarrollo.

El envío de comandos hacia las tarjetas de desarrollo y la lectura de datos se realiza a través de una
interfaz UART (Universal Asynchronous Reciever-Trasnmiter). Para conocer en profundidad cómo
es la comunicación entre el software MotorControl Workbench y las tarjetas, haremos un sniffer en
el puerto serie y analizaremos el formato de las tramas enviadas.
Para realizar este sniffer, utilizaremos el programa Device Monitoring Studio. Se trata de un software
destinado a la monitorización y análisis de los datos transferidos por los diferentes puertos y
conexiones del PC. La gran ventaja de este software frente a otros del mismo tipo es la capacidad de
detectar ciertas tramas en la comunicación y generar un mensaje informando de ello. Este mensaje
puede ser editado por el usuario, tanto el texto mostrado como su color.
Así, lo primero que haremos será analizar el código del firmware STM32 MC SDK para ver qué tipo
de tramas podemos esperar. Simultáneamente, realizaremos pruebas con Device Monitoring Studio y
pondremos el motor en marcha mediante MotorControl Workbench. De esta forma, deduciremos el
formato de las tramas que se envían para en una futura fase del proyecto, poder comunicarnos con el
controlador sin utilizar MCWB.
El fichero que gestiona el protocolo de comunicación por puerto serie de las tarjetas de desarrollo es
motor_control_protocol.c, y su fichero de cabecera, motor_control_protocol.h. En él, se definen las
funciones que permiten manejar la recepción y transmisión de las tramas: esperar a la siguiente trama,
establecer o reportar un timeout, enviar una trama, decodificar una trama recibida, reportar errores de
desbordamiento de los buffers de transmisión o recepción, etcétera.
En este fichero también encontraremos la definición del formato de las tramas, las cuales son de
longitud variable y pueden contener tanto el valor de una variable como el código de un comando.
Este protocolo de comunicación depende de un protocolo de transporte de nivel inferior, que es el
protocolo de transporte por puerto serie.
2.4.1. Mensajes de escritura.

Nos referimos con mensajes de escritura a las tramas enviadas desde la aplicación de control (en
nuestro caso, MCWB) hacia el controlador. Tras analizar varias sesiones de Device Monitoring
Studio, observamos que el primer byte de los mensajes de escritura alberga el identificador del motor
al que va dirigido el comando4 (en los tres bits de mayor peso) y el código del comando a ejecutar
(en los 5 bits de menor peso). Los códigos de todos los posibles comandos que pueden ser ejecutados
por el controlador se definen en el fichero de cabecera user_interface.h:
#define MC_PROTOCOL_CODE_SET_REG 0x01
#define MC_PROTOCOL_CODE_GET_REG 0x02
#define MC_PROTOCOL_CODE_EXECUTE_CMD 0x03
#define MC_PROTOCOL_CODE_STORE_TOADDR 0x04
#define MC_PROTOCOL_CODE_LOAD_FROMADDR 0x05
#define MC_PROTOCOL_CODE_GET_BOARD_INFO 0x06
#define MC_PROTOCOL_CODE_SET_SPEED_RAMP 0x07
#define MC_PROTOCOL_CODE_GET_REVUP_DATA 0x08
#define MC_PROTOCOL_CODE_SET_REVUP_DATA 0x09
#define MC_PROTOCOL_CODE_SET_CURRENT_REF 0x0A
#define MC_PROTOCOL_CODE_GET_MP_INFO 0x0B
#define MC_PROTOCOL_CODE_GET_FW_VERSION 0x0C
#define MC_PROTOCOL_CODE_SET_TORQUE_RAMP 0x0D
#define MC_PROTOCOL_CODE_SET_POSITION_CMD 0x12
4
Recordemos que el firmware STM32 MC SDK está preparado para aplicar un método de control FOC sobre dos motores
PMSM simultáneamente,
31
Como segundo byte, encontramos el número de bytes que componen el resto de la trama. Esta
longitud dependerá del tipo de comando que hayamos ordenado en el byte anterior (por ejemplo, para
un comando GET_REG, bastará con enviar un byte, el que indica el registro que queremos obtener.
Pero si el comando enviado es SET_REG, necesitaremos enviar un byte con el registro a modificar y
otros con el dato que queremos almacenar en dicho registro).
Como tercer byte, encontramos la información del mensaje (payload). Los diferentes tamaños de
mensaje, en función de comando recibido, que se han observado a lo largo de las pruebas han sido:
 MC_PROTOCOL_CODE_GET_REG: este comando será enviado cuando se desee conocer
el valor de una variable o registro. En este caso, el payload se compondrá de un solo byte, en
el que se indicará el registro que queremos leer. Por tanto, este mensaje de escritura tendrá la
forma:
0x22 0x01 ID_REG CRC
 MC_PROTOCOL_CODE_EXECUTE_CMD: este comando se enviará cuando queramos

ejecutar una operación con el motor o el controlador (por ejemplo, arrancar o parar el motor).
La lista y códigos de las operaciones que se pueden ejecutar se encuentran en el fichero
user_interface.h:
#define MC_PROTOCOL_CMD_START_MOTOR 0x01
#define MC_PROTOCOL_CMD_STOP_MOTOR 0x02
#define MC_PROTOCOL_CMD_STOP_RAMP 0x03
#define MC_PROTOCOL_CMD_RESET 0x04
#define MC_PROTOCOL_CMD_PING 0x05
#define MC_PROTOCOL_CMD_START_STOP 0x06
#define MC_PROTOCOL_CMD_FAULT_ACK 0x07
#define MC_PROTOCOL_CMD_ENCÓDER_ALIGN 0x08
#define MC_PROTOCOL_CMD_IQDREF_CLEAR 0x09
#define MC_PROTOCOL_CMD_PFC_ENABLE 0x0A
#define MC_PROTOCOL_CMD_PFC_DISABLE 0x0B
#define MC_PROTOCOL_CMD_PFC_FAULT_ACK 0x0C
#define MC_PROTOCOL_CMD_SC_START 0x0D
#define MC_PROTOCOL_CMD_SC_STOP 0x0E
Debemos mencionar que las operaciones de PING y RESET no pueden ser ejecutadas por el
momento, ya que no están codificadas (en el firmware generado, aparece un comentario en el
cuerpo de las funciones que dice “Do nothing at the moment”). El formato de este mensaje
de escritura será:
0x23 0x01 ID_CMD CRC
 MC_PROTOCOL_CODE_SET_REG: con este comando podremos editar el valor de

cualquier registro de escritura de la aplicación. Por ejemplo, podremos modificar la referencia
de torque. El payload tendrá una longitud que se corresponderá con el tamaño del registro que
se pretende editar. El dato que queremos enviar al registro se debe hacer en formato Little
Endian (debemos enviar el dato desde su byte menos significativo hasta su byte más
significativo). Así, el formato de este mensaje será:
Nº bytes ID Datos Datos CRC

0x21 Datos Datos
de datos registro (LSB) (MSB)
32
Ilustración 36: Captura de una sesión de Device Monitoring Studio.
 MC_PROTOCOL_GET_BOARD_INFO: este comando nos devuelve un código que

identifica a nuestra placa. No requiere el envío de ningún byte de datos. Por tanto, el
formato de este mensaje de escritura será:
0x26 0x00 CRC
 MC_PROTOCOL_SET_SPEED_RAMP: con este comando el motor ejecutará una rampa

de velocidad. Esto quiere decir que alcanzará una velocidad de consigna en el tiempo que
le indiquemos. Por ello, en el mensaje de escritura debemos indicar las revoluciones que
queremos alcanzar y el tiempo en el que queremos conseguirlas. El formato del mensaje
será:
Vel_Final Vel_Final CRC

0x27 0x06 Vel_F Vel_F Tiempo_ms(LSB) Tiempo_ms(MSB)
(LSB) (MSB)
 MC_PROTOCOL_GET_REVUP_DATA: con este comando podemos obtener los datos de

una aceleración: rpm finales, tiempo y torque. Este mensaje tiene el formato:
0x28 0x01 Etapa5 CRC
 MC_PROTOCOL_SET_REVUP_DATA: establecemos una aceleración indicando las

revoluciones por minuto (rpm) que queremos alcanzar, el tiempo en hacerlo y el torque:
RPM_F RPM_F Torque Torque Tiempo_ms Tiempo_ms CRC

0x29 0x09 Etapa RPM_F RPM_F
(LSB) (MSB) (LSB) (MSB) (LSB) (MSB)
 MC_PROTOCOL_SET_CURRENT_REF: este comando permite establecer un valor de

referencia para las corrientes Id e Iq:
0x2A 0x04 Iq(LSB) Iq(MSB) Id(LSB) Id(MSB) CRC
 MC_PROTOCOL_GET_FW_VERSION: obtenemos un código que representa la versión de

firmware instalado en el driver:
0x2C 0x00 CRC
 MC_PROTOCOL_SET_TORQUE_RAMP: podemos definir una variación del par en un

tiempo especificado. El formato del mensaje será:
0x2D 0x06 Torque_F Torque_F Torque_F Torque_F Tiempo_ms Tiempo_ms CRC

(LSB) (MSB) (LSB) (MSB)
5
El dato Etapa se refiere a la fase de la curva de aceleración en la que se encuentra el motor. Van numeradas del 1 al 6.
En el apartado 4.4 de esta memoria explicaremos con mayor detalle las diferentes fases en las que se divide la aceleración
y deceleración del motor.
33
 MC_PROTOCOL_SET_POSITION_CMD: podemos definir una posición final para el

motor y que se alcance en un tiempo determinado. Para ello, enviamos 4 bytes con el dato
de posición y 4 byte con el dato de tiempo:
Posc_F Posc_F Tiempo_s Tiempo_s CRC

0x32 0x08 Posc_F Posc_F Tiempo_s Tiempo_s
(LSB) (MSB) (LSB) (MSB)
Por último, debemos mencionar que existen tres comandos que, pese a estar definidos en el fichero
user_interface.h, no ejecutan ninguna operación. Estos son:
 STORE_TOADDR y LOAD_FROMADDR: las funciones a las que se llaman cuando se
reciben no están codificadas.
 GET_MP_INFO: la función a la que se llama siempre devuelve un valor de error.

2.4.2. Mensajes de respuesta.

Denominamos mensajes de respuesta a las tramas enviadas desde el controlador al programa de
control (en nuestro caso, MCWB). Estos mensajes serán enviados después de que el controlador
reciba uno de los mensajes de escritura analizados anteriormente.
En función del mensaje de escritura que reciba el controlador, éste enviará un determinado tipo de
mensaje de respuesta. Tras varias pruebas y enviar todos los mensajes de escritura posibles, se han
detectado tres tipos de mensajes de respuesta:
 Mensaje de datos: este tipo de mensajes serán enviados cuando el controlador deba enviar
algún dato hacia el programa de control. Esto ocurre por ejemplo cuando el controlador
recibe el comando GET_REG, ya que deberá devolver el valor del registro que se indica en
el mensaje de escritura. La estructura de este mensaje será:
0xF0 ó 0xFF Nº bytes Datos CRC
o El primer byte contendrá un código que indica si el comando ha sido ejecutado con éxito
(0xF0) o no (0xFF).
o El segundo byte contendrá el número de bytes que componen el payload del mensaje.
Este tamaño dependerá del tipo de dato que queramos leer (por ejemplo, del tamaño del
registro que hayamos solicitado leer).
o En el payload se almacenarán los datos que debemos enviar al programa de control. Estos
datos se envían en formato little endian.
o El último byte será el CRC del mensaje.
 Mensaje de ACK: Este mensaje será enviado por el controlador para confirmar la correcta
ejecución de un comando y no se requiera enviar ningún dato al programa de control.
o El mensaje de ACK tendrá la forma:

0xF0 0x00 0xF0
34
o El mensaje de no ACK (NACK) tendrá la forma:
0xFF 0x01 Código de Error CRC
Los códigos de error están definidos al inicio del fichero motor_control_protocol.c y se actualizan
tras la ejecución de cada comando:
/* List of error codes */
typedef enum ERROR_CODE_e
{
ERROR_NONE = 0x00, /**< No error */
ERROR_BAD_FRAME_ID = 0x01, /**< BAD Frame ID. The Frame ID has not been
recognized by the firmware. */
ERROR_CODE_SET_READ_ONLY = 0x02, /**< Write on read-only. The master wants to
write on a read-only register. */
ERROR_CODE_GET_WRITE_ONLY = 0x03, /**< Read not allowed. The value cannot be
read. */
ERROR_CODE_NO_TARGET_DRIVE = 0x04, /**< Bad target drive. The target motor is
not supported by the firmware. */
ERROR_CODE_WRONG_SET = 0x05, /**< Value used in the frame is out of range
expected by the FW. */
ERROR_CODE_CMD_ID = 0x06, /**< NOT USED */
ERROR_CODE_WRONG_CMD = 0x07, /**< Bad command ID. The command ID has not
been recognized. */
ERROR_CODE_OVERRUN = 0x08, /**< Overrun error. Transmission speed too
fast, frame not received correctly */
ERROR_CODE_TIMEOUT = 0x09, /**< Timeout error. Received frame corrupted
or unrecognized by the FW. */
ERROR_CODE_BAD_CRC = 0x0A, /**< The computed CRC is not equal to the
received CRC byte. */
ERROR_BAD_MOTOR_SELECTED = 0x0B, /**< Bad target drive. The target motor is
not supported by the firmware. */
ERROR_MP_NOT_ENABLED = 0x0C /**< Motor Profiler not enabled. */
} ERROR_CODE;
Ahora, analizaremos el mensaje de respuesta que obtenemos en función del tipo de mensaje de
escritura que se haya realizado:
 MC_PROTOCOL_SET_REG: se enviará un mensaje de ACK que confirma o no al programa
de control que el valor de un determinado registro ha sido modificado correctamente. Por
defecto, si ha ocurrido algún error se enviará el código WRONG_SET (0x05). Pero si en
concreto, no se encuentra el identificador del registro que se quiere modificar o es un registro
de solo lectura, se enviará el código de error SET_READ_ONLY (0X02).
 MC_PROTOCOL_GET_REG: Se enviará un mensaje de datos que contendrá el valor

almacenado por el registro que se ha indicado en el mensaje de escritura. El tamaño del
payload de este mensaje puede variar de 1 a 4 bytes, en función del tamaño del registro que
se quiere leer. Por el contrario, si se produce algún error, se enviará un mensaje de NACK.
El código de error que se enviará será GET_WRITE_ONLY (0x03).
 MC_PROTOCOL_CODE_EXECUTE_CMD: si la ejecución ha sido correcta, se enviará un

mensaje de ACK. Si se produce un error, se devolverá un mensaje de NACK con el código
WRONG_CMD (0X07).
35
 MC_PROTOCOL_GET_BOARD_INFO: en este caso se enviará un mensaje de respuesta

especial, el cual no se ha definido anteriormente debido a que se utiliza exclusivamente
cuando se recibe este comando. Este mensaje se compondrá de 35 bytes, 32 de los cuales
formarán el payload. El payload almacenará un código con la versión del firmware que
ejecutan las tarjetas de desarrollo. También se enviará un mensaje de ACK y no existe un
código que gestione un posible error, por lo que nunca obtendremos un mensaje de NACK.
 MC_PROTOCOL_CODE_SET_SPEED_RAMP: siempre obtendremos un mensaje de
ACK, ya que la función a la que se llama tras recibir este comando (UI_ExecSpeedRamp)
nunca devuelve un código de error.
 MC_PROTOCOL_SET_POSITION_CMD: en este caso también obtendremos siempre un

mensaje de ACK, ya que la función a la que se llama al recibir este (UI_ExecPositionCmd)
nunca retorna un código de error.
 MC_PROTOCOL_CODE_GET_REVUP_DATA: En este caso, tendremos un mensaje de

respuesta de 11 bytes, 8 de los cuales corresponden al payload. Este mensaje contiene
información sobre las revoluciones por minuto alcanzadas, el par final y el tiempo
transcurrido en tras ejecutar una rampa de velocidad.
 MC_PROTOCOL_CODE_SET_REVUP_DATA: tras recibirse este comando, siempre se

enviará un mensaje de ACK, ya que no está codificada ninguna gestión de errores.
 MC_PROTOCOL_CODE_SET_CURRENT_REF: al igual que en el caso anterior, este

comando siempre devolverá un mensaje de ACK.
 MC_PROTOCOL_CODE_GET_MP_INFO: este comando siempre devolverá un mensaje

de NACK con el código de error MP_NOT_ENABLED (0X0C). Esto se debe a que, tal y
como explicamos en el análisis de los mensajes de escritura, la función a la que se llama tras
recibir el comando GET_MP_INFO (UI-GetMPInfo) siempre devuelve un valor de error.
 MC_PROTOCOL_CODE_GET_FW_VERSION: obtenemos un mensaje de 35 bytes, 32 de

ellos correspondientes al payload, seguido de un mensaje de ACK. El payload contiene un
código con la versión del firmware ejecutado por el controlador.
 MC_PROTOCOL_CODE_SET_TORQUE_RAMP: este comando devuelve un mensaje de

ACK, ya que la función a la que se llama tras recibir el comando (UI_ExecTorqueRamp)
siempre devuelve un código de ejecución exitosa.
 MC_PROTOCOL_CODE_SET_POSITION_CMD: obtendremos como mensaje de

respuesta un ACK.
En conclusión, tras haber utilizado la técnica sniffer en el puerto serie que comunica el PC y las
tarjetas de desarrollo y haber analizado la parte del firmware que gobierna esta comunicación,
conocemos al detalle las funciones a utilizar y los protocolos a seguir para poder enviar comandos a
los controladores y poder recibir información de los mismos a través de una aplicación de control.
En el desarrollo de estas pruebas, la aplicación de control utilizada ha sido MCWB, la cual, como ya
vimos en el apartado 1.4, no está completamente desarrollada y no ofrece una interfaz para gobernar
el controlador cuando éste ejecuta un control de posición. Gracias al análisis realizado, podremos
desarrollar nuestra propia aplicación de control que solvente esta carencia.
36
Capítulo 3
Diseño del controlador.
El hardware requerido para implementar nuestro controlador FOC para motores BLDC será montado
sobre una PCB (Printed Circuit Board). Para ello, previamente debemos diseñar el circuito
electrónico del controlador y buscaremos componentes comerciales que se adapten al diseño
realizado.
Para diseñar el circuito electrónico de nuestro controlador, tomaremos como referencia los
esquemáticos de la tarjeta X-NUCLEO-IHM07M1 [6]. Sobre estos esquemáticos realizaremos
numerosas modificaciones para cumplir las especificaciones del proyecto. Por ejemplo, eliminaremos
el hardware para la detección del BEMF, así como todas las conexiones a los conectores ST Morpho
y añadiremos el hardware necesario para implementar una interfaz CAN.
3.1. Estructura del controlador.

Mediante un diagrama de bloques, podremos ver de forma sencilla y de un vistazo la estructura
hardware del controlador para motores BLDC que queremos diseñar. Dicho diagrama representará el
modo de funcionamiento y las distintas tareas que deben quedar cubiertas en un controlador para
motores BLDC que ejecute un algoritmo de control FOC, haciendo uso de los sensores Hall y el
encóder y midiendo las corrientes que atraviesan cada una de las tres fases del motor:
Ilustración 37: Diagrama de bloques de un controlador que ejecuta un algoritmo de control FOC.
37
Diseño del controlador
Como primera aproximación al diagrama de bloques del controlador que queremos diseñar, podemos
utilizar el diseño que propone ST Microelectronics, en su documento UM2392 y que se muestra en la
Ilustración 37. Los principales bloques que podemos distinguir son:
 Bloque de alimentación.
 Inversor trifásico.
 Algoritmo de control FOC.
En la parte superior del esquema encontramos el bloque de alimentación. Nuestro controlador de
motores BLDC trabajará con corriente continua. En nuestro caso, el controlador se alimentará a partir
de la corriente continua que proporciona la batería del robot, por lo que no necesitaremos implementar
el rectificador de onda completa que propone ST Microelectronics.
En su lugar, necesitaremos integrar una serie de convertidores DC/DC que adapten la tensión continua
de la batería (la cual oscilará entre los 25 y los 32 V, en función de la carga) al valor de tensión que
requieren los distintos circuitos integrados que utilicemos. Por ejemplo, el microcontrolador
necesitará una tensión de alimentación de 3,3 V.
Después, alimentado por la tensión de la batería, encontraríamos los tres semipuentes en H que
controlan las fases del motor (a este conjunto se le conoce como inversor trifásico):
Ilustración 38: Conexión entre los tres semipuentes en H y las fases del motor.
En el circuito superior, L representa la inductancia de cada fase del motor, R su resistencia y el

generador de tensión alterna el BEMF generado en cada fase. Si queremos hacer circular corriente
por la fase A, deberemos polarizar Q1 y Q4 o Q66 en su zona de saturación. De esta forma, la corriente
siempre circulará por al menos dos fases del motor: por una de ellas en sentido entrante (desde la
fuente de alimentación) y por la otra en sentido saliente (retornando a la masa del circuito).
La tarea del microcontrolador será generar las señales que gestionen la polarización de los
transistores. Éstas serán las señales PWM generadas mediante la modulación del vector de espacio
(SVPWM), las cuales serán aplicadas en las puertas de cada MOSFET. En cada vuelta que dé el rotor,
cada MOSFET deberá seguir el siguiente esquema de conmutación:
6
No es indiferente cuál de los dos MOSFET activar. Sólo se activará uno de ellos, el cual está determinado por el
algoritmo de control FOC. En la Ilustración 39 podemos la secuencia de conmutación exacta de cada transistor.
38
Ilustración 39: Patrón de conmutación de los MOSFET que forman el inversor trifásico.
Como vemos, la tensión aplicada en las puertas de los transistores superiores es una señal PWM. Así,
el valor medio de la tensión aplicada en las puertas de los transistores vendrá determinado por el ciclo
de trabajo de las señales PWM, determinando la intensidad de la corriente que debe circular por una
determinada fase.
Por otra parte, vemos que las tensiones aplicadas en las puertas de los transistores inferiores son
señales cuadras. De esta forma habilitamos el retorno de la corriente desde el motor por una
determinada fase.
El momento en el que se debe producir la conmutación de los transistores y el ciclo de trabajo de las
señales PWM es determinado por el microcontrolador en función de la posición del rotor, obtenida
mediante las señales devueltas por los tres sensores Hall del motor.
Por último, encontramos el bloque de color amarillo de la Ilustración 37, el cual representa todas las
tareas que deben ejecutarse para implementar el algoritmo de control FOC. Todas estas tareas son
llevadas a cabo por el microcontrolador de la tarjeta, pero las relacionadas con el tratamiento de las
señales de los sensores requieren de bloques adicionales hardware que acondicionen estas señales
para hacerlas aptas para el microcontrolador.
Además de no representar los circuitos que acondicionan las señales de los sensores, el diagrama de
la Ilustración 37 tampoco muestra el hardware necesario para implementar la comunicación por CAN
Bus de la que debe disponer nuestro controlador. Por ello, a partir del esquema de la Ilustración 37
definiremos nuestro propio diagrama de bloques que represente la totalidad del hardware que debe
incorporar nuestro controlador:
39
Ilustración 40: Diagrama de bloques del controlador a diseñar.
Como vemos, el hardware del controlador se dividirá en ocho bloques funcionales. La mayor parte
de estos bloques (cuatro de ellos), están destinados a la medida de diferentes parámetros del
controlador, tales como la temperatura del inversor trifásico, la tensión existente en el bus de
alimentación, las corrientes de cada una de las fases del motor y la posición y velocidad del rotor
mediante los sensores Hall y el encóder que incorpora el motor. Así, mientras que la medida de la
tensión de alimentación y la temperatura sirven para implementar una protección frente a
sobrecalentamientos y tensiones de alimentación inadecuadas, el resto de medidas son utilizadas y
requeridas por el algoritmo de control FOC.
También podemos ver un bloque de comunicaciones, el cual estará formado por el bus CAN y la
interfaz UART del microcontrolador. Este bloque servirá para poder enviar comandos al
microcontrolador. Tal y como ocurría en el diagrama de la Ilustración 37, el microcontrolador se
encargará de ejecutar el algoritmo de control FOC y generar las señales de conmutación correctas
para las puertas de los MOSFET que forman el inversor trifásico.
Finalmente, el bloque de alimentación se encargará de adaptar la tensión entregada por la batería del
robot a la tensión de alimentación requerida por cada uno de los bloques funcionales y circuitos
integrados que implemente nuestro controlador.
40
3.2. Diseño del circuito electrónico.

A partir del diagrama de bloques definido en la Ilustración 40, podemos diseñar el circuito electrónico
que implementará nuestro controlador FOC para motores BLDC. Dicho diseño lo realizaremos
utilizando el software Altium Designer, herramienta de diseño CAD (Computer-Aided Design) de
tarjetas de circuito impreso.
En un proyecto de Altium Designer, el diseño del circuito electrónico se realiza sobre un fichero con
extensión “SchDoc”. Estos ficheros albergarán toda la información sobre los componentes que
forman nuestro circuito y las conexiones a realizar entre ellos. Así, para hacer más inteligible nuestro
diseño, dividiremos el diseño del circuito electrónico en 7 ficheros “SchDoc”, en los cuales
agruparemos todo el hardware que esté destinado a cumplir una misma tarea:
Ilustración 41: Árbol de ficheros del proyecto en Altium Designer
 En el fichero Index.SchDoc se establecen las conexiones entre el resto de ficheros. Este fichero
no define un determinado circuito electrónico, si no que establece las conexiones que deben
realizarse entre el hardware diseñado en distintos ficheros. Por ejemplo, en este fichero se
establecería la conexión entre los pines de la interfaz UART del microcontrolador (el cual se
encuentra en el fichero MCU) y el conector de la tarjeta para acceder a esos pines (el cual se
encuentra en el fichero Connectors).
 En el fichero MCU.SchDoc se diseña toda la circuitería y el hardware del bloque de control.
Este incluye el microcontrolador, el oscilador y los componentes pasivos adyacentes.
 En el fichero Power.SchDoc encontraremos el diseño del circuito electrónico que adapta la
tensión de la batería del robot a las distintas tensiones de alimentación que requiere el
hardware del controlador.
 En el fichero Drivers.SchDoc encontraremos la implementación del circuito integrado que
controla las fases del motor, así como sus componentes adyacentes y las tres resistencias de
medida de corriente.
 En el fichero Connectors.SchDoc están implementados todos los conectores con los que
contará la PCB, así como 8 interruptores que permitirán establecer el ID CAN de nuestra
tarjeta y habilitar o deshabilitar la resistencia de terminación para el bus CAN.
 En el fichero SENS.SchDoc encontramos los tres amplificadores operacionales que adaptan
las tensiones caídas en las tres resistencias de medida de corriente a los pines del ADC que
incorpora el microcontrolador.
 En el fichero SENS2.SchDoc tenemos el diseño del hardware que acondiciona las señales de
los sensores Hall y del encóder del motor para que puedan ser procesadas por el
microcontrolador.
En estos 6 ficheros queda definida la totalidad del circuito electrónico que forma nuestro controlador
de motores BLDC. A continuación, estudiaremos el diseño concreto de cada uno de los bloques
funcionales del circuito y elegiremos el modelo comercial de los principales componentes que
materializarán este diseño.
41
3.2.1. Alimentación de la tarjeta.

Es el bloque encargado de adaptar la tensión de entrada al controlador a las tensiones de alimentación
requeridas por el resto de componentes de la tarjeta. La tensión de alimentación del controlador
variará desde 32V a 25V, en función del grado de descarga de la batería del robot. A partir de esta
tensión, necesitamos obtener los siguientes valores:
 5V para el encóder y los circuitos integrados acondicionadores de sus señales.
 3,3V para el microcontrolador.
 3,3 V para los amplificadores operacionales (alimentación analógica).
En primer lugar, circuito integrado que L6230 soporta entre 8 y 52 V y debe estar alimentado con la
tensión nominal del motor. Esta tensión será directamente proporcionada por la batería del robot.
La tensión continua de 5V se obtendrá mediante un convertidor DC/DC reductor cuya entrada sea la
tensión de la batería el robot. El hecho de colocar un convertidor DC/DC reductor en lugar de un
regulador lineal de tensión se debe a dos factores:
 En primer lugar, la caída de tensión es demasiado grande (como mínimo, de unos 20V), lo
que hace casi imposible encontrar un regulador lineal de estas características.
 Además, la eficiencia de los reguladores lineales es muy baja si la comparamos con la de los
convertidores DC/DC (la cual se sitúa habitualmente en torno al 90%). El usar un regulador
lineal aumentaría mucho el consumo del controlador, lo cual hace que su uso no sea
recomendable en un sistema alimentado por baterías como el robot.
Por tanto, el convertidor DC/DC que utilicemos deberá ser capaz de funcionar, al menos, con
tensiones de entrada comprendidas entre los 32 V y los 25 V. En un principio, se pensó en utilizar el
convertidor LT3907-5, del fabricante Analog Devices. Se trata de un convertidor que admite en su
entrada tensiones de entre 4 y 40 V y entrega a su salida una tensión continua de 5V y que requiere
incorporar una serie de componentes adyacentes, tales como condensadores de entrada y de salida y
una bobina.
Tras comprobar la implementación de este convertidor en la PCB, se observó que no había espacio
suficiente para colocar todos los componentes adyacentes que acompañan al convertidor, en especial
debido a que, pese a la extensa búsqueda realizada, el tamaño de la bobina requerida era demasiado
grande. Por ello, se optó por buscar otro convertidor que requiriese colocar menos componentes para
su funcionamiento, tal y como el modelo TPSM53602RDAR, de Texas Instruments.
A este convertidor solo se le deben conectar dos resistencias para programar la tensión de salida, dos
condensadores en paralelo a su entrada y otros dos condensadores en paralelo a la salida. Además, es
capaz de funcionar con tensiones de entrada comprendidas entre 3,8 V y 36 V, por lo que será apto
para nuestro diseño:
 Para programar la tensión de salida, el fabricante indica que se debe conectar un divisor
resistivo al pin FB del convertidor. Para calcular el valor de las resistencias del divisor, el
fabricante proporciona una ecuación y una tabla con los valores más comunes de tensión de
salida. En nuestro caso, al requerir de una tensión de 5 V, debemos colocar una resistencia de
10 kΩ (fijo para cualquier para todas las tensiones de salida mostradas en la tabla) y otra de
2,49 kΩ:
42
Ilustración 42: Divisor resistivo para programar la tensión de salida del convertidor TPSM53602RDAR.
Tabla 2: Valores de resistencia para programar la tensión de salida del convertidor TPSM53602RDAR.
 En cuanto a los condensadores de entrada, el fabricante recomienda colocar dos

condensadores cerámicos en paralelo, de dieléctrico X5R o X7R y 10 µF de capacidad. De
esta forma se consigue disminuir la ESR (Equivalent Series Resistance) a la entrada del
convertidor.
 De la lista de condensadores recomendados por Texas Instruments para colocar a la salida
del convertidor, el valor mínimo de capacitancia es 47 µF. Dado que en la tercera columna
de la Tabla 2 se recomienda una capacidad mínima de 27 µF, colocaremos dos
condensadores en paralelo de 47 µF a la salida del convertidor.
 Se añadirá un divisor de tensión a la entrada del convertidor, conectado al pin de Enable para
establecer una tensión mínima de funcionamiento superior a los 3,8 V anteriormente
mencionados. De esta forma, nos aseguraremos de que los controladores no sigan
consumiendo corriente cuando la batería esté demasiado descargada. A esta protección se le
conoce como Undervoltage Lockout (UVLO). En nuestro diseño, se aplicará un UVLO de
10 V para lo cual, según la información del fabricante, deberemos colocar una resistencia de
100 kΩ y otra de 14,3 kΩ:
Tabla 3: Valores para el divisor resistivo que determina el UVLO del convertidor TPSM53602RDAR.
La tensión de 3,3 V alimentará al microcontrolador y a los sensores Hall del motor y será utilizada
por los circuitos acondicionadores de las señales del encóder. Para ello, colocaremos un regulador
lineal LDO (Low Dropout) en serie con el TPSM53602RDAR para obtener una tensión continua de
3,3 V a partir de los 5V entregados con el convertidor DC/DC reductor.
43
El modelo escogido ha sido el LD39050PU33R, de ST Microelectronics, que soporta hasta 5,5 V. El

fabricante indica que debemos colocar dos condensadores, uno de entrada y otro de salida, ambos
1µF. También nos avisa de que si no se utiliza el pin de Enable del regulador (como es nuestro caso,
ya que se ha implementado un UVLO en el convertidor anterior), no puede dejarse flotante porque
este pin no cuenta con un pull-up interno. La solución indicada es colocar un condensador de 100 nF
entre este pin y masa.
A partir de esta tensión continua de 3,3 V obtendremos una alimentación de 3,3 V exclusiva para
alimentar a los amplificadores operacionales que adaptan la tensión caída en las resistencias de shunt.
Para ello, añadimos una ferrita (L1) conectada al pin VDDA del microcontrolador. Esta ferrita se
encarga de filtrar el posible ruido que pueda generarse en la alimentación de 3,3 V debido a las señales
digitales y obtener una señal de alimentación de 3,3 V que se utilice exclusivamente para alimentar a
la parte analógica de la tarjeta.
Por último, se va a añadir un LED alimentado con los 5V entregados por el convertidor DC/DC que
indique si el controlador está recibiendo alimentación.
3.2.2. Bloque de control.

El componente principal de este bloque es el microcontrolador, el cual ejecutará el firmware En
nuestro caso, utilizaremos el microcontrolador STM32L476RGT3, del fabricante ST
Microelectronics. La única diferencia entre este microcontrolador y el que incluye la tarjeta de
desarrollo NUCLEO-L476RG es el rango de temperatura que soportan. El STM32L476RGT3 es capaz
de operar entre -40ºC y 125ºC, frente a los 85ºC de temperatura máxima que soporta el
microcontrolador de la tarjeta de desarrollo.
Se trata de un microcontrolador de bajo consumo basado en una arquitectura de 32 bits ARM Cortex-
M4. Incluye 1 MB de memoria Flash y es capaz de funcionar con una fuente de reloj comprendida
entre los 4 y los 48 MHz [7]. En nuestro caso, siguiendo el diseño realizado por ST Microelectronics
en la tarjeta de desarrollo, incluiremos un oscilador de cuarzo de 8 MHz. En concreto, usaremos el
modelo LFXTAL029914, del fabricante IQD.
A los pines del microcontrolador conectaremos las diferentes señales siguiendo la asignación de pines
que se indica en la Ilustración 23. Además, añadiremos un LED que se encenderá nada más comenzar
la ejecución del firmware para indicar que la programación del controlador es correcta. Este LED se
conectará al pin PD2, el cual funcionará como un pin de propósito general de entrada/salida (GPIO).
No debemos olvidar realizar las conexiones entre la interfaz Serial Wire Debug (SWD) y el conector
de programación de la tarjeta. La señal de reloj debe ir al pin PA14, y la de datos al PA13.
Por último, debemos incluir condensadores de desacoplo de 100 nF en todas las entradas de
alimentación del microcontrolador y un solderbridge que permita resetear el microcontrolador en
caso de que sea necesario. Esta no será una operación habitual.
44
3.2.3. Medida de la corriente en las fases del motor.

Mediante tres resistencias de shunt y tres amplificadores operacionales, conseguiremos obtener una
tensión proporcional a la corriente que atraviesa cada fase del motor. Esta tensión obtenida debe ser
apta para ser convertida mediante uno de los ADC del microcontrolador.
Para diseñar este bloque funcional tomaremos como referencia el diseño realizado por ST
Microelectronics para la tarjeta X-NUCLEO-IHM07M1:
Ilustración 43: Hardware de la tarjeta X-NUCLEO-IHM7M1 para la medida de las corrientes en las fases
del motor.
La idea es hacer circular la corriente que atraviesa cada una de las fases del motor por una resistencia.
Así, la tensión caída en esa resistencia será directamente proporcional a la corriente que la atraviesa,
que se corresponde con la corriente de las fases del motor.
Estas resistencias deben tener un valor bajo para minimizar la disipación de potencia. Pero esto
provoca que la tensión que cae en ellas sea demasiado baja para ser introducida al ADC del
microcontrolador (no se aprovecharía todo el rango de entrada del convertidor). Para solventar este
problema, utilizamos tres amplificadores operacionales configurados como amplificador no inversor,
en cuya entrada conectaremos la tensión caída en las resistencias de shunt.
En la tarjeta X-NUCLEO-IHM07M1 se utilizan unas resistencias de 0,33 Ω. Pero en nuestro diseño
vamos a utilizar unas resistencias de shunt de menor valor para minimizar al máximo el consumo de
potencia. Nuestras resistencias de shunt tendrán un valor de 0,1 Ω.
El siguiente paso es calcular la ganancia que se debe ajustar en los amplificadores operacionales. Si
tenemos en cuenta que la corriente de pico que es capaz de entregar el circuito L6230 es de 2,8 A,
podemos afirmar que la tensión caída en las resistencias de shunt oscilará entre -280 y 280 mV, según
la ley de Ohm:
𝑉 = 𝑅 ∗ 𝐼 → 𝑉𝑚á𝑥 = 𝑅 ∗ 𝐼𝑚á𝑥 = 0,1 ∗ 2,8 = 280 𝑚𝑉
45
Tal y como se indica en la hoja de datos del microcontrolador, el rango de tensión de entrada está
entre 0 y 3,3 V. Por tanto, necesitamos añadir una tensión de offset de 280 mV a la entrada de los
amplificadores operacionales para que, cuando en la resistencia caigan -280 mV, a la salida del
amplificador obtengamos 0V. Esto lo conseguiremos añadiendo un divisor resistivo en el pin positivo
del amplificador operacional. Si utilizamos como alimentación del divisor la tensión de 3,3 V, la
relación entre las resistencias del divisor podría ser de un factor de 10. De esta forma obtendríamos
un offset de 0,33 V.
Dado que hemos cambiado el valor de las resistencias de shunt, debemos modificar la ganancia de
los amplificadores con respecto al diseño de la X-NUCLEO-IHM07M1. En nuestro diseño, la
ganancia de los amplificadores deberá ser:
𝑉𝑜𝑚á𝑥 − 𝑉𝑜_𝑚𝑖𝑛 3,3
𝐺(𝑉⁄𝑉 ) = =
𝑉𝑠ℎ𝑢𝑛𝑡 𝑚á𝑥 + 𝑉𝑜𝑓𝑓𝑠𝑒𝑡 − (𝑉𝑠ℎ𝑢𝑛𝑡 𝑚𝑖𝑛 + 𝑉𝑜𝑓𝑓𝑠𝑒𝑡 ) 0,28 + 0,33 − (−0,28 + 0,33)
3,3
𝐺 (𝑉⁄𝑉 ) = = 5,89 𝑉⁄𝑉
0,61 − 0,05
Al ser un amplificador no inversor, su ganancia queda definida por la siguiente ecuación:
𝑅2 𝑅2
𝐺 =1+ → = 𝐺 − 1 = 5,89 − 1 = 4,89 → 𝑅2 = 4,89 ∗ 𝑅1
𝑅1 𝑅1
Donde R2 es la resistencia de realimentación y R1 la resistencia conectada al pin negativo del
amplificador. Escogeremos un valor de R2 de 4,7 kΩ y un valor de R1 de 1kΩ. Finalmente, la
topología de los amplificadores no inversores sería:
Ilustración 44: Amplificador no inversor para acondicionar la tensión caída en las resistencias de shunt
El modelo comercial de los tres amplificadores operacionales será el TLV9061IDCKR, de Texas

Instruments. Una característica importante de dicho amplificador es que es Rail-to-Rail Input/Output
(RRIO), lo cual nos permite obtener tensiones de salida de 3,3 V conectando al amplificador la
alimentación analógica de 3,3 V, consiguiendo un menor ruido debido a las conmutaciones de la parte
digital de la tarjeta. Además, su offset de entrada es bastante bajo (± 0,3 mV).
Un factor importante a tener en cuenta a la hora de generar el firmware para nuestro controlador es
que debemos cambiar los valores que por defecto asigna MCWB a las resistencias de las redes de
amplificación y a las resistencias de shunt. Para ello, se abrirá una interfaz gráfica tras pulsar en el
bloque de Current Sensing.
46
3.2.4. Circuito integrado controlador para motores BLDC.

El circuito integrado L6230, de ST Microelectronics, agrupa los MOSFET que forman los tres
semipuentes en H, la lógica que activa las puertas de cada MOSFET y circuitos de protección frente
a consumos excesivos de corriente y sobrecalentamiento. Es el mismo circuito integrado sobre el que
se basa la tarjeta X-NUCLEO-IHM07M1 con la que se realizaron las primeras pruebas del firmware,
por lo que su funcionamiento está perfectamente validado.
Es un circuito pensado especialmente para ejecutar un algoritmo de control FOC, ya que ofrece tres
pines independientes para conectar la medida de las corrientes en las fases. Es capaz de entregar
hasta 2,8 A y su rango de tensión de entrada se sitúa entre los 8 y los 52 V.
En su hoja de datos, podemos encontrar el circuito típico de aplicación para implementar un algoritmo
de control FOC:
Ilustración 45: Circuito típico de aplicación del circuito integrado L6230Q [8]
Las claves del circuito implementado a partir de este circuito integrado son:
 VSA y VSB son los pines de alimentación para los semipuentes en H.
 Podemos ver como las tres resistencias de shunt se conectan a las 3 salidas SENSE1, SENSE2
y SENSE3, las cuales entregan la corriente consumida por cada fase del motor. Además, ST
Microelectronics muestra el bloque de acondicionamiento de estas tensiones que estudiamos
en el apartado anterior. En los pines SENSE1, SENSE2 y SENSE3 tendremos la tensión que
cae en las resistencias, no la tensión amplificada que se introduce al ADC.
 El circuito L6230Q entregará por sus salidas OUT1, OUT2 y OUT3 las tres corrientes que
deben aplicarse al motor.
 Los pines CP+ y CP- se corresponden con las entradas de un comparador interno que incluye
el circuito integrado. En CP- conectaremos una de las salidas del DAC que incorpora el
microcontrolador y que se corresponderá con un límite de corriente programado. En CP+
conectaremos la tensión de salida del amplificador de la fase 2 (o V) del motor. El pin CPOUT
se corresponde con la salida de este comparador. Así, cuando la tensión de salida entregada
por el amplificador supera a la entregada por el DAC, el pin CPOUT generará un nivel alto.
Es necesario conectar una resistencia de pull-up a dicho pin.
47
 El pin CPOUT se conectará a uno de los pines del microcontrolador. Este generará la señal
llamada BKIN, que se conecta a la entrada de habilitación del L6230 (DIAG-EN) y detendrá
su funcionamiento. El pin DIAG-EN también indica cuando se ha disparado la protección por
sobrecorriente integrada en el L6230.
 Las entradas lógicas (IN1, IN2 e IN3) y las entradas de habilitación (EN1, EN2 y EN3) son
generadas por el microcontrolador. Las entradas INx se conectarán a las señales PWM
(llamadas SPH.CH1, SPH.CH2 y SPH.CH3 en los esquemáticos) y controlarán las puertas de
los transistores superiores de cada semipuente. Tal y como explicamos en el aparatado 3.1, el
ciclo de trabajo de las señales PWM determinará la intensidad de la corriente que atraviesa
cada fase. Por otra parte, las entradas ENx (llamadas SPH.EN1, SPH.EN2 y SPH.EN3 en los
esquemáticos) se conectan a las puertas de los transistores inferiores de los semipuentes en H
y habilitan el retorno de la corriente desde el motor por una determinada fase.
Para completar la implementación de este circuito, utilizaremos los esquemáticos de ST
Microelectronics de la tarjeta X-NUCLEO-IHM07M1:
Ilustración 46: Esquema de la implementación del circuito L6230Q en la tarjeta X-NUCLEO-IHM07M1.
3.2.5. Acondicionamiento de las señales del encóder y de los sensores Hall.

Las señales recibidas desde el encóder llegan en formato diferencial, para protegerlas frente al ruido
que pueda generarse durante su recorrido. Pero el microcontrolador debe recibir estas señales en
formato single-ended. Esta conversión puede ser realizada por un receptor RS-485.
El encóder acoplado al motor Vishan EC2240 es un encóder incremental. Este tipo de encóders
indican la posición en la que se encuentra el rotor del motor con respecto a un punto de referencia.
Este encóder entregará dos señales cuadradas, llamadas A y B, que son iguales, pero están desfasadas
90 º entre sí. Estás señales incluirán 1024 pulsos por cada vuelta que dé el eje del motor. Este número
de pulsos por vuelta (PPR- Pulses per revolution) determina la resolución de un encóder incremental.
El hecho de disponer de dos señales iguales desfasadas 90º permite conocer el sentido de giro del
rotor. Si la señal A está adelantada respecto a la señal B, sabremos que el rotor está girando en sentido
horario mientras que, si la señal B está adelantada respecto a la señal A, el rotor estará girando en
sentido antihorario.
48
Además, el encóder que utilizaremos entrega una tercera señal, llamada Z. En esta señal se generará
un pulso por cada vuelta completa que dé el rotor del motor. Con ella podremos calcular fácilmente
la velocidad del motor y alinear el motor cuando se arranque el controlador.
Cada una de estas señales son generadas por el encóder en formato diferencial teniendo que conectar
8 señales entre el controlador el encóder: la alimentación de 5V, A+, A-, B+, B-, Z+, Z- y GND.
Cada par de señales se conectará a la entrada de un circuito integrado XR33184ESBTR, del fabricante
MaxLinear. Se trata de un receptor para protocolos de comunicación como RS-485 o RS-422. Soporta
una tasa de datos de hasta 52 Mbps. Dado que los pulsos de cada señal del encóder son enviados en
serie, podemos afirmar que cada pulso se corresponderá con un bit. La tasa máxima de datos que
generará nuestro encóder será:
𝐵𝑖𝑡 𝑟𝑎𝑡𝑒𝑒𝑛𝑐𝑜𝑑𝑒𝑟 = 𝜔𝑚á𝑥 𝑚𝑜𝑡𝑜𝑟 (𝑟𝑝𝑚) ∗ 1024 𝑝𝑝𝑟 = 16713 ∗ 1024 = 17,114 𝑀𝑏𝑝𝑚 → 285 𝐾𝑏𝑝𝑠
Como vemos, es una tasa muy inferior a la que soporta el circuito receptor.
Las entradas del circuito a las que conectaremos las señales diferenciales deben estar conectadas a
través de una resistencia de 120 Ω según el fabricante. Además, debemos conectar dos tensiones
diferentes al circuito integrado: una de ellas es la tensión de alimentación, que será de 5V, y otra de
ellas se corresponde con la tensión de un nivel alto en la salida del circuito. En nuestro caso, a este
pin conectaremos una tensión de 3,3 V.
También debemos conectar un condensador de desacoplo a la entrada del circuito. Finalmente, a su
salida obtendremos una señal single-ended a partir de la señal diferencial generada por el encóder, la
cual será procesada por el microcontrolador.
Ilustración 47: Implementación típica del circuito XR33184ESBTR en el controlador [9].
Finalmente, conectaremos una resistencia en serie de 1,8 kΩ entre la señal entregada por el circuito
receptor y el pin del microcontrolador para limitar la corriente, así como un condensador de 10 pF
que filtre el ruido que haya podido generarse en el receptor.
Con respecto a los sensores Hall, necesitaremos conectar 5 señales entre los sensores Hall que
incorpora el motor y el controlador: tres de ellas correspondientes a los tres sensores Hall, otra la
alimentación de 3,3 V y la masa.
Los sensores Hall del motor se distribuyen con una separación de 120º entre sí y generarán un pulso
cada vez que uno de los imanes permanentes del rotor pase justo enfrente de él. De esta forma
podemos conocer tanto la velocidad como la posición precisa en la que se encuentra el rotor en cada
instante, en función de la información conjunta aportada por los tres sensores Hall.
Estas señales son single-ended, por lo que no debemos replicar el circuito diseñado para acondicionar
las señales del encóder. En su lugar, utilizaremos el circuito implementado en la tarjeta X-NUCLEO-
IHM07M1:
49
Ilustración 48:Circuito acondicionador de las señales de los sensores Hall y del encóder en la tarjeta X-
NUCLEO-IHM07M1.
Como vemos, también se utiliza la resistencia de 1,8 kΩ y el condensador de 10 pF de la misma forma

que se hacía con las señales del encóder. Además de esto, se añaden tres resistencias de pull-up y tres
diodos de protección.
3.2.6. Interfaz CAN y puerto serie.

Las comunicaciones entre los distintos dispositivos del robot se realizan a través de un bus CAN,
protocolo desarrollado por la empresa Bosch a mediados de la década de 1980. Por ello, el controlador
debe contar con un transceptor CAN que adapte las señales recibidas del bus para el microcontrolador
y viceversa.
De forma similar a lo que ocurría con las señales diferenciales generadas por el encóder, el protocolo
CAN establece que los datos deben transmitirse a través de dos señales diferenciales, llamadas
comúnmente Can High y CAN Low. Pero el microcontrolador tan solo admite señales single-ended,
por lo que debemos utilizar un transceptor CAN.
El transceptor que utilizaremos será el modelo SN65HVD232D, de Texas Instruments. Este
dispositivo se encarga de adaptar los datos trasmitidos en dos sentidos: del microcontrolador al bus
CAN y viceversa:
 Si queremos enviar datos por el bus CAN, el microcontrolador trasmitirá los bits en serie a
través de la señal CAN.Tx. Esta señal será adaptada por el transceptor para enviarse por el bus
CAN, generando las señales CANH y CANL.
 En sentido inverso, el transceptor convertirá las señales CANH y CANL en una única señal
single-ended que se conectará al microcontrolador. Ésta es la señal CAN.Rx.
Ilustración 49: Conexiones del circuito integrado SN65HVD232D.
50
Además, cuando se arranque la ejecución del firmware, se leerán 7 pines GPIO del microcontrolador
para programar el ID CAN. Utilizaremos 7 interruptores que permitirán establecer un nivel alto o
bajo en los pines del microcontrolador B0, B1, B2, B3, B4, B5, B6 y B7. Otro interruptor permitirá
habilitar la resistencia de terminación en nuestro controlador, en caso de que el controlador se
encuentre en uno de los extremos del bus CAN. Estos ocho interruptores se integran en el componente
CVS-08B:
Ilustración 50: Conexiones en el microinterruptor CVS-08B para establecer el ID CAN y la resistencia de

terminación.
Por otra parte, es necesario tener acceso a la interfaz UART (Universal Asynchronous
Receiver/Transmitter) del microcontrolador. Para ello, solo necesitamos incluir un conector en la
tarjeta que de acceso a esos pines.
Los pines del microcontrolador destinados a la interfaz UART son el A2 para la transmisión de datos
y el A3 para la línea de recepción. Por problemas de espacio, estas señales se conectarán al mismo
conector que dará acceso a 4 pines GPIO del microcontrolador, el J7.
3.2.7. Medida de la temperatura y de la tensión de entrada.

Con el fin de implementar una protección firmware frente a un posible sobrecalentamiento de la
tarjeta o a una tensión de entrada inadecuada (demasiado alta o baja), es necesario implementar los
circuitos de medida correspondientes.
Para medir la tensión que existe en el bus de alimentación, utilizaremos un divisor resistivo, de la
misma forma que se hace en los esquemáticos de la tarjeta X-NUCLEO-IHM07M1:
51
Ilustración 51: Divisor resistivo para la medida de la tensión en el bus de alimentación de la tarjeta X-
NUCLEO-IHM07M1.
Es necesario incluir este divisor resistivo, ya que los pines del microcontrolador no soportan tensiones
tan altas como las del bus de alimentación. En concreto, este divisor presenta una atenuación de 0,052
V/V. De esta forma, en el pin del ADC del microcontrolador al que se conecta la medida de tensión
tendremos una tensión máxima de 1,75 V.
Podríamos ajustar el divisor resistivo para obtener 3,3 V (tensión máxima de los pines del
microcontrolador) en lugar de 1,75 V. Pero esto cambiaría la atenuación del divisor, lo que obligaría
a modificar el firmware. Por ello, utilizaremos los mismos valores de resistencia que se utilizan en el
diseño de la X-NUCLEO-IHM07M1. El condensador C14 de la Ilustración 51 se encarga de filtrar el
posible ruido y hacer que la señal que llega al ADC sea lo más clara posible.
Por otra parte, para medir la temperatura a la que se encuentra el circuito L6230 (que será la parte de
la tarjeta en la que más potencia se disipe), implementaremos otro divisor resistivo en el que una de
las resistencias será una de coeficiente de temperatura negativo (NTC) en lugar de una resistencia
fija. Implementaremos el mismo circuito que existe en la tarjeta X-NUCLEO-IHM07M1:
Ilustración 52: Divisor de tensión para la medida de la temperatura en la tarjeta X-NUCLEO-IHM07M1.
La resistencia del termistor disminuirá conforme aumente la temperatura, por ser su coeficiente de
temperatura negativo. Según la fórmula del divisor resistivo, tendríamos:
𝑁𝑇𝐶
𝑉𝑇𝐹𝐵 =
𝑁𝑇𝐶 + 4,7 𝑘Ω
Por tanto, cuando la tensión en el divisor resistivo descienda por debajo de un determinado valor, el
firmware detendrá el funcionamiento del controlador.
52
3.2.8. Selección de componentes pasivos.

Un componente pasivo es aquel componente electrónico que no amplifica la corriente que lo
atraviesa, tales como resistencias, condensadores y bobinas. Su principal uso es adaptar las corrientes
y tensiones de un circuito electrónico a las requeridas por los distintos circuitos integrados.
A la hora de escoger entre la gran variedad de modelos comerciales que pueden existir para un
componente del mismo tipo, es importante verificar cual de esos modelos se adapta mejor a nuestro
diseño. Debemos comprobar que:
 El componente sigue la norma AEC-Q200: este estándar otorga un grado de fiabilidad y
resistencia que lo hace apto para aplicaciones automotrices. Esto nos garantiza, por ejemplo,
un amplio margen de temperatura de trabajo y una baja tasa de fallos del componente.
La norma AEC-Q200 está desarrollada por el organismo Automotive Electronic Council
(AEC) y es de amplio reconocimiento en el mundo del diseño de circuitos electrónicos y sólo
es aplicable a componentes pasivos.
 Utilizar componentes SMD siempre que sea posible: esto ayudará a conseguir una mayor
densidad de componentes y ahorrar espacio en la PCB. Además, dado que esta es la primera
versión que se desarrolla de un controlador para motores BLDC, es conveniente que el tamaño
de los componentes pasivos no sea inferior al del estándar 0603 (0,6 x 0,3 pulgadas). Esto
facilitará la sustitución de los componentes en caso de que se produzca cualquier tipo de fallo.
3.3. Diseño de la tarjeta de circuito impreso.

Debido al tamaño reducido de la tarjeta, la cantidad de componentes a colocar y el número señales a
conectar; resulta casi imprescindible que nuestra PCB cuente con 4 capas de cobre sobre las que trazar
las pistas entre componentes. De esta forma también podremos diseñar unos planos de cobre bastante
homogéneos para las distintas tensiones de alimentación que se manejan en nuestro controlador.
El archivo de diseño de la PCB en Altium Designer tiene la extensión “PcbDoc”. Al contrario que
ocurre con el diseño de los esquemáticos, el diseño completo de la PCB se almacenará en un solo
fichero, en nuestro proyecto, llamado Driver LP.PcbDoc (ver Ilustración 41). A continuación, se
analizarán los pasos que se han seguido para diseñar la PCB de nuestro controlador.
3.3.1. Definición de las capas y dimensiones de la PCB.

Lo primero que haremos en nuestro fichero PcbDoc será definir con cuántas capas contará nuestra
tarjeta y el tipo de cada una. Para ello, abriremos la herramienta Layer Stack Manager de Altium
Designer:
53
Ilustración 53: Documento generado a partir del Layer Stack Manager de Altium Designer.
Como vemos, nuestra tarjeta contará con 4 capas de cobre (en color naranja y numeradas) y 3 capas
de dieléctrico FR-4, situadas entre las capas de cobre. Adicionalmente, se representan las capas de
soldermask7 y leyendas (Overlay) superior e inferior, que suelen encontrarse en todas las PCB.
La capa interna número 2 estará destinada a trazar un plano de masa. Este plano se extenderá por toda
la tarjeta, ya que una masa homogénea (sin cortes o agujeros) en el circuito disminuye la generación
de ruido en las señales. En la capa interna número 3 se distribuirán los planos de las 4 tensiones de
alimentación que existen en el circuito. Las capas de cobre externas 1 y 4 serán utilizadas para trazar
las pistas entre los componentes del circuito.
Por otra parte, las dimensiones y forma de la tarjeta fueron establecidas por el departamento de
Mecánica de Star Robotics. Esta tarjeta debe tener una forma rectangular, con una longitud de 82 mm
y una anchura de 33 mm. Para establecer el área de la tarjeta en el documento de diseño, trazaremos
unas líneas con estas dimensiones en la capa Mechanical 17. Después, las seleccionaremos e
indicaremos a Altium Designer que ésos son los límites de la tarjeta en la pestaña Design:
Ilustración 54: Bordes de la tarjeta del controlador (en rosa) en Altium Designer.
7
El soldermask es un material que facilita la soldadura de los componentes en la tarjeta ya que, sobre él, el estaño no se
suelda. Este material se impregna en las caras exteriores de la PCB, donde se colocan los componentes, para hacer que
todo el estaño quede recogido en los pads de los componentes.
54
3.3.2. Colocación de los componentes y de las serigrafías.

En nuestra tarjeta, colocaremos todos los componentes sobre la capa Top. Para colocar los
componentes de forma ordenada, conviene comenzar por dividir, de forma imaginaria, la tarjeta en
varias zonas, en las cuales se colocarán los componentes de los bloques funcionales descritos en el
apartado 3.2. De esta forma, la colocación de los componentes tendrá coherencia y, de producirse
algún fallo en el hardware, sería más fácil descubrir en que parte se ha dado. En el modelo 3D de
nuestra tarjeta puede apreciarse claramente esta distribución:
Alimentación
Encóder
Medida de las
CAN y corrientes
Bloque de control
UART
Inversor
trifásico
Hall
Ilustración 55: Distribución de los bloques funcionales en la PCB del controlador.
También es importante respetar las reglas que impone el fabricante de la tarjeta para evitar que se
produzcan errores en su producción. El fabricante de nuestra tarjeta será Eurocircuits y las principales
normas de diseño a las que debemos prestar atención para colocar los componentes son:
 Distancia mínima entre pads de componentes adyacentes: los pads de dos componentes
pequeños (tales como resistencias o condensadores cerámicos) deben mantener una distancia
entre ellos de al menos 1mm. Para componentes más grandes, como algunos integrados, es
recomendable dejar algo más de distancia.
 Distancia mínima entre una leyenda y un pad: si no se respeta una distancia entre estos
elementos de al menos 0,2mm, la leyenda del componente será borrada parcialmente:
Ilustración 56: Ejemplo de Eurocircuits de”Clipping”.
Pese a que la leyenda sigue siendo legible, es preferible evitar esta violación, ya que dificulta
el proceso de fabricación y puede generar problemas. A este ajuste se le conoce como
Clipping.
 Distancia mínima entre dos pistas o entre pad y pista: a la hora de colocar los componentes
debemos ir pensando por dónde se trazarán las pistas de manera aproximada, para dejar
espacio y poder trazarlas.
55
Trataremos de mantener una distancia de 0,2mm entre el pad de cobre de un componente y

una pista cercana a él, aunque debido a la alta densidad de componentes y el gran número de
señales, podremos disminuir esta distancia mínima a, como máximo, a 0,150 mm (límite de
fabricación de la clase 68 de Eurocircuits) .
 Distancia mínima entre el borde de la tarjeta y el cobre: no podremos trazar pistas ni planos
de cobre a una distancia inferior a 0,25 mm en las capas internas y de 0,4 mm en las capas
internas.
 Layout recomendado de los fabricantes: La mayoría de los fabricantes de circuitos integrados
ofrecen una colocación recomendada para los componentes adyacentes al integrado (por
ejemplo, esto es habitual verlo en las hojas de datos de en convertidores conmutados).
Debemos revisar este diseño previamente a la colocación de cualquier circuito integrado.
 Colocación en hardware que sea similar: por ejemplo, los componentes de las tres redes de
amplificación que acondicionan la tensión caída en las resistencias de shunt deben replicar su
estructura.
 Altura de los textos serigrafiados: la altura mínima de 1,25 mm para aumentar su legibilidad.
 Distancia entre dos serigrafías: La distancia entre dos serigrafías debe ser de, al menos,
0,2mm.
 Colocación del texto: Debemos tratar de colocar la base del texto serigrafiado sobre el
componente y orientado en la misma dirección que el mismo:
Ilustración 57: Ejemplo de buena colocación del identificador de un componente en la tarjeta.
3.3.3. Ruteo.
Llamamos ruteo al proceso de trazar las pistas que conectan los pines de los componentes de la tarjeta.
El recorrido de estas pistas, así como su ancho, resulta crucial para evitar introducir ruido en las
señales y poder disipar el suficiente calor en las señales que transportan una mayor intensidad de
corriente.
A la hora de rutear la tarjeta, tendremos siempre en cuenta las siguientes reglas y buenas prácticas:
 Antes de empezar a rutear las conexiones entre zonas, es conveniente pensar de manera
aproximada por dónde trazaremos las pistas de señales que recorren distancias largas.
 Debemos empezar a rutear por zonas pequeñas y bloques funcionales. Por ejemplo, debemos
rutear las redes de amplificación de medida de las corrientes antes que trazar las pistas que
van del chip L6230Q al microcontrolador.
 En circuitos repetidos (como las redes de amplificación), el trazado de las pistas debe ser
prácticamente igual.
8
Los fabricantes asignan una clase a cada PCB en función de la dificultad de fabricación de la misma. Por ejemplo, cuanto
menor sea la distancia entre pistas, la fabricación será más compleja y la clase de la tarjeta será más alta. Así, todos los
fabricantes establecen unos límites de distancias entre elementos y de tamaño de agujeros y vías para clasificar una tarjeta
en una clase u otra. La clase de nuestra PCB será 6C.
56
 Las pistas deben entrar de manera perpendicular al pad y hasta el centro del mismo. De esta
forma evitaremos que el componente pueda desplazarse al ser soldado.
Ilustración 58: Ejemplo de desplazamiento de un componente de Altium Resources.
 Dejar una separación entre las pistas y los pads conectados a una misma señal de mínimo
0,2mm para evitar peelables9:
Ilustración 59: Representación de Eurocircuits de un peelabe.
 El ancho de las pistas será:

o En general, de 0,4mm.
o Para pistas que manejen mayor intensidad de corriente, utilizaremos un ancho de entre
0,6mm y 1mm.
o Si el tamaño es muy reducido, podemos utilizar pistas de como mínimo 0,25mm para
señales digitales o estáticas (límite de la clase 6 de Eurocircuits).
o Si la una pista une dos pads de diferente ancho, igualaremos el ancho de la pista al
menor de los pads.
 Cuando varias pistas entren o salgan del mismo pad, se debe trazar una “V” entre ellas, de
forma que al pad se conecte una sola pista. De esta forma facilitaremos la fundición del estaño
en el proceso de soldadura:
Ilustración 60: Trazado correcto de dos pistas que deben conectarse al mismo pad.
9
Los peelables son pequeñas áreas que existen entre dos pistas o pads que provocan que pueda desprenderse la foto-
resistencia utilizada para imprimir las pistas de cobre en las capas conductoras de la tarjeta.
57
 Nunca deben trazarse ángulos rectos en una pista. Esto provoca variaciones en la sección de
la pista, lo cual provoca cambios de la impedancia a lo largo de la pista. Este efecto introduce
mucho ruido en la señal.
 Las vías deben tener 0,25mm de diámetro de agujero y 0,6mm de diámetro total para ajustarse
a la clase de fabricación C de Eurocircuits.
 Tratar que las pistas hagan el menor número de curvas posibles. Esto ayudará a reducir el
ruido introducido en la señal y a ahorrar espacio en la tarjeta.
3.3.4. Diseño de los planos de cobre.
Un plano de cobre es un área sobre alguna de las capas conductoras de la PCB que se encuentra
recubierta completamente por cobre. De forma general, colocar un plano de cobre para que por él
circule una determinada señal presenta las siguientes ventajas:
 Se facilita el ruteo, pues se deberán trazar menos pistas. De esta forma, se reduce el recorrido
que debe realizar una determinada señal, lo que es especialmente importante en el retorno de
las señales a masa.
 Se consigue una mayor disipación de calor en señales que manejan intensidades de corriente
altas. Al aumentar la superficie de un buen conductor térmico (como lo es el cobre) se facilita
el intercambio de calor entre éste y el ambiente.
 Cuanto mayor sea la sección de un conductor, menor será su resistencia tal y como indica la
siguiente ecuación:
l
R= ρ∗
S
Donde ρ es la resistividad eléctrica del material, l la longitud del conductor y S su sección.
Por la ley de Joule, al disminuir la resistencia del conductor también disminuirá el calor que
generado:
Q = I2 ∗ R ∗ t
Donde Q es el calor generado, I la intensidad de la corriente, R la resistencia eléctrica y t el

tiempo que circula la corriente por el conductor.
 Cuanto más homogéneo sea el recorrido que realiza una señal (sin curvas, agujeros o vías)
menor será el ruido que se genere, debido a que la impedancia a lo largo del conductor será
más uniforme.
Por estas razones, trazaremos un plano de cobre para cada una de las tensiones de alimentación del
controlador en la capa 3 de la tarjeta. Gracias a haber colocado los componentes de forma ordenada
según los bloques funcionales definidos, es sencillo definir los planos de alimentación, ya que todos
los circuitos que necesitan la misma tensión de alimentación quedan muy cercanos entre sí. Este es
el diseño que se ha implementado en la PCB del controlador:
58
5V
33 V
V
3,3 V A3,3 V
Ilustración 61: Planos de cobre de las tensiones de alimentación en la tarjeta del controlador.
Este plano se representa en negativo, lo que quiere decir que las zonas rojas más opacas representan
las zonas donde no habrá cobre. Como vemos, la zona del oscilador se ha dejado sin cobre, ya que
podría afectar negativamente al funcionamiento del mismo. El resto de líneas representan los límites
entre los planos.
En la capa 2 de la tarjeta colocaremos las dos masas del circuito: la digital y la analógica. Pese a que
están conectadas entre sí, debemos procurar que se conecten en un único punto del circuito lo más
pequeño posible. De esta forma evitamos introducir el ruido generado por las conmutaciones de la
parte digital del circuito en la parte analógica. Esta capa también se representa en negativo:
GND
AGND
Ilustración 62: Diseño del plano de masa de la tarjeta del controlador.
Como vemos, el plano de la masa analógica (destinado a los amplificadores que acondicionan la
tensión caída en las resistencias de shunt) está totalmente separado del plano de masa general. Estos
dos planos están conectados únicamente a través del solderbridge JP2. También para evitar introducir
ruido en el oscilador, disminuimos el punto de conexión de la masa que queda debajo del oscilador
con la masa general al mínimo.
59
Además, para disipar el máximo calor posible y tener un recorrido homogéneo, cada una de las
corrientes de salida del circuito L6230 que alimentan al motor se conectan a éste mediante un plano
de cobre del máximo tamaño posible en la capa 4. Lo mismo ocurre con la conexión de los pines
SENSEx a las resistencias de shunt:
Ilustración 63: Planos de cobre para conectar las fases 2 y 3 del motor al circuito L6230Q.
Ilustración 64: Plano de cobre para conectar la salida SENSE1 del circuito L6230Q a la resistencia de
shunt.
En la capa 1 también definiremos planos de cobre para la tensión de entrada al controlador y la de 5

V. Además, tiraremos dos planos de cobre de GND a lo largo de todas las capas 1 y 4. Altium Designer
se encargará de distribuir estos planos por todos los espacios que hayan quedado libres en la tarjeta.
De esta forma, facilitamos todavía más el retorno de la corriente de los componentes hacia masa.
Por último, para reducir las interferencias electromagnéticas de la tarjeta (EMI - Electromagnetic
Interference) cebemos colocar un conjunto de vías sobre las grandes superficies de cobre para mejorar
su conexión a la señal correspondiente. De lo contrario, un conductor que no estuviese bien conectado
podría actuar como una antena y podría captar las EMIs generadas por el resto de componentes
electrónicos del robot.
60
3.4. Fabricación de la tarjeta.

La fabricación de las PCBs es encargada a la empresa Eurocircuits, la cual se ocupa también del
montaje de los componentes. Para ello, debemos enviarles los ficheros que contienen la información
sobre el diseño de nuestra PCB. Éstos son los ficheros GerberX2, Report Board Stack, Bill of
Materials y Pick and Place:
 Ficheros GerberX2: son un tipo de archivo utilizados exclusivamente para la fabricación de
PCBs. Son la evolución del formato Gerber y con respecto a éstos, se ha unificado la extensión
de los archivos generados. En la versión de archivos GerberX2, todos los ficheros tendrán
extensión “gbr”. Con Altium Designer generaremos 15 ficheros a partir del documento
PcbDoc, en cada uno de los cuales se almacena la información de una de las capas de la PCB,
así como de los agujeros y vías:
o Copper_Signal_Top: contiene la información sobre el trazado y la ubicación de las
pistas y planos de cobre de la capa 1.
o Copper_Signal_Bot: contiene la información sobre el trazado y la ubicación de las
pistas y planos de cobre de la capa 4.
o Copper_Plane_1: contiene la información sobre el trazado y la ubicación de los
planos de cobre de la capa 2.
o Copper_Plane_2: contiene la información sobre el trazado y la ubicación de los
planos de cobre de la capa 3.
o Drawing_1: almacena la posición y tamaño de los agujeros de la tarjeta.
o Drillmap_1: contiene las guías para realizar los agujeros.
o Legend_Top: leyendas de los componentes situados en la capa 1.
o Legend_Bot: leyendas de los componentes situados en la capa 2.
o NPTH_Drill: informa sobre qué agujeros no deben recubrirse de cobre (por ejemplo,
los agujeros de las esquinas de la PCB).
o Pads_Top: posición y tamaño de los pads de la capa 1.
o Pads_Bot: posición y tamaño de los pads de la capa 4.
o Paste_Top: dónde debe colocarse la pasta de soldadura en la capa 1.
o Paste_Bot: dónde debe colocarse la pasta de soldadura en la capa 4.
o Profile: Contiene los bordes de la tarjeta.
o PTH_Drill: informa sobre qué agujeros deben recubrirse de cobre (como las vías).
o Soldermask_Top: dónde debe haber soldermask en la capa 1.
o Soldermask_Bot: dónde debe haber soldermask en la capa 4.
o REP: fichero de información de la generación de los archivos. Indica si se ha
producido algún error o si la generación ha sido correcta.
o EXTREP: fichero de información que indica los ficheros generados.
 Report Board Stack: este archivo contiene la información que podíamos visualizar en la
herramienta Board Stack Manager de Altium. Representa las diferentes capas que forman la
tarjeta, el material del que se forman, su espesor, etcétera. Es un fichero Excel, el cual se
mostró en la Ilustración 53.
Este fichero resulta muy útil al fabricante ya que, pese a que los ficheros GerberX2 ya
contienen la información sobre el orden y la numeración de la tarjeta, con este fichero le
aportamos información adicional, como el material de fabricación o su espesor.
61
Estos datos pueden ser utilizados para comprobar que el diseño realizado se corresponde con
las características seleccionadas en el pedido.10
 Bill of Materials (BOM): se trata de un documento Excel en el que quedan recogidos todos los
componentes que forman la tarjeta y sus principales parámetros. Este fichero solo es necesario
entregarlo al fabricante si se va a solicitar el ensamblaje de los componentes en la tarjeta
(como será nuestro caso). Los datos que deben recogerse en este fichero, según recomienda
Eurocircuits son:
o Designator: nombre del componente en el diseño (el mismo que se verá en la
leyenda).
o Description: Descripción del componente. Tipo de componente, encapsulado, tensión
o potencia máxima que soporta, etcétera.
o Manufacturer_Name: nombre del fabricante.
o Manufacturer_Part_Number: referencia que el fabricante da al componente.
o Value: valor de la resistencia, capacidad o inductancia de un componente.
o Mounting Type: tipo de montaje del montaje del componente. Puede ser de montaje
superficial (Surface Mounted Device-SMD) o de inserción (Through Hole-TH).
o Distributor: nombre del suministrador donde se puede encontrar el componente.
o Reference: referencia que el suministrador da al componente.
o Distributor Link: link de la web del distribuidor del componente.
Estos parámetros son editados manualmente en cada componente nuevo que se añade a las
librerías de símbolos y footprints de componentes, utilizando la herramienta Parameter
Manager de Altium. Con esta información, el fabricante es capaz de buscar y comprar los
componentes exactos que queremos montar en nuestra tarjeta.
 Pick and Place: este fichero contiene las coordenadas de la tarjeta dónde deben colocarse cada
componente. Además, informa sobre la orientación del mismo y la capa (Top o Bottom) sobre
la que deben montarse. Este fichero será interpretado por la máquina de Pick and Place del
fabricante, la cual coloca cada componente en su posición de forma automática. Esto solo
ocurre con los componentes SMD. Los TH son montados por operarios manualmente.
Al igual que ocurría con el fichero BOM, este archivo solo debe entregarse al fabricante si se
va a solicitar el ensamblaje de la tarjeta.
Ilustración 65: Fragmento del documento Pick and Place de la tarjeta del controlador.
10
En los pasos finales del pedido de la tarjeta a Eurocircuits, se solicita indicar el espesor de las capas de las tarjetas, así
como el material del dieléctrico. Por eso, con el fichero Board Stack Report pueden corroborar que las opciones
seleccionadas en el pedido se corresponden con el diseño.
62
Con estos documentos el fabricante es capaz de fabricar nuestra tarjeta. Antes de finalizar el pedido,
debemos verificar que todos los componentes son reconocidos por el fabricante, así como que la
interpretación del fichero Pick and Place es correcta. Para ello, Eurocircuits ofrece un visualizador
en su web que interpreta los ficheros Gerber y el Pick and Place para representar la posición de los
componentes sobre la tarjeta. Estos aparecen como cuadrados rojos sobre los pads de los
componentes. De esta forma, si se observa que los cuadrados no coinciden con la posición de los
pads, podemos ajustar la posición del componente y editar el fichero Pick and Place.
63
Capítulo 4
Calibración y puesta en marcha del
controlador.
El proceso de calibración del controlador consiste en ajustar una serie parámetros del firmware con
el fin de lograr un compromiso entre rapidez y suavidad en la respuesta de los motores. Este proceso
resulta fundamental para que los motores puedan ser controlados de forma rápida y precisa, así como
para evitar tensiones mecánicas demasiado grandes en los diferentes componentes del motor.
En concreto, los parámetros que se deben ajustar son las constantes Kp, Ki y Kd de los reguladores PID
que intervienen en el algoritmo de control FOC. Estos parámetros determinarán la señal de salida de
cada regulador y, en consecuencia, son los parámetros más influyentes en la respuesta del motor.
Pero antes de calibrar el controlador, debemos verificar el correcto estado y funcionamiento de las
PCB recibidas, así como programarlas por primera vez y comprobar que tanto el hardware diseñado
como el firmware generado son aptos para nuestra aplicación.
Por último, describiremos las modificaciones y funcionalidades más importantes añadidas al
firmware generado a partir de MotorControl Workbench, como son el cálculo de una nueva
trayectoria S-Curve en los cambios de posición y la mejora de la resolución de la medida de la tensión
del bus de alimentación.
4.1. Recepción y puesta en marcha del controlador.

Al recibir las PCB del controlador, se revisa que el proceso de fabricación y el montaje de los
componentes ha transcurrido con éxito. Para ello, antes de programar y calibrar el controlador,
realizaremos una inspección visual y mediremos la continuidad entre puntos clave de las tarjetas
recibidas. Los pasos seguidos han sido:
 Comprobación a grandes rasgos del estado de las tarjetas recibidas: no presentan roturas, todos
los componentes están montados, etcétera. Las tarjetas suelen llegar con unos pequeños
salientes en sus bordes, que son los restos de los puntos de unión de las tarjetas al panel donde
se fabrican. Para retirar estos restos, puede utilizarse un cúter o un papel de lija de grano fino.
 Comprobación de la soldadura de los componentes: todos los pines deben estar bien soldados
al pad y el componente no debe estar desplazado. En las cinco tarjetas que se recibieron, se
puede observar que el conector J7 está desplazado hacia la izquierda y ligeramente hacia
abajo. Con el polímetro, comprobamos que existe continuidad entre los pines del conector y
los pines del microcontrolador a los que están conectados, por lo que no resulta necesario
recolocar este componente.
65
Calibración y puesta en marcha del controlador
Ilustración 66: Captura en el microscopio del desplazamiento del conector J7.
 Comprobación de la posición en los componentes con polaridad: tales como condensadores

electrolíticos, diodos, etcétera. Por ejemplo, en el caso de un diodo, debemos verificar que el
cátodo y el ánodo están soldados en los pads correctos y no se han intercambiado las
posiciones entre ellos. Para evitar estos problemas, se debe incorporar alguna marca en la capa
overlay del footprint de este tipo de componentes, como un símbolo “+” o “- “.
Ilustración 67: Marca del pin positivo (“+”) del condensador C18.
 Comprobación de la posición de los circuitos integrados: para evitar errores en el montaje los
encapsulados de los circuitos integrados suelen tener marcados el pin número 1. Por nuestra
parte, debemos añadir en el footprint de estos componentes una marca que indique la posición
del primer pin. Esta marca suele ser un punto.
Ilustración 68: Punto que indica el pin 1 de los receptores de las señales del encóder.
66
 Limpieza de las PCBs: en ocasiones, las PCBs recibidas tienen adheridos algunos residuos
del proceso de soldadura, principalmente restos de fundente11. Para eliminarlos, puede
utilizarse una cubeta de ultrasonidos o un limpiador de fundente, el cual se aplica en la tarjeta
en forma de spray y permite retirar los restos de fundente con un cepillo.
 Comprobación de posibles cortocircuitos: una vez tenemos las tarjetas limpias, debemos
comprobar que no existen cortocircuitos entre los pines más cercanos de los componentes.
Para ello, primero se realiza una inspección visual con el microscopio y, si se observa algún
posible cortocircuito, utilizamos el polímetro para comprobar si existe continuidad entre esos
pines.
Una vez comprobados los principales problemas que puede presentar el hardware y con las tarjetas
limpias, podemos programarlas y comprobar su funcionamiento. En primer lugar, debemos fabricar
el conector para poder alimentar el controlador. Para ello, utilizaremos dos cables AWG 20, los
crimparemos y los introduciremos en un conector Molex Minifit. El otro extremo de cada cable irá
soldado en los soldercups del conector J4.
Ilustración 69: Conector de alimentación del controlador.
Tras ello, conectaremos el controlador a una fuente de alimentación programada a 30 V y con una
limitación de corriente de 0,5 A. Si el controlador está alimentado correctamente, veremos el LED
LD2 encendido.
A partir de aquí, podemos programar el controlador a través de su interfaz SWD. Para ello
necesitaremos utilizar el dispositivo ST-LINK/V2, que se utiliza de interfaz entre el puerto USB del
PC y el conector SWD del controlador y nos permite programar y depurar en microcontroladores de
ST de la familia STM8 y STM32. También utilizaremos el software gratuito STM32 ST-LINK Utility,
el cual nos permite escribir y verificar la programación de la memoria flash del microcontrolador
mediante una interfaz gráfica bastante sencilla.
Tras iniciar el programa, conectaremos el ST-LINK/V2 a uno de los puertos USB del PC y al
controlador. Pulsando sobre Target -> Connect obtendremos una conexión. Para programar el
microcontrolador, debemos pulsar en ST-LINK -> Program & Verify. En unos 3 segundos se habrá
programado el controlador.
11
El fundente, también conocido por su nombre en inglés (flux), es un compuesto químico utilizado en el proceso de
soldadura electrónica el cual mejora su calidad. Entre sus principales propiedades, podemos mencionar que elimina el
posible óxido de los componentes y que concentra el calor para facilitar la fundición del estaño.
67
Ilustración 70: Interfaz gráfica del programa STM32 ST-LINK Utility.
El firmware que se programará en los controladores encenderá el LED LD1 nada más comience la
ejecución del código, lo cual nos permitirá verificar que la programación del controlador y la
ejecución del código es correcta. Tras este procedimiento, habremos verificado el correcto
funcionamiento de los bloques de alimentación y del microcontrolador. A partir de aquí, realizaremos
el resto de pruebas y modificaciones pertinentes para poder verificar el correcto funcionamiento del
controlador completo.
4.2. Calibración de los PID implementados en el firmware.

La Ilustración 13 muestra el diagrama de bloques del algoritmo de control FOC, donde vemos que
tres de los bloques representan reguladores PID12: uno de ellos regula la corriente Id , otro la corriente
Iq y otro la velocidad. Estos reguladores son determinantes en la respuesta del motor.
La señal entregada por cada uno de estos PIDs depende del valor de tres constantes: Kp, Ki y Kd. Estas
constantes determinan la influencia de las partes proporcional, integral y derivativa de la señal de
entrada al regulador en la señal de salida. El proceso de calibración consiste en encontrar los valores
óptimos de cada una de estas constantes en cada PID para conseguir una respuesta del motor
equilibrada, dinámica y sin sobreimpulsos.
El método de calibración que utilizaremos será una adaptación a nuestro sistema del método
presentado por ST Microelectronics en uno de sus webinars, impartido el día 8 de septiembre de 2020
y titulado “How to tune a BLDC motor using a STSPIN32 system in package”.
12
En un sistema de control en lazo cerrado, nos referimos con PID (Proportional, Integral and Derivative) a un regulador
que calcula la señal de acción (y) a partir de la suma de las respuestas proporcional, integrada y derivada de la señal de
su entrada (e). En un sistema discreto como el procesador: 𝑦(𝑡) = 𝐾𝑝 ∗ 𝑒(𝑡) + 𝐾𝑖 ∗ ∑𝑡𝑗=0 𝑒(𝑗) + 𝐾𝑑 ∗ (𝑒(𝑡) − 𝑒(𝑡 − 1)).
68
4.2.1. Método de calibración de ST Microelectronics.
ST Microelectronics distingue tres fases durante la calibración de un controlador de motores BLDC

que implementa un algoritmo FOC sensorless sobre un determinado motor que trabaja en unas
condiciones específicas. Estas son:
 Calibración de los reguladores de corriente.
 Ajustes en el cambio de lazo abierto a lazo cerrado.
 Calibración del regulador de velocidad.
Para calibrar los reguladores de corriente debemos obtener los valores de Kp y Ki de los reguladores
de las corrientes Iq e Id , llamados PId y PIq en la Ilustración 13. Como podemos deducir de sus siglas,
estos reguladores no tienen en cuenta la derivada de la señal de entrada (son reguladores PI).
Para obtener estos valores ST recomienda generar dos escalones de corriente en las fases del motor y
observarlo en el osciloscopio. El objetivo es observar un escalón limpio, en el que la corriente varía
rápidamente, pero sin sobreimpulsos:
Ilustración 71: Escalón de corriente ideal que debemos observar en las fases del motor durante la
calibración.
En la ventana Configuration del monitor de MCWB, aparece una tabla en la que se puede programar
una rampa de velocidad y torque para alinear el motor durante su arranque en un control FOC sin
sensores. En este caso, la utilizaremos para programar el escalón de corriente
Ilustración 72: Configuración del escalón de corriente en la ventana “Configuration” de MCWB.
69
Mediante 5 fases en las que la velocidad se mantendrá a cero, generaremos el escalón de corriente.
Para ello, en la columna Final Torque indicaremos la corriente13 que queremos aplicar en las fases
del motor. En la columna Duration, configuramos el tiempo durante el que se aplicará dicha corriente,
en milisegundos.
Estos valores son enviados al controlador por el puerto serie desde el PC hasta el controlador. Una
vez configurado, colocamos la pinza amperimétrica en la fase A del motor y lo arrancamos. Si el
osciloscopio está configurado correctamente, observaremos algo similar al escalón mostrado en la
Ilustración 71. Pueden darse dos problemas:
 La variación de la corriente es demasiado lenta (como en la Ilustración 73). Esto se debe a
que el valor de Ki es demasiado bajo.
Ilustración 73: Ejemplo de una respuesta lenta de la corriente en la fase A del motor.
 Existen demasiadas oscilaciones cuando la corriente permanece constante. Esto se debe a

que el valor de Ki y Kp es demasiado alto, como en la Ilustración 74.
Ilustración 74: Ejemplo de respuesta ruidosa debido a valores demasiado altos de Kp y Ki.
13
Las unidades de estos valores se verán más adelante.
70
Para comenzar la calibración, ST recomienda asignar el valor 0 a las constantes Kp y Ki del regulador
de la corriente Id y calibrar únicamente el regulador de la corriente Iq. Esto se debe a que es muy
complicado regular simultáneamente ambos reguladores y a que el valor de Kp y Ki en ambos
reguladores puede ser prácticamente el mismo en el 95 % de los motores BLDC.
Si la respuesta es demasiado lenta, aumentaremos el valor de Ki hasta que se produzca un
sobreimpulso en alguno de los dos escalones. En ese momento, aumentaremos Kp hasta que
desaparezca el sobreimpulso.
Ilustración 75: Ejemplo de un sobreimpulso en la corriente de la fase A del motor.
Debemos seguir aumentando Ki y Kp (en este orden) sin llegar a una respuesta demasiado ruidosa14,
como ocurría en la Ilustración 74. Los valores que escogeremos serán los más altos posibles, siempre
que no generen demasiado ruido. Estos mismos valores se aplicarán al regulador PId.
Tras calibrar los reguladores de corriente, ST ajusta los parámetros que definen en cambio del control
en lazo abierto a control en lazo cerrado. En el control FOC sensorless, el sistema de control del
motor comienza a funcionar en lazo abierto, ya que cuando el motor está parado, éste no genera
ningún BEMF y no se puede averiguar la posición de rotor. Dado que nuestro motor dispone de
sensores Hall y encóder, se puede conocer en cualquier momento la posición del rotor y no será
necesario ajustar los parámetros del cambio de lazo abierto a lazo cerrado.
El último paso es la calibración del regulador de velocidad. Este proceso es bastante similar al
realizado en los reguladores de corriente: si en la gráfica de la velocidad se observa que la respuesta
el lenta, aumentaremos Ki hasta que se produzca un sobreimpulso. En ese momento, aumentaremos
Kp para que desaparezca. Si se producen muchas oscilaciones, se debe a que los valores de Kp y Ki son
demasiado altos.
14
Parte del ruido observado en los dos escalones en los que la corriente se mantiene constante se debe a la frecuencia de
conmutación de las señales PWM aplicadas sobre los MOSFET de los tres semipuentes en H. Este ruido podría reducirse
si aumentamos la frecuencia de estas señales, pero esto también incrementaría las EMI emitidas por el controlador, por
lo que se mantendrá el valor de la frecuencia por defecto.
71
4.2.2. Trabajos previos a la calibración del controlador.

Antes de comenzar la calibración del controlador, debemos añadir el código necesario al firmware
del controlador para generar estos escalones de corriente. Este código es exclusivo del control FOC
sensorless y no es compatible para trabajar con los sensores Hall y el encóder de nuestro motor.
Por ello, cuando queramos calibrar el controlador, se compilarán las partes del código necesarias para
que el controlador implemente un control FOC sensorless, mientras que, cuando el controlador vaya
a trabajar en su modo de operación habitual, se compilarán las partes del código que permiten obtener
la velocidad instantánea del motor mediante los sensores Hall y el encóder.
Para distinguir el código necesario de cada modo de operación, generaremos dos proyectos en MCWB
para las tarjetas de desarrollo en los que sólo varía la configuración del bloque Speed Sensing que
vemos en la Ilustración 31. En uno de los proyectos, configuraremos el encóder y los sensores Hall,
mientras que en el otro configuremos la opción Observer + PLL. En esta opción, un observador de
Luenberger y un PLL software estimarán el BEMF y reconstruirán la posición instantánea del rotor
[4] y la velocidad.
Ilustración 76: Configuración sensorless de MCWB.
El número de diferencias encontradas es demasiado grande como para enumerarlas en esta memoria,
pero la manera en la que han sido tratadas en el firmware del controlador ha sido la misma en todas
ellas:
 En el caso de querer realizar la calibración de los reguladores PI de corriente del controlador, se
activará la directiva del preprocesador CALIBRATION. Esto se hará en las opciones de
compilación del proyecto en STM32CubeIDE.
 Para decidir que código debe compilarse, utilizaremos las directivas del preprocesador #ifnef,
#else y #endif:
#ifndef CALIBRATION
MCT[M1].pRevupCtrl = MC_NULL; /* only if M1 is not sensorless*/
MCT[M1].pSpeedSensorMain = (SpeednPosFdbk_Handle_t *) &ENCÓDER_M1;
MCT[M1].pSpeedSensorAux = (SpeednPosFdbk_Handle_t *) &HALL_M1;
MCT[M1].pSpeedSensorVirtual = MC_NULL;
#else
MCT[M1].pRevupCtrl = &RevUpControlM1; /* only if M1 is sensorless*/
MCT[M1].pSpeedSensorMain = (SpeednPosFdbk_Handle_t *) &STO_PLL_M1;
MCT[M1].pSpeedSensorAux = MC_NULL;
MCT[M1].pSpeedSensorVirtual = &VirtualSpeedSensorM1; /* only if M1 is
sensorless*/
#endif
72
Por ejemplo, vemos como en el fichero mc_tasks.c, cambiará el valor asignado a algunas de las
variables de la estructura MCT[M1] en función de si definimos la directiva CALIBRATION al
compilar el firmware o no.
 En el caso de las funciones cuyo código es diferente en función de los sensores configurados, se
codificarán de ambas formas: una de estas implementaciones se codificará en caso de no definirse
CALIBRATION y la otra, en caso de definirse. Esto ocurre por ejemplo con la función
TSK_HighFrequencyTask(void).
Sí que es importante mencionar la parte del código donde se definen la amplitud y duración de los
escalones de corriente, ya que puede que se necesite editar en algún momento. Estas constantes se
definen al final del fichero fichero drive_parameters.h. La duración de los escalones se expresa en
milisegundos y la amplitud de la corriente al final de cada fase cumple la ecuación:
Corrientefase 1 ∗ 32767 ∗ Rshunt ∗ Gananciaamplificadores ∗ 2

Corrientefase 1 (int16) =
VMCU
En nuestro caso, aplicaremos unos escalones de 300 mA y 150 mA. Por tanto, el valor que debemos
asignar a las constantes del firmware serán:
/* Phase 1 */
#define PHASE1_DURATION 0 /*milliseconds */
#define PHASE1_FINAL_SPEED_UNIT (0*SPEED_UNIT/_RPM)
#define PHASE1_FINAL_CURRENT_mA 300 // miliamperios
#define PHASE1_FINAL_CURRENT (PHASE1_FINAL_CURRENT_mA * 32767 / MAX_CURRENT)
/* Phase 2 */
#define PHASE2_FINAL_CURRENT_mA 300 // miliamperios
/* Phase 3 */
#define PHASE3_FINAL_CURRENT_mA 150 // miliAmperios
/* Phase 4 */
/* Phase 5 */
#define PHASE5_DURATION 0 /* milliseconds */
Este trabajo ha sido necesario para poder obtener unos valores de calibración lo más óptimos posibles
para las condiciones reales de trabajo y poder calibrar los controladores ya montados en el módulo
de visión del robot. Esto deja inaccesible el puerto serie del controlador y hace imposible utilizar
MCWB para programar el escalón de corriente.
Gracias a las modificaciones mencionadas, el controlador tendrá los escalones de corriente ya
programados en su firmware y tan sólo necesitaremos enviarle los comandos necesarios para arrancar
el motor, pararlo, reconocer los fallos producidos (Fault ACK) y modificar el valor de las constantes
de los reguladores PID.
73
Para enviar estos comandos, utilizaremos un programa15 desarrollado en C# por el departamento de

Electrónica de Star Robotics, con el que podremos enviar todos los comandos necesarios al
controlador a través del bus CAN.
Ilustración 77: Interfaz gráfica del software de control.
En el bloque Registros de Lectura podemos seleccionar los registros cuyo valor queremos visualizar.
Si activamos la casilla de la derecha de cada uno de los desplegables, estos registros se actualizarán
constantemente y sus valores se representarán en la gráfica superior.
En el bloque Registros de Escritura podemos escribir un valor en cualquiera de los registros de
escritura del controlador. Una vez introducido el nuevo valor y tras salir de la casilla de escritura, se
activará la casilla de al lado, indicando que el registro se ha escrito correctamente. Esto se utilizará,
por ejemplo, para probar distintos valores de Kp y Ki en cada regulador.
En el bloque Comandos derecho podemos seleccionar el comando que queremos que ejecute el
controlador. Si pulsamos el botón Execute, este comando se enviará al controlador. Al ser recibido,
se activará la casilla cuadrada de su izquierda.
Finalmente, en el bloque Mensajes de Error se muestran los posibles errores que puedan darse.
La interfaz entre el PC que ejecuta el software de control y la interfaz CAN del controlador será la
tarjeta EMCB-200U-MP10E, de Advantech. Es un dispositivo plug&play, por lo que será suficiente
con conectarla a un puerto USB del PC y a uno de los dos conectores CAN del controlador (J1 o J2)
para poder comunicarnos con él.
15
A partir de aquí, a este programa le denominaremos programa de control.
74
Ilustración 78: Tarjeta EMCB-200U-MP10E conectada y en funcionamiento.
4.2.3. Método de calibración para el controlador diseñado.

Habiendo adaptado el método de calibración propuesto por ST Microelectronics seremos capaces de
ajustar las constantes de los reguladores PID a las condiciones reales de funcionamiento de los
motores, pues podremos realizar la calibración una vez esté el controlador montado en el robot. Esto
es un gran avance, ya que el valor de las constantes de los PIDs puede variar bastante en función de
la masa y las inercias que deba vencer el motor.
En esta memoria describiremos el proceso de calibración del controlador de la izquierda, el cual
controla el eje Pan del módulo de visión del motor. Distinguimos 4 fases:
 Conexionado.
 Calibración de los reguladores de corriente.
 Calibración del regulador de velocidad.
 Calibración del regulador de posición.
4.2.3.1. Conexionado.
En primer lugar, conectaremos la tarjeta EMCB-200U-MP10E al bus CAN del módulo de visión. Esta
tarjeta también se conectará al puerto USB del PC a través de su conector USB1. Es importante
conectar la resistencia de terminación en la tarjeta EMCB-200U-MP10E y en el controlador del eje
Tilt (eje horizontal). Para ello, colocaremos en la posición ON el microinterruptor 8 del circuito
integrado S1 del controlador (en la tarjeta EMCB-200U-MP10E se activa mediante un software
ofrecido por el fabricante).
Después, conectaremos la alimentación. Para ello, conectaremos la fuente de alimentación al
controlador, a través del conector mostrado en la Ilustración 69. Alimentaremos el controlador a 30
V (igual que la tensión nominal de la batería del robot) y limitaremos la corriente a 400 mA.
4.2.3.2. Calibración de los reguladores de corriente.
Para calibrar los reguladores PI de las corrientes Iq e Id, debemos compilar el firmware del controlador
con la directiva CALIBRATION definida. Después, programaremos el controlador con ese firmware.
Si el controlador recibe el comando START MOTOR, circulará por sus fases los escalones de corriente
programados. Podremos observarlo en el osciloscopio conectando la sonda amperimétrica a la fase A
del motor. Si colocamos la sonda en cualquiera de las otras dos fases, observaremos dos escalones en
los que la amplitud será la mitad de la indicada en el código.
75
Para obtener los valores óptimos de Kp y Ki, aplicaremos el método definido por ST Microelectronics
y que hemos descrito en el apartado 4.2.1. Tras aumentar lentamente el valor de las constantes, los
mejores resultados obtenidos se muestran en la Ilustración 79:
Ilustración 79: Respuesta tras la calibración de corriente. Kp = 3800, Ki = 3700.
Tras obtener esta respuesta, se realizó otra prueba con unos valores superiores: Kp = 4000 y Ki = 3900.
En este caso se pueden observar unas sobreoscilaciones en el primer escalón de corriente.
Ilustración 80: Respuesta obtenida con los valores Kp = 4000, Ki = 3900
Tras obtener los valores finales de las constantes para el regulador de Iq, los utilizaremos también para
el regulador de Id. Podemos verlos en la Tabla 4.
4.2.3.3. Calibración del regulador de velocidad.
Para realizar esta calibración debemos actualizar el valor de las constantes de los reguladores PIq y
PId obtenidos anteriormente y compilar el firmware del controlador sin definir la directiva
CALIBRATION. Después, programaremos el controlador. En este caso también aplicaremos el
método que propone ST Microelectronics.
En primer lugar, estableceremos unos valores bajos de Kp y Ki. Obtendremos una respuesta lenta y
con muchas oscilaciones, como observamos en la Ilustración 81:
76
Ilustración 81: Velocidad del motor (en verde) con Kp = Ki = 100.
Aumentaremos Ki hasta obtener un sobreimpulso al alcanzar la velocidad de consigna. En este punto,

aumentaremos Kp hasta que desaparezca el sobreimpulso. Si aumentamos demasiado el valor de las
constantes, se producirán muchas oscilaciones:
Ilustración 82: Velocidad del motor (en verde) con Kp = 5000 y Ki =25000
Los valores con los que mejores resultados se han obtenido son: Kp = 3500 y Ki = 20000. Esta
respuesta se muestra en la Ilustración 83.
Ilustración 83: Velocidad del motor (en verde) con Kp = 3500 y Ki = 20000 (valores finales).
77
En la respuesta obtenida con los valores resultantes de la calibración del regulador de velocidad aún
se observan oscilaciones. Estas también pueden deberse a efectos mecánicos, tales como la fricción
entre las piezas del módulo de visión, ya que vemos que depende del instante de tiempo (y por tanto,
de la posición) en el que nos encontremos.
4.2.3.4. Calibración del regulador de posición.
Para realizar esta calibración, actualizaremos el valor de las constantes Kp y Ki del regulador de
velocidad y compilaremos el firmware del controlador sin activar la directiva CALIBRATION. En
este caso utilizaremos el método recomendado por ST Microelectronics en su documento AN5464
[10]:
 Programaremos todas las constantes del regulador de posición a 0.
 Aumentar Kp hasta que el motor comience a oscilar. Este efecto podemos verlo si ordenamos
un cambio de posición.
 Aumentar Kd hasta que deje de oscilar.
 Repetir estos pasos hasta que Kd no haga desaparecer las oscilaciones.
 Aumentar Ki hasta obtener la respuesta deseada. Si este valor es demasiado bajo, la respuesta
será demasiado lenta y, si es demasiado alto, se producirá un sobreimpulso al alcanzar la
posición objetivo.
Ilustración 84: Respuesta con los valores resultantes de la calibración: Kp = 2000, Ki = 300 y Kd = 200.
A modo de resumen final, en la Tabla 4 se muestran los valores de cada una de las constantes de los
reguladores PID calibrados:
Valores para el regulador de corriente. Driver LP y Vishan ECG2240 Pan
Kp 3800
PI de Iq e Id
Ki 3700
Kp 3500
PI de velocidad
Ki 20000
Kp 2000
PID de posición Ki 300
Kd 200
Tabla 4: Valores de las constantes de los PIDs resultantes de la calibración.

78
4.3. Modificaciones en la lectura de la tensión de alimentación del

controlador.
Dado que los controladores de los motores del robot están conectados directamente a la batería, uno
de ellos será el encargado de leer la tensión que entrega y enviarla al software de control del robot
para determinar la autonomía restante. Para ello, será necesario modificar el firmware generado a
partir de las herramientas de ST Microelectronics para que esta medida de tensión tenga una
resolución de milivoltios.
Como ya estudiamos en el apartado 3.2, para poder leer la tensión de entrada al controlador se utiliza
un divisor resistivo, el cual atenúa la tensión de alimentación hasta un valor que pueda ser leído por
el canal 4 del ADC del microcontrolador. El controlador debe recibir un comando GET_REG con el
código del registro que almacena este dato (0x19). Al recibir este comando, se llama a la función
VBS_GetAvBusVoltage_V, codificada en el fichero bus_voltage_sensor.c:
__weak uint16_t VBS_GetAvBusVoltage_V( BusVoltageSensor_Handle_t * pHandle )

{
uint32_t temp;
temp = ( uint32_t )( pHandle->AvBusVoltage_d );

temp *= pHandle->ConversionFactor;
temp /= 65536u;
return ( ( uint16_t )temp );

}
En primer lugar, a la variable temp se le asigna el valor de pHandle->AvBusVoltage_d. Según los

comentarios del código, este valor es el último promedio de la tensión de alimentación, expresado en
lo que llaman u16Volt. Este dato se corresponde con el promedio de los códigos digitales devueltos
por el ADC y almacenado en una variable del tipo uint16_t.
Para obtener voltios reales a partir del código digital, éste se multiplica por la variable
ConversionFactor, que se define como:
𝑉𝑀𝐶𝑈
𝐶𝑜𝑛𝑣𝑒𝑟𝑠𝑖𝑜𝑛 𝐹𝑎𝑐𝑡𝑜𝑟 =
𝑎𝑡𝑒𝑛𝑢𝑎𝑐𝑖ó𝑛 𝑑𝑖𝑣𝑖𝑠𝑜𝑟
Obteniéndose la siguiente ecuación, implementada en la función VBS_GetAvBusVoltage_V:
𝑐ó𝑑𝑖𝑔𝑜 𝑑𝑖𝑔𝑖𝑡𝑎𝑙(𝑢16𝑉𝑜𝑙𝑡) ∗ 𝐶𝑜𝑛𝑣𝑒𝑟𝑠𝑖𝑜𝑛 𝐹𝑎𝑐𝑡𝑜𝑟

𝑡𝑒𝑛𝑠𝑖ó𝑛 (𝑉) =
65536
Así, si a VMCU le asignamos el valor de la tensión de alimentación del microcontrolador en milivoltios

(3300 mV), la tensión obtenida también vendrá dada en milivoltios. También se podría haber
multiplicado el factor de conversión por 1000, pero con el fin de mantener las mismas unidades de
tensión en todo el firmware, se optó por modificar el valor de VMCU y modificar el resto de parámetros
de las operaciones en las que intervienen. Los cambios que se han debido realizar han sido:
79
 Fichero paramaters_conversion.h:
o ADC_REFERENCE_VOLTAGE: 3.30 -> 3300.0 (VMCU)
o Cambiar el tipo de dato con el que se hace casting en la constante
OVERVOLTAGE_THRESHOLD_d. Pasamos de uint16_t a uint32_t para evitar que se
produzca overflow.
 Fichero drive_parameters.h:
o OV_VOLTAGE_THRESHOLD_V: 35 -> (uint32_t) 35000 (tensión de disparo de la
protección por sobretensión, en mV).
o UD_VOLTAGE_THRESHOLD_V: 22 -> (uint32_t) 22000 (tensión mínima de
alimentación, en mV).
 Fichero power_stage_parameters.h:
o dV_dT: 0.023 -> 23.0
o VO_V: 1.055 -> 1055.0
4.4. Cálculo de la trayectoria en los cambios de posición.

Una de las tareas que debe realizar el firmware de control es programar la trayectoria que seguirá el
rotor del motor ante una consigna de posición. Esto implica calcular diferentes periodos de tiempo y
los valores de los parámetros del movimiento (aceleración, velocidad, etcétera) en esos periodos, en
función del tipo de trayectoria que queremos describir.
Definiremos como trayectoria al conjunto de valores a lo largo del tiempo que debe alcanzar
cualquiera de los parámetros del movimiento: la posición, la velocidad, la aceleración y el jerk. El
firmware STM32 MC SDK programa una trayectoria de la velocidad de tipo S-Curve en base a la
nueva posición y la duración del movimiento que el usuario indica, tal y como se explica en la nota
de aplicación AN5464 de ST Microelectronics.
Ilustración 85: Perfil del jerk y la aceleración calculados por el firmware STM32 MC SDK.
Esta trayectoria S-Curve tiene por objetivo obtener un perfil de aceleración trapezoidal, definiendo
un jerk constante en cada uno de los intervalos del movimiento. De esta forma se consigue minimizar
el estrés mecánico que sufriría el motor en caso de que el perfil de la aceleración fuese escalonado
pues esto implicaría cambios instantáneos en la aceleración (que, en la realidad, son imposibles de
conseguir).
80
Ilustración 86: Comparación entre un perfil de velocidad trapezoidal y uno S-Curve.
ST explica que, para facilitar los cálculos, aproxima la duración de las tres fases del movimiento
(aceleración, velocidad de crucero y deceleración) al mismo valor. Esto provoca que, ante cambios
grandes de posición (más o menos, a partir de 100 grados), la aceleración y deceleración del motor
sea demasiado lenta, ya que crece la duración de las fases (debido al aumento de la duración de
velocidad constante).
Para conseguir una respuesta más rápida, modificaremos el firmware del controlador para que se
calcule la duración mínima de cada una de las fases del movimiento en función únicamente del
desplazamiento ordenado.
4.4.1. Definición de los parámetros del movimiento.

En primer lugar, definiremos los parámetros que necesitamos para manejar y definir una trayectoria
S-Curve de velocidad. Éstos son:
 Jerk (J): matemáticamente, se define el jerk como la derivada de la aceleración. Es decir,
indica la variación de aceleración producida en un intervalo de tiempo. Su definición resulta
imprescindible en un movimiento que no está uniformemente acelerado, como es el caso de
una trayectoria S-Curve:
da(t)
J=
dt
En el tipo de trayectoria que queremos definir, el jerk tendrá un valor constante. Este valor
será determinado de forma experimental, realizando pruebas de movimiento del motor con
diferentes valores de jerk. Aunque como veremos más adelante, su valor puede conllevar
ciertas limitaciones.
 Aceleración (a): definimos la aceleración como la variación de la velocidad respecto del
tiempo:
dv(t)
a(t) =
dt
 Velocidad (v): se define como la variación de la posición con respecto al tiempo:
ds(t)
v(t) =
dt
 Posición (s): en nuestro caso, se refiere a la posición angular del rotor en un determinado
instante de tiempo. Es el parámetro final a controlar en cualquier movimiento.
81
Todos los parámetros definidos se tratan de magnitudes angulares, ya que el desplazamiento que
realiza el rotor del motor es angular. A lo largo de este apartado, mencionaremos a todos estos
parámetros sin la connotación de angular.
En cuanto a las fases de la trayectoria, ya hemos distinguido tres grandes intervalos, los cuales se
corresponden con los definidos en la AN5464 [10] de ST: aceleración, velocidad de crucero y
deceleración.
Además, dentro de las fases de aceleración y deceleración, distinguiremos tres sub-intervalos, entre
los que cambiará el valor del jerk. Para entenderlo mejor, nos fijaremos en la Ilustración 87, la cual
muestra las gráficas descritas por los cuatro parámetros del movimiento en una trayectoria de
velocidad S-Curve:
Ilustración 87: Perfil del jerk, la aceleración, la velocidad y la posición en una trayectoria S-Curve.
 La fase de aceleración estaría comprendida entre los instantes t0 y t3. En ella, vemos como la
aceleración describe un perfil trapezoidal y se alcanza la velocidad de crucero:
o El intervalo de tiempo entre t0 y t1 se corresponde con la fase en la que la aceleración

pasa de 0 (su valor inicial) a un valor constante.
o El intervalo entre t1 y t2 se corresponde con la fase en la que la aceleración es constante.
o Finalmente, en el intervalo entre t2 y t3 la aceleración pasará de su valor máximo hasta
cero, para entrar en la fase de velocidad de crucero.
 La fase de velocidad de crucero se encuentra comprendida entre t3 y t4 y en ella, el valor de

la velocidad será constante. Lo ideal sería que la velocidad de crucero se correspondiese con
la velocidad máxima del motor. La duración de esta fase dependerá del desplazamiento que
se deba realizar: a mayor desplazamiento, más larga será la fase de velocidad de crucero.
 Finalmente, en la fase de deceleración la velocidad pasará de su valor máximo hasta cero.

Se divide en los mismos sub-intervalos que la fase de aceleración y la gráfica descrita por la
aceleración será la misma, solo que con signo invertido:
o El intervalo de tiempo entre t4 y t5 se corresponde con la fase en la que la aceleración

pasa de 0 a la aceleración máxima del motor, pero con signo negativo, con el fin de
detener el motor.
o El intervalo entre t5 y t6 se corresponde con la fase en la que la deceleración es máxima.
o Finalmente, en el intervalo entre t6 y t7 la aceleración pasará a ser cero, al igual que la
velocidad del motor llegando al final del movimiento.
82
Así, la tarea del firmware será calcular cada uno de estos intervalos de tiempo y asignar el valor
correcto al jerk en cada intervalo en función del desplazamiento de consigna. La aceleración, la
velocidad y la posición serán calculadas en cada instante en función del valor del jerk.
Sólo aplicaremos nuestra trayectoria en los desplazamientos que sean suficientemente largos. En
concreto, solo será aplicada cuando la consigna de desplazamiento sea mayor a un valor de
desplazamiento que haga que la fase de velocidad de crucero tenga duración nula. A este
desplazamiento le denominaremos desplazamiento crítico.
4.4.2. Cálculo de las ecuaciones del movimiento.
En la AN5464 [10] de ST podemos encontrar las ecuaciones de las leyes del movimiento que rigen en
este tipo de trayectoria. De forma general y a partir de las definiciones de los parámetros del
movimiento, podemos afirmar que:
𝑗 = 𝑐𝑡𝑒
𝑎(𝑡) = ∫ 𝑗 ∗ 𝑑𝑡 = 𝑗 ∗ 𝑡 + 𝑎0
𝑗 ∗ 𝑡2
𝑣(𝑡) = ∫ 𝑎(𝑡) ∗ 𝑑𝑡 = + 𝑎0 ∗ 𝑡 + 𝑣0
2
j ∗ t 3 a0 ∗ t 2
s(t) = ∫ v(t) ∗ dt = + + v0 ∗ t + s0
6 2
Ahora particularizaremos estas ecuaciones para cada uno de los sub-intervalos analizados
anteriormente partiendo de una condición de inicial de reposo:
 Primer sub-intervalo (𝑡0 < 𝑡 < 𝑡1 ): como podemos observar en la Ilustración 87, en este
intervalo el jerk tendrá un valor constante distinto de 0. Las condiciones iniciales son:
j11 = J; a0 = 0; v0 = 0; s0 = 0
Si sustituimos en las ecuaciones que definen el movimiento, tendremos:
t=t1
a11 (t) = j11 ∗ t → a11 = J ∗ t1
j11 ∗ t 2 t=t1 J ∗ t1 2
v11 (t) = → v11 =
2 2
3 t=t
j11 ∗ t 1 J ∗ t1 3
s11 (t) = → s11 =
6 6
Además, en la Ilustración 87 podemos ver que durante 𝑡0 < 𝑡 < 𝑡1 , la aceleración tiene una
pendiente constante que se corresponde con el jerk:
da(t) A − a0 A A
j= →J= = → t1 =
dt t1 − t 0 t1 J
Donde A es el valor de la aceleración en su fase constante. Sustituyendo esta ecuación, durante
este intervalo se cumple que:
a11 = A
A2
v11 =
2∗J
83
J ∗ t1 3
s11 =
6
 Segundo sub-intervalo (𝑡1 < 𝑡 < 𝑡2 ): en esta fase la aceleración tendrá un valor constante, A.
Por tanto, en este intervalo se describe un MUA (Movimiento uniformemente acelerado). Esto
se debe a que el valor del jerk en esta fase es nulo. Si sustituimos en las ecuaciones generales,
obtenemos:
j12 = 0
𝑎12 (𝑡) = 𝐴
𝑣12 (𝑡) = 𝐴 ∗ 𝑡 + 𝑣11
𝐴 ∗ 𝑡2 𝐴 ∗ 𝑡2
𝑠12 (𝑡) = + 𝑣0 ∗ 𝑡 + 𝑠0 → 𝑠12 (𝑡) = + 𝑣11 ∗ 𝑡
2 2
Durante este intervalo, se cumple que:

𝑎12 = 𝐴
A2
𝑣12 = 𝐴 ∗ 𝑡2 +
2∗J
𝐴 ∗ 𝑡2 2 A2
𝑠12 = + ∗ 𝑡2
2 2J
 Tercer sub-intervalo (𝑡2 < 𝑡 < 𝑡3 ): las ecuaciones de esta fase serán iguales que las del primer
sub-intervalo, solo que el jerk tendrá valor negativo y los valores iniciales de la aceleración,
la velocidad y la posición son distintos de cero. Además, la duración de este sub-intervalo será
la misma que la del primero (es decir, igual a t1):
j13 = −J
𝑎13 (𝑡) = j13 ∗ 𝑡 + 𝑎0 → 𝑎13 (𝑡) = −𝐽 ∗ 𝑡 + 𝐴
j13 ∗ 𝑡 2 −𝐽 ∗ 𝑡 2
𝑣13 (𝑡) = + 𝑎0 ∗ 𝑡 + 𝑣0 → 𝑣13 (𝑡) = + 𝐴 ∗ 𝑡 + 𝑣12
2 2
𝑡3 𝑡2 𝑡3 𝑡2
𝑠13 (𝑡) = j13 ∗ + 𝑎0 ∗ + 𝑣0 ∗ 𝑡 → 𝑠13 (𝑡) = −𝐽 ∗ + 𝐴 ∗ + 𝑣12 ∗ 𝑡
6 2 6 2
Con este intervalo, habrá finalizado la fase de aceleración y los parámetros del movimiento
tendrán el siguiente valor:
𝑎13 = −𝐽 ∗ 𝑡1 + 𝐴
−𝐽 ∗ 𝑡1 2
𝑣13 = 𝑉 = + 𝐴 ∗ 𝑡1 + 𝑣12
2
𝑡3 𝑡1 2
𝑠13 = −𝐽 ∗ + 𝐴 ∗ + 𝑣12 ∗ 𝑡1
6 2
Ahora, buscaremos una expresión de la posición final alcanzada tras la fase de aceleración.
Para ello, primero conviene obtener una expresión simplificada de V:
−𝐽 ∗ 𝑡1 2 −𝐽 ∗ 𝑡1 2 A2
𝑉= + 𝐴 ∗ 𝑡1 + 𝑣12 → 𝑉 = + 𝐴 ∗ 𝑡1 + 𝐴 ∗ 𝑡2 +
2 2 2∗J
84
A
Sustituimos por t1 = J :
A2 𝐴2 A2 𝐴
𝑉=− + + 𝐴 ∗ 𝑡2 + → 𝑉 = 𝐴 ∗ ( + 𝑡2 )
2∗J 𝐽 2∗J 𝐽
𝑉 = 𝐴 ∗ (𝑡1 + 𝑡2 )
A partir de esta expresión podemos calcular t2:
𝑉 𝑉 𝐴
𝑡2 = − 𝑡1 = −
𝐴 𝐴 𝐽
 Fase de aceleración (𝑡0 < 𝑡 < 𝑡3 ): La posición final alcanzada tras la fase de aceleración
será:
𝑠1 = 𝑠11 + 𝑠12 + 𝑠13
J ∗ t1 3 𝐴 ∗ 𝑡2 2 A2 𝑡3 𝑡1 2
𝑠1 = + + ∗𝑡 −𝐽∗ +𝐴∗ + 𝑣12 ∗ 𝑡1
6 2 2∗J 2 6 2
Podemos expresar v12 como la velocidad de crucero menos el incremento de la velocidad

producido en el tercer sub-intervalo de la fase de aceleración:
2
𝐴2
𝑣12 = 𝑉 − 𝑗 ∗ 𝑡1 =𝑉−
2∗𝐽
Si sustituimos en la ecuación de s1:
J ∗ t1 3 𝑡2 2 A2 𝑡3 𝑡1 2 𝐴2
𝑠1 = +𝐴∗ + ∗ 𝑡2 − 𝐽 ∗ + 𝐴 ∗ + (𝑉 − ) ∗ 𝑡1
6 2 2∗J 6 2 2∗𝐽
𝐴 A2
𝑠1 = ∗ (𝑡1 2 +𝑡2 2 ) + ∗ (𝑡2 − 𝑡1 ) + 𝑉 ∗ 𝑡1
2 2∗J
Sustituyendo las expresiones de t1 y t2 obtenemos:
𝑉 𝑉 𝐴
𝑠1 = ∗( + )
2 𝐴 𝐽
 Fase de velocidad de crucero (𝑡3 < 𝑡 < 𝑡4 ): durante esta fase el motor se moverá a
velocidad constante. Por tanto, estamos ante un movimiento uniforme, en el que los
parámetros del movimiento toman los siguientes valores:
𝑗=0
𝑎=0
𝑣=𝑉
𝑠2 = 𝑉 ∗ 𝑡3
85
 Fase de deceleración (𝑡4 < 𝑡 < 𝑡7 ): los sub-intervalos en los que se divide esta fase son
iguales a los de la fase de aceleración, al igual que todos los parámetros del movimiento,
solo que su signo está invertido y la velocidad inicial del movimiento no es nula. En este
caso será V. Por tanto, podemos afirmar que la variación de posición durante la fase de
desaceleración será igual a la variación de la posición en la fase de aceleración. Esto
significa que:
𝑉 𝑉 𝐴
𝑠3 = 𝑠1 = ∗( + )
2 𝐴 𝐽
 Desplazamiento global (𝑡0 < 𝑡 < 𝑡7 ): la variación de la posición total será conocida y puede
expresarse como:
𝑠1 =𝑠3
𝑠 = 𝑠1 + 𝑠2 + 𝑠3 → 𝑠 = 2 ∗ 𝑠1 + 𝑠2
A partir de esta expresión, podremos calcular t3, que es el último parámetro que nos queda por
conocer para poder implementar la trayectoria S-Curve:
𝑠2 = 𝑉 ∗ 𝑡3 = 𝑠 − 2 ∗ 𝑠1
𝑉 𝑉 𝐴
𝑆 − 2 ∗ ( 2 ∗ (𝐴 + 𝐽 ))
𝑠 − 2 ∗ 𝑠1
𝑡3 = =
𝑉 𝑉
𝑆 𝑉 𝐴
𝑡3 = − −
𝑉 𝐴 𝐽
Como conclusión, diremos que:
 El desplazamiento crítico será aquel que haga que t3 sea 0:
𝑆 𝑉 𝐴 𝑡3 =0 𝑉 𝐴
𝑡3 = − − → 𝑆𝑐𝑟í𝑡𝑖𝑐𝑜 = 𝑉 ∗ ( + )
𝑉 𝐴 𝐽 𝐴 𝐽
 Los parámetros J, A y V serán constantes. Para determinarlos, primero fijaremos V y A.

Después, ajustaremos A para cumplir el requisito del desplazamiento crítico. Este valor de A
devolverá un valor mínimo de J.
 t1 y t2 tendrán siempre el mismo valor, independientemente del cambio de posición ordenado.
Así, mientras que el desplazamiento sea superior al desplazamiento crítico, el único tiempo
que variará será el de la fase de velocidad de crucero, t3.
 A continuación, se presenta una tabla con los resultados más importantes:
86
Tiempo del primer y tercer sub-intervalo. A

t1 =
Aceleración y desaceleración. J
Tiempo del segundo sub-intervalo 𝑉 𝐴

𝑡2 = −
(aceleración constante). 𝐴 𝐽
𝑆 𝑉 𝐴
Tiempo de velocidad de crucero. 𝑡3 = − −
𝑉 𝐴 𝐽
Cambio de posición en fase de 𝑉 𝑉 𝐴

𝑠1 = 𝑠3 = ∗( + )
aceleración o desaceleración. 2 𝐴 𝐽
Cambio de posición en fase de velocidad

𝑠2 = 𝑉 ∗ 𝑡3
de crucero.
𝑉 𝐴
Desplazamiento crítico 𝑉∗( + )
𝐴 𝐽
Tabla 5: Ecuaciones principales de la trayectoria S-Curve implementada.
87
4.4.3. Implementación en el firmware del controlador.

Una vez calculadas todas las ecuaciones, debemos implementarlas en el firmware del controlador.
Todo el código relacionado con el cálculo y la ejecución de la trayectoria está codificado en el fichero
trajectory_ctrl.c. Este fichero forma parte del Middleware del SDK, y se encuentra en el directorio
Middlewares/MotorControl.
Dentro de este fichero, los tiempos y valores de los parámetros del movimiento se calculan en la
función TC_MoveCommand. Nuestro algoritmo calculará el desplazamiento crítico en función de los
valores de las constantes J, A y V y lo compararemos con la consigna de desplazamiento. Si la
consigna es mayor al desplazamiento crítico, implementaremos nuestra trayectoria S-Curve. De lo
contrario, se calculará y ejecutará la trayectoria implementada por ST Microelectronics.
El primer detalle a tener en cuenta es la cuantización de los subintervalos con respecto a un tiempo
de muestreo. Esto se debe a que, en el código original de ST, se dice que la duración de cada
subintervalo debe ser un múltiplo entero del valor Sampling Time:
// WARNING: Movement duration value is rounded to the nearest valid value
// [(DeltaT/9) / SamplingTime]: shall be an integer value
Donde DeltaT/9 se corresponde que la duración de los subintervalos. En nuestro caso, esto se traduce
en que t1, t2 y t3 deben ser múltiplos enteros de Sampling Time. Para conseguirlo, dividimos el valor
de t1, t2 y t3 devueltos por las ecuaciones entre ese tiempo y hacemos un casting del resultado a tipo
int y redondeamos al entero superior. Por ejemplo, con t1:
t1 = (float) ((int)(Amax/Jmax/ samplingTime) + 1) * samplingTime;
Con estos nuevos tiempos, que son los que realmente se aplicarán en la trayectoria, debemos
recalcular los valores reales de J, A y V que se aplicarán mediante las siguientes ecuaciones obtenidas
a partir de las de la
Tabla 5:
S
V=
t 3 + t 2 + 2 ∗ t1
V
A=
t 2 + t1
A
J=
t1
Se ha tratado de mantener, en la medida de lo posible, la misma estructura que en el código original
de ST. Por ello, para asignarle la duración a cada subintervalo, se mantiene la asignación de valores
a los elementos del array SubStep [0]. En cada elemento del array debemos almacenar el tiempo total
acumulado del movimiento. Por ejemplo, la fase de aceleración quedaría definida así:
pHandle->SubStep[0] = t1; /*Time at the Sub-step 1 of acceleration phase*/

pHandle->SubStep[1] = (t1 + t2); /*Time at the Sub-step 2 of acceleration phase. */
pHandle->SubStep[2] = (2*t1 + t2) /*Time at the Sub-step 3 of acceleration phase. */
88
Finalmente, se calcula el tiempo total del movimiento:

pHandle->MovementDuration = (float) (4*t1 + 2*t2 + t3);
4.4.4. Determinación de los valores máximos del jerk, la aceleración y la

velocidad.
El primer parámetro que ajustaremos será V. En primer lugar, le asignaremos el valor de velocidad
máxima que se calculó en el perfil del motor con ST Motor Profiler: 12162 rpm. Pero al realizar
pruebas con tensiones de alimentación de 24 V (próxima a la tensión mínima entregada por la batería),
se observó que el valor máximo de velocidad alcanzado es aproximadamente 8000 rpm. Finalmente
aplicaremos una velocidad máxima de 7500 rpm. El valor de estas constantes en el firmware debe
darse en rad/s (V), rad/s2 (A)y rad/s3 (J). Por tanto, V quedará definido como:
#define S_Curve_TRAJECTORY_VMAX 785
En cuanto al valor de máximo de A, se han realizado varias pruebas con distintos valores, llegando a
la conclusión de que es factible alcanzar una aceleración de 5000 rad/s2:
#define S_Curve_TRAJECTORY_AMAX 5000
Finalmente, aplicamos el valor de jerk mínimo necesario para que los tiempos de los subintervalos
sean lo suficientemente grandes para que el módulo de visión alcance las posiciones calculadas. Este
valor es de 32000 rad/s3:
#define S_Curve_TRAJECTORY_JMAX 32000
El valor de jerk mínimo es el que hace que t2 sea cero. A partir de la ecuación para calcular t2,
obtenemos:
𝐴2
𝐽>
𝑉
Con estos valores, el desplazamiento crítico que resulta es de:
𝑉 𝐴 7852 5000
𝑆𝑐𝑟𝑖𝑡𝑖𝑐𝑜 =𝑉∗( + )= + 785 ∗ = 245,9 𝑟𝑎𝑑
𝐴 𝐽 5000 32000
𝑆𝑐𝑟𝑖𝑡𝑖𝑐𝑜 245,9 180
Scritico salida = = = 1,32 𝑟𝑎𝑑 ∗ = 76 𝑔𝑟𝑎𝑑𝑜𝑠
𝐼_𝑟𝑒𝑑𝑢𝑐𝑡𝑜𝑟𝑎 185,3 𝜋
Ilustración 88: Desplazamiento de 300 grados con la trayectoria de ST.

89
Ilustración 89: Desplazamiento de 300 grados con nuestra trayectoria.
Comparando la Ilustración 89 con la Ilustración 88, vemos que el tiempo del desplazamiento es
bastante inferior (13 periodos de muestreo16 frente a 27, aproximadamente) gracias a la
implementación de los cálculos que hemos realizado.
Ilustración 90: Velocidad descrita ante un desplazamiento de 300 grados con la trayectoria de ST.
16
El eje horizontal de las gráficas del programa de control representa el número de muestras tomadas, no tiempo. Estas
muestras se toman con un periodo constante.
90
Ilustración 91: Velocidad ante un desplazamiento de 300 grados con nuestra trayectoria.
Además, si analizamos la Ilustración 90, veremos que la duración de las tres fases del movimiento es
la misma (8 periodos de muestreo, aproximadamente) y que no se supera una velocidad de 4000 rpm.
Por el contrario, en Ilustración 91 vemos como la fase de velocidad de crucero es claramente más
duradera que las fases de aceleración y desaceleración, alcanzándose la velocidad de 7500 rpm.
En conclusión, podemos afirmar que el cálculo de las ecuaciones de la nueva trayectoria y su
implementación en el firmware han sido satisfactorias, ya que se consigue disminuir
considerablemente el tiempo de los desplazamientos del módulo de visión del robot. Esto puede
suponer un factor clave en muchas de las tareas que requiera el robot como, por ejemplo, la detección
de intrusos.
4.5. Pruebas para la validación del controlador.

Finalmente agruparemos todas las pruebas que han sido realizadas a lo largo del proyecto y que nos
permiten validar y verificar el correcto funcionamiento del controlador para motores BLDC diseñado
y de esta forma, poder ser montado en el módulo de visión del robot:
 Alimentación de la tarjeta: cuando se quieran realizar pruebas con un controlador que no esté
montado en el robot, se debe alimentar a 30V. Si todo es correcto, deberá iluminarse el LED
rojo LD2. Si el controlador está montado en el robot y éste está encendido, el resultado debe
ser el mismo.
 Programación del controlador: para programar el controlador a través de la interfaz SWD,
debemos utilizar el programador ST-LINK/V2 y la herramienta ST-LINK Utility. Si la
programación ha sido correcta, deberá encender el LED verde LD1. Este encendido se
programa en el firmware nada más comenzar la ejecución.
91
Ilustración 92: Controlador alimentado y programado correctamente.
 Comunicación por bus CAN: La prueba consiste en enviar una consigna de velocidad al motor
y comprobar su respuesta. Esta consigna de velocidad será baja (por ejemplo, 500 rpm). Tras
conectar las fases del motor y sus sensores Hall en el conector J5, el encóder en el conector
J3 y la tarjeta interfaz CAN en el conector J1 o J2 (ver Ilustración 78) el controlador estará
listo para funcionar. Debemos verificar que la resistencia de terminación del bus CAN esté
conectada (para eso, el microinterruptor 8 debe estar en la posición ON).
Para gobernar el controlador, abriremos el programa de control. Si enviamos el comando
START MOTOR, el motor debería comenzar a moverse. Para pararlo, enviaremos el comando
STOP MOTOR.
Puede que en el inicio se active algún flag de error. Para que el motor funcione, habrá que
enviar el comando FAULT ACK y verificar que el registro Flags está a 0.
 Medida de la velocidad: al igual que en el punto anterior, enviaremos una consigna de
velocidad baja y enviaremos el comando STAR MOTOR. Para comprobar que la velocidad
medida concuerda con la real contaremos el número de vueltas que da el rotor en un minuto.
Si consideramos la relación de la reductora del motor (en el caso del Vishan EC2240-3016,
es de 185,3) deberíamos obtener el mismo valor que el que se almacena en el registro Current
Speed.
𝑣𝑒𝑙𝑜𝑐𝑖𝑑𝑎𝑑𝑚𝑜𝑡𝑜𝑟
𝑣𝑒𝑙𝑜𝑐𝑖𝑑𝑎𝑑𝑠𝑎𝑙𝑖𝑑𝑎 =
𝐼𝑟𝑒𝑑𝑢𝑐𝑡𝑜𝑟𝑎
 Control de posición: otra de las modificaciones realizadas en el firmware del controlador fue
la de introducir la consigna de desplazamiento en grados a la salida de la reductora. Por ello,
para comprobar que el control de posición es correcto, solo tendremos que escribir la consigna
de desplazamiento, en grados, en el registro Target Position y ejecutar el comando START
MOTOR.
El firmware está programado para realizar un homing17 cada vez que entra en el modo de
control de posición (este instante coincide con la recepción de la primera consigna de
posición). Si enviamos una nueva consigna de desplazamiento (sin haber parado el motor), el
rotor debe moverse hasta la posición deseada. Para comprobarlo, debemos observar el valor
del registro Current Position y medir el desplazamiento producido.
17
El homing consiste en la búsqueda de la posición de origen. Para encontrarla, el controlador comienza a mover el motor
hasta que se alcanza algún tope mecánico. En este instante, el controlador aumenta la corriente aplicada sobre el motor
hasta un límite programado. Cuando se sobrepasa ese límite sin que el motor se mueva, se considera que se ha encontrado
la posición de origen. Esta posición de origen está programada como 90º.
92
 Protecciones frente a tensiones de alimentación inadecuadas: los límites de tensión

programados en el controlador se encuentran en 25V y 32V. El límite de tensión máxima es
inferior a la máxima tensión soportada por el controlador (impuesta por los 36 V de entrada
máximos del convertidor DC/DC), por lo que no deben generarse problemas al comprobar
estas protecciones.
En la aplicación de control, configuraremos la lectura de los registros Bus Voltage y Flags y
primero comprobaremos la protección frente a una tensión demasiado baja. Para ello,
disminuimos la tensión de la fuente de alimentación lentamente hasta un valor por debajo de
22V. A continuación, se pueden ver todos los posibles flags de error. Como vemos, el error
de Undervotlage es el número 4:
#define MC_NO_ERROR (uint16_t)(0x0000u) /**< No error.*/

#define MC_NO_FAULTS (uint16_t)(0x0000u) /**< No error.*/
#define MC_FOC_DURATION (uint16_t)(0x0001u) /**< Error: FOC rate to high.*/
#define MC_OVER_VOLT (uint16_t)(0x0002u) /**< Error: Software over voltage*/
#define MC_UNDER_VOLT (uint16_t)(0x0004u) /**< Error: Software under voltage.*/
#define MC_OVER_TEMP (uint16_t)(0x0008u) /**< Error: Software over temperature.*/
#define MC_START_UP (uint16_t)(0x0010u) /**< Error: Startup failed.*/
#define MC_SPEED_FDBK (uint16_t)(0x0020u) /**< Error: Speed feedback.*/
#define MC_BREAK_IN (uint16_t)(0x0040u) /**< Error: Emergency input Ov.current).*/
#define MC_SW_ERROR (uint16_t)(0x0080u) /**< Software Error.*/
Ilustración 93: Lectura de la tensión del bus y del flag 4 (Undervoltage).
Para comprobar la protección frente a Overvoltage, debemos configurar la tensión de alimentación a

un valor dentro del rango válido y enviar el comando FAULT ACK (para reconocer el error de
Undervoltage generado anteriormente). Si aumentamos lentamente la tensión de la fuente hasta un
valor cercano y por encima a 32 V deberá observarse el valor 2 en el registro Flags.
Ilustración 94: Lectura de la tensión del bus y del flag 2 (Overvoltage).
Si el desarrollo de estas pruebas es correcto, podemos dar por válido el funcionamiento del
controlador, pudiendo ser montado en el módulo de visión del robot.
93
Capítulo 5
Conclusiones.
El objetivo de este proyecto era diseñar un controlador para motores eléctricos de corriente continua
sin escobillas (BLDC) y de baja potencia, el cual implementase un algoritmo de control FOC. Tras
las pruebas y modificaciones realizadas en el capítulo 4, podemos afirmar que el resultado obtenido
con este diseño cumple las especificaciones que se establecieron en el anteproyecto. A continuación,
mencionaremos las especificaciones más importantes y justificaremos su cumplimiento:
 El driver soportará una tensión de entrada de hasta 36 V: en ningún momento se ha
alimentado el controlador con una tensión superior a los 32 V máximos que entrega la batería
del robot, con el fin de no poner en peligro innecesariamente el hardware. Pero el componente
cuya tensión de entrada máxima es más baja es el convertidor DC/DC, y se sitúa en 36V. Por
ello, consideramos esta restricción como cumplida.
 La PCB debe tener unas dimensiones de, como máximo, 85x35 mm: las dimensiones finales
de la PCB son 83x32 mm, por lo que se cumple esta restricción.
 La PCB debe incluir una interfaz de comunicación CAN para la comunicación con otros
dispositivos del robot: esta funcionalidad ha sido comprobada en múltiples ocasiones a lo
largo de todo el proyecto como, por ejemplo, en el proceso de calibración.
 Tanto el firmware como el hardware debe ser válido para implementar el algoritmo de
control FOC: el software STM32 MC SDK está especialmente diseñado para ejecutar el
algoritmo FOC y ha sido probado con éxito en el controlador diseñado, por lo que podemos
dar por validada esta restricción.
 El sistema debe ser capaz de responder a situaciones de un consumo de corriente excesiva,
temperatura excesiva o tensión de alimentación inadecuada: la única situación que ha sido
comprobada ha sido la de alimentar al controlador con una tensión demasiado baja o alta,
dado que el resto de situaciones ponían en riesgo la integridad del hardware. Pero sí es cierto
que, en alguna ocasión, se ha generado el flag de Over Current, principalmente cuando la
fuente de alimentación ha sido encendida después de conectarla al controlador. Además, esta
es una funcionalidad que ST Microelectronics ofrece por defecto en el software STM32 MC
SDK, por lo que podemos dar por validada esta especificación.
 Debe ser un producto completamente funcional y capaz de integrarse en los robots diseñados
por Star Robotics: el robot que actualmente está siendo desarrollado en la empresa ha
realizado algunas demostraciones ante posibles clientes con los controladores diseñados
incorporados, por lo que podemos afirmar que el controlador es completamente funcional.
Por otra parte, el desarrollo de este controlador ha supuesto un importante avance en la empresa Star
Robotics, ya que se han reducido considerablemente los costes de producción de los robots. Los
detalles del coste de los controladores y el ahorro conseguido se describen en el Anexo I:
Presupuesto .
95
Conclusiones
Finalmente, mencionaremos el aprendizaje y las competencias18 adquiridas durante la realización de

este proyecto. Dado que este proyecto se ha desarrollado en un entorno profesional y trata sobre el
diseño de un equipo electrónico completo y funcional, los conocimientos adquiridos son numerosos
y muy útiles, siendo la culminación perfecta del estudio del grado en Ingeniería Electrónica de
Comunicaciones de la UPM. Las competencias adquiridas más importantes son:
 CG_04: Capacidad de abstracción, de análisis y de síntesis y resolución de problemas.
 CG_05: Capacidad de trabajo en equipo y en entornos multidisciplinares.
 CG_10: Habilidades para manejar especificaciones, reglamentos y normativas y la aplicación
de las mismas en el desarrollo de la profesión.
 CE_EC_03: Capacidad de realizar la especificación, implementación, documentación y
puesta a punto de equipos y sistemas electrónicos, de instrumentación y control, considerando
tanto los aspectos técnicos como las normativas reguladoras correspondientes.
 CE_EC_04: Capacidad para aplicar la electrónica como tecnología de soporte en otros campos
y actividades, y no sólo en el ámbito de las Tecnologías de la Información y las
Comunicaciones.
 CE_EC_06: Capacidad para comprender y utilizar la teoría de realimentación y los sistemas
electrónicos de control.
 CE_PFG: Capacidad de presentar y defender frente a un tribunal Universitario, un trabajo
desarrollado individualmente, consistente en un proyecto profesional en el campo específico
de la Ingeniería Electrónica de Comunicaciones/Telecomunicaciones, que integra y sintetiza
los resultados alcanzados durante el periodo de formación de los estudios.
5.1. Líneas futuras de trabajo.

En las futuras versiones que se diseñen de este controlador es necesario incluir un sensor inercial, que
sea capaz de medir la orientación del controlador. La necesidad de incorporar este sensor reside en la
posible incorporación de estos controladores en un brazo robótico que diseñará Star Robotics en el
próximo año.
La idea es que los controladores que manejen los motores de cada articulación del brazo sean los que
envíen su posición al ordenador central del robot para que éste determine las consignas necesarias
para realizar un determinado movimiento con el brazo. Para poder enviar los mensajes con la posición
a través del bus CAN, el sensor inercial deberá comunicarse con el microcontrolador para que sea
éste quien envíe los mensajes al ordenador central.
Este tipo de sensores suelen contar con una interfaz SPI o I2C integrada. El microcontrolador
STM32L476RG que integra el controlador cuenta con 3 interfaces SPI. Para configurar los pines como
interfaz SPI, debemos seleccionar las Alternative Function AF5 (SPI1, SPI2) y AF6 (SPI3).
Ilustración 95: Funciones alternativas de los pines del microcontrolador STM32L476RG.
18
Estas competencias se corresponden con las descritas en la página web de la ETSIST de la UPM [22].
96
La interfaz SPI debe contar, como mínimo, de tres líneas de datos: MISO (Master In Slave Out),
MOSI (Master Output Slave Input) y SCLK (señal de reloj). La primera de ellas transporta los datos
enviados del Master (en nuestro caso, el microcontrolador) y el Slave (en nuestro caso, el sensor
inercial). Por la línea MISO circulan los datos en sentido contrario (es decir, del Slave al Master) y
por la línea SCLK el Master envía la señal de reloj al Slave.
 En el caso de la interfaz SPI1, la línea MOSI se puede encontrar en los pines PB5 y PA7, los
cuales ya están ocupados en el diseño (en concreto, por las señales ID.5 del bus CAN y
EN.1 del circuito integrado L6230, respectivamente). Por tanto, no podremos utilizar esta
interfaz.
 Los pines en los que se pueden encontrar las líneas MOSI (PB15 y PC3) y MISO (PB14 y
PC2) de la interfaz SPI2 también están ocupadas.
 La interfaz SPI3 sí podría ser utilizada, siguiendo las siguientes conexiones:
Ilustración 96: Asignación de pines a las líneas de la interfaz SPI3 en el microcontrolador STM32L476RG.
Ilustración 97: Pines PC10, PC11 y PC12 en los esquemáticos del controlador.
Según vemos en la Ilustración 95, estos pines deberán ser configurados en la función alternativa 6
(AF6). Sí es cierto que el pin asignado a la señal de habilitación del esclavo (nSS) ya está ocupado
en nuestro diseño. Dado que esta señal es activa a nivel bajo, el pin nSS del sensor inercial deberá
ser conectado a masa.
El microcontrolador también cuenta con 3 interfaces I2C, disponibles si los pines necesarios son
configurados en la función alternativa 4 (ver Ilustración 95). Este tipo de interfaz se compone de
como mínimo 2 líneas: SDA (por la que se transmiten los datos) y SCL (por la que se transmite la
señal de reloj). Al igual que el bus SPI, se trata de una comunicación del tipo Master-Slave.
Realizando un análisis de los pines disponibles similar al realizado con las interfaces SPI, se observa
que tan solo es posible utilizar la interfaz I2C2 del microcontrolador, ya que es la única que puede
encontrarse en los pines disponibles. Éstos pueden verse en la Ilustración 98:
97
Conclusiones
Ilustración 98: Asignación de pines a las líneas de la interfaz I2C2 en el microcontrolador STM32L476RG.
Finalmente, vemos que contamos con dos posibilidades para conectar un sensor inercial: utilizar la
interfaz SPI3 o la interfaz I2C2 del microcontrolador STM32L476RG. Sería preferible utilizar la
interfaz SPI, ya que la velocidad de transmisión es considerablemente superior. Mientras que en a
través del bus I2C pueden transmitirse datos a una velocidad de hasta 5 Mbps (en el modo Ultra
Fast), el bus SPI no define una velocidad máxima de transmisión y pueden establecerse
comunicaciones de 10 Mbps o más.
Esta velocidad de transmisión determinará en cierta medida la frecuencia con la que el ordenador
central del robot puede recibir los datos de la posición de las articulaciones del brazo, lo que puede
afectar a los cálculos del movimiento.
Durante este Proyecto Fin de Grado se ha conseguido el gran avance de diseñar un controlador de
motores BLDC de bajo coste, lo cual es ventajoso tanto para la empresa Star Robotics como para el
sector de la robótica en general. Esto se debe a que el precio final del robot se reducirá, haciendo que
crezca el alcance del producto y el número de robots desplegados, contribuyendo al desarrollo de la
Industria 4.0 tanto nuestro país como en el extranjero.
98
ANEXOS
Anexo I: Presupuesto.
Uno de los requisitos más importantes que debía cumplir el controlador diseñado era que su precio
fuese inferior al de la solución que se implementaba en los robots anteriores. Además, nuestro
controlador debe resultar más barato y adaptase mejor al robot que el resto de soluciones que podemos
encontrar actualmente en el mercado. Por ello, tras haber completado todas las etapas del diseño, se
presenta un análisis del coste del proceso de diseño y fabricación de nuestro controlador para motores
BLDC
En el gasto en prototipos, podríamos incluir el coste de las tarjetas de desarrollo NUCLEO-L476RG
y X-NUCLEO-IHM07M1. Éstas pueden encontrarse en Mouser por 12,37€ y 11,01€,
respectivamente.
El coste de fabricación, montaje y envío de 5 PCBs del controlador diseñado es de 902,21 €, tal y
como vemos en la Ilustración 99:
Ilustración 99: Factura de Eurocircuits por la fabricación y montaje de las tarjetas.
Así, podemos determinar el coste de cada controlador en 180,44 €. Este coste unitario se vería
claramente reducido si el número de tarjetas fuese mayor, debido a que el coste de los servicios de
fabricación y montaje se incrementaría muy poco. Por ejemplo, si se solicitase la fabricación y
montaje de 20 paneles (100 tarjetas), obtendríamos los siguientes costes:
Costes para fabricar y montar 100 controladores

Fabricación de las Montaje de los Componentes Envío
PCBs componentes
562 € 1902 € 4113 € 8,75 €
Total
6564,75 €
Tabla 6: despliegue de los costes de fabricación y montaje de 100 PCBs de nuestro controlador.
De esta forma, podríamos establecer el coste de cada controlador en 65,65 €. Si lo comparamos con
el precio de un controlador de motores BLDC comercial de características similares como el EPOS 2
P de Maxon (373 € si se piden entre 20 y 49 unidades), vemos que el ahorro conseguido es
considerable.
Finalmente, estableceremos el coste del proyecto en 925.59 €, considerando el coste de las tarjetas de
desarrollo y el de fabricación y montaje de 5 controladores.
99
Anexo I: Presupuesto
100
Anexo II: Referencias.
[1] «Wikipedia» 6 Octubre 2020. [En línea]. Available:

https://es.wikipedia.org/wiki/Motor_as%C3%ADncrono. [Último acceso: 13 Noviembre
2020].
[2] A. Lita y M. Cheles «Microchip.com» 25 10 2012. [En línea]. Available:
https://www.microchip.com/wwwAppNotes/AppNotes.aspx?appnote=en533912. [Último
acceso: 25 Octubre 2020].
[3] Texas Instruments «ti.com» Junio 2019. [En línea]. Available:
https://www.ti.com/product/DRV8353. [Último acceso: 30 Septtiembre 2020].
[4] ST Microelectronics «UM2392: STM32 motor control SDK,» 2018.
[5] Vishan Motor «vishanmotor.com» [En línea]. Available:
http://www.vishanmotor.com/detail.php?pid=35. [Último acceso: 5 Octubre 2020].
[6] ST Microelectronics, «st.com» [En línea]. Available: https://www.st.com/en/ecosystems/x-
nucleo-ihm07m1.html#. [Último acceso: 13 Noviembre 2020].
[7] ST Microelectronics, «st.com,» 7 Junio 2019. [En línea]. Available:
https://www.st.com/en/microcontrollers-microprocessors/stm32l476rg.html#documentation.
[Último acceso: 14 Noviembre 2020].
[8] ST Microelectronics, «L6230: DMOS driver for three-phase brushless DC motor. Datasheet -
production data» 2016.
[9] MaxLinear, «XR33180/81/83/84 3V to 5.5V, 52Mbps, TSOT23 RS-485/RS-422 Receivers
with ±15kV ESD Protection Datasheet,» 2018.
[10] ST Microelectronics, «st.com,» 2 Abril 2020. [En línea]. Available:
https://www.st.com/content/st_com/en/search.html#q=an5464-t=resources-page=1. [Último
acceso: 4 Diciembre 2020].
[12] M. Á. R. Pozueta, «F.M.M y campo magnético en el entrehierro de las máquinas eléctricas
simétricas,» Universidad de Cantabria, Cantabria.
[13] Schneider Electric, «Capitulo 3: Motores y cargas,» de Guía de Soluciones de Automatización,
2009, pp. 38-42.
[14] D. Collins, «Motion Control Tips,» 14 Marzo 2019. [En línea]. Available:
https://www.motioncontroltips.com/what-is-space-vector-pulse-width-modulation-svpwm/.
[Último acceso: 13 Octubre 2020].
[15] Roboteq, «Roboteq.com» 21 Agosto 2019. [En línea]. Available:
https://www.roboteq.com/technology/field-oriented-control. [Último acceso: 12 Octubre
2020].
101
Anexo II: Referencias
[16] ST Microelectronics, «AN1946: Sensorless BLDC Motor Control and BEMF sampling
methods with ST7MC.» 2007.
[17] NXP, «AN4058: BLDC Motor Control with Hall Effect sensors using the 9S08MP,» 2010.
[18] Microsemi, «Sensorless FOC of PMSM using SmartFusion2 Devices».
[19] Colaboración de Editores de Digi-Key de América del Norte, «Digi-Key,» 17 Enero 2017. [En
línea]. Available: https://www.digikey.es/es/articles/why-and-how-to-sinusoidally-control-
three-phase-brushless-dc-motors. [Último acceso: 29 Septiembre 2020].
[20] D. Pérez Dorantes, «Análisis de las técnicas de modulación SPWM y SVPWM en control de
inversores trifásicos de dos y tres niveles.,» 2012.
[21] ST Microelectronics, «st.com,» 25 Octubre 2018. [En línea]. Available:
https://www.st.com/en/embedded-software/x-cube-mcsdk.html#documentation.
102

TFG Roberto Carrasco Serrano

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

TFG Roberto Carrasco Serrano

Cargado por

Copyright:

Formatos disponibles

ESCUELA TÉCNICA SUPERIOR DE INGENIERÍA

PROYECTO FIN DE GRADO

TÍTULO: Diseño de un controlador para motores eléctricos de

AUTOR: Roberto Carrasco Serrano.

TITULACIÓN: Grado en Ingeniería Electrónica de Comunicaciones.

DIRECTOR: José Carlos Prieto Honorato.

TUTOR: Eduardo Barrera López de Turiso.

DEPARTAMENTO: Electrónica y Telemática.

Miembros del Tribunal Calificador:

PRESIDENTE: Francisco Aznar Ballesta.

TUTOR: Eduardo Barrera López de Turiso.

SECRETARIO: Julián Nieto Valhondo.

3.3.3. Ruteo. ....................................................................................................................... 56

Lista de acrónimos y siglas

1.1. Motores eléctricos: tipos y principios de funcionamiento.

1.1.1. Motores de corriente alterna (CA).

 Número de fases del estátor.

Por características como la eficiencia, la suavidad en su respuesta y su bajo coste y mantenimiento,

Donde 𝜙 es el flujo magnético, 𝑉𝜀 es la tensión o fuerza electromotriz inducida, 𝐵

Ilustración 1: Estructura de un motor trifásico asíncrono.

1.1.2. Motores de corriente continua (CC).

 Motores CC con escobillas (brushed): El rotor de estos motores se compone de un bobinado,

Ilustración 2: Componentes de un motor CC con escobillas.

Donde I es la intensidad de corriente, 𝑑𝑙 el diferencial de longitud del conductor (cuyo sentido

Ilustración 3: Representación simplificada de un motor CC con escobillas.

Si aplicamos la regla de la mano derecha en la Ilustración 3, entenderemos por qué se genera

 Motores CC sin escobillas (brushless): el principio de funcionamiento es muy parecido al de

Si aplicamos la regla de la mano derecha en la ley de Biot-Savart, veremos que el campo

A modo de resumen, se presenta el siguiente esquema, el cual muestra la clasificación de motores

Ilustración 5: Clasificación de los motores eléctricos.

Ilustración 6: robot de la empresa Star Robotics en el que se integrará el controlador diseñado.

1.2. Métodos de control para motores de corriente continua sin

Ilustración 7: Módulo de visión donde se ubicarán los controladores.

1.2.1. Control trapezoidal o Six-Steps.

1.2.2. Control sinusoidal.

1.2.3. FOC (Field Oriented Control).

El campo magnético ejercido sobre el rotor puede descomponerse en dos componentes

1.3. Soluciones en el mercado para el control de motores de CC sin

1.3.1. Soluciones de Maxon.

Ilustración 15: Imagen de la estructura de la gama IDX de Maxon Motors.

También en Maxon, podemos encontrar controladores de motores BLDC. Reciben el nombre de

Ilustración 16: Controlador EPOS2 P de Maxon.

1.3.2. Soluciones de Texas Instruments.

1.3.3. Soluciones de ST Microelectronics.

1.4. Elección de las herramientas de desarrollo.

Así, centrándonos en las características de su alimentación y consumo, vemos que el circuito

El PC de la Ilustración 19 será el encargado de ejecutar las herramientas software de ST

2.1. Configuración hardware de las tarjetas de desarrollo.

Ilustración 20: Esquema de conexiones del conector CN10 en el diseño MB1136

Ilustración 21: Esquema de conexiones del microcontrolador en el diseño MB1136.

Ilustración 24: Módulo ST-LINK/V2 incorporado en el diseño MB1136.

 Se han colocado los jumpers J5 y J6 de la tarjeta X-NUCLEO-IHM07M1 en la posición 3Sh.

Ilustración 25: Conexiones en los conectores J5 y J6 de la tarjeta X-NUCLEO-IHM07M1.

Como podemos deducir de la Ilustración 25, cuando estos jumpers se encuentran en la

2.2. Estructura del firmware generado a partir de Motor Control

Ilustración 26: Arquitectura del STM32 MC firmware. [4]

Ilustración 27: Componentes que forman la librería PMSM FOC.

2.3. Generación y pruebas de una primera versión del firmware.

2.3.1. Generación del perfil del motor con ST Motor Profiler.

Ilustración 28: Ventana de selección del hardware de desarrollo en ST Motor Profiler.

Ilustración 29: Panel de configuración de ST Motor Profiler.

2.3.2. Personalización del firmware mediante MCWB y generación del código.

Ilustración 30: Ventana de configuración del hardware en MCWB.