Diseño E Implementación en Fpga de Un Sistema de Control para Bipedestador Móvil Tesis

TECNOLÓGICO NACIONAL DE MÉXICO
Instituto Tecnológico de La Paz
INSTITUTO TECNOLÓGICO DE LA PAZ

DIVISIÓN DE ESTUDIOS DE POSGRADO E INVESTIGACIÓN
MAESTRÍA EN SISTEMAS COMPUTACIONALES
DISEÑO E IMPLEMENTACIÓN EN FPGA DE UN

SISTEMA DE CONTROL PARA BIPEDESTADOR MÓVIL
TESIS
QUE PARA OBTENER EL GRADO DE

MAESTRO EN SISTEMAS COMPUTACIONALES
PRESENTA:
JOSÉ LUIS GÓMEZ TORRES
DIRECTORES DE TESIS:
DR. SAÚL MARTÍNEZ DÍAZ DR. ISRAEL SANTILLÁN
LA PAZ, BAJA CALIFORNIA SUR, MÉXICO, AGOSTO DE 2015.
Blvd. Forjadores de B.C.S. #4720, Col. 8 de Oct. 1era. Sección C.P. 23080
La Paz, B.C.S. Conmutador (612) 121-04-24, Fax: (612) 121-12-95
www.itlp.edu.mx
Dedicatoria
Me encontré de pronto en la vida queriendo hacer cosas que amara, queriendo hacer cosas útiles,
queriendo vivir hoy, porque la vida es ahorita; a veces me sale y a veces no.
Descubrı́ que cuando te atreves a aceptar tus sueños y a decirlo (porque las palabras son
poderosas) es más fácil que te encuentres con personas con sueños parecidos y es lo más sabroso
del mundo convivir con esas personas[1] .
Gracias a todos por estar ahı́, por las atenciones, por los mensajes, por las risas. Estos dos años
estuve un poco apartado, pero tal vez los estuve pensando más que nunca[2] .
Gracias a los que confiaron[3] aunque todo indicaba que ese muchacho[4] era medio デスマドロ
ソ , y estuvieron ahı́ siempre para resolver las muchas y básicas dudas del aludido sujeto.
[1] Blanca, Flor, Camacho, Cerezo, Jorge, Moyrón, Pedro, Zamudio.

[2] Amá, Apá, Negrita, Annie, China, Diana, Laura, Lidia, Sarahı́, Teffa, Christian, Gabo,
Hugo.
[3] Dr. Alejandro, Dr. Israel, Dr. Saúl.
[4] Un servidor.
Para ustedes y Gracias.
i
Agradecimientos
Gracias al pueblo mexicano, que se muere de hambre y nos ha dado estudios. Gracias a
CONACyT que ha administrado la beca de la última fase de los mencionados estudios.
Un agradecimiento especial para Jorge Cobos, que de la forma más desinteresada y atenta
colaboró en la construcción de las piezas del exoesqueleto, con tanto o más entusiasmo que
nosotros.
ii
Resumen
De acuerdo a la Organización Mundial de la Salud (OMS) alrededor del 15 % de la población

mundial presenta algún tipo de discapacidad. La Electrónica digital, la Robótica y el Control se
ofrecen como herramientas poderosas para afrontar esta problemática. La integración humano-
robótica ha sido un área de investigación desde mediados del siglo pasado sin embargo la com-
plejidad de la tarea en cuestión de actuadores, sistemas de control, autonomı́a y velocidades de
procesamiento necesarias, hacen que sea un área de investigación abierta.
En la presente tesis se muestra el diseño y construcción de un exoesqueleto cuya función es
permitir la postura de pie a usuarios con debilidad muscular general. Ası́ mismo se muestra el
diseño del sistema de Control para un dispositivo tipo Péndulo Invertido sobre ruedas (WIP -
Wheeled Inverted Pendulum) que se propone como la plataforma de locomoción para el exoesque-
leto. También se presenta la implementación del mencionado sistema en un FPGA (Arreglo de
Compuertas Lógicas Programable en Campo).
Una de las tareas centrales del sistema es la determinación de la orientación del dispositivo me-
diante la lectura de una Unidad de Medición Inercial compuesta por un acelerómetro, un giróscopo
y un magnetómetro. Se implementó una primera arquitectura en el FPGA para esta tarea, que
aunque efectiva, no es eficiente en cuestión de uso de hardware. Por lo que se implementó una
segunda arquitectura que reduce el uso de hardware a poco menos de la mitad mostrando además
una mejorı́a en velocidad de procesamiento respecto a la primer arquitectura. Ambas arquitecturas
reducen el tiempo de procesamiento a la mitad, con respecto al microcontrolador utilizado.
iii
Abstract
According to the World Health Organization (WHO) about 15 % of the world population has
some type of disability. Digital Electronics, Robotics and Control offered as powerful tools to
address this problem. The human-robotic integration has been an area of research since the middle
of last century, however, the complexity of the task at actuators, control systems, autonomy and
necessary processing speeds, make it an area of ongoing investigation.
In this thesis the design and construction of an exoskeleton, whose function is to allow users
with general muscle weakness the standing posture, is shown; likewise, the control system design
for a Wheeled Inverted Pendulum type device, which is proposed as the transportation platform
for the exoeskeleton. The implementation of that system on an FPGA (Field Programmable Gate
Array) is also presented.
One of the central tasks of the system is the determination of the orientation of the device
by reading an Inertial Measuremente Unit, consisting of an accelerometer, a gyroscope and a
magnetometer. A first architecture was implemented in the FPGA for this task, which, although
effective, was not efficient in the use of hardware. So a second architecture that reduces the use
of hardware to just under half also showing an improvemente in processing compared to the first
architecture was implemented. Both architectures reduce processing time by half, with respect to
the microcontroller used.
iv
Índice general
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . iii
Abstract . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . iv
Lista de figuras VII
Lista de tablas VIII
1. Introducción 1
1.1. Antecedentes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.2. Justificación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.3. Planteamiento del problema . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.4. Hipótesis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.5. Objetivo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.6. Objetivos Especı́ficos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2. Marco teórico 11
2.1. Electrónica digital . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.1.1. ASICs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.1.2. ASIC Programable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.1.3. Arquitectura FPGA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.1.4. Metodologı́a de Diseño VLSI con Herramientas CAD . . . . . . . . . . . . . 15
2.1.5. Lenguajes de Descripción de Hardware . . . . . . . . . . . . . . . . . . . . . 17
2.1.5.1. Elementos básicos de VHDL . . . . . . . . . . . . . . . . . . . . . . 18
2.1.5.2. Niveles de Abstracción . . . . . . . . . . . . . . . . . . . . . . . . . 19
2.2. Control automático . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.2.1. Introducción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.2.2. Modelos matemáticos de los sistemas . . . . . . . . . . . . . . . . . . . . . . 24
2.2.3. Modelos en variables de estado . . . . . . . . . . . . . . . . . . . . . . . . . 24
2.2.3.1. La ecuación diferencial del estado . . . . . . . . . . . . . . . . . . . 27
2.3. El Péndulo Invertido sobre Ruedas (WIP) . . . . . . . . . . . . . . . . . . . . . . . 28
3. Metodologı́a 38
3.1. Propuesta de solución . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
3.1.1. Construcción del prototipo . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
3.2. Definición de la tecnologı́a digital a utilizar . . . . . . . . . . . . . . . . . . . . . . . 41
3.3. Arquitectura general del sistema. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
3.4. Diseño del controlador para el primer prototipo . . . . . . . . . . . . . . . . . . . . 47
3.5. Implementación en el microcontrolador . . . . . . . . . . . . . . . . . . . . . . . . . 53
v
ÍNDICE GENERAL
3.6. Implementación en el FPGA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54

3.6.1. Primera arquitectura para la multiplicación de matrices . . . . . . . . . . . . 57
3.6.2. Segunda arquitectura para la multiplicación de matrices . . . . . . . . . . . 60
4. Resultados, conclusiones y trabajo futuro 66

4.1. Resultados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
4.2. Conclusiones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
4.3. Trabajo futuro . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
Apéndices 79
A. Descripción de los módulos del sistema en VHDL 80

A.1. Tipos de datos definidos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
A.2. Aplicación de offsets a las entradas (AsignaDatos.vhd) . . . . . . . . . . . . . . . . 81
A.3. FSM para todos los cálculos de la IMU (CalculosIMU.vhd) . . . . . . . . . . . . . . 83
A.4. FSM Actualización de la DCM (MatrixUpdate.vhd) . . . . . . . . . . . . . . . . . . 89
A.4.1. Escalación de un vector (Gyro Scaled.vhd) . . . . . . . . . . . . . . . . . . . 96
A.4.2. Suma de dos vectores (VectorAdd.vhd) . . . . . . . . . . . . . . . . . . . . 97
A.4.3. Obtención de la matriz temporal de actualización (UpdateMatrixAsig.vhd) . 98
A.4.4. Multiplicación de dos matrices (MatrixMultiply.vhd) . . . . . . . . . . . . . 100
A.4.5. Producto punto de dos vectores (VectorMultIterativo.vhd) . . . . . . . . . . 102
A.4.6. Suma de dos matrices (MatrixSuma.vhd) . . . . . . . . . . . . . . . . . . . . 103
B. Módulos de prueba para verificar la funcionalidad de los circuitos diseñados 105

B.0.7. Banco de prueba para el módulo principal del sistema (test Principal.vhd) . 105
B.0.8. Banco de prueba para el módulo con la FSM que controla los cálculos de la
IMU (test CalcIMU.vhd) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
B.0.9. Banco de prueba para el módulo con la FSM que controla los cálculos que
actualizan la DCM (test MatrixUpdate.vhd) . . . . . . . . . . . . . . . . . 110
C. Códigos CORDIC y Bancos de prueba 114

C.0.10. Módulo para calcular seno y coseno basado en la técnica CORDIC . . . . . . 114
C.0.11. Banco de pruebas para el módulo de cálculo de seno y coseno . . . . . . . . 119
C.0.12. Módulo para calcular la arco tangente en Verilog . . . . . . . . . . . . . . . 122
C.0.13. Banco de prueba para el cálculo de la tangente . . . . . . . . . . . . . . . . . 131
D. Piezas del exoesqueleto 138
vi
Índice de figuras
1.1. Ejemplos de exoesqueletos actuales. De izquierda a derecha: BLEEX, eLegs, HAL-5,

Rewalk y Rex. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2. Tek RMD. (Cortesı́a de Matia Robotics) . . . . . . . . . . . . . . . . . . . . . . . . 4
1.3. Segway PT. (Cortesı́a de Segway Inc.) . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.4. Opciones Tecnológicas para el diseño de Circuitos digitales. (Cortesı́a de Ian Grout,
2008). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.1. Arquitectura general de un ASIC. (Cortesı́a de Herrera Lozada, 2002). . . . . . . . 12

2.2. Diferencia arquitectural entre ASIC’s. (Cortesı́a de Herrera Lozada, 2002). . . . . . 13
2.3. Arquitectura demostrativa de un FPGA de Xilinx. (Cortesı́a de Herrera Lozada,
2002). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.4. Flujo de desarrollo de ASICs programables usando Herramientas VLSI CAD. (Cor-
tesı́a de Herrera Lozada, 2002). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.5. Sistema descrito por el código en VHDL. . . . . . . . . . . . . . . . . . . . . . . . . 19
2.6. Proceso a controlar. (Cortesı́a de Richard Dorf et al., 2008). . . . . . . . . . . . . . 23
2.7. Sistema de control en lazo abierto (sin retroalimentación). (Cortesı́a de Richard
Dorf et al., 2008). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
2.8. Sistema de control en lazo cerrado (con retroalimentación). (Cortesı́a de Richard
Dorf et al., 2008). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
2.9. Sistema de control multivariable. (Cortesı́a de Richard Dorf et al., 2008). . . . . . . 23
2.10. Diagrama de bloque del sistema. (Cortesı́a de Richard Dorf et al., 2008). . . . . . . 25
2.11. Sistema dinámico. (Cortesı́a de Richard Dorf et al., 2008). . . . . . . . . . . . . . . 25
2.12. Sistema resorte-masa-amortiguador. (Cortesı́a de Richard Dorf et al., 2008). . . . . 26
2.13. Modelo del Péndulo Invertido con Ruedas. (Cortesı́a de Zhijun Li et al, 2013). . . . 29
2.14. Diagrama de cuerpo libre del WIP. (Cortesı́a de Amir Bature et al., 2014). . . . . . 30
3.1. Propuesta de prototipo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38

3.2. Actuador lineal de 6 pulgadas y 50 kg. (Cortesı́a de Pololu Corporation). . . . . . . 39
3.3. Piezas para la construcción de la estructura exoesquelética. . . . . . . . . . . . . . . 41
3.4. Prototipo de plataforma autobalanceada y exoesqueleto. . . . . . . . . . . . . . . . 42
3.5. Componentes principales del prototipo construido. . . . . . . . . . . . . . . . . . . . 43
3.6. SoC Zybo de Xilinx. (Cortesı́a de Xilinx Inc.) . . . . . . . . . . . . . . . . . . . . . 44
3.7. Unidad de Medición inercial para determinar la orientación del dispositivo. (Cortesı́a
de Pololu Corporation). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
3.8. Ángulos de orientación de la IMU. Pitch, roll y yaw; cabeceo, alabeo y guiñada,
respectivamente. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
3.9. Diagrama general del funcionamiento del filtro que actualiza la DCM. . . . . . . . . 46
vii
ÍNDICE DE FIGURAS
3.10. Diagrama general de la arquitectura del sistema. . . . . . . . . . . . . . . . . . . . . 47

3.11. Primer prototipo utilizado. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
3.12. Sistema de referencia para el modelo del dispositivo. . . . . . . . . . . . . . . . . . . 49
3.13. Comportamiento del sistema sin retroalimentación. . . . . . . . . . . . . . . . . . . 51
3.14. Modelo en simulink del sistema con retroalimentación. . . . . . . . . . . . . . . . . 52
3.15. Comportamiento del sistema con la retroalimentación propuesta. . . . . . . . . . . . 53
3.16. Interfaz para comunicación en tiempo real con el sistema. . . . . . . . . . . . . . . . 54
3.17. Máquina de Estados para la Actualización de la DCM. . . . . . . . . . . . . . . . . 57
3.18. Arquitectura tipo Árbol para la multiplicación de matrices. . . . . . . . . . . . . . . 58
3.19. Analizador Lógico TLA5204B de Tektronix. . . . . . . . . . . . . . . . . . . . . . . 60
3.20. Comportamiento de las señales del sistema para la multiplicación de matrices. . . . 60
3.21. Representación del hardware utilizado para la actualización de la DCM con la ar-
quitectura de Árbol y precisión de 25 bits. . . . . . . . . . . . . . . . . . . . . . . . 61
3.22. Arquitectura tipo Multiplicador-Acumulador para la multiplicación de matrices. . . 61
quitectura de MAC y precisión de 25 bits. . . . . . . . . . . . . . . . . . . . . . . . 63
quitectura MAC y precisión de 32 bits. . . . . . . . . . . . . . . . . . . . . . . . . . 64
3.25. Diagrama de bloques del sistema en Vivado. . . . . . . . . . . . . . . . . . . . . . . 65
4.1. Opción de simulación en el Manejador de Proyectos de Vivado. . . . . . . . . . . . . 67

4.2. Simulación de 40 ciclos de reloj del sistema que actualiza la DCM. . . . . . . . . . . 68
4.3. Simulación de 40 ciclos de reloj del sistema que actualiza la DCM. . . . . . . . . . . 69
viii
Índice de tablas
2.1. Parámetros y variables del Péndulo invertido sobre ruedas. . . . . . . . . . . . . . . 30
3.2. Cálculo de la fuerza requerida en los actuadores lineales. . . . . . . . . . . . . . . . 40

3.1. Masas contempladas para la elección de los actuadores. . . . . . . . . . . . . . . . . 40
3.3. Parámetros y variables del Péndulo invertido con ruedas. . . . . . . . . . . . . . . . 47
3.4. Ejemplos de tipos de datos definidos para la implementación en VHDL y cantidad
de bits utilizados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
3.5. Hardware utilizado para multiplicar matrices de 3x3 con distinta precisión con la
arquitectura de árbol. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
3.6. Hardware utilizado para la actualización de la DCM con la arquitectura de Árbol. . 60
3.7. Hardware utilizado para multiplicación de matrices de 3x3 con la arquitectura
Multiplicador-Acumulador . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
3.8. Hardware utilizado para la actualización de la DCM con la arquitectura MAC. . . . 63
4.1. Tiempos de procesamiento en el microcontrolador con optimización O3. . . . . . . . 69

4.2. Tiempos de procesamiento en ticks del FPGA con la segunda arquitectura de Mul-
tiplicación de matrices. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
4.3. Ángulos de Euler calculados por el microcontrolador (PS) y el FPGA (PL). . . . . . 71
ix
Capı́tulo 1
Introducción
1.1. Antecedentes
De acuerdo a la Organización Mundial de la Salud (OMS), en su Informe Mundial sobre Disca-

pacidad de 2011, alrededor del 15 % de la población mundial presenta algún tipo de discapacidad.
Según el censo de 2010 realizado por el INEGI, en México esa cifra es de alrededor de 5.1 %, de la
cual 58.8 % tiene una discapacidad motriz.
Una de las principales motivaciones de la robótica es liberar al hombre de tareas tediosas o

peligrosas, sin embargo, principalmente en el último siglo se ha explorado, y llevado a cabo con
mayor o menor éxito, la integración humano-robótica para incrementar la fuerza y/o resistencia
del usuario o bien con fines de rehabilitación o corrección de la marcha. Los dispositivos que
buscan esta integración tienen varias denominaciones, pero las más usuales son “órtesis activas”
y, especialmente cuando cubren gran parte del miembro inferior, “exoesqueletos”.
Las primeras investigaciones en torno a exoesqueletos pueden ubicarse temporalmente a fi-

nales de 1960, casi paralelamente entre grupos de investigación de Estados Unidos y la antigua
Yugoslavia. El primero centrado principalmente en el desarrollo de tecnologı́as para aumentar las
capacidades de humanos sanos, a menudo para fines militares, mientras que el segundo se centraba
en desarrollar tecnologı́a de asistencia para personas con discapacidad fı́sica [1]. A pesar de las
diferencias en sus objetivos ambos grupos enfrentaron en gran medida los mismos desafı́os, rela-
cionados con la portabilidad y la necesidad de una interacción estrecha con el operador humano.
1
1.1. ANTECEDENTES
Desafı́os que quedaron reafirmados cuando la General Electric construyó el Hardiman (Human
Augmentation Research and Development Investigation), un prototipo para cuerpo completo que,
como señalan Zoss y Kazerooni [2] por cuestiones de seguridad y complejidad jamás caminó.
Un exoesqueleto puede definirse como una estructura electromecánica usada por un operador,
que tiene correspondencia en forma y funciones con el cuerpo humano. Puede aumentar la capaci-
dad de los miembros humanos y/o tratar músculos, articulaciones o partes del esqueleto que sean
débiles o hayan sufrido daño por enfermedad o por alguna condición neurológica. Además, mez-
cla la fuerza de las máquinas con la inteligencia humana para complementarlas. El exoesqueleto
trabaja en paralelo con el cuerpo humano y puede ser actuado pasiva o activamente [3].
La mayorı́a de los exoesqueletos actuales, como los mostrados en la Figura 1.1, están orientados
a la marcha bı́peda, sin embargo dada la complejidad de los algoritmos para esta tarea, a menudo
no están pensados en equilibrar su masa y la del usuario; a excepción del Rex, que lo logra a costa
de una baja velocidad de operación (alrededor de 3 metros por minuto). De los demás, algunos
delegan la labor de equilibrio al uso de bastones por parte del usuario (Rewalk, eLegs), dando por
sentado que éste tiene la suficiente fuerza en sus extremidades superiores; otros, como el BLEEX,
están orientados a cumplir con una función de sombra (seguir los movimientos del operador sin
interferir con estos) en individuos sanos, para efectos de mejorar su fuerza y resistencia; otros
más están orientados a personas que son capaces de equilibrarse pero que tienen una debilidad
muscular moderada (HAL-5). Otra caracterı́stica propia de los exoesqueletos mostrados, cuando
están orientados a personas con discapacidad, es que están pensados en usuarios que puedan
trasladarse desde su propia silla de ruedas al lugar donde se encuentra el exoesqueleto, o bien se
requiere asistencia para colocarlos.
Una alternativa, que si bien no procura la marcha bı́peda sı́ permite la bipedestación (postura
de pie) del usuario se encuentra en dispositivos como el Tek RMD (Robotic Mobility Device)
de la empresa turca, AMS Mekatronic, mostrado en la Figura 1.2, que permite al usuario una
colocación desde el frente, que resulta mucho más adecuado para personas con poca movilidad. Esta
alternativa resulta mucho menos compleja y soluciona el problema de la bipedestación, sin embargo
no posee la principal ventaja de un exoesqueleto de marcha bı́peda: el acceso a terrenos irregulares,
2
CAPÍTULO 1. INTRODUCCIÓN
Figura 1.1: Ejemplos de exoesqueletos actuales. De izquierda a derecha: BLEEX, eLegs, HAL-5,
Rewalk y Rex.
escaleras, entre otros. Además también da por hecho que el usuario tiene suficiente fuerza en sus
extremidades superiores para mover su cuerpo en un punto del proceso de colocación, lo cual no
se cumple en el caso de padecimientos neuromusculares como la Atrofia y la Distrofia Muscular,
entre otras, que se caracterizan por hipotonı́a general, no solo en los miembros inferiores.
Otra alternativa para la locomoción en bipedestación (no confundir con marcha bı́peda) es el
Segway, mostrado en la Figura 1.3; un vehı́culo de transporte ligero, controlado con un sistema
giroscópico, de dos ruedas con autobalance. El sistema de procesamiento y los motores mantienen
la base horizontal todo el tiempo y el usuario puede inclinarse hacia la dirección en que desea
moverse (adelante, atrás o hacia los lados). Una ventaja importante de este tipo de dispositivos es
que tienen un radio de giro cero, es decir pueden girar sobre su propio eje, una función muy útil en
interiores, que no poseen los dispositivos de cuatro ruedas como las sillas de ruedas o el mismo Tek
RMD. Cabe aclarar que el Segway no está orientado especı́ficamente para personas con movilidad
reducida severa, siendo su uso mas habitual el paseo turı́stico o como medio para realizar entregas,
entre otros; sin embargo cabe explorar su potencial dada su locomoción relativamente semejante
a la marcha humana, es decir erguido y sobre dos puntos de apoyo.
Este tipo de dispositivos es conocido como Péndulo Invertido sobre Ruedas (WIP, por Wheeled
Inverted Pendulum), es un sistema subactuado (con más grados de libertad que actuadores), con
dos ruedas actuadas, pero tres grados de libertad (GdL), dos movimientos planos y una inclinación
3
1.1. ANTECEDENTES
Figura 1.2: Tek RMD. (Cortesı́a de Matia Robotics)
angular; inestable, es decir si no se le aplica control el sistema perderá el equilibrio; y con una
dinámica no lineal. [4–7].
Este tipo de dispositivos, como se indica en [8], son una aplicación directa de uno de los
principios más importantes de la teorı́a y la práctica de los sistemas de control dinámico moderno,
el péndulo invertido; un sistema muy utilizado desde 1950 y que fue originalmente usado para
ilustrar ideas en Control Lineal como estabilización de sistemas inestables pero que debido a su
naturaleza no lineal ha mantenido su utilidad y es ahora utilizado para ilustrar ideas del campo
del Control No Lineal como estabilización por retroalimentación, control de estructura variable,
observadores no lineales, compensación de la fricción y reducción de modelos no lineales, como
se apunta en [9]. En la actualidad el análisis del péndulo invertido se sigue abordando desde
perspectivas como generación de patrones de marcha en tiempo real [10], tecnologı́as de control en
red [11], diseño de control lineal cuadrático óptimo [12], entre otros.
4
Figura 1.3: Segway PT. (Cortesı́a de Segway Inc.)
Electrónica digital
Lograr el control de este tipo dispositivos resulta por si solo un reto, pues se requiere la lectura
de varios sensores y el control de varios motores de forma simultánea. La electrónica disponible
para este propósito puede clasificarse en tres grupos: microcontroladores, microprocesadores y
dispositivos lógicos programables. Si bien no son las únicas son las más asequibles y las más
adecuadas, tanto técnica como económicamente.
Desde que en 1947 Walter Brattain, John Barden y W. Shockley desarrollaron el primer tran-
sistor en los laboratorios Bell, lo que les valió el premio Nobel de fı́sica en 1956 [13], y que vino
a reemplazar a la tecnologı́a regente hasta el momento, los bulbos de vacı́o, la electrónica ha ex-
perimentado una impresionante evolución, que tuvo su siguiente gran paso con el desarrollo del
Circuito Integrado (CI), construido por Jack S. Kilby en 1959, que se componı́a de varios tran-
sistores en una misma base semiconductora. Unos meses después Robert Noyce presentó una idea
propia para la construcción de CI’s que resolvı́a algunos problemas de la propuesta de Kilby, prin-
cipalmente la interconexión de los componentes, que resolvió agregando una capa de metal de la
cual se removı́a material para formar los “cables”. Si lo pensamos un momento, la tecnologı́a actual
basada completamente en el uso de circuitos altamente integrados (cientos de millones en algunos
circuitos) se debe en gran parte a estos hombres, anónimos para la mayorı́a de nosotros.
5
1.1. ANTECEDENTES
Una vez lograda la integración el paso natural fueron los Circuitos Reconfigurables, como los
Dispositivos Lógicos Programables (PLD’s, por Programmable Logic Device) y los más versátiles
Arreglos Lógicos Programables (PAL, por Programmable Array Logic ). Los primeros dispositivos
programables en campo surgieron como alternativas al caro proceso de fabricación de ROM’s.
Almacenar código en una ROM era un proceso caro que requerı́a que el vendedor de ROM’s creara
una maqueta única para cada cliente. Los cambios en el código eran imposibles a no ser que se
creara una maqueta nueva y un nuevo chip.
Las PROM’s vinieron a resolver este problema, permitiendo que el usuario, en lugar del vende-
dor, almacenara código en el dispositivo usando un sencillo y relativamente barato programador de
escritorio. Este nuevo dispositivo fue denominado Memoria de Solo Lectura Programable (PROM,
por Programmable Read Only Memory).
La integración cada vez mayor de los dispositivos ası́ como la necesidad de poder reprogramar
los circuitos llevó eventualmente a la construcción de microcontroladores; mientras que la conver-
gencia de los dispositivos lógicos programables y los Circuitos integrados de Aplicación especı́fica
(ASIC, por Application-Specific Integrated Circuit) dio como resultado el desarrollo de los Arreglos
de Compuertas Lógicas Programables en Campo (FPGA’s, por Field Programmable Gate Array).
En un principio se pensó que los FPGA’s eventualmente reemplazarı́an a los microcontroladores
sin embargo la sencillez en la programación de los µC en contraposición a la más elaborada confi-
guración de los FPGA’s ha hecho que el microcontrolador siga siendo la tecnologı́a más extendida.
Sin embargo, en la actualidad ambos pueden complementarse armoniosamente en los llamados
System-on-a-Chip (SoC) [14], con el uso de tecnologı́as de fabricación que logran integrar uno o
más microcontroladores con FPGA’s en una misma placa.
Sistemas digitales
En los campos de la ciencia, la tecnologı́a y en la mayorı́a de los campos de trabajo, constante-

mente tratamos con cantidades. Básicamente existen dos maneras de representar el valor numérico
de las cantidades: analógica y digital.
En la representación analógica una cantidad se representa mediante un indicador proporcional
6
que varı́a en forma continua. Las cantidades analógicas tienen una importante caracterı́stica: sin
importar cómo se presenten pueden variar a través de un intervalo continuo de valores.
En la representación digital las cantidades se representan no mediante indicadores que varı́an

en forma continua, sino mediante sı́mbolos llamados dı́gitos. Esta representación cambia en in-
crementos discretos. Debido a la naturaleza discreta de las representaciones digitales, no existe
ambigüedad cuando se lee el valor de una cantidad digital, mientras que el valor de una cantidad
analógica, por lo general, se deja abierto a la interpretación.
Cada vez hay más aplicaciones en la electrónica, al igual que en la mayorı́a de las otras tec-
nologı́as, que utilizan técnicas digitales para hacer operaciones que antes se realizaban mediante
métodos analógicos. Las razones principales del cambio son que generalmente, los sistemas digi-
tales son más fáciles de diseñar; es fácil almacenar información, ası́ como mantener la precisión y
la exactitud en todo el sistema; la operación puede programarse, los circuitos digitales son más
resistentes al ruido y pueden fabricarse más circuitos digitales en los chips de CI [15].
En el dominio digital, la elección de la tecnologı́a a implementar está esencialmente entre usar

lógica digital de funcionalidad dedicada (fija); usar un sistema basado en procesador (micropro-
cesador, microcontrolador o DSP) programado por software; o usar un dispositivo lógico progra-
mable configurado a nivel de hardware, ya sea simple (SPLD), complejo (CPLD) o un Arreglo de
Compuertas Lógicas Programable en Campo (FPGA, Field Programmable Gate Array) [16]. Las
opciones son mostradas en la Figura 1.4.
1.2. Justificación
A pesar de que actualmente existen opciones de dispositivos de asistencia, algunos de ellos

no están pensados para personas con discapacidad; la motivación de su desarrollo a menudo es
darle aplicación en la milicia; mientras que las que sı́ están orientados a aquel segmento de la
población se concentran especı́ficamente en personas con daño espinal en vértebras bajas, es decir
usuarios que tienen fuerza suficiente en sus miembros superiores, o bien en personas sanas y que son
capaces de equilibrarse pero que tienen una debilidad muscular moderada. La propuesta final de
este proyecto es un dispositivo de asistencia para personas con movilidad reducida y con hipotonı́a
7
1.2. JUSTIFICACIÓN
Figura 1.4: Opciones Tecnológicas para el diseño de Circuitos digitales. (Cortesı́a de Ian Grout,
2008).
general, inexistente entre las opciones tecnológicas actuales.
Mantener una misma postura por largos periodos de tiempo acarrea complicaciones agregadas
a las de la propia discapacidad motriz, por lo cual mantener una postura de pie por algún periodo
de tiempo durante el dı́a es recomendable; sin embargo ésta sola tarea puede implicar tener que
asistir a centros especializados o bien realizar modificaciones arquitectónicas y estructurales para
permitir dicha postura a una persona con retos fı́sicos. La bipedestación (posición de parado), como
se ha mencionado, tiene ventajas entre las que se cuentan ayudar a estirar los músculos y tendones,
por lo cual evita contracturas, mejora la circulación, permite extender la cavidad abdominal para
8
respirar e incluso facilita la función de los procesos digestivos.
Desde una perspectiva tecnológica, la electrónica reconfigurable es un área que, si bien no es

nueva, no ha sido profundamente explotada a pesar de que debido a su naturaleza de procesamiento
paralelo, es altamente efectiva tanto en tareas de control como de procesamiento en general. Una
de las razones de su menor difusión con respecto a los sistemas secuenciales puede ser su comple-
jidad, provocando que existan relativamente pocas implementaciones que utilicen esta tecnologı́a
en comparación con los microcontroladores y microprocesadores. Sin embargo los algoritmos de
control, adquisición y procesamiento de señales para un dispositivo robótico de bipedestación au-
tobalanceado puede tornarse lo suficientemente complejo como para que su implementación en
procesadores convencionales sea poco eficaz, lo que hace necesario considerar alternativas, como la
electrónica reconfigurable para lograr un mejor desempeño.
1.3. Planteamiento del problema
La robótica presenta una alternativa viable para la rehabilitación motriz y la autonomı́a de

personas con retos fı́sicos, sin embargo, dada la complejidad de los movimientos antropomórficos y
los requerimientos implı́citos de seguridad y velocidad de procesamiento, es necesario implementar
electrónica con gran poder de cómputo. El sistema propuesto debe mantener la verticalidad del
usuario, para lo cual estará leyendo sensores de aceleración, velocidad angular y campo magnético,
y deberá generar la señal de control necesaria en el momento adecuado para evitar que el dis-
positivo pierda el equilibrio, por lo que puede considerarse un sistema de tiempo real. Dadas las
exigencias de procesamiento de estos sistemas los dispositivos secuenciales (como los procesadores
y microcontroladores) diseñados para aplicaciones genéricas, pueden resultar insuficientes.
1.4. Hipótesis
El algoritmo implementado en el FPGA tendrá un mejor desempeño para efectos de tiempo de

procesamiento que en un procesador secuencial.
9
1.5. OBJETIVO
1.5. Objetivo
Diseñar e implementar en FPGA un sistema de control para bipedestador móvil.
1.6. Objetivos Especı́ficos
Diseñar un sistema de control para dispositivo tipo péndulo invertido sobre dos ruedas.
Implementar el sistema en un procesador.
Implementar el sistema de control en un FPGA de gama baja.
Hacer pruebas comparativas.
10
Capı́tulo 2
Marco teórico
2.1. Electrónica digital
2.1.1. ASICs
Un ASIC (Circuito Integrado de Aplicación Especı́fica, por Application Specific Integrated Cir-
cuit) es un dispositivo terminal; un diseño que ha sido probado y optimizado, se manufactura en
una pastilla de silicio cuya operación será prefijada. Sólo contiene las interconexiones y elementos
necesarios para realizar la función especı́fica deseada [17].
De manera general, un ASIC contiene dos elementos básicos: Módulos Lógicos e Interco-
nexiones, como se muestra en la Figura 2.1. Los módulos lógicos contendrán una configuración
elemental para generar una función lógica dada. Por su parte, las interconexiones permiten el en-
lace entre módulos lógicos básicos para crear módulos más complejos que realicen operaciones más
elaboradas, lo que se conoce como enrutado [18].
Los ASICs se clasifican en tres grupos caracterı́sticos: Full-Custom (arquitectura a la medida),

Semi-Custom (arquitectura parcialmente a la medida) y Programmables (arquitectura programa-
ble). La programación, tanto para los ASIC Full- Custom como para los Semi- Custom se realiza
directamente en fábrica. Los Programmable ASICs pueden programarse por un usuario final, por
lo que se denominan dispositivos Programables en Campo [19]. Los FPGA’s pertenecen a este tipo
de ASIC.
11
2.1. ELECTRÓNICA DIGITAL
Figura 2.1: Arquitectura general de un ASIC. (Cortesı́a de Herrera Lozada, 2002).
2.1.2. ASIC Programable
Los ASIC’s Programables, conocidos también como ASIC’s Basados en Arreglos de Compuertas
(Gate-Array-Based ASIC’s), son las arquitecturas más representativas en el mercado actual [20]. In-
cluyen a los PLD’s (Dispositivos Lógicos Programables, por Programmable Logic Devices), CPLD’s
(PLD’s Complejos, por Complex PLD’s) y FPGA’s (Arreglos de Compuertas Programable en Cam-
po, por Field Programmable Gate Array).
Los ASIC’s Programables contienen módulos prediseñados por el fabricante que pueden ser
interconectados o enrutados por el usuario, permitiendo crear nuevos módulos que pueden ser
reutilizados. La ventaja inmediata está en que los diseños pueden ser implementados en su totalidad
en un mismo ambiente de desarrollo por el usuario final, reduciendo el costo y el tiempo de diseño,
al no necesitar de una manufactura terminal en fábrica.
Aunque cualquier ASIC programable tiene una arquitectura programable en campo la mayorı́a
de los usuarios de estas tecnologı́as coinciden en distinguir un Arreglo Programable en Campo (por
ejemplo, un FPGA) de un Dispositivo Lógico Programable (por ejemplo, un GAL –Generic Array
Logic). La diferenciación se basa en las estrategias de programación utilizadas para cada uno, que
a su vez están determinadas por la complejidad en la arquitectura de cada dispositivo. Los CPLDs
y FPGAs se consideran de arquitectura avanzada y programable en campo, con aplicaciones más
elaboradas en comparación con un PLD [21, 22].
Un PLD tiene recursos comprometidos, es decir, no requiere de un proceso de interconexión
12
CAPÍTULO 2. MARCO TEÓRICO
Figura 2.2: Diferencia arquitectural entre ASIC’s. (Cortesı́a de Herrera Lozada, 2002).
entre sus elementos internos, ya que sus arreglos AND - OR son fijos. Debido a esta caracterı́stica,
sus estructuras internas son simples y no pueden ser muy grandes, limitándose a una escala de
integración SSI (Integración de pequeña escala, por Small Scale Integration). Los dispositivos más
avanzados, como los CPLD’s y los FPGA’s, están conformados por recursos no comprometidos, que
pueden seleccionarse, configurarse e interconectarse, en función de los requerimientos del diseñador.
Este tipo de arquitecturas más versátiles y complejas desembocan escalas LSI (Integración de
Gran Escala, por Large Scale Integration) y VLSI (Integración de Muy Gran Escala, por
Very Large Scale Integration). En la Figura 2.2 se muestra la diferencia arquitectural entre
dispositivos programables [23–25].
2.1.3. Arquitectura FPGA
Un FPGA se compone de elementos con recursos no comprometidos que pueden ser seleccio-
nados, configurados e interconectados por un usuario. Como se ha mencionado, en un PLD las
interconexiones entre los elementos ya están prefijadas o comprometidas y solamente es posible
habilitar o deshabilitar la interconexión; en el caso de un FPGA no hay tal interconexión prefijada.
Estos dispositivos se componen de cierto número de Módulos Lógicos que determinan la ca-
pacidad del dispositivo. Los módulos son independientes entre sı́ y pueden interconectarse para
formar un módulo más complejo. Dependiendo del fabricante, estos módulos pueden ser Bloques
Configurables (como es el caso de Xilinx y Altera), o bien Elementos de Función Fija formados
por arreglos de compuertas (como es el caso de Actel).
13
Figura 2.3: Arquitectura demostrativa de un FPGA de Xilinx. (Cortesı́a de Herrera Lozada, 2002).
Los módulos del FPGA, se interconectan por medio de Canales Configurables como se aprecia en
la Figura 2.3. Al proceso de interconexión, se le conoce como enrutamiento y consiste en determinar
la mejor estrategia de interconectar los módulos, utilizando para ello alguna herramienta de diseño
electrónico.
La gran ventaja de utilizar estos dispositivos radica en que todo el desarrollo se lleva a cabo en
un solo ambiente de trabajo. El diseñador propone la función lógica a realizar a través de métodos de
descripción y define los parámetros de su problema. Esto se hace por medio de código programable,
que puede ser un Lenguaje de Descripción de Hardware, o bien, un Diagrama esquemático de
conexiones.
Las principales ventajas de diseñar sobre FPGA’s, de acuerdo a [17] se listan a continuación:
a. Minimización del número de componentes de un diseño. Con esto se reducen los gastos
de inventario, inspección y prueba, ası́ como el número de fallas a nivel de circuito impreso,
propiciando un ahorro de espacio fı́sico.
b. Reducción en el tiempo de diseño. Debido a su naturaleza programable, reducen el tiempo

y los costos de desarrollo, no sólo de nuevos productos sino también de aquellos que requieren
modificaciones (reingenierı́a).
c. Uso de una gran variedad de herramientas de Diseño Asistido por Computadora (CAD),
disponibles actualmente en el mercado. Estas herramientas promueven y facilitan el diseño sobre
14
Figura 2.4: Flujo de desarrollo de ASICs programables usando Herramientas VLSI CAD. (Cortesı́a
de Herrera Lozada, 2002).
este tipo de dispositivos. Ası́ mismo, no se requiere de grandes recursos de cómputo.
2.1.4. Metodologı́a de Diseño VLSI con Herramientas CAD
El conjunto EDA (Diseño Electrónico Automatizado, por Electronic Design Automation) son
todas las herramientas, tanto de hardware como de software, que se utilizan para el diseño de
sistemas electrónicos. Dentro de EDA, las herramientas VLSI CAD juegan un importante papel en
el diseño de hardware a través de software [17]. Debido al inminente incremento en la complejidad
de los circuitos con arquitectura avanzada, se hace indispensable un sofisticado aporte por parte de
las herramientas CAD para automatizar el proceso de desarrollo, repercutiendo en una disminución
en el tiempo de diseño y los costos de producción, y aumentando la calidad del producto.
La Figura 2.4 esquematiza las fases necesarias para diseñar sobre FPGAs.
1. Captura del diseño (Design Entry ). Se ingresa el modelo de solución al ambiente de

desarrollo VLSI CAD. (En este caso Vivado 2014.4). La captura puede ser mediante uno (es
válido el uso de varios) de los siguientes medios que describen el funcionamiento del circuito:
un diagrama esquemático, un Lenguaje de Descripción de Hardware, o mediante un Netlist
(Archivos de Conexiones). Entre los diferentes fabricantes se respetan algunos estándares de
15
diseño con HDL y captura de esquemáticos, pero no ası́ de configuración fı́sica de los dispositivos,
debido a que los ambientes y arquitecturas de propietario son distintas entre sı́.
2. Sı́ntesis Lógica (Logic Synthesis). El software de desarrollo incluye la herramienta propia

para realizar la sı́ntesis lógica de un código en HDL o de un diagrama esquemático. A través
de una compilación es posible producir un netlist a partir de cualquiera de los métodos de
captura. Un netlist es un archivo que registra la descripción de celdas lógicas (primitivas) y sus
conexiones especı́ficas, que conforman un circuito. El formato de netlist más utilizado es EDIF
(Formato de Intercambio de Diseño Electrónico, por Electronic Design Interchange Format).
3. Simulación Pretrazado (Prelayout Simulation). También conocida como Preruteado;

hasta el segundo paso aún no se ha comenzado con el diseño fı́sico, solamente se ha realizado
el diseño lógico del circuito modelado. La mayorı́a de los ambientes de desarrollo incluyen
dos tipos de simulación, una llamada lógica y la otra fı́sica. La primera es antes del ruteo o
trazado (interconexión de lı́neas) y la otra es posterior al mismo. La simulación lógica solamente
permite observar el comportamiento del diseño con las celdas lógicas más básicas del dispositivo
seleccionado.
4. Mapeo o Planeación de la Superficie (Floorplanning ). Una vez que se simuló el diseño,

se procede a mapear el netlist sobre el FPGA seleccionado. La configuración de las celdas lógicas
y sus respectivas conexiones, descritas por el netlist, se distribuyen sobre la superficie del circuito
integrado a manera de identificar recursos. Los algoritmos involucrados en este proceso permiten
minimizar espacio fı́sico y retardos de señal, en una primera aproximación.
5. Colocación (Placement). Estratégicamente, el software decide la colocación de las primiti-

vas sobre un bloque del dispositivo fı́sico (módulo lógico). Los algoritmos inteligentes con los
que trabaja el sistema de sintetización, deciden la mejor ubicación para cada celda lógica, con-
siderando las redundancias en el diseño (componentes o conexiones repetidas) y una segunda
aproximación para eliminar los retardos crı́ticos.
6. Trazado o Ruteo (Rutting ). Realiza la conexión fı́sica entre los módulos lógicos y determina
el tipo de interconexión proponiendo rutas cortas o largas, según sea el mejor caso.
16
7. Traducción (Translate). Es la extracción de caracterı́sticas del circuito, determinando la

resistencia y capacitancia eléctrica, entre las interconexiones para verificar un correcto ruteo de
las lı́neas. El software de diseño se encarga automáticamente de generar el ruteo y la extracción
de impedancias; sin embargo, algunas herramientas incluyen editores para realizar las conexiones
de modo personalizado.
8. Simulación Post trazado (Postlayout Simulation). Una vez que se han colocado y ruteado
las celdas primitivas y los módulos que las contienen, la configuración fı́sica que ha adquirido
el dispositivo puede simularse. A este tipo de simulación se le conoce como fı́sica, debido a su
proximidad con el comportamiento real que tendrá el diseño. Es posible considerar los retardos
de propagación que sufren las señales. El retardo generado dentro de un módulo lógico será igual
a la suma de los retardos de los elementos contenidos en el mismo (flip flops, LUT’s -Look
Up Tables, Tablas de Consulta-, multiplexores, entre otros). Para determinar la ruta crı́tica,
el analizador del software suma los retardos de cada módulo lógico más los retardos de las
interconexiones que participan en la ruta, desde un puerto de entrada hasta un puerto de
salida. Las bibliotecas de cada dispositivo en particular, contienen información referente a los
retardos de cada elemento dentro del módulo lógico, por lo que los resultados entregados por la
simulación son certeros y confiables.
2.1.5. Lenguajes de Descripción de Hardware
Un HDL (Hardware Description Language - Lenguaje de Descripción de Hardware), es un

lenguaje usado para modelar la operación funcional de una pieza de hardware (circuitos electrónicos
y/o sistemas completos), en una forma textual. Al igual que en los lenguajes de programación
comunes, se observan ciertas diferencias entre HDL’s que van desde la sintaxis de codificación
hasta los métodos de simulación y sı́ntesis, pasando por su capacidad de compatibilidad.
Para algunos diseñadores, se conocen dos tipos generales de HDL’s: los de bajo modelado y
los de alto modelado. Los de bajo modelado son capaces de realizar descripciones simples y no
permiten la jerarquización de módulos; los de alto modelado son aptos para diseños más complejos.
En el contexto tecnológico mundial, los HDL’s más comunes e importantes para alto modelado
17
son dos: Verilog (Verify Logic - Lógica Verificable) y VHDL (VHSIC Hardware Description Lan-
guage, donde VHSIC se refiere a Very High Speed Integrated Circuit - Circuito Integrado de Muy
Alta Velocidad). Ambos permiten diseñar de acuerdo a ecuaciones, tablas de verdad y diagrama
de estados; su sintaxis es particular a cada uno con palabras reservadas para indicar al sintetizador
el método de diseño que se elija.
VHDL presenta cierta complejidad debido a la sintaxis propuesta, aunque en otro sentido,
está diseñado para trabajar preferentemente en escala VLSI. Este lenguaje de descripción es am-
pliamente utilizado actualmente al igual que Verilog con la excepción de que éste es más reciente y
presenta menor complejidad de sintaxis, debido a que sus raı́ces sintácticas se basan en Lenguaje
C estándar.
Las caracterı́sticas que comparten ambos lenguajes son 1 :
a. El diseño puede descomponerse jerárquicamente, por lo que la modularización puede ser reali-
zada desde un nivel muy bajo de abstracción.
b. Soportan cualquier nivel de modelado y de abstracción.
c. Cada elemento de diseño tiene una interfaz bien definida (para conectarse a otros elementos) y
una precisa especificación de comportamiento (funcionamiento del circuito) que permite certeras
simulaciones.
2.1.5.1. Elementos básicos de VHDL
Partiendo de la abstracción de un diseño, la cual se representa por un solo bloque, es posible

comparar los elementos básicos que componen cada uno de los lenguajes de descripción utilizados.
Para declarar un módulo, VHDL recurre a dos instancias: entity y architecture. Entity es la
declaración de los pines de entrada y salida del módulo, ası́ como de las señales internas que maneja
el diseño; también identifica el nombre que lleva el módulo. Architecture es la arquitectura del
módulo referido por el nombre con el que se etiquetó entity, conteniendo la descripción detallada
de la estructura interna o del comportamiento que tiene el módulo.
1
Extraı́do de Herrera Lozada, 2002.
18
A continuación se muestra el código en VHDL para el modelado de un circuito combinatorio

que realiza operaciones lógicas básicas.
-- Ejemplo de circuito para operaciones l’ogicas

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
--Declaraci’on de M’odulo y Puertos de entrada y salida

entity MOD_OP is
port(
A, B : in std_logic; --Entradas de la entidad o m’odulo.
C, D : out std_logic); --Salidas de la entidad o m’odulo.
end MOD_OP;
--Comienza funcionamiento
architecture FUNCIONAMIENTO of MOD_OP is
begin
C <= A and B;
D <= A or B;
end FUNCIONAMIENTO;
El código anterior describe un sistema con un comportamiento equivalente al de la Figura 2.5.
Figura 2.5: Sistema descrito por el código en VHDL.
2.1.5.2. Niveles de Abstracción
Un diseño mediante HDL, inicia con la representación fı́sica del modelo a partir de una des-
cripción del comportamiento (behavioral ) o una descripción estructural (structural ) del
mismo [17].
La descripción del comportamiento representa el funcionamiento de un circuito con respecto

a sus entradas y salidas; esto es, se modela la operación integral del circuito desde un panorama
muy exterior, por lo que se considera de alto nivel de abstracción. La representación estructural
19
describe la conformación del circuito en términos de los componentes y las interconexiones entre
ellos, connotando un nivel bajo de abstracción.
Cada una de las descripciones tiene connotaciones más formales, por ejemplo a la descripción de
comportamiento se le llama también RTL (Register Transfer Level - Transferencia a Nivel de Re-
gistros), mientras que a la estructural se le conoce como GTL (Gate Transfer Level - Transferencia
a Nivel de Compuertas Lógicas).
La mayorı́a de los diseños complejos (por ejemplo, un procesador) se describen a nivel RTL, ya
que es más simple de describir un comportamiento que realizar un diseño componente a compo-
nente. La desventaja es que a nivel de registro perdemos, de cierta forma, el control de las acciones,
suponiendo solamente el funcionamiento sin reparar en cómo se está llevando a cabo y por quién.
Hace algunos años era un verdadero inconveniente; sin embargo, la evolución y sofisticación de
las herramientas VLSI CAD, soporta algoritmos inteligentes que compilan de la mejor manera un
diseño, dejando a consideración del diseñador si se desea un circuito con restricciones de velocidad
o de espacio fı́sico.
Independientemente de la descripción abstracta del diseño (Comportamiento o Estructural),
es necesario definir el método que se seguirá para jerarquizar los diferentes niveles de concepción
con los que se trabajará. Principalmente se definen dos métodos para jerarquizar los niveles de
desarrollo en función de una operatividad por bloques, donde cada bloque realiza de manera
independiente una tarea.
1. Diseño de Abajo hacia Arriba (Bottom-Up). Se trata de un método ascendente mediante

el cual se realiza la descripción del circuito a modelar, empezando por describir los componentes
más básicos del sistema (primitivas) para posteriormente agruparlos en diferentes módulos, y
éstos a su vez en otros módulos hasta llegar a uno solo que representa el sistema completo.
Esta metodologı́a comienza con un nivel bajo de abstracción (nivel de compuertas) y se dirige
progresivamente hacia un nivel alto de abstracción (nivel de registros).
2. Diseño de Arriba hacia Abajo (Top - Down). Este método parte de una idea en un alto
nivel de abstracción y después prosigue la descripción hacia abajo, incrementando el nivel de
detalle según sea necesario. El circuito inicial se particiona en diferentes módulos, cada uno de los
20
cuales se encuentra a su vez subdividido hasta llegar a los elementos primarios de la descripción,
siguiendo un flujo descendente. No necesariamente se debe alcanzar un nivel de primitivas, ya
que un planteamiento correcto no lo permite. El método Top - Down es ampliamente utilizado
pues permite dividir un circuito grande en otros circuitos más pequeños, derivados del mismo,
o que permite tratar de manera más personal un módulo sin llegar a un nivel de abstracción
muy bajo. Expresamente presenta tres ventajas2 :
a. Incrementa la productividad del diseño. Al especificar un diseño en HDL, el software de

desarrollo generará automáticamente el nivel correspondiente de compuertas lógicas, por lo
que el tiempo utilizado en un diseño disminuye radicalmente.
b. Incrementa la reutilización del diseño. En el proceso del diseño VLSI se utilizan tecnologı́as
genéricas (Circuitos Integrados Genéricos), esto es, la tecnologı́a a utilizar no se fija hasta
llegar al diseño fı́sico (mapeo, colocación y ruteo), permitiendo reutilizar los datos del diseño
únicamente cambiando la tecnologı́a de implementación.
c. Rápida detección y predicción de errores. Como es necesario un claro análisis en la definición

de la descripción del diseño, es posible detectar y predecir errores desde el momento de la
modularización.
2.2. Control automático
2.2.1. Introducción
La ingenierı́a trata de comprender y controlar los materiales y fuerzas de la naturaleza en

beneficio de la humanidad. El ingeniero de sistemas de control está interesado en el conocimiento y
control de una parte de su medio, frecuentemente denominado sistema, con el fin de proporcionar
productos económicos útiles para la sociedad [26].
La ingenierı́a de control se basa en los fundamentos de la teorı́a de realimentación y el análisis

de sistemas lineales, e integra los conceptos de las teorı́as de redes y de comunicación.
2
Extraı́do de Implementación de un controlador difuso en un FPGA, utilizando lenguajes de descripción de
hardware, Herrera Lozada, 2008.
21
2.2. CONTROL AUTOMÁTICO
Un sistema de control es una interconexión de componentes que forman una configuración

del sistema que proporcionará una respuesta deseada. La base para el análisis de un sistema
es el fundamento proporcionado por la teorı́a de los sistemas lineales, que supone una relación
entre causa y efecto para sus componentes. Por tanto, un componente o proceso que vaya a
ser controlado puede representarse mediante un bloque como se muestra en la Figura 2.6. La
relación entrada-salida representa la relación entre la causa y efecto del proceso, que a su vez
representa un procesamiento de la señal de entrada para proporcionar una señal de salida. Un
sistema de control en lazo abierto utiliza un regulador o actuador de control para obtener la
respuesta deseada, como se muestra en la Figura 2.7. Un sistema en lazo abierto es un sistema
sin realimentación. Un ejemplo puede ser un tostador eléctrico en la cocina.
En contraste con un sistema de control en lazo abierto, un sistema de control en lazo cerrado
utiliza una medida adicional de la salida real, para compararla con la respuesta de la salida
deseada. La medida de la salida se denomina señal de realimentación (o retroalimentación).
En la Figura 2.8 se muestra un sencillo sistema de control con realimentación en lazo
cerrado. Un sistema de control con realimentación es aquel que tiende a mantener una relación
prescrita de una variable del sistema con otra, comparando funciones de estas variables y usando la
diferencia como un medio de control. A menudo, la diferencia entre la salida del proceso y la entrada
de referencia se amplifica y se emplea para controlar el proceso, de manera que esta diferencia se
reduce continuamente. El concepto de realimentación es el fundamento para el análisis y diseño
de sistemas de control. Un ejemplo de un sistema de control en lazo cerrado es una persona
que conduce un automóvil al mirar la posición del coche en la carretera y realizar los ajustes
apropiados. La introducción de la realimentación permite controlar una salida deseada y puede
mejorar la precisión, pero requiere que se preste atención al tema de la estabilidad de la respuesta.
Conforme los sistemas se hacen más complejos, deben considerarse en el esquema de control
las interrelaciones de muchas variables controladas. En la Figura 2.9 se muestra un diagrama de
3
bloques que representa un sistema de control multivariable.
3
Extraı́do de Modern Control Systems, Dorf et al., 2008.
22
Figura 2.6: Proceso a controlar. (Cortesı́a de Richard Dorf et al., 2008).
Figura 2.7: Sistema de control en lazo abierto (sin retroalimentación). (Cortesı́a de Richard Dorf
et al., 2008).
Figura 2.8: Sistema de control en lazo cerrado (con retroalimentación). (Cortesı́a de Richard Dorf
et al., 2008).
Figura 2.9: Sistema de control multivariable. (Cortesı́a de Richard Dorf et al., 2008).
23
2.2.2. Modelos matemáticos de los sistemas
Para controlar sistemas complejos, hay que obtener modelos matemáticos cuantitativos de
ellos. Por tanto, es necesario analizar las relaciones entre las variables del sistema y obtener un
modelo matemático [26]. Como los sistemas considerados son de naturaleza dinámica, las ecuaciones
descriptivas son generalmente ecuaciones diferenciales. Además, si estas ecuaciones pueden
linealizarse, entonces se puede utilizar la transformada de Laplace para simplificar el método
de solución. En la práctica, por la complejidad de los sistemas y el desconocimiento de todos los
factores relevantes, es necesario introducir hipótesis sobre la operación del sistema. Por tanto, a
veces es útil considerar el sistema fı́sico, delinear algunas hipótesis necesarias y linealizar el sistema.
Luego, empleando leyes fı́sicas que describen el sistema lineal equivalente, se pueden obtener un
conjunto de ecuaciones diferenciales lineales. Finalmente, utilizando herramientas matemáticas,
como la transformada de Laplace, se obtiene una solución que describe la operación del sistema.
En resumen, el tratamiento de los problemas de sistemas dinámicos puede establecerse como sigue:
1. Definir el sistema y sus componentes.
2. Formular el modelo matemático y enumerar las suposiciones necesarias.
3. Escribir las ecuaciones diferenciales que describan el modelo.
4. Resolver las ecuaciones para las variables de salida deseadas.
5. Examinar las soluciones y las hipótesis.
6. Si resulta necesario, volver a analizar o diseñar el sistema.
2.2.3. Modelos en variables de estado
Con la aparición de los computadores digitales conviene considerar la formulación en el dominio

del tiempo de las ecuaciones que describen los sistemas de control. Las técnicas en el dominio del
tiempo se utilizan para sistemas no lineales, variantes en el tiempo y multivariables. El dominio
en el tiempo es el dominio matemático que incorpora la respuesta y la descripción de un sistema
24
Figura 2.10: Diagrama de bloque del sistema. (Cortesı́a de Richard Dorf et al., 2008).
Figura 2.11: Sistema dinámico. (Cortesı́a de Richard Dorf et al., 2008).
en función del tiempo, t. La representación de los sistemas de control en el dominio del tiempo es
una base fundamental para la teorı́a moderna de control y optimización de sistemas.
En el análisis y diseño de los sistemas de control en el dominio del tiempo se utiliza el concepto de
estado de un sistema. El estado de un sistema es un conjunto de variables tales que el conocimiento
de estas variables y de las funciones de entrada, junto con las ecuaciones que describen la dinámica,
proporcionan la salida y el estado futuro del sistema.
Para un sistema dinámico, el estado de un sistema se describe en función de un conjunto

de variables de estado [x1 (t), x2 (t), ..., xn (t)]. Estas variables son las que determinan el com-
portamiento futuro de un sistema cuando se conocen el estado presente de éste y las señales de
excitación [26]. Considérese el sistema mostrado en la Figura 2.10, donde y1 (t) e y2 (t) son las
señales de salida y u1 (t) y u2 (t) son las señales de entrada. Un conjunto de variables de estado
(x1 , x2 , ..., xn ) para el sistema mostrado en la figura, es un conjunto tal que el conocimiento de
los valores iniciales de las variables de estado [x1 (t0 ), x2 (t0 ), ..., xn (t0 )] en el tiempo inicial t0 y las
señales de entrada u1 (t) y u2 (t) para t = 0, son suficientes para determinar los valores futuros de
las salidas y de las variables de estado.
La Figura 2.11 muestra la forma general de un sistema dinámico. Un ejemplo sencillo de

variable de estado es el estado de un interruptor de luz. El interruptor puede estar en una de sus
dos posiciones. Por tanto, si se conoce el estado presente en t0 y se aplica una entrada, se puede
determinar el valor futuro del estado del elemento.
El concepto de conjunto de variables de estado que representan un sistema dinámico puede

ilustrarse en términos del sistema resorte-masa-amortiguador de la Figura 2.12. El número de
25
Figura 2.12: Sistema resorte-masa-amortiguador. (Cortesı́a de Richard Dorf et al., 2008).
variables de estado elegidas para representar este sistema deberá ser lo más bajo posible, con el
objeto de evitar variables de estado redundantes. Un conjunto suficiente de variables de estado
para describir este sistema son la posición y la velocidad de la masa. Por tanto, se definirá un
conjunto de variables de estado como (x1 , x2 ), donde
x1 (t) = y(t)
y
dy(t)
x2 (t) =
dt
La ecuación diferencial describe el comportamiento del sistema, y generalmente se escribe
d2 y dy
M 2
+ b + ky = u(t) (2.1)
dt dt
Con el objeto de escribir la Ec. 2.1 en función de las variables de estado, se sustituye la
definición de éstas para obtener
dx2
M + bx2 + kx1 = u(t) (2.2)
dt
Por tanto, se pueden escribir las ecuaciones diferenciales que describen el comportamiento del
sistema resorte-masa-amortiguador como un conjunto de dos ecuaciones diferenciales de primer
26
orden:
dx1
= x2 (2.3)
dt
dx2 −b k 1
= x2 − x1 + u (2.4)
dt M M M
Este conjunto de ecuaciones diferenciales describe el comportamiento del estado del sistema en
función de la relación de cambio de cada variable de estado.
2.2.3.1. La ecuación diferencial del estado
El estado de un sistema se describe por el conjunto de ecuaciones diferenciales de primer orden

escritas en función de las variables de estado (x1 , x2 , ..., xn ). Estas ecuaciones pueden escribirse de
forma general como
x˙1 = a11 x1 + a12 x2 + ... + a1n xn + b11 u1 + ... + b1m um ,
x˙2 = a21 x1 + a22 x2 + ... + a2n xn + b21 u1 + ... + b2m um ,

(2.5)
..
.
x˙n = an1 x1 + an2 x2 + ... + ann xn + bn1 u1 + ... + bnm um ,
donde ẋ = dx/dt. Por ello, este conjunto de ecuaciones diferenciales simultáneas puede escribirse
de forma matricial como sigue:
    
 x1   a11 a12 ··· a1n   x1    
       b11 · · · b1m   u1 
d  x2   a21 a22
  ··· a2n 
  x2  
 
.. ..   . 
 =  . + . .   .  (2.6)
dt  ...   ... ..   . 
.   ..  

   ···     
     bn1 · · · bnm um
xn an1 an2 ··· ann xn
La matriz de columnas formada por las variables de estado se denomina vector de estado y
27
2.3. EL PÉNDULO INVERTIDO SOBRE RUEDAS (WIP)
se escribe
 
 x1 
 
 x2 
x= .  (2.7)
 
 .. 
 
 
xn
donde la letra en negrita indica un vector. El vector de las señales de entrada se define co-
mo u. Entonces el sistema puede representarse mediante la notación compacta de la ecuación
diferencial de estados como
ẋ = Ax + Bu (2.8)
La ecuación diferencial 2.8 también suele denominarse ecuación de estado.
A es una matriz cuadrada de n × n y B es una matriz de n × m. La ecuación diferencial

de estados relaciona la rapidez de cambio en el estado del sistema con el estado del sistema y las
señales de entrada. En general, las salidas de un sistema lineal pueden relacionarse con las variables
de estado y con las señales de entrada por la ecuación de salida
y = Cx + Du, (2.9)
donde y es el conjunto de señales de salida expresado en forma de vector columna. La repre-

sentación en el espacio de estados (o la representación en variables de estado) consta de la
4
ecuación diferencial de estados y la ecuación de salida.
2.3. El Péndulo Invertido sobre Ruedas (WIP)
El péndulo es uno de los ejemplos más importantes en dinámica y control y, de acuerdo a [27]
ha sido estudiado ampliamente desde los tiempos de Galileo. Muchos sistemas, como cohetes,
exoesqueletos de marcha bı́peda, o en este caso plataformas autobalanceadas pueden ser modelados
4
Extraı́do de Modern Control Systems, Richard Dorf et al., 2008.
28
como péndulos. El Péndulo Invertido sobre Ruedas, como se muestra en la Figura 2.13 consiste en
un par de ruedas idénticas, un chasis, dos actuadores para las ruedas, un péndulo invertido y una
unidad de control de movimiento [4]. El chasis soporta el par de ruedas y el péndulo invertido, y
los actuadores hacen rotar las ruedas con respecto al chasis. La unidad de control de movimiento,
por su parte, controla los actuadores para mover el vehı́culo y estabilizar el péndulo.
Figura 2.13: Modelo del Péndulo Invertido con Ruedas. (Cortesı́a de Zhijun Li et al, 2013).
Para poder controlar cualquier sistema fı́sico por medios analı́ticos primero debemos obtener
el modelo del mismo, tanto cinemático como dinámico. La cinemática se centra en el análisis de
las relaciones de velocidad concernientes a las velocidades lineales y angulares representadas en
el espacio de trabajo y en el espacio articular. La dinámica por su parte estudia la relación entre
las fuerzas aplicadas al sistema y su movimiento resultante, es decir el modo en que las fuerzas
actuando sobre el sistema hacen que este se mueva, de acuerdo a su cinemática.
Matemáticamente, las ecuaciones cinemáticas establecen un mapeo entre las posiciones y orien-
taciones en el espacio cartesiano y las posiciones en el espacio articular. La relación de velocidad
es determinada por el Jacobiano asociado con este mapeo. El modelado nos ayuda a entender las
propiedades fı́sicas y es la base de desarrollo para algoritmos de control relevantes.
Para la obtención del modelo dinámico utilizado en [5], que se ha utilizado como referencia, se
usa el método de Euler-Lagrange. El WIP es modelado como se muestra en la Figura 2.14.
Los parámetros para este modelo se muestran en la Tabla 2.1. Se asume que el WIP tiene 3
g.d.l., un movimiento traslacional en x, un ángulo de inclinación φ, y un ángulo en yaw ψ.
De la fórmula general de Lagrange se tiene que
L=T −V (2.10)
29
Figura 2.14: Diagrama de cuerpo libre del WIP. (Cortesı́a de Amir Bature et al., 2014).
Parámetro Sı́mbolo Unidades

Masa del cuerpo del péndulo Mb kg
Masa de cada rueda Mw kg
Centro de masa (gravedad) desde la base d m
Diámetro de las ruedas R m
Distancia entre las ruedas L m
Momentos de inercia del cuerpo respecto al eje x Ix kgm2
Momentos de inercia del cuerpo respecto al eje z Iz kgm2
Momentos de inercia de la rueda alrededor del centro Ia kgm2
Aceleración debido a la gravedad g ms−2
Tabla 2.1: Parámetros y variables del Péndulo invertido sobre ruedas.
30
Donde:
T = Energı́a cinética total del sistema.
V = Energı́a potencial total del sistema.

d ∂L ∂L
− = Qi (2.11)
dt ∂ ẋl ∂xi
Donde:
Qi = Función de Fuerza, xi está en coordenadas generalizadas.
Para el WIP tenemos dos pares fuerza de entrada a los motores controlados por voltaje.
La energı́a cinética total para el WIP está dada por:
TBT + TBR + TW
T R
+ TW (2.12)
Donde:
TBT = Movimiento traslacional del cuerpo del WIP.
TBR = Movimiento rotacional del cuerpo del WIP.
T
TW = Movimiento traslacional de la rueda.
R
TW = Movimiento rotacional de la rueda.
Para TBT : Movimiento traslacional lineal = x + Lsinφ
: Arco distancia para el componente x = φLsinφ
: Arco distancia para el componente ψ = ψLsinφ
TBR : De la fórmula general de par fuerza, P arF uerza = 1/2Iω 2
Donde I = inercia, ω= velocidad angular
1
TBR = [Ix φ̇2 + Iy ψ̇ 2 sin2 φ + Iz ψ̇ 2 cos2 φ] (2.13)
2
Para la rueda:
1 1
Tw = Mw R2 (θ˙r2 + θ˙l2 ) + Ia (θ˙r2 + θ˙l2 ) (2.14)
2 2
31
Pero θr = x + Lψ, θl = x − Lψ. Sustituyendo estas ecuaciones en la Ec. 2.14;

Ia
Tw = Mw + 2 x˙2 + L2 ψ˙2 (2.15)
R
Con lo que la Energı́a Potencial total V del sistema, está dada por la Ec. 2.16
V = Mb gdcosφ + Mb gR (2.16)
Y de la Ec. 2.10

Mb Ia ˙2 1 ˙ Ia 1
2 2
Iz cos φ + ly sin φ + Mb dsin φ ψ˙2 +
2 2 2

L= 2
+ Mw + 2 x + Mb d + Ix φ + Mw + 2 L +
2 R 2 R 2
Mb dcosφẋφ̇ − [Mb gdcosφ + Mb gR]
(2.17)
Considerando el eje x:

∂L 2Ia
= Mb + 2Mw + 2 ẋ + Mb dcosφφ̇ (2.18)
∂ ẋ R

d ∂L 2Ia
= Mb + 2Mw + 2 ẍ − Mb dsinφφ̇2 + +Mb dcosφφ̇2
dt ∂ ẋ R
Y de la Ec. 2.11

2Ia τ1 + τ2
Mb + 2Mw + 2 ẍ − Mb dsinφφ̇2 + Mb dcosφφ̇2 = (2.19)
R R
De la Ec. 2.19

τ1 + τ2 2 2Ia
ẍ = − Mb dcosφφ̈ + Mb dsinφφ̇ / Mb + 2Mw + 2 (2.20)
R R
32
Para la coordenada φ: El Lagrangiano se muestra en la Ec. 2.21:
Mb d2 + Ix φ̈ + Mb dcosφẍ − Mb d2 + Iy − Iz sinφcosφψ̇ 2 − Mb gdsinφ = − (τ1 + τ2 )

(2.21)
Sustituyendo la Ec. 2.20 en 2.21 para ẍ y haciendo φ̈ el sujeto de la fórmula:

2Ia
φ̈ = − Mb + 2Mw + 2 + Mb dcosφ (τ1 + τ2 )/D
R

2 2 ˙2
2
2Ia
− Mb d cosφsinφφ /D + Mb d + Iy − Iz Mb + 2Mw + 2 sinφcosφ/D (2.22)
R

2Ia
+ Mb gdsinφ Mb + 2Mw + 2 /D
R
2Ia

Donde D = Mb + 2Mw + R2
[Mb2 d2 + Ix ] − Mb2 d2 cosφ, que se convierte en:
D = (RMb dsinφ)2 + (Mb + 2Mw )R2 + 2Ia Ix + 2Mb d2 (Mw R2 + Ia )

(2.23)
Después de simplificar:
(Mb d2 + Iy − Iz )(Mb R2 + 2Mw R2 + 2Ia )sinφcosφ

φ̈ = ψ˙2
(RMb dsinφ)2 + [(Mb + 2Mw )R2 + 2Ia ]Ix + 2Mb d2 (Mw R2 + Ia )
Mb2 d2 R2 sinφcosφ
− φ˙2
(2.24)
(Mb R2 + 2Mw R2 + 2Ia )Mb gdsinφ
+
RMb dsinφ)2 + [(Mb + 2Mw )R2 + 2Ia ]Ix + 2Mb d2 (Mw R2 + Ia )
(Mb R2 + 2Mw R2 + 2Ia ) + Mb dRcosφ
− (τ1 + τ2 )
Para la coordenada x:
De la Ec. 2.17
h i
τ1 +τ2
R
+ Mb dsinφφ˙2 − (Mb + 2Mw + 2Ia
R2
ẍ
φ̈ = (2.25)
Mb dcosφ
33
Se sustityuye la Ec. 2.25 en la Ec. 2.21
h i
τ1 +τ2
R
+ Mb dsinφφ˙2 − Mb + 2Mw + 2Ia
R2
ẍ
(Mb d2 + Ix )
Mb dcosφ
(2.26)
+ Mb dcosφẍ − Mb d2 + Iy − Iz sinφcosφψ˙2

− Mb gdsinφ = −(τ1 + τ2 )
Ahora, combinando los términos con ẍ y haciéndolo el sujeto de la fórmula, se obtiene:
Mb dRcosφ(Mb d2 + Iy − Iz )sinφcosφ
ẍ = ψ˙2
(Mb d2 + Ix )(Mb R2 + 2Mw R2 + 2Ia ) − (Mb dRcosφ)2
Mb2 d2 gR2 sinφcosφ
−
(2.27)
R2 (Mb d2 + Ix )Mb dsinφ
+ φ˙2
R(Mb d2 + Ix + Mb dRcosφ)
+ (τ1 + τ2 )
Para la coordenada ψ: El Lagrangiano está dado en la Ec. 2.28

Ia 2 2 2 2
2 Mw + 2 L + Iy sin φ + Iz cos φ + Mb d sinφ ψ̈
R
(2.28)
L
+ 2[Mb d2 + Iy − Iz ]sinφcosφψ̇ φ̇ = (τ1 − τ2 )
R
L
ψ̈ = Ia
(τ1 − τ2 )
R 2 Mw + R2
L2 + Iy sin2 φ + Iz cos2 φ + Mb d2 sinφ
(2.29)
2[Mb d2 + Iy − Iz ]sinφcosφψ̇ φ̇
−
2 Mw + RIa2 L2 + Iy sin2 φ + Iz cos2 φ + Mb d2 sinφ

Dada la complejidad de los sistemas No lineales y las pocas herramientas con que se cuenta para
tratarlos, se requiere linealizar el sistema para poder utilizar las herramientas matemáticas de los
sistemas lineales. Para linealizar el modelo se asume que el punto de operación para el ángulo de
34
inclinación será φ = 0. Es decir que el dispositivo permanecerá en posición vertical o muy cercano
a la misma (±10o ). Ası́ sinφ = φ, cosφ = 1, ψ̇ = 0, φ̇ = 0. Por lo anterior las Ecuaciones 2.24,
2.27 y 2.29 se convierten en:
(Mb R2 + 2Mw R2 + 2Ia )Mb gd

φ̈ = φ
[(Mb + 2Mw )R2 + 2Ia ]Ix + 2Mb d2 (Mw R2 + Ia )
(2.30)
(Mb R2 + 2Mw R2 + 2Ia ) + Mb dR
− (τ1 + τ2 )
Mb2 d2 gR2
ẍ = − φ
(Mb d2 + Ix )(Mb R2 + 2Mw R2 + 2Ia ) − (Mb dR)2
(2.31)
R(Mb d2 + Ix + Mb dR)
+ (τ1 + τ2 )
L
ψ̈ = (τ1 − τ2 ) (2.32)
R 2 Mw + RIa2 L2 + Iz

En el formato de Espacio de Estados tenemos
 
0 1 0 0 0 0
 
0 0 0 0 t3 0
 
 
0 0 0 1 0 0
 
A=


 (2.33)
0 0 0 0 0 0
 
 
0 0 0 0 0 1
 
 
0 0 0 0 t1 0
 
0 0 
 
t t 
4 4 
 
0 0 
 
B=


 (2.34)
t5 −t5 
 
 
0 0 
 
 
t2 t2
35
Donde:
t1 = (2.35)
(Mb R2 + 2Mw R2 + 2Ia ) + Mb dR

t2 = − (2.36)
Mb2 d2 gR2
t3 = − (2.37)
R(Mb d2 + Ix + Mb dR)
t4 = (2.38)
L
t5 = (2.39)
R 2 Mw + RIa2 L2 + Iz

 
1 0 0 0 0 0
 
0 1 0 0 0 0
 
 
0 0 1 0 0 0
 
C=


 (2.40)
0 0 0 1 0 0
 
 
0 0 0 0 1 0
 
 
0 0 0 0 0 1
 
0 0
 
0 0
 
 
0 0
 
D=


 (2.41)
0 0
 
 
0 0
 
 
0 0
Además
x(t) = [x, ẋ, ψ, ψ̇, φ, φ̇] (2.42)
36
Obsérvese que, dado que:

ẋ(t) = [ẋ, ẍ, ψ̇, ψ̈, φ̇, φ̈] (2.43)
Se cumple que ẋ = Ax + Bu.
37
Capı́tulo 3
Metodologı́a
3.1. Propuesta de solución
Dada la problemática expuesta en los antecedentes ası́ como las opciones actuales ofrecidas se
propone una alternativa con las ventajas de la postura de pie y que a la vez permita ir explorando
los requerimientos de fuerza y velocidad necesarios en las articulaciones de un exoesqueleto. El
dispositivo podrá autobalancearse en dos ruedas coaxiales y soportará al usuario portando un
exoesqueleto afianzado en la base de la plataforma, como se muestra en la Figura 3.1.
Figura 3.1: Propuesta de prototipo.
La estructura del dispositivo está pensada para que pueda portarse desde la parte posterior,
con el usuario en la posición de sentado y sin que tenga que moverse de la silla de ruedas (en caso
38
CAPÍTULO 3. METODOLOGÍA
de requerirla) para colocarse el exoesqueleto. Las ruedas coaxiales se proponen por permitir un
radio de giro 0, un comportamiento más cercano al del ser humano que el de una silla de ruedas
y que permite un desenvolvimiento más adecuado en entornos estrechos como baños o pasillos.
No obstante, durante el proceso de colocación es necesario que el sistema tenga una configuración
estable, con al menos tres puntos de apoyo en el piso, por lo que se propone el uso de actuadores
lineales adicionales (no instalados aún) que se retraigan durante el uso de pie, una vez colocado el
exoesqueleto.
3.1.1. Construcción del prototipo
Uno de los principales puntos a considerar para la construcción del prototipo fue la elección de
los actuadores para la estructura exoesquelética. Dada la naturaleza de la aplicación se requieren
actuadores con mucha fuerza durante la primera fase de la actuación (la fase sentado a parado),
si bien para cuestiones de marcha, que podrı́an explorarse en un futuro, convienen actuadores
con velocidades de operación alta. Dado que la combinación de motores y reductores rotacionales
que amplificaran la fuerza, y dieran como resultado velocidades suficientemente altas y pares
fuerza elevados producı́an elementos demasiado grandes para ser incorporados de forma práctica,
se decidió utilizar actuadores lineales, como los mostrados en la Figura 3.2.
Figura 3.2: Actuador lineal de 6 pulgadas y 50 kg. (Cortesı́a de Pololu Corporation).
La elección de los actuadores está en función del diseño de la estructura ası́ como del peso
del usuario. En este caso se considera un usuario de 50 kg, más 10 kg extra de la estructura
exoesquelética como se muestra en la Tabla 3.1.
39
3.1. PROPUESTA DE SOLUCIÓN
Tabla 3.2: Cálculo de la fuerza requerida en los actuadores lineales.

Radio de la biela (m) 0.08 0.09 0.1 0.11 0.12
Factor masa en extremo 4.39 3.9 3.51 3.19 2.96
Fuerza requerida (N) 3228.10 2869.43 2582.48 2347.71 2152.07
Fuerza requerida por motor (N) 1614.05 1434.71 1291.24 1173.86 1076.03
Factor masa centrada 2.19 1.95 1.76 1.59 1.46
Fuerza requerida (N) 1614.05 1434.71 1291.24 1173.86 1076.03
Fuerza requerida por motor (N) 807.03 717.36 645.62 586.93 538.01
Tabla 3.1: Masas contempladas para la elección de los actuadores.

Elemento Masa (kg) Cantidad Subtotal (kg) Total (kg)
Usuario 50 1 50
Actuadores cadera 1.5 2 3
Segmento pierna 1 2 2
Segmento espalda 1 2 2
Soportes varios 3 1 3 60
Una vez calculada la masa total y agregando un factor de seguridad de 25 %, se calculó la fuerza
necesaria para levantar esa masa en el escenario más exigente, es decir a partir de la horizontal,
en una configuración de sentado. Para lo anterior se construyó la Tabla 3.2, donde el radio de la
biela se refiere a la distancia entre el punto de rotación (la rodilla) y el punto en el que el actuador
ejerce efectivamente la fuerza. Se consideraron dos escenarios, uno en que se trata de incorporar la
masa con la espalda en posición vertical y otro donde el usuario se inclina, procurando adelantar
el centro de masa lo más posible para efectos de reducir la palanca y por tanto la carga en los
actuadores. El factor, tanto con la masa en el extremo como centrada, se calcula con un largo total
del segmento Rodilla-Cadera de 35 cm.
Se optó por la construcción de piezas con una distancia entre el punto de rotación y el punto
de apoyo de los actuadores de 12 cm, puesto que con la configuración de los motores de seis
pulgadas que actúan la articulación de caderas, los cuales mueven el tronco del exoesqueleto, es
difı́cil asegurar que pueda centrarse la masa del tronco del usuario, por lo tanto se deja un factor
de holgura adicional para los actuadores de las piernas.
40
Figura 3.3: Piezas para la construcción de la estructura exoesquelética.
Para la articulación de rodilla se utilizaron actuadores que tienen capacidad de levantar 180 lb
(81.64 kg, 799.12 N) de carga dinámica, comercializados por ServoCity, con una velocidad de
operación de 0.20 in/s (0.508 cm/s) con carga máxima. Para la articulación de cadera se utilizaron
actuadores de la marca Concentric, comercializados por Pololu, con una capacidad de 110 lb
(49.89 kg, 489.42 N) de carga dinámica y una velocidad de operación de 0.5 in/s (1.27 cm/s).
Para controlar los actuadores se utilizaron los manejadores Sabertooth 2x25, cada uno de
los cuales puede controlar dos motores de corriente directa, con cargas de hasta 25 A y picos de
hasta 50 A.
Las piezas mostradas en la Figura 3.3 fueron construidas en Nylamid y se acoplan por pares
para funcionar como articulaciones, unidas por segmentos concéntricos tubulares de aluminio
para permitir una adaptación más sencilla a usuarios de distintas estaturas.
Los planos para las piezas de las articulaciones se muestran en el Apéndice D. El estado actual
del prototipo se muestra en la Figura 3.4, mientras que en la Figura 3.5 se muestra el esquema
del prototipo con la ubicación de sus elementos principales.
3.2. Definición de la tecnologı́a digital a utilizar
Dada la naturaleza de la aplicación en la mira, se consideraron 3 posibilidades como las más

viables para la implementación: microprocesadores, microcontroladores y Arreglos de Compuertas
41
3.2. DEFINICIÓN DE LA TECNOLOGÍA DIGITAL A UTILIZAR
Figura 3.4: Prototipo de plataforma autobalanceada y exoesqueleto.
lógicas programables (FPGA). Los dos primeros pueden ser programados por software y funcionan
de forma secuencial; mientras que el FPGA requiere una configuración a nivel de hardware, y es
posible lograr procesamiento paralelo.
Microprocesadores: Es en esencia una unidad central de procesamiento (CPU) en un circuito

integrado, el cual puede comunicarse a los demás bloques de un sistema computacional. Los mi-
croprocesadores no están pensados para cuestiones de interconexión con dispositivos externos sino
más bien como unidades de procesamiento y por tanto la mayorı́a de sus pines de entrada/salida
son para acceso a registros del procesador.
Microcontroladores: Son computadoras dedicadas que realizan actividades tales como operar
el motor de un automóvil, controlar el sistema de frenos antibloqueo u operar el horno de micro-
ondas. Por lo general tienen todos los elementos de una computadora completa (CPU, memoria y
puertos I/O), lo cual está contenido dentro de un solo circuito integrado. Los microcontroladores
sı́ están enfocados a la interconexión y comunicación con otros dispositivos, analógicos o digitales,
aunque generalmente tienen menor poder de cómputo que los procesadores. Tanto los microproce-
sadores como los microcontroladores son sistemas secuenciales, es decir ejecutan una instrucción
42
Figura 3.5: Componentes principales del prototipo construido.
tras otra para realizar sus tareas.
FPGA’s: Un FPGA es un dispositivo semiconductor que contiene bloques de lógica cuya in-
terconexión y funcionalidad puede ser configurada ’in situ’ mediante un lenguaje de descripción
especializado. La lógica programable puede reproducir desde funciones tan sencillas como las lle-
vadas a cabo por una puerta lógica o un sistema combinacional hasta complejos sistemas en un
chip (SoC).
Existen tecnologı́as como las PC’s y los DSP’s que están basadas en un microprocesador y un
microcontrolador, respectivamente, por lo que básicamente mantienen las ventajas y desventajas
de los mismos.
Existe una opción adicional que integra dos tecnologı́as, los denominados System on a Chip
(SoC) que integran en un mismo chip uno o más procesadores con un FPGA y explotan las ventajas
de ambos sistemas; la facilidad de interconexión de uno con la velocidad de procesamiento del otro.
El microprocesador (y por tanto las PC’s) tiene la gran ventaja de no requerir mucho tiempo
para la implementación, y que puede realizarse en casi cualquier lenguaje utilizando herramientas
bien desarrolladas para el control, sin embargo no es un dispositivo especialmente orientado para
43
3.2. DEFINICIÓN DE LA TECNOLOGÍA DIGITAL A UTILIZAR
Figura 3.6: SoC Zybo de Xilinx. (Cortesı́a de Xilinx Inc.)
la interconexión con periféricos, lo cual es el caso de todos los microprocesadores; además, su gran
tamaño la descalifica inmediatamente dada la naturaleza del dispositivo propuesto.
El microcontrolador es una de las opciones más naturales para el dispositivo propuesto, es

relativamente fácil de programar y está orientado a la interconexión, sin embargo debe considerarse
que es un sistema secuencial y el tiempo de procesamiento incrementará proporcionalmente a la
complejidad del sistema y al número de sensores a procesar.
Por lo anterior y dado que los sensores a utilizar usan protocolos seriales para su comunicación
(SPI - Serial Protocol Interface, I2C - Inter-Integrated Circuit) se optó por un SoC de Xilinx,
mostrado en la Figura 3.6, el cual cuenta con dos procesadores ARM 9 y un FPGA equivalente a
un Artix-7. El microcontrolador puede encargarse de las tareas de comunicación mientras que el
FPGA se encargará de las tareas más exigentes del sistema en cuestión de procesamiento.
La naturaleza inherentemente paralela del FPGA permite, dependiendo de la tarea a realizar,

reducir el tiempo de procesamiento, respecto a tecnologı́as secuenciales, sin embargo esta no es su
única ventaja; al diseñarse el circuito puede especificarse la precisión de las variables a utilizar de
forma personalizada, algo que no es posible con los microcontroladores, donde el usuario se ajusta
a la arquitectura de los mismos (8, 16, 32 o 64 bits). Esta flexibilidad permite diseñar sistemas con
la precisión más adecuada en función de la naturaleza de las operaciones y de los datos a procesar.
44
Figura 3.7: Unidad de Medición inercial para determinar la orientación del dispositivo. (Cortesı́a
de Pololu Corporation).
3.3. Arquitectura general del sistema.
La tarea del sistema que resulta más compleja es mantener la estructura que se muestra en la
Figura 3.1 en posición vertical, es decir, mantener la plataforma horizontal, usando solamente dos
ruedas; para esto el sensor principal del sistema y el que requiere mayor procesamiento es la IMU
(Unidad de Medición Inercial, por Inertial Measurement Unit), compuesta por un acelerómetro,
un giróscopo y un magnetómetro, todos sensores de 3 ejes con precisión de 16 bits; mostrada en
la Figura 3.7. El giróscopo mide la velocidad angular en cada eje, con lo cual, integrando este
valor podrı́a calcularse la posición del dispositivo [5], pero estos sensores tienen un problema de
desplazamiento, es decir tienen cierta desviación de la velocidad angular real, lo que causa un
error acumulativo en el tiempo debido a la acción integral que se realiza para obtener el ángulo,
por lo que las mediciones son confiables solo en intervalos de tiempo cortos. El acelerómetro,
como su nombre indica, mide fuerzas de aceleración en cada eje, por lo que, puede darnos una
medida del ángulo como función de la aceleración estática debido a la gravedad, sin embargo
tiene el problema de altos niveles de ruido como resultado de la aceleración dinámica cuando el
robot se mueve horizontalmente. El magnetómetro es bastante similar al acelerómetro, pero en
lugar de detectar la gravedad detecta el norte magnético terrestre; al igual que los acelerómetros
son susceptibles al ruido. Debido a las caracterı́sticas de los sensores, en dispositivos robóticos
móviles no se utilizan de forma independiente para calcular la orientación, sino que se combinan los
datos para obtener una estimación más precisa de la orientación. En intervalos cortos la medición
del giróscopo puede ser confiable, pero cada determinado tiempo se utilizan las mediciones del
acelerómetro y el magnetómetro que, aunque ruidosas, en promedio son precisas y se utilizan para
compensar el error acumulado debido al giróscopo.
45
3.3. ARQUITECTURA GENERAL DEL SISTEMA.
Figura 3.8: Ángulos de orientación de la IMU. Pitch, roll y yaw; cabeceo, alabeo y guiñada,
respectivamente.
Figura 3.9: Diagrama general del funcionamiento del filtro que actualiza la DCM.
Existen diversas técnicas para calcular la orientación combinando los datos de estos sensores.
El resultado de este cálculo son los ángulos del dispositivo respecto a los ejes mostrados en el
esquema en la Figura 3.8. El método utilizado en este caso es el propuesto por [28], un filtro
complementario que utiliza la DCM (Direction Cosine Matrix - Matriz de Cosenos Directores)
para estimar la orientación de nuestro dispositivo respecto a un marco de referencia global. El
funcionamiento general de este algoritmo se muestra en la Figura 3.9. El fundamento teórico-
matemático para su funcionamiento puede consultarse en [29].
En la Figura 3.10 se muestra la arquitectura general del sistema, en cuestión de hardware, para
el equilibrio de la plataforma. El proceso inicia con la lectura de los tres sensores que se utilizan
46
para determinar la orientación del dispositivo: giróscopo, acelerómetro y magnetómetro; debido a

que son sensores de tres ejes, cada uno de ellos devuelve tres valores de 16 bits. La lectura de los
sensores se realiza con el ARM A9 por medio del protocolo I2C y son enviados al FPGA por
medio de la interfaz AXI Lite. El sistema espera una señal de arranque que es generada por el
microcontrolador posteriormente al envı́o de los datos. Al terminar el procesamiento se envı́a una
señal al microcontrolador que desencadena la lectura de los resultados.
Figura 3.10: Diagrama general de la arquitectura del sistema.
3.4. Diseño del controlador para el primer prototipo
Para efectos de probar el modelo propuesto por [5] se construyó un primer prototipo, no
funcional en su parte exoesquelética, mostrado en la Figura 3.11.
Los parámetros de este prototipo, requeridos en el modelo, se obtuvieron experimentalmente y

se muestran en la Tabla 3.3
Parámetro Sı́mbolo Valor Unidades

Masa del cuerpo del péndulo Mb 96.34 kg
Masa de cada rueda Mw 3.86 kg
Centro de masa (gravedad) desde la base d 0.1 m
Diámetro de las ruedas R 0.33 m
Distancia entre las ruedas L 0.6 m
Momentos de inercia del cuerpo respecto al eje x Ix 7.51 kgm2
Momentos de inercia del cuerpo respecto al eje z Iz 7.68 kgm2
Momentos de inercia de la rueda alrededor del centro Ia 0.25 kgm2
Aceleración debido a la gravedad g 9.81 ms−2
Tabla 3.3: Parámetros y variables del Péndulo invertido con ruedas.
Si bien el modelo del WIP contempla 6 variables (x, ẋ, ψ, ψ̇, φ y φ̇, que corresponden con el
desplazamiento lineal, la velocidad lineal, la posición angular en yaw, la velocidad angular en yaw,
47
3.4. DISEÑO DEL CONTROLADOR PARA EL PRIMER PROTOTIPO
Figura 3.11: Primer prototipo utilizado.
48
Figura 3.12: Sistema de referencia para el modelo del dispositivo.
la posición angular en pitch y la velocidad angular en pitch, respectivamente), inicialmente solo

se desea controlar la inclinación del dispositivo, para que mantenga la vertical (vertical del
exoesqueleto, horizontal de la plataforma), es decir su ángulo de pitch o cabeceo, ası́ como la
velocidad angular del mismo (φ y φ̇) por lo que puede hacerse una reducción de las matrices para
considerar únicamente estos estados. En la Figura 3.12 se muestra el sistema de referencia espacial
bajo al que se sujeta el modelo del sistema.
Las matrices del sistema considerando únicamente el cabeceo y su velocidad angular se muestran
a continuación:
 
 0 1
A=  (3.1)
t1 0
 
0
B=  (3.2)
t2
49
 
1 0
C=  (3.3)
0 1
 
0
D=  (3.4)
0
Donde:
t1 = (3.5)
(Mb R2 + 2Mw R2 + 2Ia ) + Mb dR

t2 = − (3.6)
Dado que estas matrices son una representación del modelo del sistema en cuestión, es posible
hacer análisis de su comportamiento a través de las mismas. Por ejemplo, si obtenemos los valores
propios de la matriz A podemos determinar si el sistema es o no estable en lazo abierto (sin
retroalimentación). Para ello utilizamos el comando eig (eigenvalues) de Matlab.
ValoresPropios = eig(A)
ValoresPropios =
3.5219
-3.5219
El hecho de que uno de estos valores sea No negativo muestra que el sistema es inestable sin
retroalimentación. En la Figura 3.13 se muestra una simulación del comportamiento del sistema
con con condiciones iniciales de 0.1745 radianes (10 grados) de inclinación , y 0 rad/s de
velocidad. Se vuelve a verificar la inestabilidad del sistema mostrándose que los valores de los
estados tienden a infinito.
Una vez que se comprueba que el sistema es inestable en lazo abierto, se busca un vector de
retroalimentación K que estabilice el sistema; para lo cual se proponen los polos siguientes del lado
50
Figura 3.13: Comportamiento del sistema sin retroalimentación.
estable (semiplano izquierdo) del plano complejo:
 
−8,1366 + 0,4192i
P olosP ropuestos =   (3.7)
−8,1366 − 0,4192i
y se calcula el vector de retroalimentación con la función place de Matlab.
K = place(A, B, PolosPropuestos)
K = [-473.1370, -97.7291]
Lo cual denota que debe multiplicarse el error en radianes en la orientación del sistema (φ) por
-473.1370, considerando la vertical (π/2 rads) como la salida deseada, y el error en la velocidad (φ̇)
por -97.7291, considerando 0 rads/s como la salida deseada, para efectos de estabilizar el sistema.
Para verificar la validez del vector de retroalimentación propuesto se analiza el comportamiento
del sistema retroalimentado. Primeramente se buscan los valores propios (eigenvalues) de la matriz
(A - B*K) con la función eig de Matlab.
EigVals = eig(A - B*K)
51
Figura 3.14: Modelo en simulink del sistema con retroalimentación.
eigvals =
-8.1366 + 0.4192i
-8.1366 - 0.4192i
El hecho de que ambos valores sean negativos en su parte real denota que el sistema es estable
con el vector de retroalimentación propuesto. En la Figura 3.14 se muestra el modelo en bloques de
simulink del sistema con retroalimentación, que genera el comportamiento de la Figura 3.15. Como
puede observarse, ante las mismas condiciones iniciales ([0.1745 radianes, 0 rad/s] ) el sistema logra
estabilizarse en poco más de un segundo, lo que se consideró como un comportamiento aceptable
y se procedió a la implementación del controlador.
Los polos fueron propuestos a después de realizar pruebas empı́ricas, corroborándose que va-
lores reales más cercanos al eje imaginario (menos negativos) conducen a mayores tiempos de
estabilización mientras que valores más alejados (más negativos) generan constantes de retroali-
mentación muy elevadas, que en resultarı́an en un consumo energético muy elevado en la práctica;
por otra parte, valores imaginarios más cercanos al eje real ralentizan la estabilización, mientras
que valores más alejados generan mayor oscilación en el sistema.
Una vez se corroboró en las simulaciones la controlabilidad del sistema, se procedió a la im-
plementación en el microcontrolador para realizar pruebas en el primer prototipo y verificar si las
constantes de retroalimentación calculadas, efectivamente generaban un comportamiento que lo
estabilizara.
52
Figura 3.15: Comportamiento del sistema con la retroalimentación propuesta.
3.5. Implementación en el microcontrolador
Para efectos de comparación, el algoritmo fue primeramente implementado en un microcontro-

lador ARM Cortex A9 de 650 MHz. El código fue portado de Arduino a C++ en la plataforma
Vivado SDK para programarlo en el Cortex A9 del Zybo.
En cada ciclo el programa utiliza los datos del giróscopo y el acelerómetro para actualizar la
matriz DCM que nos permite calcular los ángulos de pitch y roll (cabeceo y alabeo) y cada cinco
ciclos se utilizan los datos del magnetómetro para corregir el ángulo de yaw (guiñada). El código
completo puede consultarse en [30].
Se desarrolló la interfaz de la Figura 3.16 para mantener comunicación en lı́nea con el sistema;
la interfaz permite desplegar los ángulos actuales de pitch y roll (cabeceo y alabeo), ası́ como
modificar en tiempo real los parámetros de retroalimentación para verificar el comportamiento que
generan en el prototipo, acelerando la búsqueda empı́rica de constantes de retroalimentación.
Inicialmente se utilizó solo la constante de retroalimentación correspondiente al error en la

posición angular del dispositivo respecto a la vertical (φ, pitch o cabeceo), dejando en cero la
constante proporcional para el error en la velocidad de la misma (φ̇), en miras de encontrar el
53
3.6. IMPLEMENTACIÓN EN EL FPGA
Figura 3.16: Interfaz para comunicación en tiempo real con el sistema.
sistema más simple que lograra estabilizar el sistema. Al verificarse que este modelo de control
bastaba para equilibrar el sistema, a pesar de tener oscilaciones, se procedió a la implementación
en el FPGA, dejándose como una tarea futura la afinación del sistema de control para reducir las
oscilaciones al mı́nimo.
3.6. Implementación en el FPGA
Para la implementación en el FPGA se eligió la parte del algoritmo que se encarga de la

actualización de la matriz DCM, por considerarse la sección crucial del mismo y la que tendrı́a
mayores ventajas de su implementación en paralelo. En esta sección se realizan operaciones como
1. Multiplicación de Matrices. Presente en la casi totalidad de las áreas de las matemáticas

aplicadas, siendo sus aplicaciones más frecuentes en procesamiento de imágenes, robótica,
procesamiento de señales, entre otras [31].
54
La multiplicación de matrices estándar A x B = C se define en [32], como sigue:
N
X −1
Ci,j = Ai,k × Bk,j , (0 ≤ i < M, 0 ≤ j < R),
k=0
Donde las matrices A, B y C son de M × N , N × R y M × R, respectivamente. Para efectos

de simplicidad se considerarán matrices cuadradas de M × M .
La definición anterior puede describirse claramente en pseudocódigo de la forma:
Algoritmo 1 Pseudocódigo de la multiplicación de matrices

for i ← 0; i < M ; i ← i + 1 do
for j ← 0; j < M ; j ← j + 1 do
for k ← 0; k < M ; k ← k + 1 do
C[i, j] ← C[i, j] + (A[i, k] ∗ B[k, j])
end for
end for
end for
2. Escalamiento de un vector:  
ax 
 
pa = p 
 ay 

 
az
3. Suma de vectores:
     
ax  bx  ax + bx 
     
a+b= a  + b  =  a + b 
 y  y  y y
     
az bz az + b z
4. Suma de matrices:
 
A11 + B11 A12 + B12 A13 + B13 
 
A+B=
A21 + B21 A22 + B22 A23 + B23 

 
A31 + B31 A32 + B32 A33 + B33
55
Tabla 3.4: Ejemplos de tipos de datos definidos para la implementación en VHDL y cantidad de
bits utilizados
Tipo de dato Descripción Signo Bits parte entera Bits parte decim
int16 Datos recibidos de los sensores x 15 0
gyr vec t Vector del giróscopo escalado por una ganancia x 3 28
gyr gain t Ganancia por la que se multiplica 1 31
fpNorm Valores normalizados entre -1 y 1 x 1 30
Antes de iniciar la implementación en el FPGA se hicieron consideraciones acerca del software

a utilizar para la generación de los elementos de procesamiento (EP). Existen tecnologı́as definidas
como de desarrollo acelerado en las que el comportamiento del sistema puede definirse en un
dialecto de C llamado SystemC, y se especifica las secciones de código que pueden ser paralelizables.
Xilinx ofrece la herramienta Vivado High-Level Synthesis, la cual efectivamente acelera el desarrollo
pero también tiene algunas desventajas: es un software privativo cuyo costo ronda los $20,000 M.N.;
se pierde el control fino sobre nuestro sistema ya que es el software el que define la precisión de
los datos o la forma especı́fica en que se harán las operaciones; finalmente se pierde la capacidad
de portabilidad, ya que el sistema generado con Vivado HLS es solo para FPGA’s fabricados por
Xilinx. Por lo anterior se decidió realizar el sistema mediante VHDL utilizando las herramientas
gratuitas que Xilinx ofrece para sintetizar los módulos generados.
La primera consideración que se hizo para la implementación en el FPGA fue la precisión de

las variables a utilizar, ya que el uso de hardware está en función de esta. En la Tabla 3.4 se
muestran algunos de los tipos de datos creados ası́ como la cantidad de bits utilizados para su
representación. En la Sección A.1 pueden observarse todos los datos utilizados para el sistema.s
A pesar de que la intención de la implementación es paralelizar el procesamiento, hay secciones

que requieren datos calculados en alguna operación anterior y por tanto deben correr en forma
secuencial. La forma de especificar esto en VHDL es mediante una Máquina de Estados Finitos o
FSM (Finite-State Machine). Como puede verse en [33], existen dos tipos de FSM, la máquina
Mealy y la máquina Moore. En este caso utilizamos la máquina Moore debido a que es una máquina
sı́ncrona, es decir sus salidas cambian en función de las entradas pero solo cuando se presentan
flancos de subida del reloj, lo cual nos permite asegurar el momento preciso en que la máquina
56
Figura 3.17: Máquina de Estados para la Actualización de la DCM.
tiene salidas válidas. La Figura 3.17 muestra el esquema general de la máquina de estados para
la actualización de la Matriz de Cosenos Directores. En el Apéndice A se muestran los códigos en
VHDL para la implementación del sistema; en la Sección A.4 se muestra el código para generar la
máquina de estados que actualiza la DCM.
3.6.1. Primera arquitectura para la multiplicación de matrices
La tarea que mayor ventaja obtiene de la paralelización, ası́ como la que más hardware consume
resultó ser, como se esperaba, la multiplicación de matrices por lo tanto fue a la que mayor atención
se le prestó en busca de la implementación más eficiente.
La primera arquitectura utilizada para la multiplicación de matrices fue la mostrada en la
Figura 3.18, denominada arquitectura de Árbol. La forma de describirla con VHDL se muestra a
continuación:
package mat_mult is
function MatrixMul( A : M3f2_23; B : M3f2_23) return M3f2_23;
end mat_mult;
package body mat_mult is
function MatrixMul(A : M3f2_23; B : M3f2_23) return M3f2_23 is

variable i,j,k : integer := 0;
variable prodT : MatMMT := (others=>(others=>(others=>’0’)));
variable prod : M3f2_23 := (others=>(others=>(others=>’0’)));
57
begin
for i in 0 to 2 loop --(N’umero de renglones en la primer matriz - 1)
for j in 0 to 2 loop --(N’umero de columnas en la segunda matriz - 1)
for k in 0 to 2 loop --(N’umero de renglones en la segunda matriz

- 1)
prodT(i)(j) := prodT(i)(j) + (A(i)(k) * B(k)(j));
end loop;
prod(i)(j) := prodT(i)(j)(47 downto 23);
end loop;
end loop;
return prod;
end MatrixMul;
end mat_mult;
Figura 3.18: Arquitectura tipo Árbol para la multiplicación de matrices.
Con esta arquitectura todas las operaciones necesarias para la multiplicación de matrices se
tratan de realizar en un solo ciclo de reloj, para lo cual se hacen todas las multiplicaciones de forma
simultánea y se reduce la frecuencia del sistema para poder asegurar que tanto los tres productos
58
Tabla 3.5: Hardware utilizado para multiplicar matrices de 3x3 con distinta precisión con la arqui-
tectura de árbol.
Precisión (bits) DSP’s utilizados LUT (Lógica) Registros (Flip-flops)
16 (2.14) 27 (33.75 %) 0 (0 %) 0 (0 %)
18 (2.16) 27 (33.75 %) 0 (0 %) 0 (0 %)
25 (2.23) 54 (67.50 %) 450 (2.55 %) 450 (1.27 %)
32 (2.30) 80 (100 %) 9909 (56.3 %) 576 (1.63 %)
como las dos sumas necesarias para calcular cada elemento de la matriz puedan realizarse. El
sistema (Vivado) logra sintetizar este comportamiento, a costa del alto consumo de hardware
mostrado en la Tabla 3.5. Para comprender los datos de la tabla es necesario analizar la estructura
de los DSP’s (Digital Signal Processor - Procesador Digital de Señales) incluidos en el Zybo.
Los DSP’s son elementos de hardware desarrollados especialmente para realizar multiplicación de
señales de manera eficiente. El Zybo cuenta con 80 DSP’s modelo DSP48E1 de 18x25 bits; esto es,
puede multiplicar señales de 18 bits por señales de 25 bits, la razón de que no sean simétricos es
que, a menudo, cuando se procesan señales los coeficientes tienen mayor precisión que los datos de
los sensores. Por esto es que, como se observa en la tabla, para datos de 16 y hasta 18 bits se utilizan
27 DSP’s, el número de multiplicaciones necesarias para una matriz de 3x3; para datos entre 19 y
25 bits se requieren 2 DSP’s para cada multiplicación y para datos de 26 o más bits se requieren
al menos 3 DSP’s para cada multiplicación (al menos en la etapa de Sı́ntesis, ya que en la etapa
de Implementación el software puede aplicar optimizaciones adicionales). Ası́, para una precisión
de 32 bits los multiplicadores dedicados son insuficientes y parte de la lógica se implementa en el
resto del hardware del FPGA (Look Up Table’s - Tablas de consulta, y Flip Flops).
Para verificar que las operaciones se estuvieran realizando efectivamente en un ciclo de reloj
se interconectó el sistema con un Analizador Lógico TLA5204B de Tektronix como el mostrado
en la Figura 3.19, enviando una parte de los bits de la matriz resultante a través de los puertos
de salida PMOD del Zybo, obteniéndose los resultados mostrados en la Figura 3.20. El grupo
de pines denominado QpMU es el “Estado Presente”de la máquina de estados encargada de la
actualización de la DCM. En el estado 5 se le asignan valores a las matrices a multiplicar cuyo
producto se almacena en TMatrix, de la cual observamos algunos bits que de antemano sabemos
59
Figura 3.19: Analizador Lógico TLA5204B de Tektronix.
Figura 3.20: Comportamiento de las señales del sistema para la multiplicación de matrices.
Tabla 3.6: Hardware utilizado para la actualización de la DCM con la arquitectura de Árbol.
25 (2.23) 57 (71.25 %) 1874 (10.64 %) 862 (2.44 %)
que deben cambiar dados los datos con que alimentamos al sistema. En el ciclo de reloj siguiente a la
alimentación del sistema TMatrix obtiene su valor y ya no cambia hasta el final del procesamiento
(ProcListo) cuando se le asigna un valor de cero manualmente; lo anterior nos permite inferir que
efectivamente el sistema realiza la multiplicación de dos matrices de 3 × 3 en un solo ciclo de reloj,
sin embargo, la frecuencia del sistema se reduce a 80 MHz para que esto sea posible.
El hardware utilizado en la implementación para la actualización de la DCM con una precisión

de 25 bits se muestra en la Figura 3.21, ası́ como en la Tabla 3.6.
3.6.2. Segunda arquitectura para la multiplicación de matrices
Debido al alto consumo de hardware presentado por la arquitectura de Árbol y dado que uno de
los objetivos de la implementación en el FPGA era dejar como una posibilidad la lectura de varios
60
Figura 3.21: Representación del hardware utilizado para la actualización de la DCM con la arqui-
tectura de Árbol y precisión de 25 bits.
sensores en paralelo, se buscó una segunda arquitectura, más eficiente en cuestión de hardware.
La propuesta se muestra en la Figura 3.22, denominada de Multiplicador-Acumulador (MAC),
basada en la propuesta mostrada en [34]. Como se observa, para cada elemento de la matriz se
implementa un acumulador que suma los tres productos necesarios para calcular ese elemento.
Nueve elementos de procesamiento como estos implementados en paralelo permiten calcular la
matriz resultante en tres ciclos de reloj.
Figura 3.22: Arquitectura tipo Multiplicador-Acumulador para la multiplicación de matrices.
61
El código en VHDL que describe este comportamiento se muestra a continuación:
use IEEE.NUMERIC_STD.ALL;
use work.tipos_datos.all;
entity VectorMultIterativo is
Port (
Clk : in std_logic;
Rst : in std_logic;
En : in std_logic;
Ind : in IndMat;
VR : in ar3Norm; --Vector Renglon.
VC : in ar3Norm; --Vector Columna
Eo : out fpNorm --Escalar de Salida.

);
end VectorMultIterativo;
architecture Behavioral of VectorMultIterativo is

signal Acumulador : fpNormMultAcum;
signal Producto : fpNormMult;
begin
process (Clk) begin

if rising_edge(Clk) then
if Rst = ’0’ then
Acumulador <= (others => ’0’);
Producto <= (others => ’0’);
else
if En = ’1’ then
Acumulador <= Acumulador + Producto;
--fpNorm * fpNorm
--(I_P_NS*2)+(F_PRE_S*2)
Producto <= VR(Ind) * VC(Ind);
end if;
end if;
end if;
end process;
Eo <= Acumulador(F_PRE_S*2+I_P_NS -1 downto F_PRE_S);
end Behavioral;
El hardware utilizado para la multiplicación de matrices con la arquitectura Multiplicador-
62
tectura de MAC y precisión de 25 bits.
Acumulador (MAC) se muestra en la Tabla 3.7; mientras que en la Tabla 3.8 y la Figura 3.23 se
muestra el uso de hardware para todo el proceso de la actualización de la DCM con una precisión
de 25 bits con la segunda arquitectura.
Tabla 3.7: Hardware utilizado para multiplicación de matrices de 3x3 con la arquitectura
Multiplicador-Acumulador .
25 (2.23) 18 (22.5 %) 584 (3.31 %) 587 (1.66 %)
32 (2.30) 36 (45 %) 1170 (6.64 %) 868 (2.46 %)
Tabla 3.8: Hardware utilizado para la actualización de la DCM con la arquitectura MAC.
25 (2.23) 21 (26.25 %) 3474 (19.73 %) 2713 (7.70 %)
Al observarse una reducción en el uso del hardware a casi un cuarto de los multiplicadores
dedicados disponibles, se procedió a incrementar la precisión general del sistema de 25 a 32 bits.
A pesar de que el microcontrolador también utiliza registros de 32 bits, usa el estándar IEEE
63
tectura MAC y precisión de 32 bits.
754 para valores flotantes para representar los datos, en el cual solo 23 bits son utilizados para el
significante o mantisa, mientras que en el sistema implementado, dado que se sabe de antemano
que se utilizarán valores normalizados [-1, 1] se utilizan 30 bits para la parte fraccional y solo dos
bits para la parte entera con signo, lo que va en pro de la precisión del sistema.
En la Figura 3.24 se muestra el hardware utilizado para la actualización de la DCM (Direction
Cosine Matrix - Matriz de Cosenos Directores) con una precisión de 32 bits.
Mientras que en la Figura 3.25 se muestra el diagrama de bloques de interconexión del sistema
en el entorno Vivado. Como se observa, la sección correspondiente a los cálculos para la actua-
lización de la DCM se integran en el bloque denominado DCM Matrix Update 0, que mantiene
comunicación con el resto del sistema mediante el protocolo AXI.
64
Figura 3.25: Diagrama de bloques del sistema en Vivado.
65
Capı́tulo 4
Resultados, conclusiones y trabajo

futuro
4.1. Resultados
Se diseñó y construyó el prototipo de la Figura 3.4, actualmente se logra estabilizar el disposi-

tivo aunque sus oscilaciones son de alrededor de ±5o , consideradas grandes dada la aplicación del
dispositivo, pero aceptables para realizar pruebas con el sistema.
En el aspecto de los sistemas digitales, una de las caracterı́sticas de VHDL es que permite
escribir test benches (bancos de prueba) en el mismo lenguaje que el diseño a ser verificado [35]. El
primer recurso y el más rápido para realizar pruebas sobre los módulos diseñados es la simulación,
que se realiza mediante los mencionados test benches o bancos de pruebas.
Un banco de pruebas es un módulo en VHDL que es “autosuficiente”, es decir, no tiene entradas

ni salidas, pero dentro de este se instancia el módulo o circuito que se simulará y se definen las
señales de entrada con las que se desea probar el circuito instanciado, ası́ como las señales de
salida donde se recibirán las salidas del circuito bajo prueba. En el Apéndice B se muestran
los bancos de prueba realizados para los distintos módulos del sistema. Mediante el banco de
pruebas podemos verificar si el módulo instanciado se comporta de la forma esperada ante las
entradas con que se alimente, además pueden definirse relojes, en el caso de sistemas sı́ncronos,
entre otras. Cabe destacar que VHDL tiene instrucciones que son especı́ficas para la simulación y
66
CAPÍTULO 4. RESULTADOS, CONCLUSIONES Y TRABAJO
FUTURO
Figura 4.1: Opción de simulación en el Manejador de Proyectos de Vivado.
no son “sintetizablesçomo las funciones, wait, wait for, entre otras, que no pueden utilizarse en la
descripción de la entidad o circuito, sino solamente para describir escenarios en los que el circuito
podrı́a funcionar, por ejemplo para especificar que se esperen 10 ms antes de enviar la siguiente
entrada.
Vivado ofrece Vivado Simulator, mostrado en la Figura 4.1, como parte de su versión gratuita,
que se utilizó para desarrollar los bancos de pruebas con los que se probaron los circuitos diseñados.
La Figura 4.2 muestra una simulación de 50 ciclos de reloj del funcionamiento del sistema que
actualiza la Matriz de Cosenos Directores. El procesamiento inicia con el flanco de subida de la señal
s IniciarProc lo que arranca la máquina de estados finitos general del sistema, pasa por los distintos
estados (Qp) y al finalizar envı́a la señal s ProcListo, que es leı́da desde el microcontrolador para
desencadenar la lectura de los resultados.
67
4.1. RESULTADOS
Figura 4.2: Simulación de 40 ciclos de reloj del sistema que actualiza la DCM.
La Figura 4.3 muestra 25 ciclos de reloj de simulación del módulo encargado de actualizar la
matriz DCM
Para efectos de comparar los tiempos de procesamiento para actualizar la DCM en el micro-
controlador y el FPGA, en la implementación real, se utilizó un contador que opera a la misma
frecuencia que el reloj del FPGA para medir el tiempo de procesamiento en el microcontrolador.
El tiempo de procesamiento en el FPGA (o al menos los ciclos de reloj necesarios) se conoce de
antemano ya que está en función de la Máquina de Estados diseñada. En el caso de la arquitectura
tipo árbol el procesamiento completo requiere 13 ciclos de reloj.
La Tabla 4.1 muestra 10 iteraciones del algoritmo corriendo en el µC (microcontrolador) con el

máximo nivel de optimización (O3). Con esta arquitectura la mejorı́a en velocidad de procesamiento
es de 1.96 a 1, sin embargo, como se recuerda, esta arquitectura tenı́a un alto consumo de hardware.
En la Tabla 4.2 se muestran 10 iteraciones del sistema corriendo en el microcontrolador,

implementando en el FPGA la arquitectura MAC (Multiplicador-Acumulador). La razón por la
que los ciclos de reloj aumentan es que la arquitectura más sencilla en cuestión de hardware del
MAC permite aumentar la frecuencia general del sistema y mientras que en la arquitectura
de árbol el reloj funcionaba a 80 MHz en este caso lo hace a 100 MHz, con lo que a pesar de
68
FUTURO
Figura 4.3: Simulación de 40 ciclos de reloj del sistema que actualiza la DCM.
Tabla 4.1: Tiempos de procesamiento en el microcontrolador con optimización O3.

Iteración 1 2 3 4 5 6 7 8 9 10
Ticks µC 26 26 26 24 26 26 26 24 26 26
Promedio: 25.6
Ticks FPGA: 13
Proporción: 1.97
69
4.2. CONCLUSIONES
Tabla 4.2: Tiempos de procesamiento en ticks del FPGA con la segunda arquitectura de Multipli-
cación de matrices.
Iteración 1 2 3 4 5 6 7 8 9 10
Ticks µC 32 30 31 32 32 31 31 32 32 31
Promedio 31.4
Ticks FPGA: 15
Proporción 2.09
que la actualización de la DCM ahora toma 15 ciclos, no solo se reduce el uso de hardware sino
que además se incrementa la velocidad de procesamiento en un 8 %.
Una vez implementado el sistema en el FPGA se verificó que los cálculos realizados por el
microcontrolador y el FPGA coincidieran, validándose experimentalmente obteniendo los datos de
la Tabla.
Se implementaron además funciones para calcular el seno, el coseno, y la raı́z cuadrada (con
resultado entero), basadas en el método CORDIC [36, 37], ası́ como una función para calcular la
arco tangente, propuesta por en [38, 39], que también son requeridas por el filtro complementario
que utiliza la DCM, y aunque de momento no están integradas en el sistema en el FPGA podrı́an
integrarse para realizar más tareas del filtro en la electrónica. Los códigos en VHDL de los circuitos
y los bancos de prueba se pueden consultar en Apéndice C.
4.2. Conclusiones
Se diseñó, construyó y estabilizó exitosamente un dispositivo exoesquelético autobalanceado que

se propone como asistencia para personas con debilidad muscular, buscando permitir las postura
de pie y la transición sentado a parado desde una silla de ruedas.
El sistema de control fue diseñado, basado en la técnica de Variables de estados, y se encontraron

valores de retroalimentación que estabilizaron experimentalmente el primer prototipo, si bien el
sistema tiene una oscilación que se considera elevada dada la aplicación especı́fica, es aceptable
para efectos de pruebas.
El sistema fue portado exitosamente a C++ e implementado en un microncontrolador ARM
70
FUTURO
Tabla 4.3: Ángulos de Euler calculados por el microcontrolador (PS) y el FPGA (PL).
Plataforma Pitch Roll Yaw
PS 0001.01 -000.88 -082.43
PL 0001.01 -000.88 -082.43
PS 0001.02 -000.86 -082.43
PL 0001.02 -000.86 -082.43
PS 0001.00 -000.89 -082.44
PL 0001.00 -000.89 -082.44
PS 0000.93 -000.89 -082.44
PL 0000.93 -000.89 -082.44
PS 0000.86 -000.89 -082.45
PL 0000.86 -000.89 -082.45
PS 0000.81 -000.90 -082.44
PL 0000.81 -000.90 -082.44
PS 0000.82 -000.92 -082.44
PL 0000.82 -000.92 -082.44
PS 0000.85 -000.94 -082.44
PL 0000.85 -000.94 -082.44
PS 0000.85 -000.96 -082.44
PL 0000.85 -000.96 -082.44
PS 0000.83 -000.96 -082.44
PL 0000.83 -000.96 -082.44
71
4.3. TRABAJO FUTURO
Cortex A9, realizando el procesamiento en aproximadamente 2 ms. Dadas las frecuencias de mues-
treo de los sensores utilizados (50 Hz) tanto el microcontrolador como el FPGA tienen un tiempo
de respuesta aceptable.
Se implementó la parte del sistema que se consideró crucial en el FPGA, buscando una ar-
quitectura que fuera eficiente en cuestión de hardware, logrando reducir el uso del 100 % de los
multiplicadores dedicados con los que cuenta la plataforma utilizada al implementar una arqui-
tectura tipo Árbol, a un 48.75 % usando una arquitectura de Multiplicadores-Acumuladores,
que además de reducir a algo menos de la mitad el uso de hardware incrementa la velocidad de
procesamiento un 8 % respecto a la primer propuesta en el FPGA.
La implementación de la sección del sistema implementada en el FPGA muestra una reducción

del tiempo de procesamiento a un 48 % respecto al tiempo que le toma al microcontrolador la
ejecución de esa misma sección del algoritmo configurando el compilador para el mayor nivel de
optimización (O3).
La hipótesis “El algoritmo implementado en el FPGA tendrá un mejor desempeño para efectos
de tiempo de procesamiento que en un procesador secuencial”se comprueba; sin embargo, dada la
frecuencia de muestreo de los sensores, tanto el FPGA como el microcontrolador logran hacer la
totalidad de los cálculos antes de la siguiente entrada de datos. Aunque se ha reducido el tiempo
de procesamiento a la mitad esto no tiene efecto sobre el tiempo de estabilización del sistema, pero
dada la mencionada reducción, se tiene una mayor holgura para trabajo futuro con algoritmos
más complejos (por ejemplo de marcha bı́peda) o bien, como se recomienda en sistemas que tienen
interacción con humanos, para implementar sensores redundantes para efectos de seguridad, lo que
en el microcontrolador tomará el doble de tiempo para el procesamiento, mientras que en el FPGA
mantendrá el tiempo actual, siempre que el hardware disponible sea suficiente para implementar
los elementos de procesamiento necesarios.
4.3. Trabajo futuro
A pesar de que se logró estabilizar el dispositivo se buscará afinar el sistema de control para
reducir al mı́nimo posible la amplitud de las oscilaciones de la plataforma.
72
FUTURO
Se continuará con el desarrollo de la estructura exoesquelética para sujetar adecuadamente los
miembros del usuario y brindar soporte para lograr la transición sentado-parado.
Se implementarán sistemas de comunicación inalámbrica para interactuar con el sistema a
través de una computadora, en tiempo real, modificando valores de control y analizando el com-
portamiento generado por los mismos.
73
Bibliografı́a
[1] Jonathan Martı́nez Paredes. Diseño de un exoesqueleto para miembro inferior. PhD thesis,
Instituto Politécnico Nacional, 2013.
[2] Adam Zoss and H Kazerooni. Design of an electrically actuated lower extremity exoskeleton.
20(9):967–988, 2006.
[3] Khairul Anam and Adel Ali Al-jumaily. Active Exoskeleton Control Systems: State of the
Art. 41(Iris):988–994, 2012.
[4] Zhijun Li, Chenguang Yang, and Liping Fan. Advanced Control of Wheeled Inverted Pendulum
Systems. Springer, London, 2013.
[5] Amir A Bature, Salinda Buyamin, Mohamed N Ahmad, and Mustapha Muhammad. A Com-
parison of Controllers for Balancing Two Wheeled Inverted Pendulum Robot. International
Journal of Mechanical & Mechatronics Engineering IJMME-IJENS, 14(03):62–68, 2014.
[6] Arnoldo Castro. Modeling and dynamic analysis of a Two-Wheeled Inverted-Pendulum. PhD
thesis, Georgia Institute of Technology, 2012.
[7] Mao-Lin Chen. Analysis and Design of Robust Feedback Control Systems for a Nonlinear Two-
Wheel Inverted Pendulum System. 2012 International Symposium on Computer, Consumer
and Control, pages 949–953, June 2012.
[8] Muhammad Umar Draz, Shaheer Mohsin Ali, Maryam Majeed, Umair Ejaz, and Umer Izhar.
Segway Electric Vehicle Human Transporter. pages 34–39, 2012.
74
BIBLIOGRAFÍA
[9] K.J. Astrom and K Furuta. Swinging up a pendulum by energy control. Automatica, 36:287–
295, 2000.
[10] Seokmin Hong, Yonghwan Oh, Doik Kim, and Bum-jae You. Real-Time Walking Pattern Ge-
neration Method for Humanoid Robots by Combining Feedback and Feedforward Controller.
IEEE Transactions on Industrial Electronics, 61(1):355–364, 2014.
[11] Bian Yongming, Jiang Jia, Xu Xinming, and Zhu Lijing. Research on Inverted Pendulum
Network Control Technology. 2011 Third International Conference on Measuring Technology
and Mechatronics Automation, pages 11–13, January 2011.
[12] Liu Shuang and Fang Jian. Linear Quadratic Optimal Controller Design an Inverted Pen-
dulum. 2014 International Symposium on Computer, Consumer and Control, pages 416–418,
June 2014.
[13] Nobelprize.org. The History of the Integrated Circuit, 2014.
[14] Bob Zeidman. Designing with FPGAs and CPLDSs. Elsevier, 2002.
[15] Ronald J. Tocci, Neal S. Widmer, and Gregory L. Moss. Sistemas Digitales - Principios y
aplicaciones. Pearson, 10 edition, 2007.
[16] Ian Grout. Digital Systems Design with FPGAS. Elsevier, Burlington, MA, 2008.
[17] Juan Carlos Herrera Lozada. Implementación de un controlador difuso en un FPGA, uti-
lizando lenguajes de descripción de hardware. PhD thesis, Instituto Politécnico Nacional,
2002.
[18] Michael Smith. Applications Specific Integrated Circuits. Addison - Wesley, 1998.
[19] Himanshu Bhatnagar. Advanced ASIC Chip Synthesis Using Sinopsis Design Compiler and
PrimeTime. Kluwer Academic, 1999.
[20] Joseph DiGiacomo. Designing with High Performance ASICs. Prentice Hall, 1997.
[21] David Pallerin. Practical Design Usign Programmable Logic. Prentice Hall, 1996.
75
BIBLIOGRAFÍA
[22] Ashok Shama. Programmable Logic Handbook. McGraw-Hill, 1999.
[23] Salcic Zoran. Digital Systems Design and Prototyping Using Field Programmable Logic. Klu-
wer Academic, 1998.
[24] Richard Seals. Programmable Logic PLDs and FPGAs. McGraw-Hill, 1997.
[25] Harris Mano. Logic and Computer Design Fundamentals. Prentice Hall, 2000.
[26] Richard C. Dorf and Robert H. Bishop. Modern Control Systems. 11 edition, 2008.
[27] Daniel J. Block, Karl J. Å ström, and Mark W. Spong. The Reaction Wheel Pendulum,
volume 1. January 2007.
[28] Bill Premerlani, Jordi Munoz, Jose Julio, Doug Weibel, and Ahmad Byagowi. Ardu-IMU,
2011.
[29] William Premerlani and Paul Bizard. Direction Cosine Matrix IMU : Theory. 2009.
[30] Doug Weibel, Jose Julio, Jordi Munoz, and William Premerlani. MinIMU-9-AHRS-Arduino,
2013.
[31] Ju-Wook Jang, S.B. Choi, and V.K. Prasanna. Energy and time efficient matrix multiplication
on FPGAs. IEEE Transactions on Very Large Scale Integration (VLSI) Systems, 13(11):1305–
1319, November 2005.
[32] Yong Dou, S. Vassiliadis, G. K. Kuzmanov, and G. N. Gaydadjiev. 64-bit floating-point FPGA
matrix multiplication. Proceedings of the 2005 ACM/SIGDA 13th international symposium
on Field-programmable gate arrays - FPGA ’05, page 86, 2005.
[33] René de Jesús Romero Troncoso. Electrónica digital y lógica programable. Universidad de
Guanajuato, 2007.
[34] Xilinx. Vivado Design Suite User Guide - Synthesis. Technical report, 2013.
[35] Peter J. Ashenden and James Lewis. The Designer’s guide to VHDL. Morgan Kaufmann, 3
edition, 2008.
76
BIBLIOGRAFÍA
[36] Jack E Volder. The CORDIC Trigonometric Computing Technique. IRE Transactios on
Electronic Computers, pages 330–334, 1959.
[37] Jean-Pierre Deschamps, Gustavo D. Sutter, and Enrique Cantó. Guide to FPGA Implemen-
tation of Arithmetic Functions. Springer, 2012.
[38] Dale Drinkard. Arctan verilog Opencores, 2008.
[39] Ray Andraka. A survey of CORDIC algorithms for FPGA based computers. Proceedings of
the 1998 ACM/SIGDA sixth international symposium on Field programmable gate arrays -
FPGA ’98, pages 191–200, 1998.
[40] Digilent. ZYBO Reference Manual. pages 1–26, 2014.
[41] K.J. Astrom, J. Aracil, and F. Gordillo. A family of smooth controllers for swinging up a
pendulum. Automatica, 44(7):1841–1848, July 2008.
[42] Xilinx. Vivado Design Suite User Guide - High Level Synthesys. 902:1–660, 2014.
[43] Johan Akesson and Karl Johan Astrom. Safe Manual Control of the Furuta Pendulum. pages
0–5, 1998.
[44] ARM. AMBA 4 AXI4-Stream Protocol. Technical report, 2010.
[45] Daniele Bagni, Juanjo Noguera, and Fernando Martinez Vallina. Zynq-7000 All Programmable
SoC Accelerator for Floating-Point Matrix Multiplication using Vivado HLS. Technical report,
2013.
[46] Panos J Antsaklis and Anthony N Michel. A linear systems primer. 2007.
[47] Xilinx. Zynq-7000 All Programmable SoC Software Developers Guide. 821, 2014.
[48] David Goldberg. What Every Computer Scientist Should Know About Floating-Point Arith-
metic. Computing Surveys, 1991.
[49] Starlino. DCM Tutorial - An introduction to orientation kinematics, 2011.
77
BIBLIOGRAFÍA
[50] Xilinx. Vivado Design Suite User Guide - Designing IP Subsystems Using IP Integrator.
Technical report, 2014.
[51] Ezzaldeen Edwan, Jieying Zhang, Junchuan Zhou, and Otmar Loffeld. Reduced DCM based
attitude estimation using low-cost IMU and magnetometer triad. 2011 8th Workshop on
Positioning, Navigation and Communication, pages 1–6, April 2011.
[52] Xilinx. Xilinx University Program, 2014.
[53] Robert Mahony, Senior Member, Tarek Hamel, and Jean-michel Pflimlin. Nonlinear Comple-
mentary Filters on the Special Orthogonal Group. 53(5):1203–1218, 2008.
[54] Sun-ting Lin, Tzu-hao Wang, Shou-sheu Lin, and Yan-bang Li. Proceedings of the 2nd In-
ternational Conference on Intelligent Technologies and Engineering Systems (ICITES2013).
293, 2014.
[55] Richard C. Dorf and Robert H. Bishop. Sistemas de control moderno. 10 edition, 2005.
[56] Louise H Crockett, Ross A Elliot, Martin A Enderwitz, and Robert W Stewart. The Zynq
Book: Embedded Processing with the ARM Cortex-A9 on the Xilinx Zynq-7000 All Program-
mable SoC. Strathclyde Academic Media, first edition, 2014.
[57] Xilinx. Zynq-7000 All Programmable SoC - Technical Reference Manual. Technical report,
2015.
[58] Karl Johan Astrom and Richard M Murray. Feedback Systems An Introduction for Scientists
and Engineers. Princeton University Press, 2 edition, 2012.
[59] Xilinx. AXI Reference Guide. Technical report, 2012.
[60] Douglas L Perry. VHDL Programming by Example. McGraw-Hill, 4 edition, 2002.
78
Apéndices
79
Apéndices A
Descripción de los módulos del sistema

en VHDL
A.1. Tipos de datos definidos
library IEEE;
use ieee.numeric_std.all; --Signed / Unsigned values
package tipos_datos is
constant INT_PS : natural := 16; --Integer precision for sensor’s data.
constant I_P_GV : natural := 4; --Integer precision for gyro vector type.
constant F_P_GV : natural := 28; --Fractional precision for gyro vector
type.
constant I_P_NS : natural := 2; --Interger Precision of a Normalized

signed integer.
constant F_PRE_U : natural := 31; --FRACTIONAL_PRECISION_UNSIGNED
Normalized type
constant F_PRE_S : natural := 30; --FRACTIONAL_PRECISION_SIGNED
Normalized type.
--/// TIPOS EN MATRIX UPDATE

--///** Tipo de dato para los valores de entrada de los sensores.
subtype int16 is signed(15 downto 0); --16 bits para enteros con signo, 0
para decimales.
type ar3_i16 is array (0 to 2) of int16; --AN_3

type ar9_i16 is array (0 to 8) of int16; --AN_9
--/// Tipos de datos para Gyro_Scaled

subtype gyr_vec_t is signed(I_P_GV + F_P_GV -1 downto 0); -- 4_28 --
80
APÉNDICES A. DESCRIPCIÓN DE LOS MÓDULOS DEL SISTEMA
EN VHDL
8.24--al multiplicar gyro_v * gyro_gain_rad se obtiene m’aximo 40 (
Considerando que gyro_X es una variable de
-- 16 bits con signo, asi que 15 bits que al multiplicarse por 0.001221
produce m’aximo 40; con 7 bits, 8 con signo podr’iamos albergarlo
-- pero debemos buscar los valores reales para reducir al m’inimo la
cantidad de bits. Se encontr’o el intervalo: -4.108197, 3.871889 Con 4
bits basta.
type ar3_gv is array (0 to 2) of gyr_vec_t;
subtype gyr_gain_t is signed(1 + F_PRE_U -1 downto 0); -- 1.F_PRE_U

subtype gv_temp_t is signed(16 + 1 + F_PRE_U -1 downto 0); --i16*
gyr_gain_t
type ar3_gv_temp is array(0 to 2) of gv_temp_t;
--///** Tipos para UpdateMatrixAssign

----M’inimo 2 bits para parte entera con signo.
subtype fpNorm is signed(I_P_NS+F_PRE_S-1 downto 0); --(1 downto -23)
G_Dt y G_DtN.
subtype fpNormGV is signed(I_P_GV+I_P_NS + F_P_GV+F_PRE_S-1 downto 0);

--UpdateMatrixTemporal f2_23 * f8_24
type ar3NormGV is array (0 to 2) of fpNormGV;
type MatNormGV is array (0 to 2) of ar3NormGV;
type ar3Norm is array(0 to 2) of fpNorm;

type M3Norm is array(0 to 2) of ar3Norm; --Update_Matrix, DCM_Matrix,
Temporary_Matrix
--///** Tipos para matriz Multiply

subtype fpNormMult is signed((I_P_NS*2)+(F_PRE_S*2)-1 downto 0);
subtype fpNormMultAcum is signed((I_P_NS*2)+(F_PRE_S*2) downto 0);
subtype IndMat is integer range 0 to 2;

end package tipos_datos;
A.2. Aplicación de offsets a las entradas (AsignaDatos.vhd)

library IEEE;
use IEEE.NUMERIC_STD.ALL;-- Arithmetic functions with Signed or Unsigned values
entity AsignaDatos is
Port (
Clk : in std_logic;
81
A.2. APLICACIÓN DE OFFSETS A LAS ENTRADAS
(ASIGNADATOS.VHD)
AN : in ar9_i16; --Arreglo de elementos con los valores leidos de los
sensores.
AN_OFFSET : in ar9_i16; --Arreglo de Offsets de las mediciones iniciales
de los sensores.
Gyr_Arr : out ar3_i16;

Acc_Arr : out ar3_i16;
Mag_Arr : out ar3_i16
);
end AsignaDatos;
architecture Behavioral of AsignaDatos is

signal ANTemp : ar9_i16;
signal AN_OFFTemp : ar9_i16;
signal GYRTemp,MAGTemp : ar3_i16;

signal ACCTemp,ACCTemp2 : ar3_i16;
signal GYR_OUT : ar3_i16 := (others=>(others=>’0’));
signal ACC_OUT : ar3_i16 := (others=>(others=>’0’));
signal MAG_OUT : ar3_i16 := (others=>(others=>’0’));
begin
Combinacional : process (Clk, ANTemp, AN_OFFTemp)
begin
for ii in 0 to 2 loop
GYRTemp(ii) <= ANTemp(ii) - AN_OFFTemp(ii);
ACCTemp(ii) <= SHIFT_RIGHT(ANTemp(ii+3),4); --Al ser un valor
constante de corrimiento solo implementa redireccionamiento y
puede hacerlo en un solo tick.
ACCTemp2(ii) <= AN_OFFTemp(ii+3) - ACCTemp(ii); -- -(AN - OFF)
MAGTemp(ii) <= ANTemp(ii+6);
end loop;
end if;
end process;
Gyr_Arr <= GYR_OUT;

Acc_Arr <= ACC_OUT;
Mag_Arr <= MAG_OUT;
Secuencial : process(Clk)
begin
ANTemp <= AN;
AN_OFFTemp <= AN_OFFSET;
GYR_OUT <= GYRTemp;

ACC_OUT <= ACCTemp2;
82
EN VHDL
MAG_OUT <= MAGTemp;
end if;
end process;
end Behavioral;
A.3. FSM para todos los cálculos de la IMU (CalculosI-

MU.vhd)
library IEEE;
--library ieee_proposed;
--use ieee_proposed.fixed_pkg.all;
entity CalculosIMU is
Port (
Clk : in std_logic;
--Rst : in std_logic;
IniciarCalculosIMU : in std_logic;
CalcularHeading : in std_logic;
Gyr_Arr : in ar3_i16;
Acc_Arr : in ar3_i16;
Mag_Arr : in ar3_i16;
Omega_P : in ar3_gv;
Omega_I : in ar3_gv;
DCM_Matrix_In : in M3Norm;
DCM_Matrix_Out : out M3Norm; -- Salida temporal de los c’alculos (la
salida definitiva ser’ian los ’angulos de Euler).
QpMU : out std_logic_vector(3 downto 0);

Temporary_Matrix_out : out std_logic_vector(3 downto 0);
CalculosIMUListos : out std_logic

);
end CalculosIMU;
architecture Behavioral of CalculosIMU is

--//////////////////////////////
--// DECLARACI’ON DE COMPONENTES
83
A.3. FSM PARA TODOS LOS CÁLCULOS DE LA IMU
(CALCULOSIMU.VHD)
--//////////////////////////////
-- component CompassHeading is
-- Port (
-- Clk : in std_logic;
-- En : in std_logic
-- );
-- end Component;
Component MatrixUpdate is
Port (
Clk : in std_logic;
IniciarM : in std_logic;
DCM_Matrix_in : in M3Norm;
DCM_Matrix_out : out M3Norm;

MatrixUpdateTerminado : out std_logic

);
End Component;
-- Component Normalize is
-- Port(
-- Clk: in std_logic;
-- En: in std_logic
-- );
-- end Component;
-- Component DriftCorrection is
-- Port(
-- Clk : in std_logic;
-- En: in std_logic
-- );
-- End Component;
-- Component EulerAngles is
-- Port (
84
EN VHDL
-- Clk : in STD_LOGIC;
-- En : in STD_LOGIC
-- );
-- end Component;
--/////////////////////////////////
--// Se’nales para el procesamiento
--/////////////////////////////////
--/// Matriz DCM (cambia durante el procesamiento).

-- signal DCM_Matrix : M3Norm := ( ( (23=>’1’, others=>’0’), (others=>’0’), (
others=>’0’) ),
-- ( (others=>’0’), (23=>’1’, others=>’0’), (others=>’0’) ),
-- ( (others=>’0’), (others=>’0’), (23=>’1’, others=>’0’) ) );
-- signal DCM_Matrix_Temp : M3Norm := ( ( (F_PRE_S=>’1’, others=>’0’), (others

=>’0’), (others=>’0’) ),
-- ( (others=>’0’), (F_PRE_S=>’1’, others=>’0’), (others=>’0’) ),
-- ( (others=>’0’), (others=>’0’), (F_PRE_S=>’1’, others=>’0’) ) );
--/// T’erminos Integrales y Proporcionales (Cambian durante el procesamiento

).
--signal Omega_I : ar3_gv := (others => (others=>’0’)); --T’ermino Integral
de la ganancia del Gyro.
--signal Omega_P : ar3_gv := (others => (others=>’0’)); --T’ermino
Proporcional de la ganancia del Gyro.
--///////////////////////
--// M’AQUINA DE ESTADOS
--///////////////////////
--Estados presente y siguiente.
signal Qp : std_logic_vector(3 downto 0) := "0000";
signal Qn : std_logic_vector(3 downto 0);
--Estados de la machine.
constant EInicio : std_logic_vector(3 downto 0) := "0000";
constant ECompassHeading : std_logic_vector(3 downto 0) := "0001";
constant EMatrixUpdate : std_logic_vector(3 downto 0) := "0010"; --2
constant ENormalize : std_logic_vector(3 downto 0) := "0011";
constant EDriftCorrection : std_logic_vector(3 downto 0) := "0100"; --4
constant EEulerAngles : std_logic_vector(3 downto 0) := "0101";
constant ESalida : std_logic_vector(3 downto 0) := "0110"; --6
constant ESalida2 : std_logic_vector(3 downto 0) := "0111";
--Se’nal de arranque de la FSM para

signal IniciarMatrixUpdate : std_logic := ’0’;
85
(CALCULOSIMU.VHD)
--/// Se’nales de procesamiento completado.

signal CompassHeadingListo : std_logic := ’0’;
signal MatrixUpdateListo : std_logic := ’0’;
signal NormalizeListo : std_logic := ’0’;
signal DriftCorrectionListo : std_logic := ’0’;
signal EulerAnglesListo : std_logic := ’0’;
--//////////////////////////
begin
--///////////////////////////////
--// Instanciaciones
-- InstCompassHeading : CompassHeading
-- port map(Clk, En);
InstMatrixUpdate : MatrixUpdate
port map(
Clk, IniciarMatrixUpdate, --Rst,
Gyr_Arr, --Acc_Arr, Mag_Arr,
Omega_P, Omega_I,
DCM_Matrix_In, DCM_Matrix_Out,
QpMU,
Temporary_Matrix_out,
MatrixUpdateListo );
-- InstNormalize : Normalize
-- InstDriftCOrrection : DriftCorrection
-- InstEulerAngles : EulerAngles
--// Instanciaciones
--///////////////////////////////
--///////////////
--// M’aquina 501
--//////////////
Combinacional : process(Qp, CalcularHeading, CompassHeadingListo,
86
EN VHDL
IniciarCalculosIMU, MatrixUpdateListo) --Incluir todas las se’nales de
terminaci’on?
begin
case Qp is
when EInicio =>
CalculosIMUListos <= ’0’;
IniciarMatrixUpdate <= ’0’;
--MatrixUpdateListo <= ’0’; --Es la salida de un m’odulo, no lo
modificamos ac’a.
if IniciarCalculosIMU = ’1’ then --Arrancar la m’aquina.

Qn <= ECompassHeading;
else
Qn <= EInicio;
end if;
when ECompassHeading =>

if CalcularHeading = ’1’ then

if CompassHeadingListo = ’1’ then Qn <= EMatrixUpdate;
else Qn <= ECompassHeading;
end if;
else
Qn <= EMatrixUpdate;
end if;
when EMatrixUpdate =>

if MatrixUpdateListo = ’1’ then

Qn <= ESalida; --************** Temporal cambiar por ENormalize
--Qn <= ENormalize;
else
Qn <= EMatrixUpdate;
end if;
-- when ENormalize =>

-- EnCompassHeading <= ’0’;
-- EnMatrixUpdate <= ’0’;
-- EnNormalize <= ’1’;
-- EnDriftCorrection <= ’0’;
-- EnEulerAngles <= ’0’;
87
(CALCULOSIMU.VHD)
-- if NormalizeListo = ’1’ then

-- Qn <= EDriftCorrection;
-- end if;
-- when EDriftCorrection =>

-- CalculosIMUListos <= ’0’;
-- if DriftCorrectionListo = ’1’ then
-- Qn <= EEulerAngles;
-- end if;
-- when EEulerAngles =>

-- CalculosIMUListos <= ’0’;
-- if EulerAnglesListo = ’1’ then
-- Qn <= ESalida;
-- end if;
when ESalida =>

Qn <= ESalida2;
when ESalida2 =>

Qn <= EInicio;
when others =>

Qn <= EInicio;
End case;
end process;
Secuencial : process(Clk)
begin
if rising_edge(clk) then
Qp <= Qn;
end if;
end process;
88
EN VHDL
end Behavioral;
A.4. FSM Actualización de la DCM (MatrixUpdate.vhd)

library IEEE;
use IEEE.NUMERIC_STD.ALL; -- Arithmetic functions with Signed or Unsigned values
entity MatrixUpdate is
Port (
Clk : in std_logic;
DCM_Matrix_Out : out M3Norm;
--Salidas debugueo

);
end MatrixUpdate;
architecture Behavioral of MatrixUpdate is
--///////////////////////////////////
--//Declaraci’on de componentes
component Gyro_Scaled is
Port (
Clk : in std_logic;
gyro_v : in ar3_i16;
Gyro_Vector : out ar3_gv );
end component;
Component VectorAdd is
Port (
Clk : in std_logic;
89
A.4. FSM ACTUALIZACIÓN DE LA DCM (MATRIXUPDATE.VHD)
Vec1 : in ar3_gv;
Vec2 : in ar3_gv;
VecOut : out ar3_gv );
end Component;
Component UpdateMatrixAsig is
Port(
Clk : in std_logic;
OmegaVector : in ar3_gv;
UpdateMatrix : out M3Norm );
end component;
Component MatrixMultiply is
Port(
Clk: in std_logic;
Rst : in std_logic;
Update : in std_logic;
A : in M3Norm;
B : in M3Norm;
C : out M3Norm );
end component;
Component MatrixSuma is
Port(
Clk : in std_logic;
A : in M3Norm;
B : in M3Norm;
C : out M3Norm );
end Component;
-- Component Counter is
-- generic( objetivo : natural := 3 );
-- Port (
-- Clk : in std_Logic;
-- Reset : in STD_LOGIC;
-- Finalizado : out STD_LOGIC

-- );
-- end component;
--//Declaraci’on de componentes
--///////////////////////////////////
90
EN VHDL
--////////////////////////////////////////
--///Declaraci’on de Se’nales a utilizar
--///* Se’nales para la escalaci’on del Gyro
--signal s_gyro_v : ar3_i16;
signal s_Gyro_Vector : ar3_gv; --Salida de la escalaci’on
--///* Se’nales para sumar Omega_I y Omega_P.

signal Omega_Temp : ar3_gv;-- := (others => (others=>’0’));
signal Omega_Vector : ar3_gv;
--///* Se’nales para Asignar la matriz de actualizaci’on.

signal Update_Matrix : M3Norm; --Salida
--///* Se’nales para multiplicar la matriz.

signal DCM_Matrix_in_temp : M3Norm;-- := (others=>(others=>(others=>’0’)));
--Para asignarla en el estado correspondiente y analizar cuanto tiempo
tarda en estabilizarse la se’nal con el resultado.
signal Temporary_Matrix : M3Norm;
signal MatMult_Rst : std_logic := ’1’;
signal MatMult_Upd : std_logic := ’0’;
--///* Se’nales para sumar la Matriz Temporal a la Matriz DCM.

--signal DCMMatrixTemp : Mat33;
--///* Se’nales para el contador

signal Counter_MU_Rst : std_logic := ’1’;
signal Counter_MU : natural range 0 to 5;
--///Declaraci’on de Se’nales a utilizar

--///////////////////////////////////////
--///////////////////////////////////
--// M’aquina de estados.
signal Qp : std_logic_vector(3 downto 0) := "0000";
signal Qn : std_logic_vector(3 downto 0);
--/// Estados posibles de la m’aquina

constant EInicio : std_logic_vector(3 downto 0) := "0000";
constant EGyroScaled : std_logic_vector(3 downto 0) := "0001";
constant EAddOmegaI : std_logic_vector(3 downto 0) := "0010";
constant EAddOmegaP : std_logic_vector(3 downto 0) := "0011";
constant EAsigUpdateMatrix : std_logic_vector(3 downto 0) := "0100";
constant EMatrixMultiply : std_logic_vector(3 downto 0) := "0101";
--constant EContador3 : std_logic_vector(3 downto 0) := "0110";
constant EMatrixSuma : std_logic_vector(3 downto 0) := "0110";
91
constant ESalida : std_logic_vector(3 downto 0) := "0111";

constant ESalida2 : std_logic_vector(3 downto 0) := "1000";
--// M’aquina de estados.
--///////////////////////////////////
--signal Counter : unsigned(7 downto 0) := (others=>’0’) ;

begin
--////////////////////////////////////
--// INSTANCIACIONES
InstGyroScaled : Gyro_Scaled
port map(Clk, Gyr_Arr, s_Gyro_Vector);
-- arr3_i16 arr3f8_16
InstAddOmegaP : VectorAdd
port map(Clk, s_Gyro_Vector, Omega_P, Omega_Temp);
-- f8_24 + f8_24 = f8_24
InstAddOmegaI : VectorAdd
port map(Clk, Omega_Temp, Omega_I, Omega_Vector);
-- f8_24 + f8_24 = f8_24
InstAsigUpdateMatrix : UpdateMatrixAsig
port map(Clk, Omega_Vector, Update_Matrix);
-- f8_24 M3f2_23
InstMatrixMultiply : MatrixMultiply
port map(Clk, MatMult_Rst, MatMult_Upd, DCM_Matrix_in_temp, Update_Matrix
, Temporary_Matrix);
-- M3f2_23
InstMatrixAdd : MatrixSuma
port map(Clk, DCM_Matrix_in, Temporary_Matrix, DCM_Matrix_out);
--
-- InstCounter : Counter
-- generic map(3)
-- port map(Clk, s_Counter_Rst, s_Counter_Fin);
--////////////////////////////////////////
Contador : process(Clk, Counter_MU_Rst)

begin
if Counter_MU_Rst = ’0’ then
Counter_MU <= 0;
else
Counter_MU <= (Counter_MU + 1) MOD 4; --Contador de 0 a 3.
end if;
92
EN VHDL
end if;
end process;
--///////////////////
--// MACHINE
--//////////////////
Combinacional : Process(Qp, Qn, IniciarM, Counter_MU, DCM_Matrix_In) --Si no
se pone InicarM en la lista sensitiva la m’aquina nunca reinicia (
elemental...)
begin
case Qp is
when EInicio => ---0000 0
MatrixUpdateTerminado <= ’0’;
Counter_MU_Rst <= ’1’; --Desactivar la se’nal de reset.
MatMult_Rst <= ’1’; --Se’nal de reset de la multiplicaci’on de
matrices desactivada.
MatMult_Upd <= ’0’; --Se’nal de actualizaci’on para la
multiplicaci’on-acumulaci’on desactivada.
if IniciarM = ’1’
then Qn <= EGyroScaled; --Transici’on condicional, solo si
recibimos la se’nal de Iniciar la M’aquina.
else Qn <= EInicio; end if;
DCM_Matrix_in_temp <= (others=>(others=>(others=>’0’)));
when EGyroScaled => --0001 1

--s_gyro_v <= Gyr_Arr; --Verificar si es necesario y cambiar la
instanciaci’on.
Qn <= EAddOmegaI; --Transici’on incondicional; sabemos que las
operaciones de este Estado se har’an en un ciclo de reloj.
when EAddOmegaI => --0010 2

Qn <= EAddOmegaP;
93
when EAddOmegaP => --0011 3

Qn <= EAsigUpdateMatrix;
when EAsigUpdateMatrix => --0100 4

Counter_MU_Rst <= ’0’; --Reiniciar el contador
matrices activada.
Qn <= EMatrixMultiply;
DCM_Matrix_in_temp <= DCM_Matrix_In; --Para estimar el tiempo de c

’alculo de la multiplicaci’on de matrices
when EMatrixMultiply => --0101 5

Counter_MU_Rst <= ’1’; --Desactivar la se’nal de reset del
contador (Iniciar conteo).
multiplicaci’on-acumulaci’on Activada.
if Counter_MU = 3 --3 ticks para la multiplicaci’on de matrices.

then Qn <= EMatrixSuma;
else Qn <= EMatrixMultiply; end if;
DCM_Matrix_in_temp <= DCM_Matrix_In;
when EMatrixSuma => --0110 6

Counter_MU_Rst <= ’1’;
multiplicaci’on-acumulaci’on Desactivada.
Qn <= ESalida; --
94
EN VHDL
when ESalida => --0111 7

Qn <= ESalida2;
when ESalida2 => --1000 8--Para asegurarnos que se lea la se’nal en la

m’aquina padre.
Qn <= EInicio;
when others =>

Qn <= EInicio;

end case;
QpMU <= Qp; --Salida para debugueo.

Temporary_matrix_out <= (3 => Temporary_Matrix(2)(1)(3), 2 =>
Temporary_Matrix(2)(1)(2),
1 => Temporary_Matrix(2)(1)(1), 0 =>
Temporary_Matrix(2)(1)(0));
end process;
95
Secuencial: process (Clk)

begin
if rising_edge(Clk) then --and En=’1’ then

Qp <= Qn;
end if;
End process;
end Behavioral;
A.4.1. Escalación de un vector (Gyro Scaled.vhd)
library IEEE;
entity Gyro_Scaled is
Port (
Clk : in std_logic;
--En : in std_logic;
gyro_v : in ar3_i16; --Su valor te’orico m’aximo posible es 2^16 / 2 (por
el signo)
--escala : in STD_LOGIC;
Gyro_Vector : out ar3_gv -- I_P_GV.F_P_GV 4.28--al multiplicar gyro_v *

gyro_gain_rad se obtiene m’aximo 40 (Considerando que gyro_ % es una
variable de
-- 16 bits con signo, asi que 15 bits que al multiplicarse por 0.001221
produce m’aximo 40; con 7 bits, 8 con signo podr’iamos albergarlo
-- pero debemos buscar los valores reales para reducir al m’inimo la
cantidad de bits. El valor m’aximo es 4. Con 4 bits es suficiente.
);
end Gyro_Scaled;
architecture Behavioral of Gyro_Scaled is

--constant gyro_gain_rad : fp2_16 := "000000000001010000"; --00 0000 0000
0101 0000; 0.01745329252*0.07 = 0.00122173
constant gyro_gain_rad : gyr_gain_t := "00000000001010000000100010011110"; --
0 0000 0000 0101 0000 0001 0001 0011 110; 0.01745329252*0.07 =
0.0012217305
96
EN VHDL
signal Gyro_Vec_Temp : ar3_gv_temp;-- := (others=> (others=>’0’)); --
gv_temp_t 17.F_PRE_U
begin
process (Clk)
begin
--47 46 45 44 43 42 41 40 39 38 37 36 35 34 33 32 31 30 29 28 27 26 25 24 23
22 21 20 19 18 17 16 15 14 13 12 11 10 09 08 07 06 05 04 03 02 01 00
--16 15 14 13 12 11 10 09 08 07 06 05 04 03 02 01 00 -01 -02 -03 -04 -05 -06
-07 -08 -09 -10 -11 -12 -13 -14 -15 -16 -17 -18 -19 -20 -21 -22 -23 -24
-25 -26 -27 -28 -29 -30 -31
-- f17_F_PRE_U i16 * f1_F_PRE_U => f17_F_PRE_U
Gyro_Vec_Temp(ii) <= gyro_v(ii) * gyro_gain_rad;
-- I_P_GV + F_P_GV
-- 4 + 28
Gyro_Vector(ii) <= Gyro_Vec_Temp(ii)(I_P_GV+F_PRE_U -1 downto
F_PRE_U-F_P_GV);--Se toman los bits de un GyroVector
-- 4+31-1 31-28 => 34 downto 3
end loop;
--wait for 1 ns;

-- GyroScaledTerminado <= ’1’;
end if;
End process;
end Behavioral;
A.4.2. Suma de dos vectores (VectorAdd.vhd)
library IEEE;
use IEEE.NUMERIC_STD.ALL;--Arithmetic functions with Signed or Unsigned values
entity VectorAdd is
Port (
Clk : std_logic;
Vec1 : in ar3_gv;
Vec2 : in ar3_gv;
VecOut : out ar3_gv
);
end VectorAdd;
97
architecture Behavioral of VectorAdd is
begin
process (Clk)
begin
VecOut(ii) <= Vec1(ii) + Vec2(ii);
end loop;
end if;
end process;
end Behavioral;
A.4.3. Obtención de la matriz temporal de actualización (UpdateMa-

trixAsig.vhd)
library IEEE;
-- Arithmetic functions with Signed or Unsigned values

entity UpdateMatrixAsig is
Port (
Clk : in std_logic;
--En : in STD_LOGIC;
OmegaVector : in ar3_gv; --gyr_vec_t is signed(I_P_GV + F_P_GV -1 downto
0); => 4_28
UpdateMatrix : out M3Norm
--UpdateMatrixAsigListo : out std_logic

);
end UpdateMatrixAsig;
architecture Behavioral of UpdateMatrixAsig is

constant G_Dt : fpNorm := "00000001010001111010111000010100"; --00 0000 0101
0001 1110 1011 1000 0101 00 (~ 0.02)
constant G_DtN: fpNorm := "11111110101110000101000111101011"; --11 1111 1010
1110 0001 0100 0111 1010 11 (~ -0.02)
signal UpdateMatrixTemp : MatNormGV; --fpNormGV is signed(I_P_GV+I_P_NS +
F_P_GV+F_PRE_S-1 downto 0); --fp10_47
signal UpdateMatrixT2 : M3Norm;
begin
98
EN VHDL
process (Clk)
begin
-- <= fpNorn * gyr_vec_t
-- <= I_P_NS+F_PRE_S * I_P_GV + F_P_GV =>
--(I_P_NS+I_P_GV).(F_PRE_S+F_P_GV) <= f2_30 * f4_28 => f6_58
UpdateMatrixTemp(0)(1) <= G_DtN * OmegaVector(2); --// -z

UpdateMatrixTemp(0)(2) <= G_Dt * OmegaVector(1); --// y
UpdateMatrixTemp(1)(0) <= G_Dt * OmegaVector(2); --// z

--UpdateMatrixTemp(1)(1) <= (others => ’0’);
UpdateMatrixTemp(1)(2) <= G_DtN * OmegaVector(0); --// -x
UpdateMatrixTemp(2)(0) <= G_DtN * OmegaVector(1); --// -y

UpdateMatrixTemp(2)(1) <= G_Dt * OmegaVector(0); --// x
--UpdateMatrixTemp(2)(2) <= (others => ’0’);
--10 downto -47

--09 08 07 06 05 04 03 02 01 00 -01 -02 -03 -04 -05 -06 -07 -08 -09
-10 -11 -12 -13 -14 -15 -16 -17 -18 -19 -20 -21 -22 -23 -24 ...
--56 55 54 53 52 51 50 49 48 47 46 45 44 43 42 41 40 39 38 37 36 35 34
33 32 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12
11 10 09 08 07 06 05 04 03 02 01 00
-- f2_23 <= fp9_48( 56 downto 0 ) ( 25 downto 08 )
UpdateMatrix(0)(0) <= (others => ’0’);
UpdateMatrix(0)(1) <= UpdateMatrixTemp(0)(1)((I_P_NS + F_P_GV+F_PRE_S
-1) downto F_P_GV); --Tomamos fpNorm bits
UpdateMatrix(0)(2) <= UpdateMatrixTemp(0)(2)((I_P_NS + F_P_GV+F_PRE_S
-1) downto F_P_GV);
-- 2+28+31 -1 downto 28 => 60
downto 28
UpdateMatrix(1)(0) <= UpdateMatrixTemp(1)(0)(I_P_NS + F_P_GV+F_PRE_S
-1 downto F_P_GV);
-1 downto F_P_GV);

-1 downto F_P_GV);
-1 downto F_P_GV); --48 downto 24);
end if;
99
end process;
--UpdateMatrix <= UpdateMatrixT2;
end Behavioral;
A.4.4. Multiplicación de dos matrices (MatrixMultiply.vhd)
library IEEE;
--use work.mat_mult.all;
entity MatrixMultiply is
Port (
Clk : in std_logic;
Rst : in std_logic;
Update : in std_logic;
A : in M3Norm;
B : in M3Norm;
C : out M3Norm
);
end MatrixMultiply;
architecture Behavioral of MatrixMultiply is

--Declaraci’on de componentes
Component VectorMultIterativo is
Port (
Clk : in std_logic;
Rst : in std_logic;
En : in std_logic;
Ind : in IndMat;
VR : in ar3Norm; --Vector Rengl’on.

Eo : out fpNorm --Escalar de Salida.

);
end Component;
--Declaraci’on de se’nales.
signal A0X : ar3Norm;-- := A(0); --A(0)(0), A(0)(1), A(0)(2) ?
signal A1X : ar3Norm;-- := A(1); --
100
EN VHDL
signal A2X : ar3Norm;-- := A(2);
signal BX0 : ar3Norm;-- := ( 0 => B(0)(0), 1=>B(1)(0), 2=>B(2)(0) );

signal Cont_MM : IndMat;

begin
A0X <= (0 => A(0)(0), 1=> A(0)(1), 2=>A(0)(2) ); --A(0); ?

A1X <= (0 => A(1)(0), 1=> A(1)(1), 2=>A(1)(2) ); --A(1); ?
A2X <= (0 => A(2)(0), 1=> A(2)(1), 2=>A(2)(2) ); --A(2); ?
BX0 <= ( 0 => B(0)(0), 1=>B(1)(0), 2=>B(2)(0) );

BX1 <= ( 0 => B(0)(1), 1=>B(1)(1), 2=>B(2)(1) );
BX2 <= ( 0 => B(0)(2), 1=>B(1)(2), 2=>B(2)(2) );
C00: VectorMultIterativo
port map(Clk=>Clk, Rst=>Rst, En=>Update, Ind=>Cont_MM, VR=>A0X, VC=>BX0,
Eo=>C(0)(0) );
Eo=>C(0)(1) );
Eo=>C(0)(2) );
Eo=>C(1)(0) );
Eo=>C(1)(1) );
Eo=>C(1)(2) );
Eo=>C(2)(0) );
Eo=>C(2)(1) );
101
Eo=>C(2)(2) );
Counter02 : process(Clk) begin

if rst=’0’ then
Cont_MM <= 0;
elsif Update = ’1’ then
Cont_MM <= (Cont_MM + 1) MOD 3; --Para asegurar que no haya
overflow. Cuenta de 0 a 2.
end if;
end if;
end process;
end Behavioral;
A.4.5. Producto punto de dos vectores (VectorMultIterativo.vhd)
library IEEE;
entity VectorMultIterativo is
Port (
Clk : in std_logic;
Rst : in std_logic;
En : in std_logic;
Ind : in IndMat;
VR : in ar3Norm; --Vector Rengl’on.
-- Eo : out fp5_46 --Escalar de Salida.

Eo : out fpNorm
);
end VectorMultIterativo;
architecture Behavioral of VectorMultIterativo is

signal Acumulador : fpNormMultAcum;
signal Producto : fpNormMult;
begin
process (Clk) begin

if Rst = ’0’ then
102
EN VHDL
Acumulador <= (others => ’0’);
Producto <= (others => ’0’);
else
if En = ’1’ then
Acumulador <= Acumulador + Producto;
--fpNorm * fpNorm
--(I_P_NS*2)+(F_PRE_S*2)
Producto <= VR(Ind) * VC(Ind);
end if;
end if;
end if;
end process;
Eo <= Acumulador(F_PRE_S*2+I_P_NS -1 downto F_PRE_S);
end Behavioral;
A.4.6. Suma de dos matrices (MatrixSuma.vhd)
library IEEE;
entity MatrixSuma is
Port (
Clk : in std_logic;
A : in M3Norm;
B : in M3Norm;
C : out M3Norm
);
end MatrixSuma;
architecture Behavioral of MatrixSuma is
begin
process(Clk)
begin
for i in 0 to 2 loop --(number of rows in the first matrix - 1)
for j in 0 to 2 loop --(number of columns in the second matrix -
1)
C(i)(j) <= A(i)(j) + B(i)(j);
103
end loop;
end loop;
end if;
end process;
end Behavioral;
104
Apéndices B
Módulos de prueba para verificar la

funcionalidad de los circuitos diseñados
NOTA: Algunos de los bancos de prueba en esta sección se hicieron para comprobar módulos
que estaban desarrollados con precisión de 25 bits. Una vez se comprobó la funcionalidad de cada
módulo se integraron al sistema y se cambió su precisión a 32 bits, y se desarrollaron tipos de datos
genéricos cuya precisión puede modificarse más fácilmente modificando algunas constantes, por lo
que los nombres de algunos tipos tal vez requieran cambios para probar efectivamente los módulos
de 32 bits.
B.0.7. Banco de prueba para el módulo principal del sistema (test Principal.vhd
library IEEE;
entity test_Principal is
-- Port ( );
end test_Principal;
architecture Behavioral of test_Principal is

constant Half_Clock_Period : time := 500 ps; --Cada ciclo durar’ia 1 ns (1000
ps)
component Principal is
Port (
Clk : in std_logic;
Rst : in std_logic;
AsignarOffsets : in std_logic;
IniciarProc : in std_logic;
105
AN : in ar9_i16; --Arreglo de elementos con los valores leidos de los
sensores.
AN_OFFSET : in ar9_i16; --Arreglo de Offsets de las mediciones
iniciales de los sensores.
DCM_Matrix_POut : out M3Norm;
--Salidas para TLA.

IniciarProcOut : out std_logic;
SalidaDCM : out std_logic;
Clk_out : out std_logic;
QpPral : out std_logic_vector(2 downto 0);
ProcListoOut : out std_logic;
ProcListo : out std_logic --Bandera de Procesamiento terminado.

);
end component;
signal s_Clk : std_logic := ’0’;

signal s_Rst : std_logic := ’0’;
signal s_IniciarProc : std_logic := ’0’;
signal s_AsignarOffsets : std_logic := ’0’;
signal s_CalcularHeading : std_logic := ’0’;
signal s_AN : ar9_i16:= ("0000000000001010", "0000000000001001",

"0000000000000101",
-- 10 9 5
"0000000100010000", "1111111111010000",
"1110111010000000",
-- 272 -48 -4480
"0000000011011100", "0000000101111010",
"0000001001001100");
-- 220 378 588 --Arreglo de elementos
con los valores leidos de los
sensores.
signal s_AN_OFFSET : ar9_i16:= ("0000000000001000", "0000000000000111",

"0000000000000000",
-- 8 7 0
106
APÉNDICES B. MÓDULOS DE PRUEBA PARA VERIFICAR LA
FUNCIONALIDAD DE LOS CIRCUITOS DISEÑADOS
"0000000000001110", "1111111111111101",
"1111111111101000",
-- 14 -3 -24
others => (others=>’0’) );
signal s_DCM_Matrix_In : M3Norm := ( ( (F_PRE_S=>’1’, others=>’0’), (others

=>’0’), (others=>’0’) ),
( (others=>’0’), (F_PRE_S=>’1’, others=>’0’),
(others=>’0’) ),
( (others=>’0’), (others=>’0’), (F_PRE_S
=>’1’, others=>’0’) ) );
signal s_Omega_P : ar3_gv := ( (others=>’0’), (others=>’0’), (others=>’0’) );

signal s_Omega_I : ar3_gv := ( (others=>’0’), (others=>’0’), (others=>’0’) );
--signal s_DCM_Matrix_In : in M3Norm;
signal s_DCM_Matrix_POut : M3Norm;
signal s_ProcListo : std_logic := ’0’;
begin
dut : Principal
port map( Clk=>s_Clk, Rst=>s_Rst,
AsignarOffsets=>s_AsignarOffsets, IniciarProc=>s_IniciarProc,
CalcularHeading=>s_CalcularHeading,
AN=>s_AN, AN_OFFSET=>s_AN_OFFSET,
Omega_P => s_Omega_P, Omega_I => s_Omega_I,
DCM_Matrix_In => s_DCM_Matrix_In, DCM_Matrix_POut => s_DCM_Matrix_POut,
ProcListo=>s_ProcListo
);
Clk_proc : Process
begin
s_clk <= ’0’;
wait for half_clock_period;
s_clk <= ’1’;
end process;
107
stimulus : process
begin
--wait for 1 ns;
s_AsignarOffsets <= ’1’;
wait for 1 ns;
s_AsignarOffsets <= ’0’;
wait for 3 ns;
s_IniciarProc <= ’1’;
wait for 1 ns;
s_IniciarProc <= ’0’;
wait for 25 ns;
wait;
end process;
end Behavioral;
B.0.8. Banco de prueba para el módulo con la FSM que controla los
cálculos de la IMU (test CalcIMU.vhd)
library IEEE;
-- Arithmetic functions with Signed or Unsigned values
entity test_CalcIMU is
-- Port ( );
end test_CalcIMU;
architecture Behavioral of test_CalcIMU is
--/// DECLARACI’ON DE COMPONENTES.

component CalculosIMU is
Port (
Clk : in std_logic;
IniciarCalculosIMU : in std_logic;
Acc_Arr : in ar3_i16;
Mag_Arr : in ar3_i16;
108
DCM_Matrix_Out : out M3Norm; -- Salida temporal de los c’alculos (la
salida definitiva ser’ian los ’angulos de Euler).

CalculosIMUListos : out std_logic

);
end component;
--///DECLARACI’ON DE SE’NALES PARA SIMULACI’ON

signal Clk : std_logic := ’0’;
signal IniciarCalculosIMU : std_logic := ’0’;
signal Rst : std_logic := ’1’;
signal CalcularHeading : std_logic := ’0’;
signal Gyr_Arr : ar3_i16 :=

("0000000000000010","0000000000000010","0000000000000101");
-- 2 2 5
signal Acc_Arr : ar3_i16 :=
("1111111111111101","0000000000000000","0000000100000000");
-- -3 0 256
signal Mag_Arr : ar3_i16 :=
("0000000011011100","0000000101111010","0000001001001100");
-- 220 378 588
signal s_Omega_P : ar3_gv := (others => (others=>’0’));
signal s_Omega_I : ar3_gv := (others => (others=>’0’));
signal s_DCM_Matrix_In : M3Norm := ( ( (F_PRE_S=>’1’, others=>’0’), (others

=>’0’), (others=>’0’) ),
( (others=>’0’), (F_PRE_S=>’1’, others
=>’0’), (others=>’0’) ),
( (others=>’0’), (others=>’0’), (F_PRE_S
=>’1’, others=>’0’) ) );
signal s_DCM_Matrix_Out : M3Norm;
--signal DCM_Matrix_Out_Sim : M3Norm;
signal s_QpMU : std_logic_vector(3 downto 0);
signal s_Temporary_Matrix_out : std_logic_vector(3 downto 0);
signal CalculosTerminados : std_logic := ’0’;

ps).
begin
109
dut : CalculosIMU
port map(
Clk, IniciarCalculosIMU, --Rst,
CalcularHeading,
Gyr_arr, Acc_arr, Mag_arr,
s_Omega_P, s_Omega_I,
s_DCM_Matrix_In,
s_DCM_Matrix_Out,
s_QpMU, s_Temporary_Matrix_Out,
CalculosTerminados
);
Clk_proc : Process
begin
clk <= ’0’;
clk <= ’1’;
end process;
stimulus : process
begin
IniciarCalculosIMU <= ’1’;
wait for 2 ns;
IniciarCalculosIMU <= ’0’;
wait for 20 ns;
--En <= ’0’;
--wait for 10 ns;
end process;
end Behavioral;
B.0.9. Banco de prueba para el módulo con la FSM que controla los
cálculos que actualizan la DCM (test MatrixUpdate.vhd)
library IEEE;
110
entity test_MatrixUpdate is
-- Port ( );
end test_MatrixUpdate;
architecture Behavioral of test_MatrixUpdate is

ps).
signal Clk : std_logic := ’0’;
signal IniciarM : std_logic := ’0’;
Component MatrixUpdate is
Port (
Clk : in std_logic;
--Acc_Vec : in arr3_i16; --Acc_arr es directamento Acc_Vec solo Gyro
requiere escalar.
--Mag_Arr : in arr3_i16;
DCM_Matrix_in : in M3Norm;
DCM_Matrix_out : out M3Norm;
--Salidas debugueo

);
end component;
-- Se’nales para enviar entradas.

signal CalcHeading : std_logic := ’0’;
signal Gyr_Arr : ar3_i16 := ("0000000000000010", "0000000000000010",

"0000000000000101");
-- 2 2 5
111
signal Acc_Vec : ar3_i16 := ("1111111111111101", "0000000000000000",
"0000000100000000"); --Acc_arr es directamento Acc_Vec solo Gyro requiere
escalar.
-- -3 0 256
signal Mag_Arr : ar3_i16 := ("0000000011011100", "0000000101111010",
"0000001001001100");
-- 220 378 588
signal s_Omega_I : ar3_gv := (others => (others=>’0’));

signal s_Omega_P : ar3_gv := (others => (others=>’0’));
signal s_DCM_Matrix_in : M3Norm := ( ( (F_PRE_S=>’1’, others=>’0’), (others

=>’0’), (others=>’0’) ),
( (others=>’0’), (F_PRE_S=>’1’, others=>’0’), (
others=>’0’) ),
( (others=>’0’), (others=>’0’), (F_PRE_S=>’1’,
others=>’0’) ) );
signal s_DCM_Matrix_out: M3Norm;-- := ( ( (30=>’1’, others=>’0’), (others

=>’0’), (others=>’0’) ),
-- ( (others=>’0’), (30=>’1’, others=>’0’), (
others=>’0’) ),
-- ( (others=>’0’), (others=>’0’), (30=>’1’,
others=>’0’) ) );
signal s_QpMU : std_logic_vector(3 downto 0);

signal s_Temporary_Matrix_out : std_logic_vector(3 downto 0);
signal MatrixUpdateTerminado : std_logic;-- := ’0’;

--signal Reset : std_logic := ’1’;
begin
dut : MatrixUpdate
port map(
Clk, IniciarM, --Reset,
Gyr_Arr,
s_Omega_I, s_Omega_P,
s_DCM_Matrix_in, s_DCM_Matrix_Out,
s_QpMU, s_Temporary_Matrix_out,
MatrixUpdateTerminado );
112
Clk_proc : Process
begin
clk <= ’0’;
clk <= ’1’;
end process;
stimulus : process
begin
IniciarM <= ’1’;
wait for 2 ns; --Flanco de inicio
IniciarM <= ’0’;
wait for 20 ns;
end process;
--wait for 10 ns;
end Behavioral;
113
Apéndices C
Códigos CORDIC y Bancos de prueba
C.0.10. Módulo para calcular seno y coseno basado en la técnica COR-

DIC
Basado en [37] y modificado para precisión de 32 bits.
----------------------------------------------------------------------------
-- cordic2.vhd
--
-- section 10.6 Trigonometric function (Cordic)
--
-- z = x0.x-1 x-2 ... x-n: radians, 2’complement
-- sin z, cos z: 2’s complement, with p fractional bits
-- m: internal operation accuracy
-- n: number of iterations
--
----------------------------------------------------------------------------
--///////////////////
--// PACKAGE CORDIC
LIBRARY IEEE;
USE IEEE.STD_LOGIC_1164.ALL;
USE IEEE.STD_LOGIC_ARITH.ALL;
USE IEEE.STD_LOGIC_UNSIGNED.ALL;
PACKAGE package_cordic IS
TYPE table IS ARRAY (0 TO 15) OF STD_LOGIC_VECTOR(31 DOWNTO 0);
CONSTANT angles: table := --Values of arctan 2^-i for i up to 15, with 32 bits.
u(0.32)
(
x"c90fdaa2", -- atan(1/1) => 0.78539816 => 0.1100 1001 0000 1111 1101 1010
1010 0010
x"76b19c15", -- atan(1/2) => 0.46364761 => 0.0111 0110 1011 0001 1001 1100
0001 0101
x"3eb6ebf2", -- atan(1/4) =>
x"1fd5ba9a",
114
APÉNDICES C. CÓDIGOS CORDIC Y BANCOS DE PRUEBA
x"0ffaaddb",
x"07ff556e",
x"03ffeaab",
x"01fffd55",
x"00ffffaa",
x"007ffff5",
x"003ffffe",
x"001fffff",
x"000fffff",
x"0007ffff",
x"0003ffff",
x"0001ffff" );
CONSTANT x_0: STD_LOGIC_VECTOR(31 DOWNTO 0) := x"9b74eda8"; --1001 1011 0111

0100 1110 1101 1010 1000
-- x_0 = 1 / k, where k=(1+1)^0.5 * (1+2^(-2))^0.5 * (1+2^(-2*(n-1)) )^0.5
-- Para n=16 x_0 = 0.607252935
END package_cordic;
--// PACKAGE CORDIC
--///////////////////
--//////////////////////
--// COMB_SHIFTER
LIBRARY IEEE;
ENTITY comb_shifter IS -- b = a*2^(-shift)

GENERIC(m,
logm: NATURAL);
PORT(
a: IN STD_LOGIC_VECTOR(m DOWNTO 0);
shift: IN NATURAL;
b: OUT STD_LOGIC_VECTOR(m DOWNTO 0)
);
END comb_shifter;
ARCHITECTURE circuit OF comb_shifter IS

TYPE vectors IS ARRAY (0 TO logm-1) OF STD_LOGIC_VECTOR(m DOWNTO 0);
SIGNAL c, d: vectors;
SIGNAL k: STD_LOGIC_VECTOR(logm-1 DOWNTO 0);
BEGIN
k <= CONV_STD_LOGIC_VECTOR(shift, logm); --arg:integer, size: integer
WITH k(0) SELECT d(0) <= a WHEN ’0’, a(m)&a(m DOWNTO 1) WHEN OTHERS;
115
main_iteration: FOR j IN 1 TO logm-1 GENERATE
c(j-1)(m DOWNTO m - 2**j + 1) <= (OTHERS => d(j-1)(m));
c(j-1)(m - 2**j DOWNTO 0) <= d(j-1)(m DOWNTO 2**j);
WITH k(j) SELECT d(j) <= d(j-1) WHEN ’0’, c(j-1) WHEN OTHERS;
END GENERATE;
b <= d(logm-1);
END circuit;
--// COMB_SHIFTER
--//////////////////////
--/////////////////////////
--// CORDIC2
LIBRARY IEEE;
USE WORK.package_cordic.ALL;
-------------------------------------------------------
-- sin z, cos z: 2’s complement, with p fractional bits
-- m: internal operation accuracy
-- n: number of iterations
-------------------------------------------------------
ENTITY cordic2 IS
GENERIC(
p : NATURAL:=8; -- Fractional bits.
m : NATURAL:=16; -- Internal operation accuracy.
n : NATURAL:=16; -- Number of iterations.
logn : NATURAL:=4 ); --
PORT(
z: IN STD_LOGIC_VECTOR(p DOWNTO 0); --Input Angle in radians
clk, reset, start: IN STD_LOGIC;
sin, cos: OUT STD_LOGIC_VECTOR(p DOWNTO 0);
done: OUT STD_LOGIC
);
END cordic2;
ARCHITECTURE circuit OF cordic2 IS

--//////////////////////////
--////COMPONENTS DECLARATION
COMPONENT comb_shifter IS
GENERIC(m, logm: NATURAL);
PORT(
a: IN STD_LOGIC_VECTOR(m DOWNTO 0);
shift: IN NATURAL;
116
b: OUT STD_LOGIC_VECTOR(m DOWNTO 0)

);
END COMPONENT;
--////COMPONENTS DECLARATION
--//////////////////////////
--/////////////////////
--//SIGNALS DECLARATION
SIGNAL x, y, next_x, next_y, d, next_d: STD_LOGIC_VECTOR(m DOWNTO 0);
SIGNAL a: STD_LOGIC_VECTOR(m-1 DOWNTO 0);
SIGNAL shifted_x, shifted_y: STD_LOGIC_VECTOR(m DOWNTO 0);
SIGNAL load, update: STD_LOGIC;
SUBTYPE index IS NATURAL RANGE 0 TO n-1;

SIGNAL count: index;
TYPE state IS RANGE 0 TO 3;
SIGNAL current_state: state;
BEGIN
a <= angles(count)(31 DOWNTO 32 - m); --Valor de atan 2^-count
WITH d(m) SELECT next_d <= d + (’0’&a) WHEN ’1’, d - (’0’&a) WHEN OTHERS; --Z
(n+1)
shifter_x: comb_shifter
GENERIC MAP(m => m, logm => logn)
PORT MAP(a => x, shift => count, b => shifted_x);
shifter_y: comb_shifter
GENERIC MAP(m => m, logm => logn)
PORT MAP(a => y, shift => count, b => shifted_y);
WITH d(m) SELECT next_x <= x + shifted_y WHEN ’1’, x - shifted_y WHEN OTHERS;
-- x_(i+1)
WITH d(m) SELECT next_y <= y - shifted_x WHEN ’1’, y + shifted_x WHEN OTHERS;
-- y_(i+1)
register_d: PROCESS(clk)
BEGIN
IF clk’EVENT AND clk = ’1’ THEN
IF load = ’1’ THEN
d(m DOWNTO m-p) <= z;
d(m-p-1 DOWNTO 0) <= (OTHERS => ’0’);
117
ELSIF update = ’1’ THEN
d <= next_d;
END IF;
END IF;
END PROCESS;
register_x: PROCESS(clk)
BEGIN
x(m) <= ’0’;
x(m-1 DOWNTO 0) <= x_0(31 DOWNTO 32-m);
x <= next_x;
END IF;
END IF;
END PROCESS;
cos <= x(m DOWNTO m-p);
register_y: PROCESS(clk)
BEGIN
y <= (OTHERS => ’0’);
y <= next_y;
END IF;
END IF;
END PROCESS;
sin <= y(m DOWNTO m-p);
--//////////////////////
--// M’aQUINA DE ESTADOS.
counter: PROCESS(clk)
BEGIN
IF clk’EVENT and clk = ’1’ THEN
count <= 0;
count <= (count+1) MOD n; --Para asegurarse de que no haya
overflow.
END IF;
END IF;
END PROCESS;
next_state: PROCESS(clk)
118
BEGIN
IF reset = ’1’ THEN
current_state <= 0;
ELSIF clk’EVENT AND clk = ’1’ THEN
CASE current_state IS
WHEN 0 =>
IF start = ’0’ THEN current_state <= 1; END IF;
WHEN 1 =>
IF start = ’1’ THEN current_state <= 2; END IF;
WHEN 2 =>
current_state <= 3;
WHEN 3 =>
IF count = n-1 THEN current_state <= 0; END IF;
END CASE;
END IF;
END PROCESS;
output_function: PROCESS(clk, current_state)

BEGIN
CASE current_state IS
WHEN 0 TO 1 =>
load <= ’0’; update <= ’0’; done <= ’1’;
WHEN 2 =>
load <= ’1’; update <= ’0’; done <= ’0’;
WHEN 3 =>
load <= ’0’; update <= ’1’; done <= ’0’;
END CASE;
END PROCESS;
--// M’AQUINA DE ESTADOS.
--//////////////////////
END circuit;
C.0.11. Banco de pruebas para el módulo de cálculo de seno y coseno
library IEEE;
-- Uncomment the following library declaration if using

-- arithmetic functions with Signed or Unsigned values
--use IEEE.NUMERIC_STD.ALL;
entity test_cordic2_p is
-- Port ( );
end test_cordic2_p;
119
architecture Behavioral of test_cordic2_p is
-- CONSTANT p: NATURAL:= 8;
-- CONSTANT n: NATURAL:= 16;
-- CONSTANT m: NATURAL:= 16;
-- CONSTANT logn: NATURAL:= 4;
CONSTANT p: NATURAL:= 22; --23 bits (22 downto 0)

CONSTANT n: NATURAL:= 32;
CONSTANT m: NATURAL:= 32;
CONSTANT logn: NATURAL:= 5;
-- CONSTANT p: NATURAL:= 22; --23 bits (22 downto 0)

-- CONSTANT n: NATURAL:= 16; --Esto no funciona, m debe ser mayor a p.
-- CONSTANT m: NATURAL:= 16;
-- CONSTANT logn: NATURAL:= 4;
-------------------------------------------------------
-- sin z, cos z: 2’s complement, with p fractional bits.
-- m: internal operation accuracy.
-- n: number of iterations.
-------------------------------------------------------
COMPONENT cordic2 IS
GENERIC(p: NATURAL:=8; -- Fractional bits.
m: NATURAL:=16; -- Internal operation accuracy.
n: NATURAL:=16; -- Number of iterations.
logn: NATURAL:=4);
PORT(z: IN STD_LOGIC_VECTOR(p DOWNTO 0); --8 downto 0, 9 bits.
clk, reset, start: IN STD_LOGIC;
sin, cos: OUT STD_LOGIC_VECTOR(p DOWNTO 0); --8 downto 0, 9 bits.
done: OUT STD_LOGIC
);
END COMPONENT;
--//*Se’nales para instanciaci’on

SIGNAL z: STD_LOGIC_VECTOR(p DOWNTO 0);
SIGNAL sine, cosine: STD_LOGIC_VECTOR(p DOWNTO 0);
SIGNAL clk, reset, start, done: STD_LOGIC;
--//* Se’nales para simulaci’on de reloj.

CONSTANT OFFSET : time := 10 ns;
CONSTANT PERIOD : time := 50 ns;
begin
dut: cordic2
GENERIC MAP(p => p, n => n, m => m, logn => logn)
PORT MAP(z => z, clk => clk, reset => reset, start=> start,
120
sin => sine, cos => cosine, done => done);
clk_generation: process
begin
-- wait for OFFSET;
--while not end_sim loop

clk <= ’0’;
wait for PERIOD/2;
clk <= ’1’;
wait for PERIOD/2;
--end loop;
--wait;
end process;
stimuli : Process
begin
reset <= ’1’; --Resetea en 1
start <= ’0’;
--done <= ’0’;
WAIT FOR PERIOD;
reset <= ’0’; --Reset normalmente bajo (deshabilitaci’on de la se’nal de

reset).
WAIT FOR PERIOD;
-- Primer est’imulo, 45 grados = .7853981 rads

-- p=8;
-- n=16;
-- m=16;
-- logn=4;
-- z <= "011001001"; --(Positivo); 0.78515625
-- sin = 0.703125
-- cos = 0.70703125
--z <= "100110110"; --(Complemento a 2)
-- Segundo est’imulo, 45 grados

-- p=22
-- n=32;
-- m=32;
-- logn=5;
--0 1100 1001 0000 1111 1101 10
-- z <= "01100100100001111110110"; --p=23 0.78539800
-- sin = 0.70711731
-- cos = 0.70709609
121
-- Tercer est’imulo, 5 grados = 0.087266463 rads
-- p=22 --23 bits de precisi’on
-- n=32;
-- m=32;
-- logn=5;
--0 0001 0110 0101 0111 0001 10
--z <= "00001011001010111000110"; --p=23 0.08726644515
-- sin = 0.087156295 calc = 0.08715574
-- cos = 0.996194601 calc = 0.996194698
--wait for PERIOD * p + 3*OFFSET;
z <= "11110100110101000111001"; --p=23 -0.8726644515

--1 1110 1001 1010 1000 1110 011
start <= ’1’; --Generar flanco de arranque.

WAIT FOR PERIOD;
start <= ’0’;
wait until done=’1’;
wait for PERIOD*2;
wait;
end process;
end Behavioral;
C.0.12. Módulo para calcular la arco tangente en Verilog

Configurado en modo Vector, para calcular el arcotangente, de forma iterativa y devolviendo
el valor en radianes.
/* file: cordic.v
author: Dale Drinkard
release: 08/06/2008
brief:
First Quadrant CORDIC
This is a self contained, configurable CORDIC generator

The user can modify the ‘defines below to customize the code generation.
This code is for the first quadrant, but is easily extended to the full
circle by first doing a coarse rotation. For example, to compute the
122
arctan of -y/x, in the second quadrant, feed the cordic function y/x and
then add 90 degrees (or pi/2 if using radian mode) to the result. When
computing sin and cos of an angle, coarse rotate the angle into the first
quadrant
by subtracting the appropriate number of 90 (or pi/2) increments to get the
angle in
the first quadrant, keep track of this value, feed the cordic the angle. Then
simply change the sign of the results based on this stored number.
To use the core comment/uncomment the ‘defines below. The user can change the
number
of bits that represent the x,y, and theta values. The core can operate in
either radian
or degree mode.
**NOTE** Even though there are allowances for changeing many parameters of
the code, it is
strongly advised that the user understand the CORDIC algorythm before
monkeying with these
settings. By default, the core uses 16+sign (17 bit) numbers for x,y, and
theta, and iterates 16
times in the algorythm. There are two arctan function tables,one for radian
and one for degree
mode. If more iterations or higher precision calculations are desired then a
new arctan table will
need to be computed.
The core will operate in one

of two modes:
ROTATE: In this mode the user supplies a X and Y cartesian vector and an
angle. The
CORDIC rotator seeks to reduce the angle to zero by rotating the
vector.
To compute the cos and sin of the angle, set the inputs as follows:
y_in = 0;
x_in = ‘CORDIC_1
theta_in = the input angle
on completion:
y_out = sin
x_out = cos
123
The ‘CORDIC_1 above is the inverse of the cordic gain... or ~0.603
The input angle depends on whether you build in radian or degree mode
see the description of the ‘defines below.
VECTOR: In this mode the user supplies the tangent value in x and y and the
rotator
seeks to minimize the y value, thus computing the angle.
To compute the arctan set the inputs as follows
y_in and x_in such that y/x = the tangent value for which you wish to
find the angle
theta_in = 0;
on completion
theta_out = the angle
*/
/* Data valid flag

The iterative CORDIC implementations take a predetermined number of clock
cycles to complete
If the VALID_FLAG is defined the core instantiates a dvalid_in and dvalid_out
signal. This
signal makes no sense in the COMBINATORIAL mode. */
‘define VALID_FLAG
/* ///*** Angle mode

The CORDIC can work with the angle expressed in radians or degrees
Uncomment the appropriate ‘define below.
RADIAN_16 uses 16 bit values (+ sign bit for 17 bit accuracy). angle
information
is in the format U(1,15) where bit 16 is the sign bit, bit 15 is the whole
number part
and bits [14:0] are the fractional parts.
DEGREE_8_8 uses U(8,8) + a sign bit where bit 16 = the sign bit, [15:8] = the
whole number part
and [7:0] = the fractional.
The user can define other formats by creating a new tanangle function */
// ‘define DEGREE_8_8
‘define RADIAN_16
124
/* ///*** Bit accuracy for sin and cos

The X and Y values are computed using a ‘XY_BITS + sign bit accuracy. The
format is assumed to be U(1,15) + sign bit
However, the CORDIC algorythm really doesn’t care. */
‘define XY_BITS 16
/* ///*** Bit accuracy for theta

The angle can be represented in either degree or radians. This define
determines the number of bits used to represent the
angle. Going to a higher number of bits would allow more iterations thus
improving accuracy. 16 bits is enough for
most applications. */
‘define THETA_BITS 16
/* ///*** Iteration accuracy

This is the number of times the algorithm will iterate. For pipelined options,
this is the number of stages.
This number is <= the number of bits used in the angles */
‘define ITERATIONS 16
‘define ITERATION_BITS 4 // 2^ITERATION_BITS = ITERATIONS
/* ///***Implementation options
The CORDIC core can be realized in one of three methods:
ITERATE: This option builds a single ROTATOR. The user provides the arguments
and gives the core ITERATIONS
clock cycles to get the result. A signal named init is instantiated to
load the input values. It uses the
least amount of LUTs
PIPELINE: This option can take a new input on every clock and gives results
ITERATIONS clock cycles later. It uses the
most amount of LUTS.
COMBINATORIAL: This option gives a result in a single clock cycle at the
expense of very deep logic levels. The
combinatorial implementation runs at about 10 mhz while the
iterative ones run at about 125 in a
Lattice ECP2 device. */
‘define ITERATE
//‘define PIPELINE
//‘define COMBINATORIAL
/* ///*** CORDIC function

The CORDIC core works in one of two methods: VECTOR and ROTATE.
125
VECTOR: This mode seeks to reduce the Y values and is used to compute an angle
given a point.
Enter the sin and cos of the desired angle and the core calculates the
angle. This
mode computes ARCTAN.
ROTATE: This mode seeks to reduce the angle. It can be used to compute the sin
and cos of a given angle */
‘define VECTOR // computes the arctan and square root

// ‘define ROTATE // computes sin cos
/* ///*** CORDIC GAIN

The CORDIC algorithm has an associated gain that is:
CORDIC_gain = for (i=0;i<n;i++) An = An*SQRT(1+(1/2^2i)

This quickly converges to ~ 1.647 as i goes to infinity.
For 16 bit numbers in the U(1,15) the value is 17’d53955
*** NOTE *** If you change the number representations
you will have to recompute these values. */
‘define CORDIC_GAIN 17’d53955 //b1101_0010_1100_0011
‘define CORDIC_1 17’d19896 // CORDIC inverse
//==================== DO NOT EDIT BELOW THIS LINE ======================
‘ifdef PIPELINE
‘define GENERATE_LOOP
‘endif
‘ifdef COMBINATORIAL
‘define GENERATE_LOOP
‘endif
/* Signed shifter
This module does an arbitrary right shift to implement’
the 1/2^i function on signed numbers. */
module signed_shifter (
input wire [‘ITERATION_BITS-1:0] i,
input wire signed [‘XY_BITS:0] D,
output reg signed [‘XY_BITS:0] Q );
integer j;
always @ * begin
Q = D;
for(j=0; j<i; j=j+1)
Q = (Q >> 1) | (D[‘XY_BITS] << ‘XY_BITS);
end
endmodule
126
/* Rotator
* This module is the heart of the CORDIC computer and implements the CORDIC
algorithm.
* Input values x_i, y_i, and z_i are micro computed based on the iteration step
* and the arctan of that step. See the description of the CORDIC algorithm for
details. */
module rotator (
input wire clk,
input wire rst,
‘ifdef ITERATE
input wire init,
// input wire [‘ITERATION_BITS:0] iteration,
input wire [‘ITERATION_BITS-1:0] iteration,
input wire signed [‘THETA_BITS:0] tangle,
‘endif
input wire signed [‘XY_BITS:0] x_i,

input wire signed [‘XY_BITS:0] y_i,
input wire signed [‘THETA_BITS:0] z_i,
output wire signed [‘XY_BITS:0] x_o,

output wire signed [‘XY_BITS:0] y_o,
output wire signed [‘THETA_BITS:0] z_o
);
‘ifdef GENERATE_LOOP
parameter integer iteration = 0;
parameter signed [‘THETA_BITS:0] tangle = 0;
‘endif
reg signed [‘XY_BITS:0] x_1;
reg signed [‘XY_BITS:0] y_1;
reg signed [‘THETA_BITS:0] z_1;
wire signed [‘XY_BITS:0] x_i_shifted;
wire signed [‘XY_BITS:0] y_i_shifted;
signed_shifter x_shifter(iteration, x_i, x_i_shifted);
signed_shifter y_shifter(iteration, y_i, y_i_shifted);
always @ *
‘endif
‘ifdef ITERATE
always @ (posedge clk)
‘endif
‘ifdef PIPELINE
always @ (posedge clk)
‘endif
127
if (rst) begin
x_1 <= 0;
y_1 <= 0;
z_1 <= 0;
end else begin
‘ifdef ITERATE
if (init) begin
x_1 <= x_i;
y_1 <= y_i;
z_1 <= z_i;
end else
‘endif
‘ifdef ROTATE
if (z_i < 0) begin
‘endif
‘ifdef VECTOR
if (y_i > 0) begin
‘endif
x_1 <= x_i + y_i_shifted; //shifter(y_1,i); //(y_1 >> i);
y_1 <= y_i - x_i_shifted; //shifter(x_1,i); //(x_1 >> i);
z_1 <= z_i + tangle;
end else begin
x_1 <= x_i - y_i_shifted; //shifter(y_1,i); //(y_1 >> i);
y_1 <= y_i + x_i_shifted; //shifter(x_1,i); //(x_1 >> i);
z_1 <= z_i - tangle;
end
end
assign x_o = x_1;

assign y_o = y_1;
assign z_o = z_1;
endmodule
/* CORDIC */
module cordic (
input wire clk,
input wire rst,
‘ifdef ITERATE
input wire init,
‘endif
input wire signed [‘XY_BITS:0] x_i,
input wire signed [‘XY_BITS:0] y_i,
input wire signed [‘THETA_BITS:0] theta_i,
output wire signed [‘XY_BITS:0] x_o,
128
output wire signed [‘XY_BITS:0] y_o,

output wire signed [‘THETA_BITS:0] theta_o
‘ifdef VALID_FLAG
,input wire valid_in, output wire valid_out
‘endif
);
‘ifdef RADIAN_16
/* arctan table in radian format 16 bit + sign bit. */
function [‘THETA_BITS:0] tanangle;
input [3:0] i;
begin
case (i)
4’b0000: tanangle = 17’d25735 ; // 1/1
4’b0001: tanangle = 17’d15192; // 1/2
4’b0010: tanangle = 17’d8027; // 1/4
4’b0011: tanangle = 17’d4075; // 1/8
4’b0100: tanangle = 17’d2045; // 1/16
4’b0101: tanangle = 17’d1024; // 1/32
4’b0110: tanangle = 17’d512; // 1/64
4’b0111: tanangle = 17’d256; // 1/128
4’b1000: tanangle = 17’d128; // 1/256
4’b1001: tanangle = 17’d64; // 1/512
4’b1010: tanangle = 17’d32; // 1/1024
4’b1011: tanangle = 17’d16; // 1/2048
4’b1100: tanangle = 17’d8; // 1/4096
4’b1101: tanangle = 17’d4; // 1/8192
4’b1110: tanangle = 17’d2; // 1/16k
4’b1111: tanangle = 17’d1; // 1/32k
endcase
end
endfunction
‘endif
‘ifdef DEGREE_8_8
/* arctan table in degree U(8,8) format 16 bits + sign bit */
function [‘THETA_BITS:0] tanangle;
input [3:0] i;
begin
case (i)
0: tanangle = 17’d11520; // theta = 45.000000
1: tanangle = 17’d6800; // theta = 22.500000
2: tanangle = 17’d3593; // theta = 11.250000
3: tanangle = 17’d1824; // theta = 5.625000
4: tanangle = 17’d915; // theta = 2.812500
5: tanangle = 17’d458; // theta = 1.406250
129
6: tanangle = 17’d229; // theta = 0.703125
7: tanangle = 17’d114; // theta = 0.351562
8: tanangle = 17’d57; // theta = 0.175781
9: tanangle = 17’d28; // theta = 0.087891
10: tanangle = 17’d14; // theta = 0.043945
11: tanangle = 17’d7; // theta = 0.021973
12: tanangle = 17’d3; // theta = 0.010986
13: tanangle = 17’d1; // theta = 0.005493
14: tanangle = 17’d0; // theta = 0.002747
15: tanangle = 17’d0; // theta = 0.001373
endcase
end
endfunction
‘endif
wire signed [‘XY_BITS:0] x [‘ITERATIONS-1:0];
wire signed [‘XY_BITS:0] y [‘ITERATIONS-1:0];
wire signed [‘THETA_BITS:0] z [‘ITERATIONS-1:0];
assign x[0] = x_i;
assign y[0] = y_i;
assign z[0] = theta_i;
assign x_o = x[‘ITERATIONS-1];
assign y_o = y[‘ITERATIONS-1];
assign theta_o = z[‘ITERATIONS-1];
‘endif // GENERATE_LOOP
‘ifdef VALID_FLAG
//wire [‘ITERATIONS-1:0] v;
reg [‘ITERATIONS-1:0] v;
//assign valid_out v[‘ITERATIONS-1];
assign valid_out = v[‘ITERATIONS-1]; //Modificaci’on.
always @ (posedge clk or posedge rst)
if (rst) v <= 0;
else begin
v <= v << 1;
v[0] <= valid_in;
end
‘endif
genvar i;
generate for(i = 0; i < ‘ITERATIONS-1; i = i+1) begin
rotator U (clk,rst, x[i],y[i],z[i], x[i+1],y[i+1],z[i+1]);
defparam U.iteration = i;
130
defparam U.tangle = tanangle(i);

end
endgenerate
‘endif
‘ifdef ITERATE
// reg [‘ITERATION_BITS:0] iteration;
reg [‘ITERATION_BITS-1:0] iteration;
wire signed [‘XY_BITS:0] x,y,z;
assign x = init ? x_i : x_o;
assign y = init ? y_i : y_o;
assign z = init ? theta_i : theta_o;
always @ (posedge clk or posedge init)
if (init) iteration <= 0;
else iteration <= iteration + 1;
rotator U (clk,rst,init,iteration,tanangle(iteration),x,y,z,x_o,y_o,theta_o);
‘endif
endmodule
C.0.13. Banco de prueba para el cálculo de la tangente
‘timescale 1ns/1ns
/* CORDIC testbench
This testbench assumes the default settings for ‘defines

in the cordic.v file. If you change any of the defaults
you may have to make modifications to this file as well.
This testbench uses ‘defines from the cordic.v file

make sure you have the ‘include path set correctly for your
environment. */
//‘include "cordic.v"
‘include "/media/NTFS/MisProgramas/FPGA/XilinxP/Tesis/Paralelo/
Cordic_Atan_Verilog_Drinkard/Cordic_Atan_Verilog.srcs/sources_1/imports/
Cordic_Atan_Verilog/cordic.v"
module tb ();
wire [‘XY_BITS:0] x_o,y_o;

wire [‘THETA_BITS:0] theta_o;
reg [‘XY_BITS:0] x_i,y_i;
reg [‘THETA_BITS:0] theta_i; // angle in radians
reg clock,reset;
reg init;
131
cordic UUT (.clk(clock),.rst(reset),
‘ifdef ITERATE
.init(init),
‘endif
.x_i(x_i),.y_i(y_i),.theta_i(theta_i),
.x_o(x_o),.y_o(y_o),.theta_o(theta_o) );
integer i, j, k;
real a_i, a_o, a_e;
real rx, ry, rex, rey;
reg signed [‘XY_BITS:0] ex, ey;
reg signed [16:0] x [90:0];

reg signed [16:0] y [90:0];
reg signed [16:0] z [90:0];
task show_vector_results;
input integer j;
input signed [‘THETA_BITS:0] theta;
begin
a_i = (j * 3.14) / 180;
a_o = theta;
a_o = a_o / 32768;
if (a_o > a_i) a_e = a_o - a_i; else a_e = a_i - a_o;
if (a_e > 0.001)

$display("angle %f computed %f error %f", a_i, a_o, a_o-a_i);
else
$display("angle %f computed %f", a_i, a_o);
end
endtask
task show_rotate_results;
input integer j;
input [‘XY_BITS:0] lx;
input [‘XY_BITS:0] ly;
begin
rx = lx;// / 65535;
ry = ly;// / 65535;
rx = rx / 32768; //65535;
ry = ry / 32768; //65535;
if (lx > x[j]) ex = lx - x[j]; else ex = x[j] - lx;
if (ly > y[j]) ey = ly - y[j]; else ey = y[j] - ly;
132
if (ex > 10 || ey > 10)

$display("Angle: %d sin = %f cos = %f errors %d %d",j,ry,rx,ey,ex
);
else
$display("Angle: %d sin = %f cos = %f",j,ry,rx);
end
endtask
task show_results;
input integer j;
input [‘XY_BITS:0] lx;
input [‘XY_BITS:0] ly;
input [‘THETA_BITS:0] ltheta;
begin
‘ifdef VECTOR
show_vector_results(j, ltheta);
‘endif
‘ifdef ROTATE
show_rotate_results(j, lx, ly);
‘endif
end
endtask
initial begin
$display("starting simulation");
‘ifdef PIPELINE
$display("PIPELINE configuration");
‘endif
‘ifdef ITERATE
$display("ITERATE configuration");
‘endif
$display("COMBINATORIAL configuration");
‘endif
‘ifdef VECTOR
$display("VECTOR Mode");
‘endif
‘ifdef ROTATE
$display("ROTATE Mode");
‘endif
// The following table is computed for U(1,15) format numbers

// The angle data z[] is in radians
x[0] <= 17’d32768; y[0] <= 17’d0; z[0] <= 17’d0;
x[1] <= 17’d32763; y[1] <= 17’d571; z[1] <= 17’d571;
133
x[2] <= 17’d32748; y[2] <= 17’d1143; z[2] <= 17’d1143;
x[3] <= 17’d32723; y[3] <= 17’d1714; z[3] <= 17’d1715;
x[4] <= 17’d32688; y[4] <= 17’d2285; z[4] <= 17’d2287;
x[5] <= 17’d32643; y[5] <= 17’d2855; z[5] <= 17’d2859;
x[6] <= 17’d32588; y[6] <= 17’d3425; z[6] <= 17’d3431;
x[7] <= 17’d32523; y[7] <= 17’d3993; z[7] <= 17’d4003;
x[8] <= 17’d32449; y[8] <= 17’d4560; z[8] <= 17’d4575;
x[9] <= 17’d32364; y[9] <= 17’d5126; z[9] <= 17’d5147;
x[10] <= 17’d32270; y[10] <= 17’d5690; z[10] <= 17’d5719;
x[11] <= 17’d32165; y[11] <= 17’d6252; z[11] <= 17’d6291;
x[12] <= 17’d32051; y[12] <= 17’d6812; z[12] <= 17’d6862;
x[13] <= 17’d31928; y[13] <= 17’d7371; z[13] <= 17’d7434;
x[14] <= 17’d31794; y[14] <= 17’d7927; z[14] <= 17’d8006;
x[15] <= 17’d31651; y[15] <= 17’d8480; z[15] <= 17’d8578;
x[16] <= 17’d31498; y[16] <= 17’d9032; z[16] <= 17’d9150;
x[17] <= 17’d31336; y[17] <= 17’d9580; z[17] <= 17’d9722;
x[18] <= 17’d31164; y[18] <= 17’d10125; z[18] <= 17’d10294;
x[19] <= 17’d30982; y[19] <= 17’d10668; z[19] <= 17’d10866;
x[20] <= 17’d30791; y[20] <= 17’d11207; z[20] <= 17’d11438;
x[21] <= 17’d30591; y[21] <= 17’d11743; z[21] <= 17’d12010;
x[22] <= 17’d30381; y[22] <= 17’d12275; z[22] <= 17’d12582;
x[23] <= 17’d30163; y[23] <= 17’d12803; z[23] <= 17’d13153;
x[24] <= 17’d29935; y[24] <= 17’d13327; z[24] <= 17’d13725;
x[25] <= 17’d29697; y[25] <= 17’d13848; z[25] <= 17’d14297;
x[26] <= 17’d29451; y[26] <= 17’d14364; z[26] <= 17’d14869;
x[27] <= 17’d29196; y[27] <= 17’d14876; z[27] <= 17’d15441;
x[28] <= 17’d28932; y[28] <= 17’d15383; z[28] <= 17’d16013;
x[29] <= 17’d28659; y[29] <= 17’d15886; z[29] <= 17’d16585;
x[30] <= 17’d28377; y[30] <= 17’d16383; z[30] <= 17’d17157;
x[31] <= 17’d28087; y[31] <= 17’d16876; z[31] <= 17’d17729;
x[32] <= 17’d27788; y[32] <= 17’d17364; z[32] <= 17’d18301;
x[33] <= 17’d27481; y[33] <= 17’d17846; z[33] <= 17’d18873;
x[34] <= 17’d27165; y[34] <= 17’d18323; z[34] <= 17’d19444;
x[35] <= 17’d26841; y[35] <= 17’d18794; z[35] <= 17’d20016;
x[36] <= 17’d26509; y[36] <= 17’d19260; z[36] <= 17’d20588;
x[37] <= 17’d26169; y[37] <= 17’d19720; z[37] <= 17’d21160;
x[38] <= 17’d25821; y[38] <= 17’d20173; z[38] <= 17’d21732;
x[39] <= 17’d25465; y[39] <= 17’d20621; z[39] <= 17’d22304;
x[40] <= 17’d25101; y[40] <= 17’d21062; z[40] <= 17’d22876;
x[41] <= 17’d24730; y[41] <= 17’d21497; z[41] <= 17’d23448;
x[42] <= 17’d24351; y[42] <= 17’d21926; z[42] <= 17’d24020;
x[43] <= 17’d23964; y[43] <= 17’d22347; z[43] <= 17’d24592;
x[44] <= 17’d23571; y[44] <= 17’d22762; z[44] <= 17’d25164;
x[45] <= 17’d23170; y[45] <= 17’d23170; z[45] <= 17’d25735;
x[46] <= 17’d22762; y[46] <= 17’d23571; z[46] <= 17’d26307;
x[47] <= 17’d22347; y[47] <= 17’d23964; z[47] <= 17’d26879;
x[48] <= 17’d21926; y[48] <= 17’d24351; z[48] <= 17’d27451;
134
x[49] <= 17’d21497; y[49] <= 17’d24730; z[49] <= 17’d28023;

x[50] <= 17’d21062; y[50] <= 17’d25101; z[50] <= 17’d28595;
x[51] <= 17’d20621; y[51] <= 17’d25465; z[51] <= 17’d29167;
x[52] <= 17’d20173; y[52] <= 17’d25821; z[52] <= 17’d29739;
x[53] <= 17’d19720; y[53] <= 17’d26169; z[53] <= 17’d30311;
x[54] <= 17’d19260; y[54] <= 17’d26509; z[54] <= 17’d30883;
x[55] <= 17’d18794; y[55] <= 17’d26841; z[55] <= 17’d31455;
x[56] <= 17’d18323; y[56] <= 17’d27165; z[56] <= 17’d32026;
x[57] <= 17’d17846; y[57] <= 17’d27481; z[57] <= 17’d32598;
x[58] <= 17’d17364; y[58] <= 17’d27788; z[58] <= 17’d33170;
x[59] <= 17’d16876; y[59] <= 17’d28087; z[59] <= 17’d33742;
x[60] <= 17’d16384; y[60] <= 17’d28377; z[60] <= 17’d34314;
x[61] <= 17’d15886; y[61] <= 17’d28659; z[61] <= 17’d34886;
x[62] <= 17’d15383; y[62] <= 17’d28932; z[62] <= 17’d35458;
x[63] <= 17’d14876; y[63] <= 17’d29196; z[63] <= 17’d36030;
x[64] <= 17’d14364; y[64] <= 17’d29451; z[64] <= 17’d36602;
x[65] <= 17’d13848; y[65] <= 17’d29697; z[65] <= 17’d37174;
x[66] <= 17’d13327; y[66] <= 17’d29935; z[66] <= 17’d37746;
x[67] <= 17’d12803; y[67] <= 17’d30163; z[67] <= 17’d38317;
x[68] <= 17’d12275; y[68] <= 17’d30381; z[68] <= 17’d38889;
x[69] <= 17’d11743; y[69] <= 17’d30591; z[69] <= 17’d39461;
x[70] <= 17’d11207; y[70] <= 17’d30791; z[70] <= 17’d40033;
x[71] <= 17’d10668; y[71] <= 17’d30982; z[71] <= 17’d40605;
x[72] <= 17’d10125; y[72] <= 17’d31164; z[72] <= 17’d41177;
x[73] <= 17’d9580; y[73] <= 17’d31336; z[73] <= 17’d41749;
x[74] <= 17’d9032; y[74] <= 17’d31498; z[74] <= 17’d42321;
x[75] <= 17’d8480; y[75] <= 17’d31651; z[75] <= 17’d42893;
x[76] <= 17’d7927; y[76] <= 17’d31794; z[76] <= 17’d43465;
x[77] <= 17’d7371; y[77] <= 17’d31928; z[77] <= 17’d44037;
x[78] <= 17’d6812; y[78] <= 17’d32051; z[78] <= 17’d44608;
x[79] <= 17’d6252; y[79] <= 17’d32165; z[79] <= 17’d45180;
x[80] <= 17’d5690; y[80] <= 17’d32270; z[80] <= 17’d45752;
x[81] <= 17’d5126; y[81] <= 17’d32364; z[81] <= 17’d46324;
x[82] <= 17’d4560; y[82] <= 17’d32449; z[82] <= 17’d46896;
x[83] <= 17’d3993; y[83] <= 17’d32523; z[83] <= 17’d47468;
x[84] <= 17’d3425; y[84] <= 17’d32588; z[84] <= 17’d48040;
x[85] <= 17’d2855; y[85] <= 17’d32643; z[85] <= 17’d48612;
x[86] <= 17’d2285; y[86] <= 17’d32688; z[86] <= 17’d49184;
x[87] <= 17’d1714; y[87] <= 17’d32723; z[87] <= 17’d49756;
x[88] <= 17’d1143; y[88] <= 17’d32748; z[88] <= 17’d50328;
x[89] <= 17’d571; y[89] <= 17’d32763; z[89] <= 17’d50899;
x[90] <= 17’d0; y[90] <= 17’d32768; z[90] <= 17’d51471;
clock <= 0;
init <= 0;
reset <= 1;
x_i <= 0;
135
y_i <= 0;
theta_i <= 0;
#1 clock <= 1;
#1 clock <= 0;
reset <= 0;
for (j = 0; j <= 90; j = j+1) begin // test 91 different angles, 0 to 90

degrees
‘ifdef ROTATE // compute sin and cos
x_i <= ‘CORDIC_1;
y_i <= 0;
theta_i <= z[j];
‘endif
‘ifdef VECTOR // compute the arctan
x_i <= x[j];
y_i <= y[j];
theta_i <= 0;
‘endif
‘ifdef ITERATE
init <= 1; // load the value into the rotator
#1 clock <= 1;
#1 clock <= 0;
init <= 0;
for(i=0; i<‘ITERATIONS; i = i+1) begin // iterate on the value
#1 clock <= 1;
#1 clock <= 0;
end
show_results(j, x_o, y_o, theta_o);
‘endif
#1; // give a little time to view the waveform...
show_results(j, x_o, y_o, theta_o);
‘endif
‘ifdef PIPELINE
#1 clock <= 1;
#1 clock <= 0;
if (j >= (‘ITERATIONS-2)) begin // wait until the results start popping
out
show_results((j-(‘ITERATIONS-2)),x_o,y_o,theta_o);
end
if (j == 90) // now flush the pipe

for(i=0;i<(‘ITERATIONS-2);i = i+1) begin
136
#1 clock <= 1;
#1 clock <= 0;
show_results((90-‘ITERATIONS+3+i),x_o,y_o,theta_o);
end
‘endif
end
for(i=0; i<16; i=i+1) // dump a few extra clock just for grins
#1 clock <= ~clock;
end
endmodule
137
Apéndices D
Piezas del exoesqueleto
138
APÉNDICES D. PIEZAS DEL EXOESQUELETO
SoporteAxilaGoma
SoporteAxila
ArtCaderaHombro
ArtCaderaRodilla
ArtRodillaCadera
ArtRodillaTobillo
SoporteRodilla
SoportePierna SoporteTuboTobillo
REBARBAR Y
SI NO SE INDICA LO CONTRARIO: ROMPER ARISTAS
LAS COTAS SE EXPRESAN EN MM VIVAS
NOMBRE FIRMA FECHA TÍTULO:

DIBUJ.
VERIF.
APROB.
Exo14-08-12_EstructuraTubular
FABR. ESCALA:1:20 HOJA 1 DE 1
CALID. MATERIAL:
N.º DE DIBUJO
A4
PESO:
139
18
18
32
0
R3
15
17.3
60°
90
R11
36
86
5
26
18
36
5
30
20
REBARBAR Y
ArtCaderaHombro
DIBUJ.
VERIF.
APROB.
CALID. MATERIAL:
N.º DE DIBUJO
A4
PESO:
140
30
10
.2
0
13 13
54°
40
15 6.3
5
REBARBAR Y
ArtCaderaHombro
DIBUJ.
VERIF.
APROB.
CALID. MATERIAL:
N.º DE DIBUJO
A4
PESO:
141
27.6
0
20
R3
36
45°
5
30
30
16
60
30
14
.6
13 13
18
C
ue
8
40
rd
a
es 6.3
tá 5
nd
a r
0
.5
R0
18
10
3
36
18
30
130
SI NO SE INDICA LO CONTRARIO: ACABADO: REBARBAR Y

NO CAMBIE LA ESCALA REVISIÓN
LAS COTAS SE EXPRESAN EN MM ROMPER ARISTAS
ACABADO SUPERFICIAL: VIVAS
TOLERANCIAS:
LINEAL:
ANGULAR:
ArtCaderaRodilla
DIBUJ.
VERIF.
APROB.
FABR.
CALID. MATERIAL:
N.º DE DIBUJO
A4
PESO: ESCALA:1:2 HOJA 1 DE 1
142
60
R30
14
7° 32
10
.20
15 40
1
R1
25
104
40
70
20
5
5
36
5
REBARBAR Y
ArtRodillaCadera
DIBUJ.
VERIF.
APROB.
CALID. MATERIAL:
N.º DE DIBUJO
A4
PESO:
143
30 10
13 13
12
5
6.3
10
170°
.2
0
10.20
32
15
REBARBAR Y
ArtRodillaCadera
DIBUJ.
VERIF.
APROB.
CALID. MATERIAL:
N.º DE DIBUJO
A4
PESO:
144
0
8 R3
15
30
45°
87.6
13 13
27.6
35
6.
30
R0.50
19
.50
40
10
18
36
18
130
60
SI NO SE INDICA LO CONTRARIO: ACABADO: REBARBAR Y

NO CAMBIE LA ESCALA REVISIÓN
LAS COTAS SE EXPRESAN EN MM ROMPER ARISTAS
ACABADO SUPERFICIAL: VIVAS
TOLERANCIAS:
LINEAL:
ANGULAR:
ArtRodillaTobillo
DIBUJ.
VERIF.
APROB.
FABR.
CALID. MATERIAL:
N.º DE DIBUJO
A4
PESO: ESCALA:1:2 HOJA 1 DE 1
145

Diseño E Implementación en Fpga de Un Sistema de Control para Bipedestador Móvil Tesis

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Diseño E Implementación en Fpga de Un Sistema de Control para Bipedestador Móvil Tesis

Încărcat de

Drepturi de autor:

Formate disponibile

TECNOLÓGICO NACIONAL DE MÉXICO

Instituto Tecnológico de La Paz

INSTITUTO TECNOLÓGICO DE LA PAZ

DISEÑO E IMPLEMENTACIÓN EN FPGA DE UN

QUE PARA OBTENER EL GRADO DE

LA PAZ, BAJA CALIFORNIA SUR, MÉXICO, AGOSTO DE 2015.

[1] Blanca, Flor, Camacho, Cerezo, Jorge, Moyrón, Pedro, Zamudio.

Para ustedes y Gracias.

De acuerdo a la Organización Mundial de la Salud (OMS) alrededor del 15 % de la población

Lista de figuras VII

Lista de tablas VIII

3.6. Implementación en el FPGA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54

4. Resultados, conclusiones y trabajo futuro 66

A. Descripción de los módulos del sistema en VHDL 80

B. Módulos de prueba para verificar la funcionalidad de los circuitos diseñados 105

C. Códigos CORDIC y Bancos de prueba 114

D. Piezas del exoesqueleto 138

1.1. Ejemplos de exoesqueletos actuales. De izquierda a derecha: BLEEX, eLegs, HAL-5,

2.1. Arquitectura general de un ASIC. (Cortesı́a de Herrera Lozada, 2002). . . . . . . . 12

3.1. Propuesta de prototipo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38

3.10. Diagrama general de la arquitectura del sistema. . . . . . . . . . . . . . . . . . . . . 47

4.1. Opción de simulación en el Manejador de Proyectos de Vivado. . . . . . . . . . . . . 67

2.1. Parámetros y variables del Péndulo invertido sobre ruedas. . . . . . . . . . . . . . . 30

3.2. Cálculo de la fuerza requerida en los actuadores lineales. . . . . . . . . . . . . . . . 40

4.1. Tiempos de procesamiento en el microcontrolador con optimización O3. . . . . . . . 69

De acuerdo a la Organización Mundial de la Salud (OMS), en su Informe Mundial sobre Disca-

Una de las principales motivaciones de la robótica es liberar al hombre de tareas tediosas o

Las primeras investigaciones en torno a exoesqueletos pueden ubicarse temporalmente a fi-

Figura 1.2: Tek RMD. (Cortesı́a de Matia Robotics)

Figura 1.3: Segway PT. (Cortesı́a de Segway Inc.)

En los campos de la ciencia, la tecnologı́a y en la mayorı́a de los campos de trabajo, constante-

En la representación analógica una cantidad se representa mediante un indicador proporcional

En la representación digital las cantidades se representan no mediante indicadores que varı́an

En el dominio digital, la elección de la tecnologı́a a implementar está esencialmente entre usar

A pesar de que actualmente existen opciones de dispositivos de asistencia, algunos de ellos

general, inexistente entre las opciones tecnológicas actuales.

respirar e incluso facilita la función de los procesos digestivos.

Desde una perspectiva tecnológica, la electrónica reconfigurable es un área que, si bien no es

1.3. Planteamiento del problema

La robótica presenta una alternativa viable para la rehabilitación motriz y la autonomı́a de

El algoritmo implementado en el FPGA tendrá un mejor desempeño para efectos de tiempo de

Diseñar e implementar en FPGA un sistema de control para bipedestador móvil.

1.6. Objetivos Especı́ficos

Implementar el sistema en un procesador.

Implementar el sistema de control en un FPGA de gama baja.

Hacer pruebas comparativas.

2.1. Electrónica digital

Los ASICs se clasifican en tres grupos caracterı́sticos: Full-Custom (arquitectura a la medida),

Figura 2.1: Arquitectura general de un ASIC. (Cortesı́a de Herrera Lozada, 2002).

2.1.2. ASIC Programable

Un PLD tiene recursos comprometidos, es decir, no requiere de un proceso de interconexión

2.1.3. Arquitectura FPGA

b. Reducción en el tiempo de diseño. Debido a su naturaleza programable, reducen el tiempo

este tipo de dispositivos. Ası́ mismo, no se requiere de grandes recursos de cómputo.

2.1.4. Metodologı́a de Diseño VLSI con Herramientas CAD

1. Captura del diseño (Design Entry ). Se ingresa el modelo de solución al ambiente de

2. Sı́ntesis Lógica (Logic Synthesis). El software de desarrollo incluye la herramienta propia

3. Simulación Pretrazado (Prelayout Simulation). También conocida como Preruteado;

4. Mapeo o Planeación de la Superficie (Floorplanning ). Una vez que se simuló el diseño,

5. Colocación (Placement). Estratégicamente, el software decide la colocación de las primiti-

7. Traducción (Translate). Es la extracción de caracterı́sticas del circuito, determinando la

2.1.5. Lenguajes de Descripción de Hardware

Un HDL (Hardware Description Language - Lenguaje de Descripción de Hardware), es un