50 Alberto Ibarra Domínguez

cenidet
Centro Nacional de Investigacin y Desarrollo Tecnolgico

Departamento de Ingeniera Mecatrnica
TESIS DE MAESTRA EN CIENCIAS

Diseo de una Interfaz Grfica que Reproduzca Algunos
Movimientos de una Mano Robtica
presentada por
Alberto Ibarra Domnguez

Ing. en Comunicaciones y Electrnica por la Facultad de Ingeniera Mecnica, Elctrica y Electrnica
de la Universidad de Guanajuato
como requisito para la obtencin del grado de:
Maestra en Ciencias en Ingeniera Mecatrnica
Director de tesis:
Dr. Marco Antonio Oliver Salazar
Co-Director de tesis:
Dr. Ral Pinto Elas
Cuernavaca, Morelos, Mxico.
1 4
de Agosto de 2009
cenidet
Centro Nacional de Investigacin y Desarrollo Tecnolgico
Departamento de Ingeniera Mecatrnica
TESIS DE MAESTRA EN CIENCIAS

Diseo de una Interfaz Grfica que Reproduzca Algunos Movimientos de
una Mano Robtica
presentada por

Ing. en Comunicaciones y Electrnica por la Facultad de Ingeniera Mecnica, Elctrica y Electrnica
de la Universidad de Guanajuato
como requisito para la obtencin del grado de:
Maestra en Ciencias en Ingeniera Mecatrnica
Director de tesis:
Co-Director de tesis:
Dr. Ral Pinto Elas
Jurado:
Dr. Jos Ruiz Ascencio Presidente
M.C. Andrea Magadn Salazar Secretario
M.C. Jos Martn Gmez Lpez Vocal
Cuernavaca, Morelos, Mxico.
1 4
de Agosto de 2009
Dedicado a Marxa, una en 6,774 millones, la

estrella ms brillante en el rmamento, que
en la inmensidad del tiempo y el espacio
tuve la ms grande dicha de compartir un
lugar y una poca, adems del maravilloso
privilegio de ser bendecido con sus
enseanzas y sobre todo de su innito
cario.
Agradecimientos
A May, por tu apoyo incondicional, tu paciencia, tu sabidura, tu compresin, por el
ejemplo inmenso que me das, por no dejarme claudicar, por hacer que cada da valga
la pena, y por todas las innumerables enseanzas que me regalas a cada instante, por
esto y por todo aquello que no cabra en miles de millones de palabras de gratitud que
intentaran describir lo enorme e innitamente agradecido que estoy contigo. Gracias por
dejarme caminar a tu lado y aprender de ti.
A mis Padres Daniel Alberto y Alicia, que no obstante la distancia y la situacin
siempre estuvieron ah, siendo los mejores padres del mundo.
Al. Dr. Marco Antonio Oliver Salazar que sigui creyendo en mi, an cuando ya no lo
mereca, gracias por sus consejos, por su tiempo y por darme la oportunidad de trabajar
bajo su tutela.
Al Dr. Ral Pinto Elas por sus consejos y su tiempo, por alentarme y conducirme
a concluir con este reto que en muchas partes estuvo lleno de puntos sin retorno y de
intrpretes indescifrables.
A mi compaero el M.C. Cornelio Morales Morales por su ayuda incondicional y sin
la cual hubiera sido ms difcil la conclusin de este trabajo.
A mis revisores: Dr. Jos Ruiz Ascencio, M.C. Andrea Magadn Salazar y M.C. Jos
Martn Gmez Lpez por sus atinados comentarios para el progreso y nalizacin de este
trabajo.
Al M.C. Donovan Snchez Labastida y al M.I. Jos Baudelio Zamora Lpez quienes
an teniendo obligaciones de carcter profundo siempre su inters en mis objetivos, permiti que pudiera continuar con este proyecto.
Al CENIDET que fue mi casa y parte importante de mi formacin, y a todos aquellos
con los que conviv en este lugar he hicieron mi estancia algo memorable.
Al CONACYT por su puntual apoyo sin el cual no hubiera sido posible este sueo.
Resumen
En el campo de la robtica existen diversas disciplinas las cuales deben ser empleadas
para el desarrollo de una aplicacin completa. Dentro de las herramientas necesarias para
esta labor se encuentran la mecnica, la electrnica, el control y la informtica.
Mediante la interaccin de las herramientas correspondientes es posible lograr el desempeo de tareas de complejidad y exactitud considerable. Sin embargo en el camino del
diseo de aplicaciones robticas existen pasos los cuales pueden convertirse en tropiezos
desastrosos que pueden signicar un retraso considerable.
Mediante un simulador grco es posible prescindir de pruebas que por su naturaleza
pueden ser destructivas, ya que algn mal clculo, puede inuir de forma importante a
un mal desempeo del robot e incluso a destruir partes del mismo, sobre todo en la etapa
que corresponde al control.
Para poder generar una animacin sin necesidad de la interaccin de un controlador
externo en esta aplicacin, fue desarrollado un intrprete el cual es capaz de recibir una
serie de instrucciones de movimiento y ejecutarlas de forma lineal dependiendo del tiempo
que se le asigne a cada movimiento, con la capacidad de ejecutar varios movimientos a la
vez mediante la conjuncin en grupos de movimiento.
Los dos propsitos fundamentales del trabajo de tesis fueron: obtener del control implementado en una plataforma como LabVIEW una animacin que representara lo que
ocurrira en un prototipo fsico equivalente; y mediante la recuperacin de las seales
emitidas por los sensores del prototipo fsico, lograr una simulacin que correspondiera a
lo ocurrido en ste.
El desarrollo consisti en la creacin de una aplicacin con mdulos que fueran capaces de lograr la representacin de un prototipo fsico robtico mediante los parmetros
de Denavit-Hartenberg y a travs de la actualizacin de stos parmetros una animacin
fuera generada, la cual correspondiera a los valores reales obtenidos por la tarjeta de adquisicin de datos.
Mediante la generacin y actualizacin de archivos puente, los cuales pueden ser escritos y ledos por dos aplicaciones de forma simultnea es posible de forma simplicada
la comunicacin entre el controlador del robot y el simulador grco, sin necesidad de
monitorear e intervenir los puertos directamente.
iii
iv
RESUMEN
Abstract
In the robotics eld there are several disciplines that must be used for a complete
application development. The necessary tools for this kind of labor are mechanics, electronics, control, and computer science.
By means of the interaction between the corresponding tools it is possible to achieve the performance of the tasks with remarkable complexity and exactness . However in
the way of the robotic application design there are steps that can turn into a disastrous
stumbling than can represent a remarkable delay.
By means of a graphic simulator it is possible to avoid tests that, for their nature, can
be self destructive, specially in the control test stage, because a mistake in the calculations
can have some inuence in the bad performance of the robot and inclusive destroy parts
of it.
To generate the animation without the necessity of the external controller intervention in this application. A parser was developed. This is able to receive an instruction
set of movement and perform them in a lineal way, depending on the time that has been
assigned for each movement, with the capability of performing several movements at the
same time by means of the setting of movement groups.
The two main proposes of this thesis work were: obtain from implemented control in
a LabVIEW platform an animation who represents what would happened with a robotic equivalent prototype; and by means of the signal recovery emitted by the physical
prototype, achieve a corresponding simulation.
The development consisted in the creation of an application with several modules
that were able to achieve the representation of a robotic prototype by means of the
Denavit-Hartenberg parameters and by the updating of this parameters, so animations
were generated, corresponding to the real values obtained by the data acquisition card.
By means of the generation and updating of the bridge les that can be written and
read by two programs in a simultaneous way, it is possible in a simplied way, the communication between the robot controller and the graphic simulator, without the need of
monitoring and direct reading from the ports.
ndice general
Agradecimientos
Resumen
iii
Abstract
ndice general
vii
ndice de tablas
xi
ndice de guras
xiii
ndice de listados
xv
1. Introduccin
1.1. Descripcin del problema . . . . . . .

1.2. Planteamiento de una solucin . . . .
1.3. Estado del arte . . . . . . . . . . . .
1.3.1. Interfaces grcas robticas .
1.3.2. Simuladores grcos de robots
1.3.3. Simuladores de manos . . . .
1.3.4. Libreras para generar grcos
1.3.5. Analizadores lxico-sintcticos
1.3.6. Herramientas de desarrollo . .
1.4. Especicacin del sistema . . . . . .
1.4.1. Intrprete . . . . . . . . . . .
1.4.2. Simulador grco . . . . . . .
1.4.3. Interfaz LabView/C++ . . . .
1.4.4. Prototipo fsico . . . . . . . .
1.4.5. Comando en lnea . . . . . . .
1.5. Organizacin de la tesis . . . . . . .
vii
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
articulados
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
1
5
9
9
11
13
16
16
17
22
24
26
29
31
31
34
NDICE GENERAL
viii
2. Intrprete
2.1. Scripts descriptivos . . . . . . . . . . . . . .

2.1.1. Descripcin de los parmetros . . . .
2.1.2. Sintaxis de la instruccin . . . . . . .
2.1.3. Sintaxis del script . . . . . . . . . . .
2.2. Lgica de operacin . . . . . . . . . . . . . .
2.2.1. Algoritmo del compilador de lnea . .
2.2.2. Algoritmo del compilador de archivos
2.3. Aplicacin . . . . . . . . . . . . . . . . . . .
2.3.1. Interfaz . . . . . . . . . . . . . . . .
2.3.2. Parmetros generados . . . . . . . .
2.3.3. Mensajes generados . . . . . . . . . .
2.4. Clase intrprete . . . . . . . . . . . . . . . .
2.4.1. Tipos de datos . . . . . . . . . . . .
2.4.2. Constantes . . . . . . . . . . . . . . .
2.4.3. Funciones . . . . . . . . . . . . . . .
3. Simulador Grco
3.1. Herramientas generales . . . . . . . . . .

3.1.1. Generacin de objetos . . . . . .
3.1.2. Ambientacin . . . . . . . . . . .
3.1.3. Navegacin por el entorno virtual
3.2. Parmetros Denavit-Hartenberg . . . . .
3.2.1. Morfologa del robot . . . . . . .
3.2.2. Movimiento del robot . . . . . . .
3.3. Clase grcos . . . . . . . . . . . . . . .
3.3.1. Tipos de datos . . . . . . . . . .
3.3.2. Constantes . . . . . . . . . . . . .
3.3.3. Declaraciones privadas . . . . . .
3.3.4. Funciones y mtodos . . . . . . .
3.4. Animacin de los grcos . . . . . . . . .
4. Manejo de las Seales
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
4.1. LabView como interfaz entre C++ y puertos fsicos . . . . . . . . . . . .

4.1.1. Puertos fsicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.1.2. Mdulo de tiempo real (Real Time) . . . . . . . . . . . . . . . . .
4.1.3. Lectura y escritura de variables como puente de los puertos fsicos
4.1.4. Retrasos y desfases . . . . . . . . . . . . . . . . . . . . . . . . . .
4.2. Driver virtual . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.2.1. Lectura y escritura de archivos puente . . . . . . . . . . . . . . .
4.2.2. Formato de archivos puente . . . . . . . . . . . . . . . . . . . . .
4.2.3. Utilizacin de funciones de animacin para la generacin de movimiento virtual . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.3. Simulador de movimiento en LabVIEW . . . . . . . . . . . . . . . . . . .
4.4. Modos de funcionamiento de la aplicacin . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
35
35
36
37
38
39
40
40
40
42
43
44
44
44
44
49
53
54
54
56
57
60
60
65
65
65
68
71
71
76
77
78
79
80
81
81
81
82
85
. 86
. 86
. 86
NDICE GENERAL
ix
4.4.1. Simulacin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
4.4.2. Interpretacin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
4.4.3. Emisin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
5. Pruebas y Validacin del Sistema

5.1. Modo
5.1.1.
5.1.2.
5.2. Modo
5.2.1.
5.3. Modo
5.3.1.
91
simulacin . . . . . . . . . . . . . . . . . . .
Pruebas al modo simulacin . . . . . . . . .
Validacin al modo simulacin . . . . . . . .
interpretacin . . . . . . . . . . . . . . . . .
Pruebas y validacin al modo interpretacin
emisin . . . . . . . . . . . . . . . . . . . . .
Pruebas y validacin al modo emisin . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
6. Conclusiones y Observaciones
91
91
93
94
94
95
95
99
6.1. Observaciones . . . . . . . . . . . . .
6.2. Conclusiones . . . . . . . . . . . . . .
6.2.1. Acerca del intrprete . . . . .
6.2.2. Acerca del simulador grco .
6.2.3. Acerca del manejo de seales .
6.3. Trabajo futuro . . . . . . . . . . . .
6.3.1. Grcos . . . . . . . . . . . .
6.3.2. Intrprete . . . . . . . . . . .
6.3.3. Driver virtual . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
99
99
100
101
101
102
102
102
103
Bibliografa
105
A. Manual de Usuario
109
A.1. Instalacin . . . . . . . . . . . . .
A.2. Grcos . . . . . . . . . . . . . .
A.2.1. Navegacin . . . . . . . .
A.2.2. Entorno . . . . . . . . . .
A.3. Modos . . . . . . . . . . . . . . .
A.3.1. Simulacin . . . . . . . . .
A.3.2. Interpretacin . . . . . . .
A.3.3. Emisin . . . . . . . . . .
A.4. Scripts . . . . . . . . . . . . . . .
A.4.1. Sintaxis . . . . . . . . . .
A.4.2. Lnea de comandos . . . .
A.4.3. Archivo descriptivo . . . .
A.5. Driver . . . . . . . . . . . . . . .
A.5.1. Archivo puente . . . . . .
A.5.2. SubVI's en el programa de
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
control .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
109
109
110
111
111
111
111
112
112
112
112
113
113
113
113
NDICE GENERAL
B. Cdigo Fuente
B.1. Principal . . . . . . . .
B.2. Clase para los grcos
B.2.1. Gracos.cpp . .
B.2.2. Gracos.h . . .
B.3. Clase para el intrprete
B.3.1. Interprete.cpp .
B.3.2. Interprete.h . .
B.4. Programa en LabView
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
115
115
150
150
157
160
160
172
174
C. Instalacin de Paquetes
177
D. Contacto
181
C.1. Instalacin del panel OpenGL a Bulider C++ 5.0 . . . . . . . . . . . . . . 177

C.2. Instalacin de las libreras GLUT . . . . . . . . . . . . . . . . . . . . . . . 178
ndice de tablas
1.1. Comparacin entre los diferentes generadores de parsers de fuente libre

cdigo abierto (parte 1 de 3) . . . . . . . . . . . . . . . . . . . . . . . .
1.4. Comparacin entre los diferentes generadores de parsers comerciales . .
o
.
o
.
o
.
.
. 18
. 19
. 20
. 20
2.1. Parmetros admisibles en una instruccin para generar movimiento con la

palabra reservada mov . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.2. Mensajes generados por el intrprete (parte 1 de 2) . . . . . . . . . . . .
2.3. Mensajes generados por el intrprete (parte 2 de 2) . . . . . . . . . . . .
2.4. Elementos del tipo de dato DatosLinea . . . . . . . . . . . . . . . . . . .
2.5. Constantes que denen los dedos . . . . . . . . . . . . . . . . . . . . . .
2.6. Constantes que denen las falanges . . . . . . . . . . . . . . . . . . . . .
2.7. Constantes que denen los lmites de movimiento . . . . . . . . . . . . .
2.8. Descripcin general de las funciones que integran la clase Interprete. . .
2.9. Orden de los elementos en el archivo de puente o driver . . . . . . . . . .
.
.
.
.
.
.
.
.
.
38
45
46
47
47
48
49
50
52
3.1. Tipos de forma, modicadores y parmetros admitidos para la representacin de objetos libres. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.2. Elementos del tipo de datos defDH . . . . . . . . . . . . . . . . . . . . .
3.3. Elementos del tipo de datos oC . . . . . . . . . . . . . . . . . . . . . . .
3.4. Elementos del tipo de datos parF . . . . . . . . . . . . . . . . . . . . . .
3.5. Elementos del tipo de datos camRot . . . . . . . . . . . . . . . . . . . . .
3.6. Elementos del tipo de datos parAnim . . . . . . . . . . . . . . . . . . . .
3.7. Constantes que denen las vistas . . . . . . . . . . . . . . . . . . . . . .
3.8. Constantes que denen las formas . . . . . . . . . . . . . . . . . . . . . .
3.9. Constantes que denen los ejes . . . . . . . . . . . . . . . . . . . . . . .
3.10. Constantes varias . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
55
66
66
67
68
68
69
70
70
70
xi
xii
NDICE DE TABLAS
ndice de guras
1.1.
1.2.
1.3.
1.4.
1.5.
1.6.
1.7.
Diagrama de bloques del sistema . . . . . . . . . . . . . . . . . . . . . . .

Flujo de la informacin en modo de interpretacin . . . . . . . . . . . . . .
Flujo de la informacin en modo de simulacin . . . . . . . . . . . . . . . .
Flujo de la informacin en modo de emisin . . . . . . . . . . . . . . . . .
Estructura del sistema del ratn espacial . . . . . . . . . . . . . . . . . . .
Experimento montado para el reconocimiento del movimiento de una mano
Interfaz para la representacin de los movimientos capturados de una mano
mediante cmaras digitales . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.8. Transformacin a guras geomtricas simples de una taza . . . . . . . . . .
1.9. Diagrama general del sistema . . . . . . . . . . . . . . . . . . . . . . . . .
1.10. Diagrama interno del intrprete . . . . . . . . . . . . . . . . . . . . . . . .
1.11. Diagrama interno del simulador grco . . . . . . . . . . . . . . . . . . . .
1.12. Diagrama interno de la interfaz LabView/C++ . . . . . . . . . . . . . . .
1.13. Diagrama interno del prototipo fsico (Mano) . . . . . . . . . . . . . . . . .
1.14. Diagrama interno del comando en lnea . . . . . . . . . . . . . . . . . . . .
14
15
23
25
28
30
32
33
2.1.
2.2.
2.3.
2.4.
2.5.
2.6.
2.7.
Representacin general de la sintxis . . . . . . . . . . .

Representacin general de la sintxis . . . . . . . . . . .
Ubicacin de separadores y delimitadores . . . . . . . . .
Descripcin de los parmetros de forma individual . . . .
Diagrama de ujo del algoritmo para compilar una lnea
Diagrama de ujo del algoritmo para compilar un archivo
Partes de la interfaz grca concernientes al intrprete .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
3.1. Representacin grca del cdigo representado en el listado 3.2 en el

torno de la mano . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.2. Entorno grco con iluminacin en color rojo . . . . . . . . . . . . . .
3.3. Entorno grco con color de fondo azul . . . . . . . . . . . . . . . . .
3.4. Observador trasladado . . . . . . . . . . . . . . . . . . . . . . . . . .
3.5. Observador rotado . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.6. Acercamiento del observador . . . . . . . . . . . . . . . . . . . . . . .
3.7. Mano de sin pulgar como conguracin alternativa . . . . . . . . . .
xiii
.
.
.
.
.
.
.
2
3
4
5
11
14
.
.
.
.
.
.
.
.
.
.
.
.
.
.
36
37
38
39
41
42
43
en. .
. .
. .
. .
. .
. .
. .
.
.
.
.
.
.
.
57
58
59
60
61
61
64
xiv
NDICE DE FIGURAS
3.8. Imgenes obervadas en la ejecucin de una animacin en distintos instantes

de tiempo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
4.1. Diagrama a bloques de la interconexin del driver virtual . . . . . . . . .
4.2. Tarjeta de adquisicin y generacin de datos con FPGA PCI-7833 de National Instruments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.3. Tarjeta de interconexin SCB-68 . . . . . . . . . . . . . . . . . . . . . . .
4.4. Interconexin del sistema de la mano CENIDET . . . . . . . . . . . . . .
4.5. Algorimo para la escritura en el simulador grco . . . . . . . . . . . . .
4.6. Algorimo para la lectura en el simulador grco . . . . . . . . . . . . . .
4.7. Algorimo para la escritura en el controlador . . . . . . . . . . . . . . . .
4.8. Algorimo para la lectura en el controlador . . . . . . . . . . . . . . . . .
4.9. Simulador de movimiento . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.10. Interfaz grca en modo de interpretacin utilzando el simulador de movimiento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.11. Opciones del men Modo . . . . . . . . . . . . . . . . . . . . . . . . . .
4.12. Opciones del men Animacin . . . . . . . . . . . . . . . . . . . . . . .
4.13. Pestaa para la asignacin de datos para Emisin . . . . . . . . . . . .
. 78
.
.
.
.
.
.
.
.
79
79
80
83
83
84
84
87
.
.
.
.
88
89
89
90
5.1. Resultado de los Scripts descritos en los listados 5.1 y 5.2 . . . . . . . . . . 93

5.2. Prueba en modo interpretacin. . . . . . . . . . . . . . . . . . . . . . . . . 95
5.3. Prueba en modo emisin. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
A.1. Partes del simulador grco . . . . . . . . . . . . . . . . . . . . . . . . . . 110
A.2. Interconexon del subVI Driver en el simulador de seales de movimiento . 114
B.1. Panel del VI del driver virtual . . . . . . . . . . . . . . . . . . . . . . . . . 174
B.2. Cdigo grco en LabVIEW del driver virtual . . . . . . . . . . . . . . . . 175
B.3. Caso de emisin del driver virtual . . . . . . . . . . . . . . . . . . . . . . . 176
C.1. Cuadro de dilogo indicando la pestaa Directories/Conditional . . . . . . 178
C.2. Cuadro de Dialogo para agregar directorios de ruta . . . . . . . . . . . . . 179
ndice de listados
2.1. Ejemplo de Script que describe los movimientos de la mano . . .

3.1. Comando de objeto . . . . . . . . . . . . . . . . . . . . . . . . .
3.2. Cdigo de representacin de guras . . . . . . . . . . . . . . . .
3.3. Comando para la representacin de Denavit-Hartenberg . . . . .
3.4. Conguracin de la mano . . . . . . . . . . . . . . . . . . . . .
3.5. Cdigo que dene las tapas de la palma . . . . . . . . . . . . . .
3.6. Conguracin de la mano sin pulgar . . . . . . . . . . . . . . . .
3.7. Declaracin de las variables privadas de la clase Graficos . . .
3.8. Sintaxis del mtodo DHo de la clase Graficos . . . . . . . . . .
3.9. Sintaxis de la funcin GetO de la clase Graficos . . . . . . . . .
3.10. Sintaxis de la funcin DH de la clase Graficos . . . . . . . . . .
3.11. Sintaxis de la funcin Cadena de la clase Graficos . . . . . . .
3.12. Diversas sintaxis del mtodo Objeto de la clase Graficos . . . .
3.13. Sintaxis de la funcin GraficarObjeto de la clase Graficos . .
3.14. Sintaxis del mtodo MovimientoAlfa de la clase Graficos . . .
3.15. Sintaxis del mtodo MovimientoTeta de la clase Graficos . . .
3.16. Sintaxis del mtodo MovimientoObjeto de la clase Graficos . .
3.17. Sintaxis de la funcin Camara de la clase Graficos . . . . . . .
3.18. Sintaxis de la funcin nVC de la clase Graficos . . . . . . . . .
3.19. Sintaxis de la funcin nCa de la clase Graficos . . . . . . . . .
3.20. Sintaxis de la funcin nElemento de la clase Graficos . . . . .
3.21. Sintaxis de la funcin nElementosCadenas de la clase Graficos
3.22. Sintaxis de la funcin codnOb de la clase Graficos . . . . . . .
3.23. Sintaxis de la funcin angActual de la clase Graficos . . . . .
5.1. Ejemplo de script en modo de simulacin (puo) . . . . . . . .
5.2. Ejemplo de script en modo de simulacin (cuenta 1-2-3) . . . .
A.1. Sintaxis de orden de movimiento . . . . . . . . . . . . . . . . . .
xv
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
39
54
56
60
62
63
63
71
71
72
72
72
73
73
73
74
74
74
75
75
75
75
75
76
92
92
112
xvi
NDICE DE LISTADOS
Captulo
Introduccin
El mundo de la robtica est evolucionando a una velocidad vertiginosa, y el quehacer
en este tema es extenso, sin embargo para su prctica es necesario tener un presupuesto
amplio para poder lograr avances importantes.
Mediante el desarrollo de simuladores, la robtica toma un nuevo aire en cuanto a sus
aspectos prcticos, ya que no es necesario el desarrollo de una plataforma robtica fsica
para poder continuar con el estudio de esta fascinante tarea.
Son muchos los alcances de la robtica, los cuales abarcan desde la automatizacin
de procesos, hasta la medicina con prtesis inteligentes, o herramientas que hacen ms
precisas, ms rpidas o ms fuertes las capacidades humanas.
1.1. Descripcin del problema

El presente trabajo busca el desarrollo de un simulador grco en tiempo real y fuera de lnea para un prototipo robtico similar a una mano, el cual opere por medio de
instrucciones que pueden estar contenidas en archivos descriptivos (scripts) o pueden ser
ejecutadas mediante una entrada de tipo lnea de comandos en el entorno del simulador
grco para representar el movimiento de dicho prototipo robtico. Con esto se ha de
producir una animacin ya sea en tiempo real o fuera de lnea para su inspeccin (monitoreo) y evitar movimientos destructivos en el prototipo robtico.
El simulador grco debe tener la capacidad de representar lo ocurrido en el prototipo robtico al ser controlado directamente desde LabView, en donde LabView tiene que
enviar instrucciones para su ejecucin en el prototipo robtico.
El simulador grco por su parte debe representar movimientos sin estar vinculado
con el prototipo robtico, esto es, de forma independiente a lo ocurrido en el robot, de
modo que sea posible observar secuencias de movimiento determinadas por el usuario sin
1
CAPTULO 1. INTRODUCCIN
necesidad de contar fsicamente con el prototipo robtico.
Script
to
ien
Intrprete
l
tua
Vir
Parmetros de
movimiento
vim
Mo
Simulador
Movimiento real
C++ Driver
Driver
LabView
LabView Driver
Posicin de
los encoders
HMI
Instrucciones a los FPGA's

que generan el movimiento
Controlador
Etapa de potencia
y acondicionamiento
de seales
Mano
Prototipo Robtico
Figura 1.1: Diagrama de bloques del sistema
El simulador grco debe ser capaz de enviar instrucciones a LabView para su ejecucin
en el prototipo robtico de modo que LabView con el controlador que tenga implementado recupere esa informacin, la procese y ejecute, de modo que el simulador grco
la represente en su entorno. Para lo descrito anteriormente se plantean 3 esquemas de
operacin:
1.1. DESCRIPCIN DEL PROBLEMA
1. Modo de Interpretacin: A partir de las seales recibidas del controlador el simulador

har un despliegue grco de los movimientos de la mano en tiempo real.
2. Modo de Simulacin: A partir de una secuencia de movimientos indicados por el
simulador, este ser capaz de generarla en un despliegue grco nicamente.
3. Modo de Emisin: A partir de una instruccin dada al simulador grco desde la
interfaz del mismo, se establecer un elemento (dedo, falange) y un ngulo que el
controlador en LabView ejecutar y el simulador grco representar.
El punto central y ms importante es el diseo y programacin de un intrprete, que
traduce los scripts en argumentos para las funciones que representan los movimientos. Los
movimientos tienen su origen tanto en un script ingresado para su simulacin, como de la
recuperacin de la informacin obtenida del movimiento ocurrido en el prototipo robtico.
El sistema se ilustra en el diagrama a bloques de la gura 1.1 en donde se delimita por la
lnea punteada con doble espacio en color verde lo correspondiente a otros trabajos previos
[3], [24] y delimitado por la lnea roja punteada se indica la parte desarrollada en LabView.
En la gura 1.2 se ilustra el ujo de la informacin en el modo de interpretacin y se
observa que slo se obtiene la informacin del controlador en LabView (1) la cual pasa
por el driver (2) y esta informacin alimenta al simulador grco (3).
Script
3
im
v
Mo
Simulador
to
ien
Intrprete
l
tua
Vir
Movimiento real
Parmetros de
movimiento
C++ Driver
Driver
LabView
LabView Driver
Posicin de
los encoders

1
HMI
Controlador
Etapa de potencia
y acondicionamiento
de seales
Mano
Prototipo Robtico
Figura 1.2: Flujo de la informacin en modo de interpretacin

La gura 1.3 ilustra como en modo de simulacin la parte del driver no tiene accin
alguna y la aplicacin se hace independiente del prototipo robtico y su controlador. Se
obtiene la informacin de una o varias instrucciones almacenadas en un script o de una
instruccin ingresada en la lnea de comandos(1), acto seguido mediante el intrprete(2)
se extrae la informacin contenida en las instrucciones para alimentar al simulador grco(3) y generar la animacin.
Script
2
3
im
v
Mo
Simulador
t
ien
Intrprete
al
irtu
oV
Movimiento real
Parmetros de
movimiento
C++ Driver
Driver
LabView
LabView Driver
Posicin de
los encoders
HMI

Controlador
Etapa de potencia
y acondicionamiento
de seales
Mano
Prototipo Robtico
Figura 1.3: Flujo de la informacin en modo de simulacin
El funcionamiento del modo emisin se ilustra en la gura 1.4 y consiste en obtener la

informacin de un script (1) el cual es generado mediante una parte de la interfaz dedicada especcamente a este modo de operacin, el cual slo genera una instruccin a la vez
y la enva al intrprete(2) que enseguida enva al driver (3) y ste al controlador(4) que
genera l accin requerida; el driver (5) recupera la informacin generada de lo ocurrido en
el prototipo robtico y genera la informacin requerida para la animacin en el simulador
grco(6).
1.2. PLANTEAMIENTO DE UNA SOLUCIN

Script
im
v
Mo
Simulador
to
ien
Intrprete
l
tua
Vir
Parmetros de
movimiento
Movimiento real
C++ Driver
Driver
LabView
LabView Driver
Posicin de
los encoders

4
HMI
Controlador
Etapa de potencia
y acondicionamiento
de seales
Mano
Prototipo Robtico
Figura 1.4: Flujo de la informacin en modo de emisin

An cuando los modelos cinemtico y dinmico correspondientes ya fueron desarrollados es importante entender bien su funcionamiento para detectar posibles mejoras al
modelado ya realizado, en caso de ser necesario. La informacin del modelo matemtico
es una pieza fundamental en el desarrollo del simulador, ya que, dependiendo de sta, se
calculan esfuerzos, momentos, torques, etctera, en todos los puntos crticos del prototipo
robtico.
La adquisicin y transmisin de los datos se hace con una tarjeta de adquisicin comercial, para no involucrarse en el diseo y construccin de tarjetas de adquisicin de
datos.
1.2. Planteamiento de una solucin

Para obtener la solucin al diseo de una interfaz grca en software que permita,
la inclusin de seales fsicas para el despliegue grco de los movimientos de un efector
mecnico similar a una mano con sus articulaciones correspondientes (dedos y falanges),
mediante la interpretacin de instrucciones contenidas en scripts fuera de lnea y la interpretacin de los encoders que contienen la informacin de la posicin de las articulaciones
del prototipo robtico en tiempo real, fue necesario establecer un objetivo general en el
cual se basan tres objetivos particulares que aseguran la realizacin de la tarea.
El objetivo general se establece como: obtener una herramienta que permita ver de
forma grca el movimiento de un prototipo robtico de una mano mecnica la cual fue
desarrollada en un trabajo de tesis anterior [3]llamado mano CENIDET, ya sea a partir
de un entorno de simulacin completa para la validacin de modelos matemticos, trayectorias y controladores, o de la recuperacin de la informacin de un efector mecnico
o de sensores que lo monitoreen.

Al ser establecido el objetivo general los objetivos particulares planteados ayudan a
generar una estructura sistemtica para el desarrollo de la aplicacin, y estos fueron los
siguientes:
Familiarizacin con interfaces grcas y con las libreras que ayuden al desarrollo
de una interfaz, para as crear una herramienta propia.
Estudio y anlisis de los modelos matemticos existentes para su eleccin en la
implementacin del simulador grco, de modo que ayuden a estructurar la inclusin
de conguraciones robticas.
La seleccin de una o varias plataformas de software en donde se pueda generar una
aplicacin robusta y estable.
Generacin de una variedad de modos de operacin que satisfagan las necesidades
de simulacin tanto en tiempo real como fuera de lnea.
El diseo, la estructuracin y la generacin de scripts que ejecuta el prototipo fsico
mediante la interpretacin de las seales elctricas generadas para su funcionamiento, generando el entorno original en el que fue concebido (LabView).
Documentacin del software desarrollado para su uso en aplicaciones similares mediante modicaciones al cdigo principal.
Se busc que esta interfaz despliegue algunos de los movimientos que efecta una mano
robtica basados en modelos previamente desarrollados [3], [14], [5]. Esto dar al usuario
una mejor comprensin de los movimientos reales de un efector mecnico que reproduce
algunos movimientos de una mano robtica.
Para el desarrollo del proyecto es importante que dos puntos queden claros para el
desarrollo de la interfaz a nivel del acondicionamiento de las seales fsicas, estos son:
Entender la informacin codicada proporcionada por los encoders (, ) y cmo
sta es reconocida en la PC.
Entender cmo las seales son procesadas por los FPGA's que accionan motores del
prototipo fsico.
Al haber sido contemplados estos aspectos, el proyecto se enfoc principalmente en
tres partes fundamentales las cuales estarn ligadas entre s, y se ejecutan de manera
secuencial.
1.2. PLANTEAMIENTO DE UNA SOLUCIN
1. La creacin de un simulador grco mediante libreras especializadas [10], [7], [26], [6]
que reproduzca los movimientos de una mano robtica donde se observa grcamente
una animacin en la PC de estos movimientos en tiempo real, teniendo como sistema
de referencia los modelos cinemtico y dinmico de la mano robtica anteriormente
analizados y desarrollados en una tesis previa [3]. Los datos que se utilizarn a partir
de la cinemtica directa son:
Las posiciones angulares (i (t)) de cada falange
A partir de las posiciones angulares i (t), se generar un archivo descriptivo (Script ).
2. El script contendr la informacin de la evolucin del movimiento, a partir de alguna
rutina previamente programada. Con esto se lograr obtener una representacin del
movimiento en forma virtual, que posteriormente se sincronizar para obtener una
versin en tiempo real del movimiento del prototipo.
3. Dada una secuencia de movimiento, los scripts interactuarn con los FPGAs de
un tarjeta de adquisicin de datos comercial [9] para generar las seales fsicas que
permitirn el movimiento del prototipo.
Este proyecto comprendi el desarrollo de una herramienta de simulacin para la validacin de modelos, programacin de trayectorias y validacin de algoritmos de control.
Esto ser de gran utilidad ya que ayudar a prevenir movimientos no deseados que pueden
ir desde trayectorias prohibidas hasta comportamientos destructivos del prototipo.
Buscando continuar con el conocimiento que se ha venido adquiriendo en el CENIDET
en torno al diseo de actuadores electromecnicos [3]. Este trabajo busca desarrollar una
herramienta grca que reproduzca algunos de los movimientos reales de un sistema mecnico cualquiera mediante su representacin matemtica, para la validacin completa de
los sistemas diseados, tomando como caso de estudio la mano CENIDET.
El sistema que se desarroll ser una herramienta de simulacin de sistemas robticos
articulados, en la cual se pueden observar distintas circunstancias fsicas en los lmites
de operacin, lo que evitar rutinas que daen el dispositivo, que en ocasiones por errores en los clculos se pasan por alto. El simulador grco muestra de manera virtual el
comportamiento de cada parte del prototipo robtico y entregar informacin precisa del
comportamiento de los actuadores.
Como resultado de este trabajo de tesis se obtuvo un simulador capaz de reproducir
los movimientos de una mano robtica, movimientos que podrn ser creados mediante la
obtencin de seales generadas por el prototipo robtico o bien de forma virtual mediante
comandos que produzcan el movimiento sin tener el dispositivo fsico habilitado.
El intrprete tiene la capacidad de generar animaciones para la conguracin que sea
indicada modicando el cdigo fuente de forma muy breve, y como caso de estudio ser
la mano robtica la conguracin vigente.
El simulador puede recibir conguraciones de robots con articulaciones de un grado de

libertad nicamente, por lo que las conguraciones en parmetros de Denavit-Hartenberg
tendrn esa particularidad y en caso de encontrar los parmetros para robots prismticos,
su funcionalidad se ver limitada. Se deja abierta la implementacin de robots prismticos
para futuras mejoras al sistema.
El caso de estudio que se implement es inicialmente el nico que tiene el diseo de
un driver 1 , sentando las bases para la modicacin de ste para futuras adecuaciones y
ampliaciones.
El nmero de entradas y salidas depende de los grados de libertad del robot a travs
de las tarjetas de adquisicin de datos disponibles.
La metodologa consisti en 4 partes fundamentales:
1. Bsqueda de informacin.
Su objetivo fue reunir todas las fuentes bibliogrcas pertinentes para la sustentacin terica de la interfaz.
Mediante fuentes bibliogrcas tanto impresas como electrnicas.
Dominio de las herramientas de software y hardware utilizadas.
La utilizacin de la bibliografa dio elementos fundamentales de lo que representa una interfaz grca.
Documentacin ordenada de la bibliografa.
2. Planteamiento de especicaciones en software.
Su objetivo fue delimitar el problema en lo que a software se reere para la ejecucin
adecuada de la interfaz.
Bsqueda en la bibliografa de los parmetros requeridos de software y hardware.
Establecimiento de los lmites del desarrollo en software.
Diseo de manera esquemtica el sistema completo contemplando expansiones del mismo y establecimiento de la apertura del simulador grco a otras
aplicaciones y documentacin del proceso que se requiere en la expansin.
3. Desarrollo de la interfaz.
Programacin de la interfaz utilizando las herramientas grcas de software
contempladas (OpenGL) y modelos de la mano ya desarrollados.
1 Manejador
de datos que permitir la interaccin entre el dispositivo fsico y el simulador, leyendo las
instrucciones que se escriban en el puerto que lo controle.
1.3. ESTADO DEL ARTE
Diseo de la estructura a utilizar por los scripts mediante la interpretacin de

las seales generadas en el prototipo fsico e implementacin en la ejecucin
del simulador grco.
Generacin de scripts en tiempo real as como su interpretacin y simulacin
grca en tiempo real.
4. Validacin de la interfaz.
Vericacin de los parmetros admisibles (posiciones que puede alcanzar el
sistema).
Diseo de pruebas para la validacin.
Simulacin del sistema dentro los parmetros admisibles.
Simulacin del sistema en condiciones fuera de los parmetros admisibles.
Vericacin por inspeccin visual del sistema, comparndolo con el prototipo
fsico.
1.3. Estado del arte

El presente estado del arte se sita en un contexto global de lo simuladores robticos,
tanto comerciales como desarrollos de algunas universidades. Despus se va encaminando
a simuladores de manos mecnicas, haciendo una breve referencia a ellas como tales, para
as comprender su sionoma, su funcionamiento y comportamiento. Ms adelante se hace
referencia a las interfaces de distintos tipos donde se ven involucrados sistemas robticos
de diversos tipos, para posteriormente indagar acerca de algunas alternativas de la manipulacin de grcos por computadora.
Como tpico adicional se investiga acerca de los analizadores lxico-sintcticos o bien
como comnmente se les conoce autmatas para el anlisis de cdigo que se generar
entre plataformas de software y as hacerlas compatibles y descifrables mutuamente.
En un contexto concerniente a un enfoque ms prctico se sita un anlisis a las herramientas que se utilizaron para el desarrollo, en donde se presenta de forma resumida
su funcionalidad y las ventajas de su utilizacin.
1.3.1. Interfaces grcas robticas

La interaccin que se pueda tener con los robots es una importante tarea que debe ser
resuelta de forma precisa. Muchas universidades y centros de investigacin se han dado a
la labor de disear interfaces robticas para diversos propsitos, que por lo general estn
encaminados al monitoreo y el control de diversos entornos. Muchas interfaces han sido
desarrolladas desde hace mas de 20 aos, con mltiples objetivos y en ambientes muy
10
diversos.
En la Universidad de Florida fue desarrollada una interfaz grca para la operacin
robtica a distancia en ambientes peligrosos [27] para poder supervisar en un cuarto de
control remoto las operaciones realizadas en la manipulacin de desechos nucleares y materiales con naturaleza peligrosa para el ser humano. Se cre todo un mundo virtual el cual
pudiera representar el entorno contaminado para as hacer las manipulaciones pertinentes.
En la Universidad de Nuevo Mxico en cooperacin de los Laboratorios Nacionales
Sanda se desarroll un sistema [2] para remover los residuos dentro de los tanques situados bajo tierra, esto mediante recursos robticos donde el mediador entre el software de
control y el hardware fue una interfaz grca que genera un mundo virtual que representa
el entorno real en donde los robots harn su labor.
Dentro de los aspectos simulables en una interfaz grca estn los sensores, en la Universidad de Tennessee en Knoxville, Estados Unidos, se desarroll una interfaz grca
[1] capaz de simular sensores de cinco tipos diferentes: proximidad, rango de punto lser,
rango ultrasnico, rango lser de profundidad por imagen y bordes basados en intensidad
de imagen. Mediante los modelos matemticos de los sensores es como fue posible que se
simulara su comportamiento en un entorno virtual.
En tpicos de operacin remota otro ejemplo mencionable es del una distancia considerable entre el operador y el robot a operar. El Jet Propulsion Laboratory de la NASA
desarroll un sistema grco para la operacin de robots situados en el espacio [15] en
el que cada objeto mvil puede ser manipulado mediante una interfaz grca y se puede
obtener una representacin virtual de lo sucedido sin necesidad de tener que recuperar un
video real.
Otro mundo en el que el acceso es muy limitado es aquel en que las cosas son muy
pequeas. En el Instituto Federal Suizo de Tecnologa en Zurich se desarroll una interfaz
grca [28] mediante equipo muy preciso (resolucin en nanmetros) de 6 grados de libertad y un microscopio capaz de recuperar imgenes en video en ambos modos de video
mono y estreo.
En el campo de la industria de la manufactura se encuentran aplicaciones importantes
para las interfaces robticas y su auxilio mediante interfaces grcas. En la Universidad
de Birmingham en el Reino Unido se dise una interfaz grca [23], la cual al recibir una
pieza descrita en CAD es capaz de desplegarla grcamente as como analizarla y generar
el diseo para su construccin.
Mediante la obtencin de imgenes cada vez han sido desarrolladas aplicaciones ms
complejas. En la Universidad Tcnica de Munich en Alemania y en cooperacin con dos
Universidades en los Estados Unidos, fue desarrollada una interfaz robtica[17] para la
manipulacin de un robot PUMA la cual se basa en la obtencin de imgenes del brazo real del operador, lo que representara una especie de ratn espacial (gura 1.5) en
11
Figura 1.5: Estructura del sistema del ratn espacial

donde determinados movimientos del operador representarn movimientos a realizar por
el brazo robtico.
1.3.2. Simuladores grcos de robots articulados

Existen diversos tipos de simuladores para robots articulados en la actualidad, los
cuales buscan diversos propsitos. Dependiendo de las aplicaciones que estos simuladores
tengan, ser la medida en la que puedan ser redituables.
Diversas universidades, centros de investigacin; y empresas han desarrollado sus propios simuladores para dar abasto a su necesidades, lo que lleva a conformar un amplio
campo de referencia en lo que a esta investigacin se corresponde.
En la escuela de ingeniera de la Universidad de Nagoya en Japn, se desarroll un
simulador de robots articulados para el diseo de seguridad y control [12] en el cual se
busca el clculo de un ndice de peligro en lo que a estrategias de seguridad se reere para
robots que estn programados para servir al cuidado de seres humanos. El simulador representa las trayectorias de los robots y calcula los posibles impactos de sus movimientos
en el cuerpo humano.
En la Universidad de Clarkson en N.Y. Estados Unidos, un grupo de investigadores
realiz un simulador [30] que despliega en tres dimensiones las distintas conguraciones
robticas y adems es capaz de recuperar las seales que se envan al robot mediante el
puerto serial de comunicaciones, para ser representadas en la pantalla. Este simulador fue
desarrollado para ejecutarse en una plataforma de cmputo IBM/AT/XT o PS/2 y su
caso de estudio se bas en un brazo robtico de cinco ejes llamado Rhino XR-3, pero este
mismo simulador tena la versatilidad de admitir ms modelos de robots. Esta versatilidad la logra a base de archivos descriptivos de las diferentes conguraciones robticas
dependiendo de su geometra.
12
La empresa de software Microsoft en conjunto con la NASA desarrollaron un simulador

de robots inteligentes[4] el cual tiene como objetivo representar un ambiente determinado
y ejecutar trayectorias planicadas de alto nivel. El sistema cuenta adems con un detector de colisiones, donde este tipo de deteccin representa una caracterstica importante
en el desarrollo que se abarca en este trabajo de tesis.
En Canad la Universidad Lakehead desarroll un simulador para robots manipuladores genricos animados en tiempo real [20] el cual es un sistema robtico basado en
una serie de datos de posiciones, velocidades, aceleraciones y fuerzas, que se representan
en un simulador que est controlado a travs de una interfaz grca. En este trabajo los
autores argumentan inicialmente que la implementacin experimental normalmente toma
un mayor tiempo para congurarse y no es fcil de hacerle cambios. Para el diseo y la
implementacin del simulador se respondi a las necesidades de tres premisas bsicas que
fueron el cmo seran los objetos representados, cmo sera su desempeo y cmo seran
detectadas las colisiones entre los diversos objetos.
Para la representacin de los objetos se parte de la generacin de una coleccin ordenada de elementos y uniones. Cada elemento es una entidad rgida construida por subelementos que son colocados en una posicin relativa a alguna otra. Los elementos estn
conectados a otros mediante uniones. Cada sub-elemento se reere a un poliedro convexo
que a su vez es representado por una coleccin de vrtices y caras. Cada sub-elemento
mantiene un punto central que es usado para la deteccin de colisiones, y como vector
normal para cada cara. Los elementos mantienen ligada una lista de los sub-elementos
que los conforman. Un elemento a su vez almacena vectores de fuerza de cada uno de sus
ejes de movimiento y de rotacin que tambin son utilizados para resolver las colisiones.
Las uniones tienen dos vrtices para denir un eje. Si la unin es traslacional sta indicar el movimiento del vector. Si la unin es rotacional sta indicar el eje de rotacin. Se
tienen los valores mximos y mnimos para el posicionamiento de las uniones, la posicin
actual y la razn mxima de cambio para cada posible direccin. Toda la simulacin se
basa en dos arreglos, uno que describe las uniones y otro los elementos, en donde juntos
denen todos los objetos fsicos que pueden ser representados para su interaccin en la
simulacin.
El movimiento de los objetos como en casi todos los simuladores est basado en el
tiempo, donde en intervalos regulares el sistema actualiza la posicin de cada objeto.
Los mtodos para la deteccin de colisiones estn basados principalmente en mtodos
geomtricos.
Para la interfaz de usuario se segmenta una ventana en varias partes donde se encuentran los controles de orientacin de la cmara y su direccin. El usuario podr seleccionar
un modo de despliegue usando un men de seleccin. Para el movimiento se cuenta con
un registro de eventos, ocurridos durante la simulacin, esto permite al usuario repetir la
13
reproduccin de la misma y puede ser utilizado para entrenar otra ms que se desee.
Diversos tipos de argumentos y utilidades se han dado a la propuesta de la creacin de
un simulador grco de robots, pero una de las ms recurridas es la de poder contar con
una herramienta para la enseanza de la robtica. Esto lo propone [25],dado que equipo
de laboratorio es muy costoso y requiere de mantenimiento y personal de apoyo que supervise su operacin. Mediante conceptos claves como: denicin de las cadenas enlazadas,
uniones y espacios cartesianos, transformacin de matrices homogneas, transformacin
de cinemtica directa e inversa y la programacin de robots mediante la denicin de secuencias de movimiento es como se plantea la solucin del diseo de dicha interfaz grca.
Un software diseado con funciones las cuales sean capaces de: interpretar una denicin
del robot mediante sus parmetros cinemticos; el movimiento del robot en cada unin
o espacio cartesiano; un despliegue grco de la posicin del robot acompaado de despliegues numricos de dicha posicin, orientacin y desplazamiento de cada unin; y la
creacin y edicin de programas para el robot y su ejecucin por lotes, incluyendo el
clculo de la duracin del movimiento.
Utilizando el mismo argumento de un laboratorio de robtica [11], en la Escuela de
Ingeniera ESA IGELEC en Francia,se proponen algunas prcticas que se pueden implementar con conguraciones muy recurridas en brazos robticas como son el SCARA, pero
utilizando plataformas de simulacin comerciales.
En la Universidad de Alberta en Canad, se abord el tema de la animacin tridimensional creando para esto un simulador para la representacin virtual de robots manipuladores [21] donde se propone que las trayectorias de los robots son denidas por archivo
de trayectoria pre-calculada o puntos y orientaciones especicadas por el usuario. Este
simulador cuenta con dos mtodos para la generacin de trayectorias. El primer mtodo
simplemente implica el escoger el archivo de trayectoria en tiempo de ejecucin del simulador. Este archivo consiste en una lista de valores secuenciales para cada unin que
el manipulador seguir. El otro mtodo es mediante el clculo de la cinemtica inversa
ingresando el punto al que se quiera llegar y as generar la trayectoria, y en el caso de
mltiples trayectorias ser escogida la ms corta de ellas.
La Universidad de Stanford en California, Estados Unidos [18] desarroll una herramienta ms completa donde se crea un ambiente virtual y varios controladores y celdas
de trabajo son probadas. Este simulador lo dividen en dos partes: la primera es donde
objetos locales calculan sus propias ecuaciones dinmicas de movimiento y en la segunda
un coordinador global resuelve interactivamente las fuerzas entre objetos.
1.3.3. Simuladores de manos

La simulacin de conguraciones robticas en general es un aspecto bastante amplio
en cuanto a herramientas de representacin virtual se reere, y dentro de los casos de
estudio ms complejos se encuentra el de la animacin de conguraciones robticas que
14
tengan semejanza con la de una mano, la cuales han ido desde tenazas, manos con tres,
cuatro y hasta cinco dedos.
En el Instituto de Ciencia y Tecnologa de Nara en Japn se desarroll un sistema el
cual estima los movimientos de una mano y los representa en un entorno virtual [29], mediante un algoritmo que compara las posiciones de la mano a las de un modelo esqueltico,
donde se logra la representacin de los movimientos de una mano humana capturando dichos movimientos por 4 cmaras (gura 1.6), el cual es interpretado y representado en el
entorno virtual del sistema (gura 1.7).
Figura 1.6: Experimento montado para el reconocimiento del movimiento de una mano
Figura 1.7: Interfaz para la representacin de los movimientos capturados de una mano
mediante cmaras digitales
La tarea ms recurrida en la investigacin y el desarrollo de aplicaciones para la simulacin virtual de robots con una morfologa similar a la de una mano es el agarre.
Mediante diversas tcnicas varias universidades hay tratado de resolver este problema, y
los simuladores grcos han tenido un papel importante en el desarrollo de la solucin.
15
El Royal Institute of Technology en Estocolmo, Suecia, en cooperacin con la Universidad de Columbia en Nueva York, Estados Unidos desarrollaron un planicador para
hacer sujeciones en tiempo real. Se integra de un sistema visual de bsqueda [16] en el
cual se busca encontrar la posicin de un objeto a ser sujetado, planicar los movimientos
de sujecin y las trayectorias que deben seguirse y visualizar en un monitor la ejecucin
de la tarea realizada. En este sistema se parte de tener objetos representados en CAD 2 y
as poder hacer el clculo de las trayectorias de los movimientos que se deben hacer para
el sujetado de forma adecuada.
Las instituciones mencionadas en Suecia y Estados Unidos en cooperacin con la Universidad de Karlsruhe en Alemania, disearon un planicador automtico de agarre [22]
basados en caractersticas de forma, en donde utilizando el simulador que disearon aos
atrs y mediante la transformacin de los objetos reales a formas geomtricas tridimensionales bsicas (cilindros, cubos, esferas y prismas) se implemento una recreacin del
entorno. Como se puede observar en la gura 1.8 se obtiene un modelo de una forma
real, modelo del cual se obtiene el patrn a seguir para el agarre adecuado, para algunas
conguraciones de robots manipuladores que se han descrito previamente.
Figura 1.8: Transformacin a guras geomtricas simples de una taza
En la Universidad de Palermo en Italia, se ha desarrollado un sistema control mediante

visin articial para una mano robtica [13] en donde se busca entrenar la mano para que
obtenga un aprendizaje de los movimientos de una mano humana y posteriormente pueda
utilizarse para tareas de complejidad considerable. Basado el sistema en algoritmos novedosos y teniendo como principal fuente de informacin la proporcionada por dos cmaras
estreo es posible calcular el espacio y reproducirlo virtualmente, lo que permitir ms
adelante generar el control correspondiente.
2 Del
trmino en ingls Diseo Asistido por Computadora es la representacin computacional de algn

objeto ya sea en 2 o en 3 dimensiones
16
1.3.4. Libreras para generar grcos

Existen diversos paquetes para manejar grcos, en donde tres de las ms importantes
plataformas son las de DirectX, Java3D y OpenGL. Un anlisis realizado en [19] revela que
la mejor herramienta para desarrollar entornos en 3D en los cuales se puedan manipular
seales externas es OpenGL, por la versatilidad que tiene de ser programado en lenguaje
C++, en donde no depender de un sistema operativo especco y el cdigo ser fcil
de exportar a otras plataformas, adems de ser posible escribir un programa que genere
cdigo para otras aplicaciones y sea capaz a su vez de recibir cdigo de otras aplicaciones
(LabView en este caso) para transformarlo e interpretarlo en el programa actual y generar
los movimientos virtuales respectivos.
OpenGL representa la alternativa ms viable ya que se encuentra documentada de forma suciente, es una herramienta gratuita y esta respaldada por una compaa lder, en
cuanto a generacin de grcos por computadora se reere, como lo es Silicon Graphics,
lo que sustenta una tecnologa madura y conable.
1.3.5. Analizadores lxico-sintcticos

Existe una cantidad importante de analizadores lxico sintcticos, o generadores de
parsers, (donde por citar los ms importantes se presenta las tablas 1.1, 1.2 y 1.3), lo que
tambin es conocido como compilador de compiladores o generador de compiladores.
Estos tienen la funcin de generar cdigo fuente de un parser, intrprete o compilador
para un tipo de lenguaje de programacin.
De entre todas las opciones existentes se eligen ANTLR por el lenguaje en el que se
genera el parser, la plataforma en la cual fue desarrollada, su robustez, estabilidad y la
accesibilidad de ser un cdigo abierto y de licencia gratuita. Existen herramientas comerciales que tienen entornos de programacin mucho ms amigables y se encuentran mejor
documentados, sin embargo por su costo se descartan sin ser siquiera examinados a fondo.
En la tabla 1.4 se enumeran algunos de estos ltimos con algunas de sus caractersticas
ms importantes.
Los Algoritmos para la generacin de los parsers son diversos y entre lo ms importantes destacan el LALR, GLR, LL y el CLR; acrnimos en ingls que hacen referencia de
como analizan las lneas de cdigo. El caso que interesa para este trabajo por la eleccin
hecha es el algoritmo LL que es un parser que evala de arriba hacia abajo, e interpreta de
izquierda a derecha (Left to right) y construye una derivacin cargada hacia la izquierda
(Leftmost derivation) de la secuencia.
En lo referente a lenguajes de salida se necesita un parser escrito en C++ y ANTLR
se proporciona esta opcin con la exibilidad de generar un cdigo genrico para cualquier
compilador de este lenguaje. La plataforma en la que haya sido desarrollada la aplicacin
no resulta tan importante siempre y cuando se cuenten con las herramientas para compilar
17
los parsers, en el caso de ANTLR es java la plataforma en la que se compila, compilador

que se obtiene de forma gratuita y es sumamente estable.
Algunos generadores de parsers cuentan con un ambiente de desarrollo integrado (IDE
por sus siglas en ingls) que facilita la generacin de los mismos, sin embargo en muchas
herramientas libres no se cuenta con este y se tiene que trabajar desde la consola, lo que
no permite una depuracin muy sencilla. No obstante las herramientas que tienen un IDE
estable son muy costosas y para nes prcticos sobrepasan el presupuesto de este trabajo
de tesis.
El software libre fue la opcin ms viable para la eleccin de un generador de parsers,
por lo que la licencia no tuvo un costo econmico, pero si un costo en tiempo de inmersin
al sistema y pruebas de estabilidad.
1.3.6. Herramientas de desarrollo

Lenguaje C++
El lenguaje C++ es una de las ms poderosas herramientas para desarrollar software
en la actualidad, adems de que pueden ser contenidas otras herramientas en formas de
libreras las cuales hacen ms verstil el desarrollo de una aplicacin.
Su amplia documentacin y la cantidad de grupos de desarrollo hacen que el soporte
para el sistema sea ms completo y fcilmente reconocido y documentado.
Borland Builder C++ 5

El compilador de Borland es una plataforma ampliamente utilizada alrededor del mundo y permite la opcin de agregar mdulos para la programacin de distintas instancias
directamente en las ventanas para aplicaciones sobre Windows, en donde es destacable
mencionar el mdulo de OpenGL, el cual es de utilidad fundamental en esta aplicacin.
Mediante este compilador tambin es posible programar un intrprete de forma recursiva indicando parmetros simples para la decodicacin de informacin en lneas de
sintaxis conocidas. Es posible tambin migrar al cdigo generado por un generador de
parsers como lo es el ANTLR; sin embargo, herramientas como el ANTLR requieren de
un profundo anlisis de autmatas, y constituira una mejora importante para futuras
implementaciones del sistema.
OpenGL
Las libreras de OpenGL [10], [7], [26] facilitan el manejo de grcos en un entorno de
programacin de C++, poniendo a un lado los problemas en el manejo de estructuras,
18
Tabla 1.1: Comparacin entre los diferentes generadores de parsers de fuente libre o cdigo
abierto (parte 1 de 3)
Producto
Algoritmo
Lenguajes de Salida
Plataforma
Desarrollo
APG
CLR
C++
Win32
si
ACCENT
GLR
ANSI C
no
ANTLR
LL(k)
C++, C#, Java,

Python
Java
si
Beaver
LALR
Java
Java
no
Bison
LALR,
GLR
C, C++
GNU/Linux,
Unix, Win32
no
BYACC
LALR
Unix, Win32
no
BYACC/J
LALR
C, Java
Irix, Linux, Solaris, Win32
no
Coco/R
LL(k)
C++, C#, Java
Java, .NET, Linux
no
CppCC
LL(k)
C++
Unix
no
CSTools
LALR
C#
.NET
no
CUP
LALR
Java
Java
no
Elkhound
GLR
C++, Ocaml
Unix, Win32
no
Essence
LR
Scheme
Scheme 48
no
LALR
x86 Assembly,
ANSI C, C#,
D, Delphi, Java,
Pascal, Python,
Visual
Basic
6, Visual Basic
.NET,
Visual
C++
GOLD
Win32
de
IDE
si
Licencia
Fuente Libre
Fuente
Abierta
(GPL)
Fuente
Abierta
(BSD)
Fuente
Abierta
(BSD)
Fuente
Abierta(GPL)
Dominio
pblico
Dominio
pblico
Fuente
abierta
(GPL)
Fuente
aRbierta
(GPL)
Fuente
abierta
Fuente
abierta
(GPL)
Fuente
abierta
(BSD)
Fuente
abierta
Fuente
abierta
(zlib/libpng)
19
Producto
Algoritmo
Grammatica LL(k)
Lenguajes de Salida
Plataforma
Desarrollo
de
C#, Java
Java
no
IDE
Happy
LALR,
GLR
Haskell
Unix, Win32
no
jacc
LALR
Java
Java
no
JavaCC
LL(k)
Java
Java
si
jay
LALR
BSD
yacc redirigido a
C# and Java
C or Java
no
JetPAG
LL(k)
C++
C++
no
LEMON
LALR
Unix
no
More Than
Parsing
LL(1)
Java,
JavaCC
(parser
and
scanner)
Java
no
Parser Objects
LL(k)
Java
Java
no
PRECC
LL(k)
Dos, Unix
no
Rats!
Packrat
Java
Java
no
SableCC
LALR
Java (and, with

altgen engine,
C, C++, #,
OCAML
and
Python)
Java y varios
SmaCC
LALR(1)/
LR(1)
Smalltalk
Todas
si
Spirit
LL(k)
C++
no
no
Licencia
Fuente
abierta
(LGPL)
Software
Libre
(GPL)
Fuente
abierta
(BSD)
Fuente
abierta
(BSD)
Fuente
abierta
(BSD)
Fuente
abierta
(GPL)
Dominio
pblico
Fuente
abierta
(GPL)
Fuente
abierta
(ZLib/LibPNG)
?
Fuente
abierta
(LGPL)
Fuente
abierta
(LGPL)
Fuente
abierta
(MIT)
Fuente
abierta
(Boost)
20
Producto
Algoritmo
Lenguajes de Salida
Plataforma
Desarrollo
de
Yacc
(AT&T)
LALR
C (disponible en
otros lenguajes)
Unix
no
YooParse
LR
C++
no
LISA
LR,
LL,
LALR,
SLR
Java
Todas
si
IDE
Licencia
Fuente
abierta
(various)
Fuente
abierta
(MIT)
Dominio
pblico
Tabla 1.4: Comparacin entre los diferentes generadores de parsers comerciales

Producto
DMS
Software
Reengineering
Toolkit
AnaGram
Algoritmo
Lenguajes de Salida
Plataforma
Desarrollo
GLR
Parlanse
LALR
IDE
Licencia
Win32
no
Propietario
ANSI C, C++
C++,
Cualquiera (si es
re-escrito
el
esqueleto)
C, C++, C#,
Java
Win32
si
Propietario
Win32
si
Propietario
Win32, Linux
no
Propietario
LL(k)
C++
Win32
si
Propietario
LR(1)
C#, .NET
si
Propietario
LALR
C++,
C++,
C#, Java
.NET
Framework 2.0
Win32
si
Propietario
LRgen
LALR
SLK
LL(k)
Text
Transformer
Visual
BNF
Visual
Parse++
de
21
mtodos y eventos que se encarguen de operaciones especcas en la generacin de pixeles,

los cuales en su conjunto forman las imgenes y cuya interaccin genera la sensacin de
movimiento.
La eleccin de estas libreras al igual que para la eleccin del lenguaje C++ se basa
en la gran documentacin que existe, as como el carcter de ser una plataforma gratuita, estar escrita y ser totalmente compatible con C++. Tambin existe un mdulo para
agregar elementos en las ventanas de aplicacin para Borland Builder 5, esto completa el
esquema en el que se trabaja en este proyecto.
LabView
National Instruments desarroll una aplicacin en donde por medio de iconos con determinadas propiedades y sus interconexiones se representaran programas para automatizar
o hacer pruebas de distintos tipos. Esta aplicacin [8] originalmente fue desarrollada para
interconectar los equipo que National Instruments desarrollaba, y esta es una de sus limitantes, que si bien puede ser resuelta mediante la interconexin con equipos compatibles
con protocolos de comunicacin especcos, siempre se depende de un trabajo minucioso
para hacer un correcto mapeo3 de las seales involucradas [9].
En un trabajo de tesis anterior [3] fue elegida esta herramienta tanto de software como
de hardware para el prototipo fsico, es por esto que debe emplearse nuevamente para
poder trasferir aquellas seales generadas a los parmetros de las funciones del intrprete
y poder representar aquellos movimientos en la aplicacin desarrollada en C++ con la
ayuda de las libreras de OpenGL.
Robtica
El principal objetivo que busca esta aplicacin es el de la creacin de una herramienta
que represente sistemas robticos articulados, es por esto que no podra en ningn momento dejarse de lado la robtica.
En lo que a la robtica concierne a los sistemas articulados, existe una representacin
de parmetros en los cuales se describe por completo un sistema de este tipo, y esta es
la representacin de Denavit-Hartenberg [5], [14]. Mediante los parmetros de esta representacin no slo se puede describir la forma que el robot tiene, sino que con la variacin
de los parmetros es posible obtener la descripcin del movimiento de dicho robot. Es
por esto que la herramienta matemtica de la representacin de Denavit-Hartenberg es
de utilidad fundamental en el desarrollo de la aplicacin.
3 El
mapeo es una relacin de etiquetas asignadas a distintas direcciones que alojan variables del
sistema, que representan alguna variable fsica sensada, o bien una seal que activa un actuador
22
1.4. Especicacin del sistema

El sistema consiste de bloques independientes los cuales se ven entre s como cajas
negras que entregarn ciertos parmetros a procesar. De esta manera se pueden aislar
ms fcilmente los posibles problemas de programacin.
La conguracin general del sistema (gura 1.9) indica varios mdulos interconectados, son entidades independientes que realizan diversas operaciones las cuales requieren
de determinadas entradas y entregan a su salida los datos con un formato especco que
pueden ser utilizados por otro bloque.
El intrprete, que se puede ubicar en color rojo en la parte central del diagrama,
interconecta todos los bloques del sistema, extrae los parmetros admisibles de las entradas
y los entrega a las salidas correspondientes. Como entradas tiene los siguientes datos:
a. Las funciones a realizar en tiempo real provenientes de la lnea de comando del sistema.
b. Las descripciones de movimiento provenientes directamente de los scripts.
c. Las modicaciones realizadas desde la interfaz grca que sern ingresadas mediante
la lnea de comando.
d. Los eventos del prototipo fsico provenientes de la interfaz LabView/C++ que se reportarn en la animacin del simulador.
Como salidas el intrprete generar la informacin correspondiente para los bloques
del comando en lnea, el simulador grco y la interfaz LabView/C++ y estos datos sern
respectivamente:
e. Los eventos y alarmas del simulador.
f. Los parmetros para las funciones de gracacin mediante las rutinas de OpenGL.
g. Los parmetros para generar una instruccin de movimiento.
El comando en lnea por su parte tiene acceso de entrada y salida y reportar independientemente los sucesos acontecidos en el sistema, los cuales en algunas ocasiones se
reportan en las casillas de estado4 de la interfaz.
La interfaz LabView/C++ se comunicar por su parte directamente con el prototipo
fsico teniendo la siguiente interaccin de entrada y salida respectivamente:
h. Obteniendo las seales de los sensores
. Generando las seales elctricas a los servomotores
4 En
la parte inferior de la interfaz se encuentran separadas un serie de casillas que presentan diversa
informacin del estado del sistema.
Archivo
Descriptivo
(Script)
e. Alarmas
d. Eventos del
prototipo
fsico
c. Modificaciones
de grficos
realizadas desde
la interfaz grfica
Scritpt de
Movimiento
Intrprete
h. Seales
de los
Sensores
i. Seales
elctricas
a los
servomotores
Prototipo
Fsico
(Mano)
Entrada de Hardware
Salida Principal del Sistema
Compilador de Instrucciones
Monitor del Sistema
Seales Decodificadas (Driver)
Archivo de Entrada / Salida
Scritpt de
Simulador
Movimiento
Grfico
Interfaz
C++ / Labview
f. Parmetros para
funciones de OpenGL
g. Parmetros para
generar instruccin
de movimiento
Figura 1.9: Diagrama general del sistema
b. Instrucciones de movimiento
a. Funciones a realizar
en tiempo real
Comando
en Lnea
Configuracin General del Sistema

Versin 2.0
1.4. ESPECIFICACIN DEL SISTEMA

23
24
De manera general es de esta forma (gura 1.9)como queda constituido el sistema

planteado originalmente en el objetivo del trabajo, en donde lo que se encuentra dentro
de la lnea punteada es lo que se desarrollo en esta tesis, y lo que esta fuera fue desarrollado en tesis previas. Ms a detalle a continuacin se presenta de forma especca,
los elementos de cada bloque general para la realizacin de las rutinas, necesarias para el
funcionamiento del sistema.
1.4.1. Intrprete
El intrprete es el bloque central, que se encarga de procesar la informacin para asegurar que cada bloque reciba informacin que pueda ser entendida y ejecute las rutinas
procedentes.
La descripcin esquemtica del intrprete se puede visualizar en la gura 1.10, en
donde se especica de forma puntual cada bloque interno5 , indicando su funcin, su interconexin, y el ujo de informacin que debe trasmitir.
a. Decodicador de seales de LabView

Bloque encargado de recibir las seales generadas por LabView y generar un script
en tiempo real del movimiento generado (nicamente se encontrar en un modo captura
de ejecucin de movimiento generado externamente, donde en versiones futuras podr
implementarse su captura en modo de comprobacin de ejecucin del movimiento) el cual
pasar a una instancia de seleccin, para decidir si es el movimiento indicado por este
script el que debe ser simulado grcamente.
b. Selector de origen del movimiento

Bloque de ejecucin automtica que permite al usuario elegir el ujo de entrada del
script de movimiento encargado de la animacin y de la generacin de seales al prototipo
fsico. Es posible seleccionar en el entorno de la interfaz grca el ujo ms conveniente,
de otra forma por default se considera al script de movimiento proveniente de un archivo
descriptivo. Como salida pasar el script elegido para su compilacin.
c. Compilador de movimientos
Bloque que recibe el script seleccionado o bien la funcin de la lnea de comando y
tiene la funcin de generar los parmetros para generar la animacin.
5 Para
simplicar y hacer referencia ms rpida se expondrn los bloques de arriba hacia abajo y de
izquierda a derecha.
Comando
en lnea
Archivo
descriptivo
(Script)
Comando
en lnea
(LabView - Simulador)
Selector de
origen del
control de
movimiento
Decodificador
de seales
de LabView
Restricciones
y errores de
sintaxis
Generador
de informacin
para los
grficos
Generador
de
alarmas
Parmetros
para generar
los grficos
Alarmas
Parmetros para generar

instruccin de movimiento
Cambio en controles de entorno y archivos
Parmetros para generar

la animacin
Compilador
de
movimientos
Generador
de mensajes
en la interfaz
Script electo
Seales generadas en LabView
Figura 1.10: Diagrama interno del intrprete
Mensajes de modificacin de control de entorno y archivos
Script de movimiento
Script de movimiento en tiempo real
Script de movimiento del

prototipo
Intrprete
Simulador
grfico
Simulador
grfico
Comando
en lnea
Interfaz
C++/LabView

25
26
d. Generador de alarmas
A partir de los datos de la animacin es posible calcular antes de que ocurra si se
producir alguna violacin a una restriccin en el caso de ingresar un script, o bien en
el caso de estarse ejecutando directamente una rutina en el prototipo fsico, mediante
LabView, se generar una alarma instantnea que advertir de este evento. Las alarmas
generadas, son enviadas para su despliegue en el el entorno del mdulo del comando en
lnea y harn referencia especca de las violaciones encontradas.
e. Generador de informacin para grcos

Bloque que rene la informacin necesaria para generar la animacin de forma completa, y para la extraccin de la informacin de los scripts, informacin que recibe de
los bloques compiladores y que entrega directamente como parmetros entendibles por
rutinas de OpenGL.
f. Generador de mensajes de la interfaz

Este bloque se encarga de recibir todos los cambios realizados por los botones del
simulador grco, que se transforman en mensajes reejados en el despliegue grco del
simulador o bien en la lnea de comando.
1.4.2. Simulador grco

La funcin general de este bloque es la la generacin de los grcos mediante funciones
de OpenGL, su esquema se ilustra en la gura 1.11 y consta de los siguientes sub-bloques.
a. Control de ambientacin
Conguracin de parmetros de ambientacin, tales como: iluminacin, opacidad, colores de fondo, donde se denen colores por defecto, estos parmetros podrn ser modicables en tiempo de ejecucin mediante un men especial.
b. Parametrizacin Denavit-Hartenberg
Mediante una breve modicacin en el cdigo fuente, es posible cambiar las formas
a simular de la cadena cinemtica indicando los parmetros de Denavit-Hartenberg en
funciones que adems son capaces de albergar varias cadenas independientes a simular en
el mismo entorno.
27
c. Obtencin de parmetros
Obtencin de todos los parmetros admisibles para la simulacin, (la animacin que
se genera a partir de los parmetros) se ejecutar mediante un botn en la interfaz grca (en el modo de ejecucin de script ). Este bloque entrega el conjunto completo de los
parmetros para las funciones de gracacin.
d. Funciones de gracacin
Bloque que contiene las funciones encargadas de la gracacin, que reciben el conjunto de parmetros y se distribuyen en cada una de las funciones para representar forma y
movimiento. Su salida es directamente el conjunto de grcos a representar.
e. Pantalla
Bloque que representa la salida grca en un dispositivo convencional bajo las directivas que genera OpenGL para el despliegue de grcos.
f. Controles de entorno virtual y de archivos

Bloque en el que se encuentran los controles para manejo de entorno virtual mediante
mens emergentes y botones en el entorno, y manipulacin de archivos, mediante ventanas
de acceso convencionales de fcil acceso.
Intrprete
Obtencin de
parmetros
Conjunto de
parmetros para
las funciones de
graficacin
Grficos
Pantalla
Salida del sistema
Funcin modificable desde cdigo fuente
Funciones de accin directa a la salida
Acceso de datos desde la interfaz
Funcin automtica
Controles de
entorno
virtual y de
archivos
Modificaciones del entorno virtual

con los mens y botones de la interfaz
Funciones
de graficacin
Configuracin de la ambientacin
Control de
ambientacin
Figura 1.11: Diagrama interno del simulador grco
Parmetros de movimiento
Parametrizacin Parmetros de forma

Denavit
Hartenberg
Simulador
Grfico
28
29
1.4.3. Interfaz LabView/C++

En la gura 1.12 se muestra el esquema de la interfaz entre LabView y C++ que tiene
la funcin de hacer el puente entre la aplicacin el C++ y la aplicacin en LabView.
a. Selector de control de ujo

Bloque de ejecucin automtica que elige el ujo de control entre el proveniente de un
entorno directo de LabView, o el regido por el simulador grco, mediante la descripcin
de movimientos por scripts de movimiento. A modo de salida de datos se entrega al driver
esta informacin para su ajuste.
b. Driver
Bloque que recibe las instrucciones relativas para el movimiento del dispositivo fsico,
y ajusta dependiendo de una calibracin previa, cuyo resultado son los parmetros que
contiene este bloque para la adaptacin y generacin de las seales correspondientes para
el movimiento. Su salida hacia el intrprete entrega un mensaje de movimiento (relativo
a la simulacin) realizado. En general es un archivo descriptivo con escalamientos de movimiento correspondientes al dispositivo que se est controlando.
c. Seales de control
Bloque que recibe las seales sensadas, as mismo recibe las instrucciones de movimiento para su realizacin y enva aviso del movimiento detectado. En esta etapa se est
implementando la aplicacin obteniendo la lectura de los puertos en los que escribe LabView.
Intrprete
Mensaje de
movimiento
relitivo
generado y
sendado
Driver
Mensaje de movimiento
absoluto generado y
sensado
Eleccin entre
Interfaz/LabView
Seales sensadas
Seales de
control a los
servomotores
Funciones de accin directa a la salida
Acceso de datos desde la interfaz
Archivo de configuracin de entrada
Seales
de
control
Selector de
flujo de
control
Figura 1.12: Diagrama interno de la interfaz LabView/C++
Parmetros para
la generacin
del movimiento
Interfaz
C++ / Labview
Mano
30
31
1.4.4. Prototipo fsico

El prototipo fsico o prototipo robtico es una parte incluida en el esquema general del
sistema (gura 1.13) sin embargo esta parte corresponde a trabajos de tesis anteriores,
tanto en el diseo mecnico y de electrnica [3], como en la parte de control [24].
a. Acondicionamiento de seal
Hardware que adapta las seales de control generadas por la interfaz mediante LabView, para el adecuado funcionamiento del prototipo fsico, en donde se encuentre una
correspondencia plena a la simulacin grca generada por el simulador.
b. Mano
Dispositivo fsico. Conguracin robtica que reproduce en su funcionalidad a una
mano humana. Prototipo fsico realizado en el CENIDET [3]. Dispositivo de salida que
puede ser reemplazado por cualquier otro que observe una conguracin robtica diferente mediante la representacin de Denavit-Hartenberg y programando un controlador
adecuado a esta conguracin.
1.4.5. Comando en lnea

En la gura 1.14 se encuentra el esquema del mdulo de comando en lnea el cual tiene
a su cargo la interfaz de entrada de parmetros mediante un campo de edicin que recibe
los parmetros de movimiento.
a. Instrucciones del teclado

Instrucciones generadas directamente por el teclado al ingresar un comando vlido que
sea interpretable por el mdulo correspondiente.
b. Lnea de comando
Campo para ingresar los comandos en lnea situado en la interfaz, el cual valida y exhibe en un listado de instrucciones ejecutadas toda aquella actividad observada en dicho
elemento del simulador.
Interfaz
C++/LabView
Seal sensada
Acondicionamiento
de
Seal
Sensores
Seal de control acondicionada
Figura 1.13: Diagrama interno del prototipo fsico (Mano)
Seales para
accionar los
servomotores
Prototipo
Fsico
(Mano)
Salida del Sistema
Hardware
Mano
32
Instruccin
Lnea de
comando
Alarmas (Avisos de error)
Scritpt de
Representacin
de la instruccin
Movimiento
Intrprete
Figura 1.14: Diagrama interno del comando en lnea
Informacin desplegada en la interfaz
Estmulo de entrada
Instrucciones
del teclado
Comando
en Lnea

33
34
1.5. Organizacin de la tesis

La tesis ha sido organizada por mdulos los cuales se reeren a las partes del sistema
que han sido diseadas independientemente en bloques funcionales, los cuales requieren
de diversos tipos de entradas y salidas que son compatibles entre s para el procesamiento
de las distintas rutinas.
En el captulo 2 se describe a fondo el diseo del intrprete, que es la parte central
del sistema y quien traduce toda la informacin ingresada por el usuario. En este captulo se describen las conexiones y el ujo de la informacin hacia los dems bloques
como las entradas alternativas, el mdulo de ejecucin en lnea que para nes prcticos se har referencia a l como comando en lnea, el intercambio de informacin para la
generacin de los grcos y la generacin de las seales para el control del prototipo fsico.
De manera minuciosa en el captulo 3 se describen los aspectos concernientes al simulador grco, en donde se encontrarn los detalles acerca del funcionamiento de la parte
grca del sistema tanto en lo referente a la interfaz (botones, mens, funciones) como
a la generacin de los grcos en un ambiente tridimensional y su manipulacin para la
simulacin.
El captulo 4 se hace referencia a la generacin de las seales fsicas mediante libreras
de LabView, para la generacin del movimiento del prototipo y se describen las instancias
de ingreso de datos externos de conguracin y de estmulos directos para la generacin
de la animacin; adems, de la interconexin entre bloques para la integracin del sistema completo en su estructura funcional, y la descripcin de aspectos del funcionamiento
general del simulador.
En el captulo 5 se presentan las pruebas la validacin del sistema en el caso de estudio que es el de la mano CENIDET, conguracin robtica de 16 grados de libertad en
4 eslabones independientes de 4 grados de libertad cada uno. Se muestra su modelo en
el simulador y se genera una animacin la cual corresponde al movimiento real generado
por el prototipo fsico, para concluir en el captulo 5 donde se exponen los resultados
obtenidos a los objetivos planteados inicialmente en el captulo 1.
Tres apndices al nal hacen referencia a la instalacin de la paquetera necesaria para
el funcionamiento del simulador y la generacin de las seales fsicas mediante LabView,
as como el cdigo fuente de la aplicacin comentado ampliamente.
Captulo
Intrprete
Para dar una versatilidad completa al desarrollo del simulador, es diseado un mdulo
el cual es capaz de transformar lneas de cdigo que tienen un carcter intuitivo, para
operar los distintos niveles de funcionalidad de la herramienta.
Para la herramienta hecha en este trabajo de tesis fue necesario la implementacin de
un intrprete el cual descifre lneas de cdigo que indiquen descripciones de los movimientos de las conguraciones robticas que puedan ejecutar a lo largo de una lnea de tiempo.
Es necesario entonces describir en un script todas aquellas caractersticas particulares
del sistema (que el caso especco de estudio en esta tesis, es el de la mano CENIDET)
a representar, como aquellas que puedan enriquecer el entorno virtual; Todo esto ser
contenido en un script descriptivo general que tiene la capacidad de ser modicado en
tiempo de ejecucin1 .
2.1. Scripts descriptivos

Los scripts descriptivos son una herramienta que sirven para simplicar la programacin de los movimientos que se han de simular, en donde nicamente al especicar los
parmetros deseados se obtiene sta posicin en un tiempo determinado.
Mediante una estructura simple y palabras reservadas especcas se logra una descripcin fcil de recordar para la implementacin de rutinas robticas o para implementar
una interfaz de control a un dispositivo o prototipo fsico.
1 Es
el tiempo en el cual el programa o la aplicacin se est ejecutando y en el cual no es posible

modicar el cdigo fuente.
35
36
CAPTULO 2. INTRPRETE
2.1.1. Descripcin de los parmetros

Los parmetros son aquellas variables que le indican al intrprete qu elementos del
robot van a accionarse y la forma en la que va provocarse dicha accin. Estos estn separados en campos, los cuales hacen referencia dependiendo del orden en el que se encuentren
las partes del robot.
En la gura 2.1 se muestra en qu orden van acomodados los parmetros en una instruccin.
5
3
6
4
1
2
palabra_reservada(dedo,falange,angulo,tiempo,grupo)
Figura 2.1: Representacin general de la sintxis
1.Palabra reservada
Es la palabra que precede a la instruccin e indica la accin a realizar, en el caso de la
aplicacin slo genera el movimiento y la nica palabra reservada que el sistema reconoce
es mov. Esta no es propiamente un parmetro pero es requerida para la ejecucin de
la instruccin. Se asign la palabra para futuras ampliaciones de la aplicacin en donde
podr haber otras instrucciones que formen parte del sistema.
2.Dedo
Parmetro que indica el dedo que ha de accionarse y puede ser accedido mediante su
nombre en minsculas sin acentos en caso de tenerlos o bien mediante un nmero entero
[1..,4] que lo identica y que puede ser ms prctico en algunos casos.
3.Falange
Parmetro que indica la falange que ha de accionarse del dedo seleccionado en el
parmetro anterior. Puede ser accedido mediante su nombre en minsculas sin acentos en
caso de tenerlos o bien mediante un nmero entero [1..,4] que la identica y que puede
ser ms prctico en algunos casos.
4.ngulo
Parmetro que indica el ngulo que ha de alcanzarse por la falange del dedo indicado en los parmetros anteriores y estar descrito en grados [ N ], contemplando que
dependiendo de restricciones denidas puede ser un ngulo invlido al superarse dichas
restricciones.
2.1. SCRIPTS DESCRIPTIVOS
37
5.Tiempo
Parmetro que indica el tiempo en segundos [ E] que demorar la falange del dedo
indicado en alcanzar el ngulo descrito en parmetros anteriores desde su posicin actual,
y se puede utilizar para clculos de velocidad.
6.Grupo
Parmetro que indica el grupo de movimiento en el cual se encuentra la instruccin, lo
que permite ejecutar varios movimientos a la vez, sin embargo slo es posible comenzar el
siguiente grupo de movimiento hasta que termina el actual. Por ejemplo, al poner en tres
instrucciones el grupo de movimiento 1 con diferentes tiempos, el mayor de estos tiempos
habilitar el comienzo de los movimientos que se encuentran en el grupo nmero 2. El
grupo es denido por el usuario, pero ste debe ser consecutivo y comenzar con el nmero
1.
2.1.2. Sintaxis de la instruccin

La sintaxis de los comandos que representan en este caso los movimientos en el simulador es muy parecida a la que se emplea en C y C++ al describir una funcin, en
donde se llama a sta y se le asignan parmetros, slo que en este caso como en lenguaje
ensamblador el nombre de la funcin es una palabra reservada para sta.
Se pueden denir en tres niveles de detalle la sintaxis que se emplea. En la gura
2.2 se observa la descripcin general en donde se tiene una palabra reservada seguida de
parmetros que indican a la funcin su tarea a realizar, stos parmetros se enlistan en
la tabla 2.1 y su combinacin representan todos los elementos del robot.
Palabra Reservada
mov(pulgar,distal,23.12,2.5,1)
Parmetros
Figura 2.2: Representacin general de la sintxis
Existen caracteres especiales que le dan estructura a la sintaxis, los cuales son los
separadores, y los delimitadores estos no tienen ninguna accin en la ejecucin de la instruccin, nicamente indican el principio de un parmetro y el siguiente, as como el
comienzo de la lista de parmetros y el n de una instruccin. Se emplean usualmente
smbolos como parntesis y comas, como se muestra en la gura 2.3
38
Tabla 2.1: Parmetros admisibles en una instruccin para generar movimiento con la
palabra reservada mov
Campo
1
Asignacin
Dedo
Falange
3
4
5
ngulo en
Grados
Tiempo en
Segundos
Grupo
Parmetros
pulgar 1
indice 2
medio 3
anular 4
proximal 1
media 2
distal 3
abduccin 4
Tipo de dato
Texto o entero
Formato
TTT o I
Texto o entero
TTT o I
ngulo
Flotante
SFF.FFF
Nmero
Flotante
FF.FFF
Nmero
Flotante
Delimitadores
Separadores
Figura 2.3: Ubicacin de separadores y delimitadores
En la instruccin que se dise para ser interpretada o compilada, de forma general
se presentara una estructura como la mostrada en la gura 2.4 la misma que se puede
interpretar como una orden de movimiento de 23.12 grados en un tiempo de 2.5 segundos
de la falange distal del dedo pulgar correspondiente al primer grupo de movimiento.
2.1.3. Sintaxis del script

El script se encontrar en un archivo del tipo *.rmc haciendo referencia a Robot Mano
Cenidet el cual puede ser editable directamente desde el bloc de notas de windows, se
encuentra en texto plano sin formato.
La sintaxis en sumamente simple, nicamente se escriben las instrucciones una despus
de la otra separada por un salto de lnea, cuidando que al nal no haya lneas en blanco
2.2. LGICA DE OPERACIN
Movimiento
39
Falange
Tiempo
Dedo
ngulo
Grupo de Movimiento
Figura 2.4: Descripcin de los parmetros de forma individual

ya que el n de archivo delimita el n del script y una lnea en blanco provocara un error.
En el listado 2.1 se muestra un ejemplo de lo que sera un archivo .rmc que describe los
movimientos a ser simulados.
Listado 2.1: Ejemplo de Script que describe los movimientos de la mano
mov( p u l g a r , d i s t a l , 9 0 , 3 , 1 )
mov( medio , d i s t a l , 9 0 , 3 , 1 )
mov( i n d i c e , d i s t a l , 9 0 , 3 , 1 )
mov( a n u l a r , d i s t a l , 9 0 , 3 , 1 )
mov( p u l g a r , media , 9 0 , 3 , 2 )
mov( medio , media , 9 0 , 3 , 2 )
mov( i n d i c e , media , 9 0 , 3 , 2 )
mov( a n u l a r , media , 9 0 , 3 , 2 )
mov( p u l g a r , proximal , 9 0 , 3 , 3 )
mov( medio , proximal , 9 0 , 3 , 3 )
mov( i n d i c e , proximal , 9 0 , 3 , 3 )
mov( a n u l a r , proximal , 9 0 , 3 , 3 )
mov( p u l g a r , abduccion , 2 5 , 1 , 4 )
mov( medio , abduccion , 2 5 , 1 , 4 )
mov( i n d i c e , abduccion , 2 5 , 1 , 4 )
mov( a n u l a r , abduccion , 2 5 , 1 , 4 )
2.2. Lgica de operacin

Para la realizacin del intrprete se emplearon dos algoritmos los cuales respectivamente se encargan del anlisis y la extraccin de los datos de una lnea, lo que ser llamado
como compilador de lnea. El vaciado en un arreglo de datos proveniente de la informacin
concentrada en una serie de lneas las cuales se encuentran en un archivo de texto, lo que
ser llamado compilador de archivos.
Mediante estas dos rutinas el programa es capaz de extraer la informacin que repre-
40
senta el movimiento del robot y de escribir en las rutinas que generan el movimiento en
tiempo de ejecucin, lo que constituye un ahorro de tiempo considerable, al no tener que
programar un cdigo especco para lograr una rutina de movimiento.
Mediante este compilador se dene un cdigo simplicado el cual cumple una tarea
especca y entrega al simulador los parmetros para una representacin grca animada
que puede ser determinante en el estudio de diversos controladores.
2.2.1. Algoritmo del compilador de lnea

Para la compilacin de una lnea se hace un anlisis de los parmetros que intervienen
y se validan. En caso de que alguna de las partes de la sintaxis sea incorrecta, se advertir
con un mensaje de error. Existe tambin la posibilidad de que algn parmetro no sea
correcto (tipo de datos o palabra reservada incorrecta), por lo que se observar de igual
forma esta situacin.
En la gura 2.5 se describe el ujo de la informacin para evaluar y validar una lnea
de cdigo que el intrprete pueda analizar para su extraccin de informacin.
2.2.2. Algoritmo del compilador de archivos

En lo que se reere a la compilacin de un script o un archivo de texto que incluye
varias instrucciones de movimiento se emplea el compilador de lneas de forma recursiva,
y en caso de encontrar un error lo indica y hace referencia al nmero de lnea dentro del
archivo donde fue encontrado dicho error, esto para facilitar la depuracin del listado.
En la gura 2.6 se describe el algoritmo mediante el diagrama de ujo del proceso que
es seguido para hacer el anlisis del archivo y la extraccin de la informacin, extraccin
que es almacenada en un arreglo de un tipo de datos denido exclusivamente para concentrar lo requerido.
2.3. Aplicacin
Dentro del programa existe una parte dedicada al intrprete y sta es la encargada,
sobre todo en el modo de simulacin, de lo concerniente a la interpretacin de los parmetros que se ingresan para ser representados de forma instantnea.
La funcionalidad del intrprete dentro de la aplicacin se divide en 4 partes y estas
son:
1. Lnea de comando
2.3. APLICACIN
41
2. Histrico
3. Barra de mensajes
4. Men de archivo
Inicio
Lee palabra
reservada
hasta (
( ?
NO
Error de
Sintaxis
FIN
Error de
Parmetro
FIN
Error de
Sintaxis
FIN
NO
Error de
Parmetro
FIN
NO
Error de
Sintaxis
FIN
Error de
Parmetro
FIN
SI
Validar
Palabra
NO
SI
Busca
parmetro
hasta ,
NO
, ?
SI
Validar
Parmetro
SI
Busca
parmetro
hasta ,
)?
SI
Validar
Parmetro
NO
SI
Asignacin
de valores a
arreglo de
datos
FIN
Figura 2.5: Diagrama de ujo del algoritmo para compilar una lnea
En las subdivisiones de esta seccin se exponen los aspectos particulares de lo que
compone esta parte de la aplicacin, desde lo general que es la parte visible de la interfaz,
hasta las particularidades que son cmo se compone la clase de C++ que le da funcionalidad a la aplicacin, los parmetros que son generados para la creacin de la animacin
42
Inicio
Compilacin
de lnea i
Error?
NO
Agregar
Informacin
en Arreglo
NO
i++
Fin de
Archivo?
SI
Mensaje de
Error +
nmero de
lnea
Reset de
Arreglo de
Datos
Fin
SI
Fin
Figura 2.6: Diagrama de ujo del algoritmo para compilar un archivo

y los mensajes que se producen al realizar la compilacin.
2.3.1. Interfaz
La interfaz grca de forma genrica es la aplicacin completa, y dentro de esta se
encuentra una gran parte de la funcionalidad del desarrollo. En la gura 2.7 se observa la
ventana de la aplicacin y se indican las 4 partes que componen el marco de las entradas
y salidas del intrprete.
El entorno presentado representa la ventana inicial del sistema y donde por defecto se
encuentra listo para ejecutar movimientos en modo de simulacin.
Lnea de comando
La lnea de comando es una caja de texto la cual recibe instrucciones individuales
que deben de respetar la sintaxis descrita con anterioridad. Despus de haber agregado el
comando, ste es analizado y ejecutado al ingresarlo presionando la tecla enter.
Histrico
En esta parte de la interfaz se van registrando todos los comandos ingresados, tanto
los provenientes de la lnea de comando como de un archivo.
2.3. APLICACIN
43
Men Archivo
Histrico
de Funciones
y Mensajes
Lnea de Comando
Barra de mensajes
Figura 2.7: Partes de la interfaz grca concernientes al intrprete

Mensajes de error y de ejecucin y compilacin exitosa quedarn registrados en esta
parte. No es posible escribir directamente en este espacio.
Barra de mensajes
Esta herramienta es compartida con las funciones de despliegue grco. En esta herramienta aparecern los mensajes de estado concernientes a los archivos descriptivos,
stos mensajes consisten en indicar la ubicacin del archivo abierto para su compilacin
y ejecucin, tambin indica cuntos errores sucedieron.
Men archivo
Este men cuenta con dos opciones que son las de Abrir Script y Cerrar. La funcin
de abrir script abre un cuadro de dialogo donde permite buscar un archivo descriptivo con
la extensin *.rmc la cual ha sido enmascarada para facilitar el encontrar los archivos de
este tipo.
Al abrir un archivo, ste es compilado y en caso de no encontrar errores, las instrucciones son almacenadas en un arreglo de datos, y el programa slo esperar mediante la
opcin animacin, del men ejecutar la secuencia.
2.3.2. Parmetros generados

Al resultar la compilacin exitosa el programa regresa un arreglo con un tipo de datos
denido con la informacin de hasta 100 instrucciones, las cuales pueden ser ejecutadas
44
al as indicarlo por el men animacin.

En el caso de ingresar mediante la lnea de comando una instruccin el arreglo slo
contiene un elemento. Si un archivo fue compilado e inmediatamente despus es ingresado
mediante la lnea de comando, lo compilado con anterioridad se habr borrado.
En el caso de que la ejecucin del programa sea interrumpida puede ser reanudada
desde el ltimo punto en que se qued mediante la opcin de ejecutar, por lo que no es
necesario volver a cargar la aplicacin.
2.3.3. Mensajes generados

Los mensajes generados por el intrprete pueden desplegarse tanto en el histrico como en la barra de mensajes. En la tabla 2.2 y 2.3 se muestran los posibles mensajes que
pueden aparecer, el lugar donde se muestran y la causa.
2.4. Clase intrprete

Para la generacin del intrprete se deni una clase a la cual se llam InterpreteClase.
En esta clase estn denidos los tipos de datos necesarios para la realizacin de la extraccin de los datos, las constantes numricas que se requieren para dar ciertas caractersticas
y consistencia a la estructura del programa y las funciones para el anlisis de las lneas,
las cuales se invocan mediante una instancia de clase en el programa principal.
2.4.1. Tipos de datos

Para el intrprete slo se deni un tipo de datos, el cual sirve para concentrar todos los
datos que se extraen de una lnea del script descriptivo, ste se nombr como DatosLinea.
DatosLinea
Este tipo de datos contiene 6 elementos cuyos tipos son variables enteras y de punto
otante los cuales estn descritos en la tabla 2.4 y donde se describe lo que representa el
dato que se ingresa.
2.4.2. Constantes
Para evitar la utilizacin de nmeros mgicos se denen constantes las cuales se
utilizan a lo largo del programa de forma recurrente.
2.4. CLASE INTRPRETE
45
Tabla 2.2: Mensajes generados por el intrprete (parte 1 de 2)

Modo Campo
S
Histrico
Histrico
Mensaje
El archivo aaa.bbb no
pudo ser abierto
El archivo aaa.bbb ha
sido abierto
Error:Comando o sintaxis invlida en lnea
##
Histrico
Histrico
Error:Nombre de dedo
invlido en lnea ##
Histrico
Error:Nombre de falange invlido en lnea

##
Histrico
Error:Valor de ngulo
invlido en lnea ##
Histrico
Error:Valor de tiempo
invlido en lnea ##
Histrico
Error:Valor de grupo
invlido en lnea ##
Histrico
Error:No es posible alcanzar ese ngulo en

lnea ##
Barra de msgs
Errores
##
Histrico
Compilacin Exitosa
Histrico
Advertencia: Modo de
interpretacin activado, no es posible cargar Script
encontrados:
Causa
Archivo corrupto o actualmente abierto
Correcta apertura de archivo
Error en palabra reservada o error al no
encontrar alguno de los delimitadores al
compilar archivo
El parmetro utilizado en el campo para dedo no corresponde a ninguno de
ellos al compilar archivo
El parmetro utilizado en el campo para falange no corresponde a ninguna de
ellas al compilar archivo
El valor utilizado para el parmetro ngulo no tiene el formato de un nmero
de punto otante al compilar archivo
El valor numrico utilizado para el parmetro tiempo no tiene el formato de
un nmero punto otante al compilar
archivo
El valor numrico utilizado para el grupo de movimiento no tiene el formato
de un nmero entero al compilar archivo
El valor propuesto para ese dedo y falange en particular sobrepasan los lmites de movimiento al compilar archivo
En caso de que en la compilacin existan errores se indica el nmero de estos
al compilar archivo
La compilacin del archivo se realiz de
forma satisfactoria y los valores de la
secuencia estn almacenados en el arreglo
Se intent cargar un script con el modo
de interpretacin presente por lo que no
se almacenar dato alguno
46
Tabla 2.3: Mensajes generados por el intrprete (parte 2 de 2)

Modo Campo
Mensaje
Error:Comando o sintaxis invlida
Histrico
Histrico
Error:Nombre de dedo
invlido
Histrico
Error:Nombre de falange invlido
Histrico
Error:Valor de ngulo
invlido
Histrico
Error:Valor de tiempo
invlido
Histrico
Error:Valor de grupo
invlido
Histrico
Error:No es posible alcanzar ese ngulo

Advertencia: Modo de
interpretacin activado, no es posible ejecutar instruccin
No hay dispositivo conectado
Histrico
Barra de msgs
Barra de msgs
Dispositivo en Lnea
Histrico
Error:No es posible alcanzar ese ngulo
Histrico
Posicin Asignada
Causa
Error en palabra reservada o error al no
encontrar alguno de los delimitadores
El parmetro utilizado en el campo para dedo no corresponde a ninguno de
ellos
El parmetro utilizado en el campo para falange no corresponde a ninguna de
ellas
El valor utilizado para el parmetro ngulo no tiene el formato de un nmero
de punto otante
El valor numrico utilizado para el parmetro tiempo no tiene el formato de
un nmero punto otante
El valor numrico utilizado para el grupo de movimiento no tiene el formato
de un nmero entero
El valor propuesto para ese dedo y falange en particular sobre pasan los lmites de movimiento
Se intento ejecutar un movimiento al
estar el modo de interpretacin activado por lo que este no ser cargado
Archivo de puente no inicializado o no
existente
Archivo de puente inicializado correctamente
El ngulo asignado no puede ser alcanzado por el prototipo fsico
La posicin deseada fue asignada y se
ejecutar por el prototipo fsico.
47
Tabla 2.4: Elementos del tipo de dato DatosLinea

Dato
Tipo
palabra
int
dedo
falange
angulo
tiempo
int
int
oat
oat
grupo
int
Descripcin
Recibe el identicador de la palabra reservada
Recibe el identicador del dedo
Recibe el identicador de la falange
Recibe el valor en grados del ngulo
Recibe el valor en segundos del tiempo
Recibe el identicador del grupo de movimiento
Las constantes se han dividido en grupos representativos como lo son aquellas que
describen: dedos, falanges, lmites y varios.
Dedos
Las constantes que representan los dedos permiten la denicin del sistema segn las
conveniencias en cuanto a la estructura y el orden en el que se representan dentro de la
animacin, de modo que no es necesario respetar un orden consecutivo segn la morfologa
del robot, y en caso de que la denicin no corresponda inicialmente, es posible ajustar
las constantes para que la correspondencia sea exacta.
Aunque el dedo meique no es representado tanto en el prototipo fsico como en la
conguracin grca del mismo, es posible aadirse en el futuro. De forma simblica se
agrega para tener el esquema completo de lo que sera una mano humana. En la tabla 2.5
se muestran los dedos denidos y las constantes asignadas para la correcta distribucin
de los dedos asignados.
Tabla 2.5: Constantes que denen los dedos

Dedo
Pulgar
ndice
Medio
Anular
Meique
Nombre de la Constante
pulgar
indice
medio
anular
menique
Constante
4
3
2
1
5
48
Falanges
De mismo modo que en los dedos las falanges cuentan con una constante que las dene
y stas estn descritas en la tabla 2.6.
Aunque en s no es una falange, el movimiento de abduccin se incluye como tal, por
su naturaleza de movimiento.
Tabla 2.6: Constantes que denen las falanges
Falange
Proximal
Medial
Distal
Abduccin
proximal
media
distal
abduccion
Constante
1
3
4
2
El orden consecutivo de las falanges no slo depende de su representacin de DenavitHartenberg, sino de la forma en que el generador de los objetos representa dichas falanges.
Lmites
Para asegurar la integridad del prototipo fsico, y poner una limitante de movimiento
previamente denida y no congurable en tiempo de ejecucin se denieron los ngulos
mximos y mnimos que las falanges en general pueden tener. Son tiles en el diagnstico
y la generacin de mensajes de error. Fueron agrupados por falanges debido a que todos
los dedos tienen la misma conguracin de movimiento.
Las constantes pueden ser modicadas segn la naturaleza del prototipo fsico o bien
si se quiere observar el comportamiento sin restricciones que el prototipo podra tener.
Las constantes se muestran en la tabla 2.7.
Varios
Las constantes que no se encuentran en ningn grupo genrico se enuncian en esta
parte, en donde slo restan dos por mencionar.
Es necesaria una constante que indique que un error fue cometido como salida a una
una funcin. Esta constante se deni con el nombre de: error y su constante asignada
es el valor numrico menos uno (-1).
Se detectaron errores persistentes al denir de forma dinmica el tamao del arreglo
del tipo de datos denido como DatosLinea por lo que se opt por asignar una constante
al nmero mximo de datos que un script puede adquirir, esto mediante la palabra: nDatos
49
Tabla 2.7: Constantes que denen los lmites de movimiento

Lmite
Mximo
Mximo
Mximo
Mximo
Mnimo
Mnimo
Mnimo
Mnimo
Falange
Proximal
Medial
Distal
Abduccin
Proximal
Medial
Distal
Abduccin
MaxProximal
MaxMedia
MaxDistal
MaxAbduccion
MinProximal
MinMedia
MinDistal
MinAbduccion
Constante
90
90
90
25
0
0
0
-25
la cual tiene un valor asignado de cien (100), siendo ste el mximo nmero de lneas que
puede tener un archivo descriptivo. En caso de ingresar un script con ms datos es posible
modicar esta constante en tiempo de diseo para ampliar las posibilidades del intrprete.
2.4.3. Funciones
En la clase intrprete son necesarias funciones pblicas que ejecuten tareas repetitivas
especcas, y algunas que auxilien a funciones de mayor complejidad, a calcular o encontrar informacin relevante para la ejecucin de las mismas.
Para uso interno en la clase se declara una variable privada de tipo DatosLinea.
En la tabla 2.8 se describen de forma genrica las funciones que denen la clase
Interprete en donde se indica el tipo de datos de entrada y de salida, y la descripcin de funcin en forma sintetizada. Posteriormente se denir a detalle cada una.
Interprete
La funcin Interprete en s solo sirve para inicializar la variable privada salida al
declarar la instancia de clase aprovechando las caractersticas de polimorsmo del C++.
Por lo tanto al denir una instancia de clase del tipo intrprete se inicializan los elementos
de la misma. No recibe ni entrega ningn parmetro.
mov
Esta funcin es la ms relevante en el intrprete ya que recibe la cadena para ser
analizada.
Recibe una cadena de caracteres y entrega un tipo de datos DatosLinea con la informacin que extrajo de la lnea de cdigo. Esta funcin sirve especcamente para analizar
50
Tabla 2.8: Descripcin general de las funciones que integran la clase Interprete.
Nombre de
la funcin
Interprete
mov
Entradas
Salida
Descripcin
Ninguna
Cadena de caracteres con la
instruccin
Ninguna
Instancia de Inicializazcn
Datos de la instruccin
Funcin para la extraccin de informacin de movimiento
maxgM
Arreglo de enteros
Mximo de GM
iniDatos
Arreglo de Dedos,
Arreglo
de
Falanges,
Arreglo ngulos, Arreglo de
Tiempos, Arreglo de Grupos
de Movimiento
Regresa el nmero mximo de grupo de

movimiento de un arreglo de datos tipo
DatosLinea
Ninguno
Inicializa el arreglo de datos de movimiento
pos
Cadena de Caracteres
Posicin Final
puente
Elemento,
gulo
Lnea de Datos
n-
Funcin del Driver que asigna los valores de las posiciones nales en cada
intervalo de actualizacin
Genera la lnea de datos a partir del
elemento y el ngulo ledo del archivo puente generado por el programa de
control en LabView
51
la lnea de cdigo que se describi al inicio de este captulo.

Cuando un error de sintaxis o de tipo de datos ocurre est funcin es la encargada de
indicar mediante un nmero el tipo de error que est sucediendo para que el programa
principal pueda emitir el mensaje de error.
maxgM
Esta funcin mediante comparaciones sucesivas busca el nmero mximo de grupo de
movimiento, al recibir un arreglo de nmeros enteros provenientes normalmente del arreglo general donde se almacenan los datos extrados de las lneas descriptivas de los scripts.
Regresa un nmero entero correspondiente al nmero mximo del grupo de movimiento.
iniDatos
Mediante un ciclo se inicializan todos los parmetros del arreglo de datos que contienen la informacin de las instrucciones de movimiento con la funcin iniDatos, indicando
en la funcin principal la instancia de clase utilizada como parmetro de entrada.
pos
Esta funcin simplemente toma una cadena de nmeros y regresa su valor en punto
otante.
puente
Para la generacin de un archivo puente o driver completo en donde estn actualizadas
todas las variables que componen la mano, la funcin puente escribe en una variable de
tipo DatosLinea la informacin correspondiente a cada elemento, ingresando como dato
de entrada el nmero de elemento correspondiente, segn el orden que lleva el archivo
puente, el cual se muestra en la tabla 2.9.
En el programa principal se lleva a cabo la funcin de la escritura del archivo puente
y se emplea esta funcin para generarlo.
52
Tabla 2.9: Orden de los elementos en el archivo de puente o driver

No. de Elemento
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Dedo
Pulgar
Pulgar
Pulgar
Pulgar
ndice
ndice
ndice
ndice
Medio
Medio
Medio
Medio
Anular
Anular
Anular
Anular
Falange
Proximal
Medial
Distal
Abduccin
Proximal
Medial
Distal
Abduccin
Proximal
Medial
Distal
Abduccin
Proximal
Medial
Distal
Abduccin
Captulo
Simulador Grco
La funcionalidad de la aplicacin se ve representada por la capacidad que tiene de
desplegar grcamente los eventos que en la realidad ocurren o podran ocurrir (simulacin), es en esta seccin donde el simulador grco cobra importancia en el conjunto de
mdulos que integran el proyecto. Por s mismo el simulador grco constituye la parte
que da nombre al trabajo, es aqu donde se simula el movimiento de la mano mediante herramientas para el despliegue de grcos, con libreras de OpenGL1 las cuales son
ampliamente descritas por diversos autores [7], [26], [6].
La parte del simulador grco es siempre visible en la aplicacin y la animacin que
represente depender del modo en el que est activado.
En este captulo se abordan los temas concernientes a las herramientas empleadas para
la generacin de los objetos y las animaciones de stos; as como de aquellas herramientas
que agregan un toque de realismo al entorno visual, como lo es la iluminacin y la eleccin
de los colores para el fondo y el piso. Por ltimo se habla de la navegacin en el entorno
virtual, permitiendo al usuario visualizar la animacin desde cualquier punto de vista.
En la segunda seccin del captulo se explica brevemente cmo es que mediante los
parmetros de Denavit-Hartenberg es posible representar cualquier conguracin robtica
y cmo en el programa se logra dicha representacin, de modo que abre la aplicacin para
representar cualquier conguracin robtica de tipo angular.
Por ltimo en la tercera seccin se exponen las funciones creadas describiendo su funcionalidad y el papel que desempean para la generacin de los grcos.
1 OpenGL
es una serie de libreras desarrolladas por la compaa SUN Microsystems las cuales se basan
en la generacin de formas por medio de vectores
53
54
CAPTULO 3. SIMULADOR GRFICO
3.1. Herramientas generales

Bsicamente en lo que se reere a la generacin de los grcos se implement el
desarrollo de 3 herramientas fundamentales para el funcionamiento del simulador grco
[6].
1. Herramientas grcas de generacin de objetos
2. Herramientas grcas de control de ambientacin
3. Herramientas grcas de navegacin por el entorno virtual
Con la integracin de stas herramientas es posible desplegar una animacin que represente las cadenas cinemticas correspondientes al prototipo fsico.
3.1.1. Generacin de objetos

De manera adicional y para enriquecer visualmente el entorno (adems que internamente en el programa ciertas funciones denen las formas y se reutilizan estas funciones
para generar las cadenas de Denavit-Hartenberg) es posible denir objetos geomtricos
regulares de diversos tipos los cuales se enumeran en la tabla 3.1 y estos son denidos
por sus caractersticas principales y sus coordenadas espaciales, en donde la sintaxis se
observa en el listado 3.1 2 .
Listado 3.1: Comando de objeto
Objeto ( id , f i g u r a , x , y , z , $r_{x}$ , $r_{y}$ , $r_{ z }$ , p a r m e t r o s ) ;
A continuacin se enuncia cada una de las guras que es posible describir desde la
conguracin de los grcos para el enriquecimiento del entorno Esto se hace mediante la
descripcin de sus parmetros que lo caracterizan as como sus coordenadas espaciales.
Coordenadas Espaciales
Las coordenadas espaciales estn compuestas de su origen espacial (x,y,z) y su rotacin
espacial en ese punto denido de origen (rx,ry,rz) en radianes.
Esfera
El parmetro que describe una esfera es nicamente su radio, por lo que la combinacin
de ste y sus coordenadas espaciales en la descripcin de la funcin da como resultado
una esfera.
2 El
identicador de objeto siempre debe ser cero para todos los objetos para poder ser representados
a la vez.
3.1. HERRAMIENTAS GENERALES
55
Tabla 3.1: Tipos de forma, modicadores y parmetros admitidos para la representacin

de objetos libres.
Nmero
Reservado
1
2
3
4
5
Tipo de Figura
Parmetros
Esfera
Cilindro
Caja
Cono
Pirmide
Radio
Radio, alto
Arista, alto
Radio, alto
Arista, alto
Radio interior, radio
exterior
Radio interior, radio
exterior, ngulo inicial, porcin del disco
en ngulo
Disco
Semidisco
Cilindro
Para la descripcin de un cilindro es necesario asignarle el radio de su base y la altura
que este ha de tener; precedido de sus coordenadas espaciales. Es importante considerar
que el cilindro no cuenta con tapas tanto en su base como la parte superior, y de as
desearse deber complementarse la funcin en trabajos posteriores.
Caja
Una caja en esencia se logra al describir un cilindro con cuatro lados utilizando las
funciones de quadrics de OpenGL, y en la funcin resumida es necesario slo describir el
tamao del lado y la altura de la caja; adems precedido de sus coordenadas espaciales.
Al igual que el cilindro la caja no cuenta con tapas y se observan las mismas consideraciones de ampliacin en futuras versiones.
Cono
Para la representacin de un cono al igual que el cilindro es necesario asignarle el
radio de su base y la altura que este ha de tener; precedido sus coordenadas espaciales,
recordando la particularidad de las tapas.
56
Pirmide
La pirmide es la analoga directa de lo que una caja es al cilindro, slo que en este
nicamente se cuenta con tres lados, as bien debe asignarse el lado y la altura, adems
de sus coordenadas espaciales
Disco
Una gura un tanto ms compleja es el disco, el cual es ms bien parecido a una
donael cual requiere de dos parmetros, su radio interior y exterior ms sus coordenadas
espaciales
Semi-Disco
La gura que ms parmetros requiere es el semi-disco ya que a diferencia del disco
este es representado por una seccin del mismo, por lo que es necesario describir el radio
interior, exterior, el ngulo inicial en grados en el cual el disco inicia y por ltimo la
porcin de disco en grados, precedido de sus coordenadas espaciales.
Ejemplo
En el listado 3.2 se describe el cdigo para respresentar cada una de las guras disponibles, y en la gura 3.1 se despliega lo que en la interfaz se representara. La caja en
este caso es la palma de la mano.
Listado 3.2: Cdigo de representacin de guras
fig
fig
fig
fig
fig
fig
. Objeto ( 0 , Caja , 5 , 2 0 , 3 0 , 4 5 , 0 , 0 , 4 0 , 1 0 ) ;
. Objeto ( 0 , C i l i n d r o , 5 0 , 1 0 0 , 5 0 , 0 , 0 , 0 , 1 0 , 3 0 ) ;
. Objeto ( 0 , Cono , 5 0 , 5 0 , 5 0 , 0 , 0 , 0 , 1 0 , 1 0 ) ;
. Objeto ( 0 , E s f e r a , 5 0 , 0 , 5 0 , 0 , 0 , 0 , 1 0 ) ;
. Objeto ( 0 , Disco , 5 0 , 5 0 , 5 0 , 0 , 0 , 0 , 1 0 , 1 5 ) ;
. Objeto ( 0 , S e m i d i s c o , 5 0 , 1 0 0 , 5 0 , 0 , 0 , 0 , 1 0 , 1 5 , 1 , 2 7 0 ) ;
3.1.2. Ambientacin
Como una herramienta adicional se incluy la posibilidad de asignar color a dos parmetros que ofrecen contraste para visualizar de forma ms adecuada la ejecucin de la
aplicacin. Estos parmetros son: La iluminacin y el color de fondo.
Mediante una paleta de colores es posible asignar el color que el usuario desee en
tiempo de ejecucin.
57
Figura 3.1: Representacin grca del cdigo representado en el listado 3.2 en el entorno
de la mano
Iluminacin
El color asignado a la iluminacin cubrir a todos los objetos del entorno de forma
proporcional a la naturaleza del objeto iluminado. En la gura 3.2 se muestra cmo se
representa el espacio iluminado de color rojo.
Color del fondo

El color asignado al fondo ser aplicado uniformemente a todo el espacio representado
cuya proyeccin est en el innito. En la gura 3.3 se muestra cmo se representa un
fondo de color azul.
3.1.3. Navegacin por el entorno virtual

En el ambiente grco tridimensional existe la posibilidad de cambiar el punto de
vista del observador, creando as una sensacin de movilidad dentro del entorno virtual.
Mediante un men emergente en la aplicacin es posible activar las diferentes acciones de
navegacin, as mismo con el men Ver.
58
Figura 3.2: Entorno grco con iluminacin en color rojo
Traslacin
La traslacin modica las coordenadas desde las cuales se ubica el observador y dependiendo de esto mediante el arrastre del ratn se conseguirn nuevas coordenadas. En
la gura 3.4 se muestra el entorno virtual con un desplazamiento del observador.
Rotacin
La rotacin modica el ngulo en el cual se ubica el observador, y de la misma forma
que la traslacin, mediante el arrastre del ratn se consigue modicar el mismo; la gura
3.5 ilustra cmo se representa el objeto rotado. Es importante mencionar que al rotarse el
observador y querer ver desde la parte inferior, lo que se consigue es ver la parte inferior
del plano que enmarca a la mano.
Zoom
La funcin de acercamiento y alejamiento o como comnmente se nombran a estos dos
cambios de orientacin del observador zoom hace posible observar desde un punto ms
lejano o cercano el objeto que se est representando, en este caso la mano, en la gura 3.6
se puede observar como se representa el acercamiento a la mano en el entorno virtual.
59
Figura 3.3: Entorno grco con color de fondo azul
Vistas
Varias vistas predenidas son incluidas para facilitar la representacin de las mismas en
caso de que se tenga una necesidad particular, las vistas ms frecuentemente utilizadas por
la informacin que se obtiene y por ser las ms recurridas en el dibujo son las siguientes:
1. Vista frontal
2. Vista posterior
3. Vista lateral derecha
4. Vista lateral izquierda
5. Vista superior
6. Vista inferior
7. Vista isomtrica
8. Vista dimtrica
9. Vista trimtica
60
Figura 3.4: Observador trasladado
3.2. Parmetros Denavit-Hartenberg

En el caso particular de conguraciones robticas articuladas, en donde adems las
articulaciones en principio slo obedecen a ser del tipo angular, se debe entender por
forma todo aquel eslabn que integra la cadena de la articulacin. Es posible representar
todas estas formas por medio de la representacin de Denavit-Hartenberg.
El comando que se requiere para la representacin de las formas est relacionado a la
representacin de Denavit-Hartenberg 3 y la sintaxis de este comando ser como se indica
en el listado 3.3 considerando que al principio de cada cadena es necesario denir su origen.
Listado 3.3: Comando para la representacin de Denavit-Hartenberg
DHo(#cadena , Xo , Yo , Zo ) ;
DH(#cadena ,# e s l a b n , a , a l f a , d , t e t a )
3.2.1. Morfologa del robot

Para denir la forma del robot mediante los parmetros de Denavit-Hartenberg con
las funciones que se crearon para representar el modelo en el simulador, es posible slo en
3 Tambin
existen algunos parmetros ms referentes a la geometra del eslabn, sin embargo y para
acotar el trabajo los eslabones estarn siempre denidos por cilindros los cuales en sus extremos tendrn
una esfera para dar continuidad visual.
3.2. PARMETROS DENAVIT-HARTENBERG
Figura 3.5: Observador rotado
Figura 3.6: Acercamiento del observador
61
62
tiempo de diseo, haciendo jo el modelo a representarse en tiempo de ejecucin.

Mediante la denicin de las cadenas cinemtica de cada dedo fue posible la representacin de la mano en su conjunto. En el listado 3.4 se muestra el cdigo resultante
de la conguracin de la mano con las funciones diseadas para recibir los parmetros
de Denavit-Hartenberg considerando que se deni la instancia de clase con el nombre
fig. y al nal se dene una caja donde que representar la palma. En la parte donde son
congurados los grcos es posible denir las tapaderas de la caja que conforma la palma
y se describe el listado 3.5 (no es el orden real en la aplicacin) con funciones quadrics
que denen objetos en el espacio tridimensional de OpenGL directamente.
Listado 3.4: Conguracin de la mano
//Mano
// Anular
fig
fig
fig
fig
fig
fig
. DHo( 1 , 0 , 0 , 0 ) ;
.DH( 1 , 0 , 0
.DH( 1 , 1 , 0
.DH( 1 , 2 , 30
.DH( 1 , 3 , 22
.DH( 1 , 4 , 22
,
,
,
,
,
90
90
90
0
0
,
,
,
,
,
0
0
0
0
0
,
,
,
,
,
90);
0);
0);
0);
0);
. DHo( 2 , 0 , 2 0 , 0 ) ;
.DH( 2 , 0 , 0
,
.DH( 2 , 1 , 0
,
.DH( 2 , 2 , 30 ,
.DH( 2 , 3 , 22 ,
.DH( 2 , 4 , 22 ,
90
90
90
0
0
,
,
,
,
,
0
0
0
0
0
,
,
,
,
,
90);
0);
0);
0);
0);
90
90
90
0
0
,
,
,
,
,
0
0
0
0
0
,
,
,
,
,
90);
0);
0);
0);
0);
// Medio
fig
fig
fig
fig
fig
fig
// I n d i c e
fig
fig
fig
fig
fig
fig
. DHo( 3 , 0 , 4 0 , 0 ) ;
.DH( 3 , 0 , 0
,
.DH( 3 , 1 , 0
,
.DH( 3 , 2 , 30 ,
.DH( 3 , 3 , 22 ,
.DH( 3 , 4 , 22 ,
// Pu lg ar
f i g . DHo( 4 , 0 , 4 0 , 4 0 ) ;
3.2. PARMETROS DENAVIT-HARTENBERG

fig
fig
fig
fig
fig
.DH( 4 , 0 ,
.DH( 4 , 1 ,
.DH( 4 , 2 ,
.DH( 4 , 3 ,
.DH( 4 , 4 ,
0
0
30
22
22
,
,
,
,
,
0
90
90
0
0
,
,
,
,
,
0
0
0
0
0
,
,
,
,
,
63
90);
0);
0);
0);
0);
// Palma
f i g . Objeto ( 0 , Caja , 5 , 2 0 , 3 0 , 4 5 , 0 , 0 , 4 0 , 1 0 ) ;
Listado 3.5: Cdigo que dene las tapas de la palma
/ Tapas de l a Palma /
g l B e g i n (GL_QUADS) ;
g l V e r t e x 3 i ( 8 , 2 ,5);
glVertex3i (48 , 2 ,5);
glVertex3i (48 , 58 ,5);
g l V e r t e x 3 i ( 8 , 58 ,5);
glEnd ( ) ;
g l V e r t e x 3 i ( 8 , 2 , 5);
g l V e r t e x 3 i (48 , 2 , 5);
g l V e r t e x 3 i (48 , 58 , 5);
g l V e r t e x 3 i ( 8 , 58 , 5);
glEnd ( ) ;
}
Cualquier conguracin es posible mediante la representacin con los parmetros de
Denavit-Hartenverg, en la gura 3.7 se muestra una mano sin pulgar; con diferentes longitudes en los dedos se ejemplican las posibilidades del simulador grco, en el listado
3.6 se muestra la conguracin de la mano mostrada anteriormente.
Listado 3.6: Conguracin de la mano sin pulgar
// Meique
fig
fig
fig
fig
fig
fig
. DHo( 1 , 0 , 0 , 0 ) ;
.DH( 1 , 0 , 0
.DH( 1 , 1 , 0
.DH( 1 , 2 , 30
.DH( 1 , 3 , 30
.DH( 1 , 4 , 30
,
,
,
,
,
90
90
90
0
0
,
,
,
,
,
0
0
0
0
0
,
,
,
,
,
90);
0);
0);
0);
0);
64
Figura 3.7: Mano de sin pulgar como conguracin alternativa
// Anular
fig
fig
fig
fig
fig
fig
. DHo( 2 , 0 , 1 3 , 0 ) ;
.DH( 2 , 0 , 0
,
.DH( 2 , 1 , 0
,
.DH( 2 , 2 , 30 ,
.DH( 2 , 3 , 22 ,
.DH( 2 , 4 , 22 ,
90
90
90
0
0
,
,
,
,
,
0
0
0
0
0
,
,
,
,
,
90);
0);
0);
0);
0);
90
90
90
0
0
,
,
,
,
,
0
0
0
0
0
,
,
,
,
,
90);
0);
0);
0);
0);
90
90
90
0
0
,
,
,
,
,
0
0
0
0
0
,
,
,
,
,
90);
0);
0);
0);
0);
// Medio
fig
fig
fig
fig
fig
fig
. DHo( 3 , 0 , 2 7 , 0 ) ;
.DH( 3 , 0 , 0
,
.DH( 3 , 1 , 0
,
.DH( 3 , 2 , 30 ,
.DH( 3 , 3 , 22 ,
.DH( 3 , 4 , 22 ,
// I n d i c e
fig
fig
fig
fig
fig
fig
. DHo( 4 , 0 , 4 0 , 0 ) ;
.DH( 4 , 0 , 0
,
.DH( 4 , 1 , 0
,
.DH( 4 , 2 , 30 ,
.DH( 4 , 3 , 30 ,
.DH( 4 , 4 , 30 ,
// Palma
3.3. CLASE GRFICOS
65
f i g . Objeto ( 0 , Caja , 5 , 2 0 , 3 0 , 4 5 , 0 , 0 , 4 0 , 1 0 )
3.2.2. Movimiento del robot

Una vez denidos los parmetros de Denavit-Hartenberg se declaran arreglos de variables independientes las cuales se utilizarn para variar los parmetros iniciales concernientes a los ngulos, los cuales al momento de actualizarse con respecto al tiempo generarn
el movimiento virtual en el simulador.
Los movimientos pueden ser generados simulando la generacin de valores que sean
calculados por una funcin dependiente del tiempo, o bien tomando los valores del prototipo fsico mediante un driver el cual actualizar las lecturas de forma regular y en un
intervalo de tiempo corto 4 , para obtener la animacin dependiendo de la capacidad del
procesador para desplegar las imgenes a la velocidad congurada.
3.3. Clase grcos

Para la generacin de los grcos adems del diseo y la programacin de una clase
para manejarlos fue necesario congurar en el programa principal las libreras de OpenGL
para la generacin de los mismos.
El cdigo completo de toda la aplicacin se encuentra en el apndice B con sus respectivos comentarios por seccin y por lnea en el caso de ser necesario.
3.3.1. Tipos de datos

La denicin de tipos de datos fue particularmente til para el manejo de la informacin tanto generada como extrada de las funciones que se utilizaron en la clase, sobre
todo en lo que se reere a las estructuras de datos que conforman los parmetros de
Denavit-Hartenberg y las coordenadas que se requieren para ubicar espacialmente a los
componentes del robot.
defDH
Lo que signica de forma abreviada el tipo de datos defDH es denicin DenavitHartenberg. Este tipo de datos puede albergar los parmetros de Denavit-Hartenberg,
adems de dos parmetros que identican el nmero de cadena independiente que representan y el nmero de eslabn que ocupa dentro de la cadena. Los parmetros que
4 Un tiempo adecuado para obtener una animacin uida podra ser aquel que en un segundo desplegara
al menos hasta 24 actualizaciones por segundo que son las que usualmente se utilizan en el cine y la
televisin las cuales el cerebro humano ya no puede separar en imgenes individuales.
66

Tabla 3.2: Elementos del tipo de datos defDH
Tipo de Nombre
elemento elemento
Entero
Entero
Flotante
Flotante
Flotante
Flotante
del
nC
nV
a
alfa
d
teta
Descripcin
Nmero de cadena cinemtica
Nmero de vnculo o eslabn
Parmetro de Denavit-Hartenberg
distancia a
ngulo
distancia d
ngulo
Tabla 3.3: Elementos del tipo de datos oC
Tipo de Nombre
elemento elemento
Flotante
Flotante
Flotante
x
y
z
del
Descripcin
Coordenada del origen de la cadena en el eje x
Coordenada del origen de la cadena en el eje y
Coordenada del origen de la cadena en el eje z
identican al eslabn dentro de una cadena son de tipo entero, mientras que todos los
elementos que describen los parmetros de Denavit-Hartenberg son de tipo otante.
La forma en la que estn representados los parmetros de Denavit-Hartenberg y los
identicadores en el tipo de datos se enlistan en la tabla 3.2.
oC
Para cada cadena es necesario denir el origen espacial que esta tendr, para ser representada dentro de la forma precisa. El tipo de datos oC representa el origen de la Cadena
y esta recibe dichas coordenadas espaciales. En la tabla 3.3 se enlistan los elementos que
recibe el tipo de dato.
parF
En la representacin de las formas se utilizan funciones de OpenGL para conseguirlo,
estas a su vez deben recibir ciertos parmetros para generar la forma, y es precisamente
lo que el tipo de datos parF busca; obtener los parmetros de Forma y asignarlos a las
funciones y mtodos que las generan.
Dependiendo de la forma a representar son los parmetros que se emplean, siendo de
3.3. CLASE GRFICOS
67
1 hasta 4. Un identicador de forma y un elemento que albergue el tipo de la forma son

requeridos, adems de contener las caractersticas de orientacin espacial que son representadas por un vector que contenga las coordenadas de inicio como la direccin.
En la tabla 3.4 se describen los elementos utilizados para conformar este tipo de dato.
Tabla 3.4: Elementos del tipo de datos parF
Tipo de Nombre
elemento elemento
Entero
id
Entero
Tipo
Flotante
Flotante
Flotante
Flotante
Flotante
Flotante
Flotante
Flotante
Flotante
Flotante
x
y
z
Rx
Ry
Rz
par1
par2
par3
par4
del
Descripcin
Identicador de la forma
Tipo de la forma, puede ser, caja, esfera, cilindro,
cono, pirmide, disco y semi-disco.
Coordenada del origen de la cadena en el eje x
Coordenada del origen de la cadena en el eje y
Coordenada del origen de la cadena en el eje z
ngulo del vector de la cadena en el eje x
ngulo del vector de la cadena en el eje y
ngulo del vector de la cadena en el eje z
Parmetro de forma 1
Parmetro de forma 2
Parmetro de forma 3
Parmetro de forma 4
camRot
Para tratar de manera independiente el origen y el ngulo de los objetos representados
con el del punto de vista del observador fue diseado el tipo de datos camRot que hace
referencia a la cmara y su Rotacin aunque en realidad no es slo su rotacin lo que
importa, sino tambin el ngulo que ste tiene.
Para denir este tipo de datos es necesario al igual en que en la denicin de los
parmetros de forma, asignar las coordenadas espaciales de su origen y su direccin y
por tratarse de un punto en el que se sita el observador este vector debe estar completo
contando con una magnitud, la cual la expresar un parmetro denominado zoom.
Para vistas que estn previamente denidas habr un elemento que contendr la instruccin que hace referencia a aquella vista en particular, otorgando un valor en especial
para la libre navegacin en el espacio virtual. En la tabla 3.5 se enlistan los elementos
empleados.
68

Tabla 3.5: Elementos del tipo de datos camRot
Tipo de Nombre
elemento elemento
Entero
Flotante
Flotante
Flotante
Flotante
Flotante
Flotante
x
y
z
Rx
Ry
Rz
Flotante
Zoom
del
Descripcin
Identicador de la una vista predenida o de navegacin libre
Coordenada del observador en el eje x
Coordenada del observador en el eje y
Coordenada del observador en el eje z
ngulo del vector del observador en el eje x
ngulo del vector del observador en el eje y
ngulo del vector del observador en el eje z
Magnitud del vector del observador que asigna las
propiedades alejamiento y acercamiento
parAnim
El ltimo tipo de datos denido en la clase Graficos es referente a los parmetros
para generar la Animacin los cuales se limitan a poder almacenar el ngulo de movimiento actual y el intervalo de tiempo en el cual se ha de efectuar el movimiento. En la
tabla 3.6 se hace descripcin de ellos.
Tabla 3.6: Elementos del tipo de datos parAnim
Tipo de Nombre
elemento elemento
Flotante
mA
Flotante
del
Descripcin
ngulo del eslabn que se esta moviendo actualmente
Intervalo de tiempo en el cual se efecta el movimiento
3.3.2. Constantes
La denicin de constantes es necesaria en la aplicacin para identicar determinados valores que representan directamente algn argumento para alguna funcin. Para no
recurrir a nmeros sin aparente signicado, se asignaron tanto a las vistas, las formas,
los ejes y a algunos valores para clculos aritmticos y de control de ujo constantes las
cuales se describen en cuatro grupos que de forma general han sido mencionados.
3.3. CLASE GRFICOS
69
Vistas
Son nueve las vistas predenidas que se pueden elegir, para esto fueron asignadas
constantes a cada una, en donde la rutina encargada de posicionar al observador tiene las
coordenadas en donde se logran dichas vistas. Para que la navegacin en el entorno virtual
sea libre, se asign una constante a esta condicin, para que el punto del observador no
est ligado a la posicin asignada por una vista predenida. En la tabla 3.7 se muestra
las constantes asignadas con su valor y nombre.
Tabla 3.7: Constantes que denen las vistas

FRONTAL
POSTERIOR
SUPERIOR
INFERIOR
DERECHA
IZQUIERDA
ISOMETRICA
TRIMETRICA
DIMETRICA
LIBRE
Valor
0
1
2
3
4
5
6
7
8
100
Formas
Para la asignacin de los parmetros, para la generacin de las formas se tuvieron en
cuenta todas aquellas que se pueden denir en tiempo de diseo mediante la funciones
denidas previamente.
Estas formas se enlistan en la tabla 3.8 con su nombre y valor.
Ejes
Para la denicin de los ejes y ser asignados para la navegacin en el entorno virtual,
se denieron las constantes que hicieran referencia a stos. En la tabla 3.9 se enlistan estas
constantes.
70

Tabla 3.8: Constantes que denen las formas
Esfera
Cilindro
Caja
Cono
Piramide
Disco
Semidisco
Valor
1
2
3
4
5
6
7
Tabla 3.9: Constantes que denen los ejes
Nombre de la constante
EjeX
EjeY
EjeZ
Valor
1
2
3
Varias
Se denieron constantes que ayudarn a la realizacin de clculos aritmticos y que
adquirieran funcionalidad para el control del ujo del programa. Estas se enuncian en la
tabla 3.10 y se les describe brevemente.
Tabla 3.10: Constantes varias

Nombre de
Constante
on
o
TA
STOPANI
DOSPI
RADtoDEG
la
Valor
Descripcin
Para el control del programa al estar

habilitada alguna funcin.
Para el control del programa al estar
0
deshabilitada alguna funcin.
Tiempo de actualizacin para la anima50
cin en milisegundos
Diferencia signicativa (en grados) de
0.1
la variacin de un ngulo para su actualizacin en la animacin
6.28318530718
Valor de 2
0.01745329251994 Factor par convertir radianes a grados
1
3.3. CLASE GRFICOS
71
3.3.3. Declaraciones privadas

Las declaraciones privadas cuya estructura completa se muestra en el listado 3.7 tienen
como propsito complementar las funciones y utilizarse como parmetros internos en la
clase.
Listado 3.7: Declaracin de las variables privadas de la clase Graficos
defDH e l e m e n t o [ 2 0 ] ;
oC o r i g e n [ 2 0 ] ;
parF ob [ 1 0 0 ] ;
i n t nE ;
camRot Cam;
// D e f i n i c i o n e s DH de l o s e l e m e n t o s
// Origen de l a s Cadenas
// O b j e t o s G e n e r a l e s
//Nmero de e l e m e n t o a c t u a l g e n e r a l
// Parmetros de l a cmara v i r t u a l
3.3.4. Funciones y mtodos

Las funciones y mtodos programadas en la clase Grficos tienen funcionalidades diversas, desde la inicializacin y asignacin de parmetros hasta funcionalidad interna que
extrae las caractersticas especcas del conjunto de cadenas representadas grcamente.
El orden que se presenta es en el que fueron concebidas y en el que se encuentran dentro del programa y no existe otro motivo por el cual se haya seguido este ordenamiento.
Graficos
Como en toda clase, se declara el constructor de la clase para inicializar todas las declaraciones privadas, tanto los arreglos como las variables independientes que sirven como
ndices o indicadores para algunas funciones de la clase.
Los arreglos son inicializados en su totalidad mediante un ciclo que asigna a cada
elemento de cada arreglo su valor inicial para evitar algn comportamiento errneo.
DHo
Este mtodo permite ingresar las coordenadas de origen de una cadena cinemtica
denida. Mediante el ingreso de cada una de las coordenadas espaciales y el identicador
de la cadena, el mtodo no regresa ningn argumento y slo carga al arreglo interno de la
clase las coordenadas en el tipo de datos que almacena las coordenadas de origen llamado
origen cuyos elementos son los ejes x, y y z . su sintaxis se observa en el listado 3.8.
Listado 3.8: Sintaxis del mtodo DHo de la clase Graficos
DHo( i n t nC , f l o a t x , f l o a t y , f l o a t z )
72
GetO
La funcin GetO regresa el origen de una cadena cinemtica, lo que es til para realizar algunos clculos, adems al ser la informacin propiedad de la clase no es posible
accederla ni modicarla de otro modo, lo que le da integridad a la informacin.
En el listado 3.9 se muestra la sintaxis de la funcin, la cual regresa en un tipo de
datos oC la informacin de las coordenadas de origen.
Listado 3.9: Sintaxis de la funcin GetO de la clase Graficos
oC GetO ( i n t nC)
DH
En la funcin DH es posible ingresar los parmetros de Denavit-Hartenberg con sus
identicadores de nmero de cadena y nmero de eslabn regresando el nmero (entero)
de elemento que este representa en el conjunto de los elementos denidos. Su sintaxis se
muestra en el listado 3.10.
Listado 3.10: Sintaxis de la funcin DH de la clase Graficos
DH( i n t nC , i n t nV , f l o a t a , f l o a t a l f a , f l o a t d , f l o a t t e t a )
Cadena
La funcin Cadena se encarga de convertir los parmetros de Denavit-Hartenberg en
parmetros que aceptan las funciones de OpenGL para generar los grcos que en este
caso van a ser representados por cilindros.
Esta funcin recibe el nmero de elemento global y regresa los parmetros para desplegar una gura en el tipo de datos parF.
En el listado 3.11 se muestra la sintaxis de la funcin.
Listado 3.11: Sintaxis de la funcin Cadena de la clase Graficos
Cadena ( i n t nE)
Objeto
Este tipo de datos aprovecha la capacidad que tiene C++ de poder declarar una misma
funcin en mltiples ocasiones para los casos en que la funcin acepte varios argumentos,
esto es conocido como polimorsmo.
3.3. CLASE GRFICOS
73
Lo que recibe de argumentos la funcin Objeto son todos aquellos parmetros que
requiere una forma para ser representada, parmetros tales como: identicador, tipo de
forma, coordenadas espaciales, y los parmetros que lo denen como radio, altura, lado,
etctera; dichos parmetros estn descritos en la seccin 3.3.1 referente a los tipos de datos en su apartado del tipo parF. El mtodo se encarga de que se desplieguen los objetos
indicados.
Las sintaxis del mtodo se enuncian en el listado 3.12.
Listado 3.12: Diversas sintaxis del mtodo Objeto de la clase Graficos
Objeto ( id
Objeto ( id
Objeto ( id
Objeto ( id
, tipo
, tipo
, tipo
, tipo
,
,
,
,
x,
x,
x,
x,
y , z , rx
y , z , rx ,
y , z , rx ,
y , z , rx ,
, ry
ry ,
ry ,
ry ,
, rz
rz ,
rz ,
rz ,
, par1 )
par1 , par2 )
par1 , par2 , par3 )
par1 , par2 , par3 , par4 )
GraficarObjeto
Esta funcin regresa los parmetros para la gracacin completa de un objeto extrayendo la informacin ingresada al arreglo de objetos, recibe nicamente el nmero de
elemento identicador. En el listado 3.13 se muestra su sintaxis.
Listado 3.13: Sintaxis de la funcin GraficarObjeto de la clase Graficos
G r a f i c a r O b j e t o ( i n t nE)
MovimientoAlfa
El mtodo MovimientoAlfa se encarga de escribir en los parmetros de DenavitHartenberg, variables que representan a los robots para actualizar los ngulos de las
cadenas cinemticas, como argumentos reciben los identicadoras de nmero de cadena y
nmero de eslabn, el nuevo ngulo i , el tiempo en el que la actualizacin del movimiento
se va a llevar a cabo y el grupo de movimiento en el cual se va realizar el mismo.
En el listado 3.14 se muestra la sintaxis del mtodo.
Listado 3.14: Sintaxis del mtodo MovimientoAlfa de la clase Graficos
MovimientoAlfa ( i n t nC , i n t nV , f l o a t a l f a , f l o a t tiempo , i n t gM)
MovimientoTeta
Este mtodo realiza prcticamente lo mismo que el mtodo MovimientoAlfa con la
particularidad que el ngulo a actualizar en este caso es i . La sintaxis se encuentra en el
74
listado 3.15.
Listado 3.15: Sintaxis del mtodo MovimientoTeta de la clase Graficos
MovimientoTeta ( i n t nC , i n t nV , f l o a t t e t a , f l o a t tiempo , i n t gM)
MovimientoObjeto
Los objetos independientes tambin tienen la capacidad de moverse, esto mediante la
actualizacin de algunos parmetros particulares como lo son: su ngulo, eje en el cual se
ejecuta el movimiento de dicho ngulo y el tiempo en el cual se ha de ejecutar el movimiento. En el listado 3.16 se representa la sintaxis para emplear esta mtodo.
Listado 3.16: Sintaxis del mtodo MovimientoObjeto de la clase Graficos
MovimientoObjeto ( i n t id , f l o a t angulo , i n t e j e , i n t tiempo )
Camara
Nuevamente aqu se utilizan las funciones de polimorsmo. La funcin Camara puede
recibir tres conguraciones de argumentos y dependiendo de estos ser el parmetro que
regrese.
En el caso de que reciba un entero que representa una vista predeterminada la funcin
asignar el parmetro a la variable correspondiente y regresar el mismo entero. Si recibe
las coordenadas espaciales (variables de tipo otante todas ellas) del observador la funcin regresar los parmetros asignados en un tipo de datos camRot adems de haber sido
asignados a la variable privada de la clase. Y en el caso de no recibir ningn argumento,
la funcin regresar lo que la variable privada contenga en ese momento. El listado 3.17
indica las tres posibles sintaxis.
Listado 3.17: Sintaxis de la funcin Camara de la clase Graficos
Camara ( i n t v i s t a )
Camara ( Rx , Ry , Rz , x ,
Camara ( )
y,
z , Zoom)
nVC
La funcin nVC regresa el nmero de vnculos o eslabones de una cadena, lo que es
til para calcular el nmero de elementos totales, recibe como argumento el nmero de
cadena y regresa el nmero de vnculos. En el listado 3.18 se muestra la sintaxis de la
funcin muy utilizada internamente en la clase.
3.3. CLASE GRFICOS
75
Listado 3.18: Sintaxis de la funcin nVC de la clase Graficos

nVC( i n t nC)
nCa
Esta funcin regresa el nmero (entero) total de cadenas que fueron denidas. No recibe argumento alguno. La sintaxis se puede observar en el listado 3.19.
Listado 3.19: Sintaxis de la funcin nCa de la clase Graficos
nCa ( )
nElemento
Para recuperar el nmero de elemento correspondiente a una cadena y un eslabn o
vnculo se dise esta funcin la cual recibe estos dos parmetros y regresa el identicador (entero) que representa el nmero de elemento. La sintaxis se observa en el listado 3.20.
Listado 3.20: Sintaxis de la funcin nElemento de la clase Graficos
nElemento ( i n t nC , i n t nV)
nElementosCadenas
Esta funcin regresa el nmero (entero) total de elementos que describen a todas las
cadenas denidas. No lleva argumentos. La sintaxis se muestra en el listado 3.21.
Listado 3.21: Sintaxis de la funcin nElementosCadenas de la clase Graficos
nElementosCadenas ( )
nOb
Esta funcin regresa el nmero (entero) de objetos independientes denidos. No lleva
argumentos. La sintaxis se encuentra en el listado 3.22.
Listado 3.22: Sintaxis de la funcin codnOb de la clase Graficos
nOb ( )
76
angActual
Mediante esta funcin es posible recuperar el ngulo (nmero de punto otante) asignado en el vnculo o eslabn de una cadena indicada. Como argumentos requiere del
vnculo y la cadena. La sintaxis se observa en el listado 3.23.
Listado 3.23: Sintaxis de la funcin angActual de la clase Graficos
angActual ( i n t nC , i n t nV)
3.4. Animacin de los grcos

La animacin de los grcos se logra mediante la actualizacin de los parmetros
mviles en el robot, estos estn disponibles para su actualizacin por medio de una funcin que se refresca a travs de un timerque calcula la posicin que ha de asignarse a
las variables de movimiento (ngulos) o bien mediante la lectura de un archivo de puente generado por un driver que obtiene los valores reales que ocurren en un prototipo fsico.
Los timers que se encargan de estas funciones se encuentran en el programa principal, y en modo de simulacin calculan de forma lineal el comportamiento de los ngulos
dependiendo de los parmetros de tiempo asignados, mientras que en los modos de interpretacin y generacin se emplean los valores alimentados por el driver. En el la gura 3.8
se muestra la imagen generada a lo largo de una lnea de tiempo de 4 segundos al requerir
una animacin de todos los dedos y todas las falanges en todo su rango de movimiento.
0 segundos
3 segundos
1 segundo
2 segundos
4 segundos
Figura 3.8: Imgenes obervadas en la ejecucin de una animacin en distintos instantes

de tiempo
Captulo
Manejo de las Seales

Usualmente para el manejo de seales en C deben abrirse los puertos que han de utilizarse. Sin embargo en plataformas posteriores a Windows 98 (hablando de los sistemas
operativos de Microsoft) el sistema operativo se apropia de los puertos, haciendo complicada la tarea de abrirlos y utilizarlos libremente. Si se aade a esto que los puertos que
en determinado momento han de utilizarse son propietarios de otra aplicacin, se hace la
tarea ms compleja al tratar de asignarlos para no hacer colapsar al sistema.
LabView puede controlar los puertos serial y paralelo y utilizarlos con diferentes protocolos segn sea la necesidad, con relativa facilidad, adems de contar con tarjetas ISA
y PCI, las cuales expanden las capacidades de los puertos, estos ya cuentan con un driver
especco.
La solucin que se plantea es la generacin de archivos con la informacin relevante
para la animacin, que puedan ser ledos de forma simple desde C++, en donde la actualizacin de los archivos jugar parte fundamental de una animacin en tiempo real.
Se utiliz el sistema de la mano CENIDET [3] en donde la extraccin de las seales
por medio de mdulos de LabView ya fue desarrollada, se aade un elemento de LabView
el cual fue denominado driver virtual al sistema que controla la mano CENIDET, ste se encarga de recuperar la informacin generada por dichas seales para as generar
una animacin de lo ocurrido con el prototipo robtico tal como se muestra en la gura 4.1.
En realidad el manejo de seales se hace forma virtual, ya que este trabajo no incluye
una investigacin profunda de este tema, al haberse incluido ntegramente las partes
relacionadas de trabajos realizados con anterioridad en el CENIDET [3], [24], dado que
el prototipo robtico represento el modelo para pruebas de la implementacin.
77
78
CAPTULO 4. MANEJO DE LAS SEALES
Mdulo
Driver LabView
Variables de
parmetros
Driver
LabView
LabView Driver
Escalamiento
HMI
Controlador
Etapa de potencia
y acondicionamiento
de seales
Mano
Mano CENIDET
C++ Driver
Valor Absoluto de los

sensores o actuadores
Figura 4.1: Diagrama a bloques de la interconexin del driver virtual
4.1. LabView como interfaz entre C++ y puertos fsicos

Al contar con un mdulo de tiempo real 1 y una tarjeta de adquisicin de datos se
puede acceder de forma relativamente directa a la informacin generada en los dispositivos
perifricos de control.
El mdulo utilizado es el PCI-7833 (gura 4.2) el cual puede ser accedido con las libreras de LabVIEW VISA en donde se identican las diferentes entradas y salidas de forma
particular, adems de contar con la ventaja de tener un FPGA 2 el cual puede embeber
la aplicacin para hacerla ms eciente y tener un desempeo en tiempo real.
Mediante un conector de clemas para hacer manipulable la interfaz, se hace la interconexin de las seales de control entre la tarjeta de adquisicin y generacin de datos
llamada SCB-68 (gura 4.3)
En [3] se hizo el desarrollo de la mano CENIDET en donde se expone un sistema como
se expone en la gura 4.4.
La conguracin de las tarjetas y los puertos fsicos para el funcionamiento de la mano
CENIDET se toman directamente del controlador diseado en un trabajo previo [24].
1 El
tiempo real se reere al desempeo de un cmputo durante el tiempo actual que est relacionado a
lo que transpira un proceso fsico que resulta del cmputo y puede ser utilizado guiando el proceso fsico
[8].
2 Field Programmable Gate Array, dispositivos semiconductores con bloques de lgica que son programables tanto en interconexin como en funcionalidad.
4.1. LABVIEW COMO INTERFAZ ENTRE C++ Y PUERTOS FSICOS
79
Figura 4.2: Tarjeta de adquisicin y generacin de datos con FPGA PCI-7833 de National
Instruments
Figura 4.3: Tarjeta de interconexin SCB-68
4.1.1. Puertos fsicos

Las libreras incluidas en los mdulos de tiempo real de LabVIEW son las encargadas
de la manipulacin de las seales fsicas mediante la tarjeta inteligente DAQ, en donde
mediante estas libreras es posible tambin asignar la programacin correspondiente al
dispositivo de hardware descriptivo como lo es el FPGA.
Generando un programa en LabVIEW con estas libreras en donde se implemente un
algoritmo de control es posible manipular cualquier modelo fsico que este implementado.
En trabajos anteriores en el CENIDET se hizo la implementacin de controladores[24]
para la mano en los cuales se implement la aplicacin desarrollada en este trabajo.
80
Datos
MONITOREO
Datos
SCB-68
PCI-7833
Datos
Datos
Mano
CENIDET
Datos
Tarjetas
colectoras
Tarjetas de potencia
Figura 4.4: Interconexin del sistema de la mano CENIDET
4.1.2. Mdulo de tiempo real (Real Time)

La mayora de las aplicaciones de LabVIEW se ejecutan sobre sistemas operativos de
propsito general como Windows, Linux, Solaris o MAC OS. Algunas de las aplicaciones
requieren desempeo determinstico en tiempo real que los sistemas operativos de propsito general no pueden garantizar. El mdulo de tiempo real de LabVIEW extiende las
capacidades de LabVIEW para direccionar las necesidades de desempeo determinstico
en tiempo real.
National Instruments dise el mdulo de tiempo real (Real-Time) para ejecutar VIs3
en dos diferentes plataformas de tiempo real:
1. Ejecucin de objetivos de Hardware con la Venturcom Phar Lap Emebebed Tool
Suite (ETS).
2. Ejecucin en la computadora con la Venturcom Real-Time Extension (RTX).
Venturcom Phar Lap EPS provee de un sistema operativo en tiempo real que se ejecuta en hardware de las series NI RT para conocer los requerimientos de las aplicaciones
embebidas que necesitan comportarse determinsticamente o haber extendido sus requerimientos de conabilidad.
3 VI
es un programa o ejecutable dentro del entorno de LabVIEW el cual es acrstico de "Virtual

Instrument.o Instrumento Virtual.
4.2. DRIVER VIRTUAL
81
Venturcom RTX adiciona a Windows un subsistema de tiempo real (RTSS). Venturcom RTX habilita la ejecucin de Windows y del RTSS al mismo tiempo en la misma
computadora[9].
Mediante estas herramientas se puede garantizar una ejecucin en tiempo real del sistema, para obtener un control conable.
Un sistema en tiempo real consta de elementos tanto de software como de hardware.
En los componentes de software esta incluido LabVIEW, la mquina de Tiempo Real (RT
Engine) y los VIs creados por el usuario. Los componentes de hardware constan del sistema de tiempo real, incluyendo una computadora antrin (host) y el objetivo en tiempo
real (RT target)[9].
4.1.3. Lectura y escritura de variables como puente de los puertos

fsicos
Mediante la ejecucin del mdulo de tiempo real se asegura el funcionamiento del
controlador de la mano. En lo que concierne a este trabajo es la bsqueda de una interfaz
mediante la cual sea posible asignarle destinos de control al controlador desarrollado en
LabVIEW, as como poder interpretar el estado actual del robot.
Utilizando un archivo de puente el cual es actualizado de forma peridica en ciclos lo
sucientemente cortos para poder representar de forma uida una animacin, es posible
conseguir esta informacin para la generacin de la animacin en tiempo real del comportamiento del prototipo fsico.
4.1.4. Retrasos y desfases

Es importante considerar que las caractersticas de procesamiento y memoria de la
computadora residente (host)deben ser amplias para asegurar que la ejecucin de las dos
aplicaciones. Dependiendo de la relacin de las caractersticas de la computadora residente
se observarn distintos efectos de desfases y retrasos en la animacin, al ser esta aplicacin
la que esta ligada a una dependencia de lo que ocurre en el controlador de LabVIEW.
4.2. Driver virtual

La denicin popular de un Driver es la de controlador de un dispositivo, el cual en
el mbito de la electrnica se reere a aquel componente que aumenta la corriente para
el funcionamiento de los dispositivos de control y asegurar su correcto desempeo4 . En el
mbito informtico un driver se reere a aquel controlador de un dispositivo que permite
al sistema operativo interactuar con un perifrico, haciendo una abstraccin del hardware
4 Denicin
extrada de The Illustrated Dictionary of Electronics 8th Edition.
82
y proporcionado una interfaz para usarlo5 .

En este caso en particular se emplea un driver ya existente para hacer el control del
prototipo fsico de una mano, en donde se hace la extraccin de parmetros especcos los
cuales se representan en una interfaz grca. Los parmetros se escriben en un archivo de
texto plano con una actualizacin recurrente, en donde se obtienen las posiciones actuales
de todas las partes mecnicas que estn en movimiento, de la misma forma son estos
datos ledos y representados en la interfaz grca. Por otro lado parmetros de posiciones
destino son escritos por la interfaz grca y ledos por el programa del controlador para
ser ejecutados en tiempo real en un modo de funcionamiento determinado.
4.2.1. Lectura y escritura de archivos puente

Son necesarias cuatro funciones para la lectura y escritura de los archivos puente, respectivamente un lector y un escritor tanto en la aplicacin del simulador grco como VI
que se incluye en el controlador de LabVIEW.
Mediante las funciones correspondientes se generan los archivos puente para la representacin en la interfaz grca de los movimientos de la mano correspondientes a los
datos obtenidos de los encoders del prototipo fsico. Es posible de igual forma asignar los
ngulos requeridos para ser alcanzados por el control.
Algoritmo de escritura de archivo puente en el simulador grco

En la escritura del archivo puente en el simulador grco se escriben los datos correspondientes a la emisin de un movimiento, siendo esto representado por los datos del dedo,
la falange y el ngulo respectivo a ser actualizado. El algoritmo se muestra en la gura 4.5.
Algoritmo de lectura de archivo puente en el simulador grco

La lectura del archivo puente en el simulador grco extrae la informacin de las posiciones actuales de los encoders en el prototipo fsico provenientes a su vez de LabVIEW.
En la gura 4.6 se representa el diagrama de ujo de algoritmo empleado.
Algoritmo de escritura de archivo puente en el controlador de LabVIEW

El archivo generado por LabVIEW contiene los datos correspondientes a los ngulos
que son reportados por los encoders en tiempo real al controlador en LabVIEW, la gura
4.7 representa el algoritmo empleado para el diseo de esta funcin.
5 Concepto
extrado de Wikipedia
4.2. DRIVER VIRTUAL
83
Algoritmo de lectura de archivo puente en el controlador de LabVIEW

La informacin que LabVIEW lee del archivo puente es la posicin que ha de asignarse a una falange de un dedo especco en la mano en donde se leen bsicamente tres
parmetros. En la gura 4.8 se muestra el algoritmo empleado para la lectura.
Inicio
NO
Habilitacin
de Emisin
NO
Fin
SI
Botn
de Ingreso
SI
Escribir Datos
en Archivo
Fin
Figura 4.5: Algorimo para la escritura en el simulador grco
Inicio
Modo
Interpretacin
o Emisin
NO
Fin
SI
Lectura de
Parmetro N
N+1
Parmetro
final?
Fin
Figura 4.6: Algorimo para la lectura en el simulador grco
84

Inicio
Habilitacin
de Lectura
NO
Fin
SI
Lectura de
Parmetro N
N+1
NO
Parmetro
final?
SI
Esperar
101ms
Fin
Figura 4.7: Algorimo para la escritura en el controlador
Inicio
Habilitacin
de Escritura
NO
Fin
SI
Escritura de
Parmetro N
N+1
NO
Parmetro
final?
Esperar
101ms
Fin
Figura 4.8: Algorimo para la lectura en el controlador
4.2. DRIVER VIRTUAL
85
4.2.2. Formato de archivos puente

Son dos los tipos de archivos de archivos puente que se utilizan en la aplicacin, y estos
obedecen al ujo de datos que presentan. Son llamados respectivamente Posiciones y
Emision.
En los listados 4.1 y 4.3 se muestran respectivamente el formato de cada uno de ellos,
y en los listados 4.2 y 4.4 representan ejemplos de un archivo de posiciones y emisin
respectivamente. Ambos archivos tienen una extensin del tipo .txt y son archivos de
texto plano.
Listado 4.1: Formato del archivo puente de posiciones proveniente de LabVIEW
float
float
float
float
float
float
float
float
float
float
float
float
float
float
float
float
ngulo
ngulo
ngulo
ngulo
ngulo
ngulo
ngulo
ngulo
ngulo
ngulo
ngulo
ngulo
ngulo
ngulo
ngulo
ngulo
de
de
de
de
de
de
de
de
de
de
de
de
de
de
de
de
dedo
dedo
dedo
dedo
dedo
dedo
dedo
dedo
dedo
dedo
dedo
dedo
dedo
dedo
dedo
dedo
pulgar f a l a n g e proximal
pulgar f a l a n g e medial
pulgar falange d i s t a l
p u l g a r movimiento de a b d u c c i n
n d i c e f a l a n g e proximal
n d i c e f a l a n g e medial
ndice falange distal
n d i c e movimiento de a b d u c c i n
medio f a l a n g e p r o x i m a l
medio f a l a n g e m e d i a l
medio f a l a n g e d i s t a l
medio movimiento de a b d u c c i n
anular f a l a n g e proximal
anular f a l a n g e medial
anular falange d i s t a l
a n u l a r movimiento de a b d u c c i n
Listado 4.2: Ejemplo de archivo de posiciones

64.545
39.091
36.364
10.859
90.000
37.273
0.000
0.000
90.000
0.000
0.000
0.000
90.000
0.000
86
0.000
0.000
Listado 4.3: Formato del archivo puente de emisin proveniente del simulador grco
f l o a t n g u l o TAB i n t dedo TAB i n t f a l a n g e
Listado 4.4: Ejemplo de archivo de emisin
2.22000002861023
4.2.3. Utilizacin de funciones de animacin para la generacin

de movimiento virtual
Mediante las funciones de animacin descritas en el Captulo 3 es posible actualizar
las posiciones mostradas en el simulador grco de forma instantnea nicamente dejando
como 0 el parmetro de tiempo de la animacin.
Aproximadamente cada dcima de segundo la imagen en el simulador es actualizada
generando la sensacin de movimiento. La velocidad de actualizacin puede ser modicada en tiempo de diseo, sin embargo esto cobrar un correcto efecto solo con una
computadora de alto desempeo.
4.3. Simulador de movimiento en LabVIEW

Una herramienta indispensable para la validacin del los archivos de puente e un simulador que represente el cambio en las variables fsicas generadas por LabVIEW.
Mediante la generacin indirecta de las dichas seales se hicieron las pruebas para la
generacin del archivo puente, la aplicacin actualiza posiciones las cuales se reejan en
el archivo puente y por ende en el simulador grco. En las guras 4.9 y 4.10 se muestra
la interfaz del simulador, siendo ejecutado al mismo tiempo que la interfaz grca con
la representacin exacta de los ngulos descritos los cuales fueron tomados del archivo
puente.
4.4. Modos de funcionamiento de la aplicacin

La aplicacin tiene tres modos en los cuales opera, estos estn denidos en base al
origen y al ujo de datos que manejan. Todos estos modos estn relacionados con el simulador grco y no necesariamente con el prototipo fsico.
4.4. MODOS DE FUNCIONAMIENTO DE LA APLICACIN
87
Figura 4.9: Simulador de movimiento

Los modos de Interpretacin y Emisin requieren de estar en lnea con el dispositivo fsico para su correcta operacin, con el driver virtual congurado en el programa
residente del controlador ya que este driver virtual se encuentra tanto en un VI como en
una parte del programa del simulador que generan la lectura y la escritura de un archivo
puente.
Mediante el men de Modo es posible seleccionar entre los tres tipos de modo de
disponible, considerando que es necesario contar con el dispositivo en lnea y con los archivos puente en el directorio residente de la aplicacin. En la gura 4.11 se observan los
modos desplegados por el men siempre contando con el modo de Simulacin por defecto.
4.4.1. Simulacin
En el modo de simulacin el ujo de datos es interno del simulador, pues se indican
mediante funciones o conjunto de funciones (scripts) el comportamiento que debe tener
cada componente de movimiento y en que tiempo debe realizarlo.
Los scripts pueden ingresarse de dos formas: mediante la lnea de comando y mediante
archivos descriptivos con las particularidades descritas en el captulo 2.
Mediante los botones que habilitan la animacin (men animacin, vase gura 4.12)
de los scripts es posible ejecutar el movimiento y analizar sus consecuencias, contando con
las bondades de un depurador que permite identicar que movimientos no son permitidos
antes de ejecutarlos.
El modo simulacin no tiene interaccin con el prototipo fsico, pero conociendo su
88
Figura 4.10: Interfaz grca en modo de interpretacin utilzando el simulador de movimiento

modelo es posible estimar como reaccionar el controlador y con esto asignar los movimientos que se vean regidos por este.
4.4.2. Interpretacin
El modo interpretacin es el encargado de leer el estado actual el robot, mediante la
generacin de los archivos puente y dependiendo de la capacidad de procesamiento del
equipo residente de la aplicacin es posible observar un animacin en tiempo real.
Al seleccionar el modo debe de contarse con el archivo puente listo para ser actualizado, accin que se conrmar al mostrar la leyenda de Dispositivo en Lnea en la barra
de estado ubicada en la parte inferior del simulador grco, de otra forma provocar un
error y se regresar automticamente al modo de simulacin.
Al estar en este modo es posible cargar el simulador con un simulador del controlador
a utilizar, de esta forma es posible observar su comportamiento sin necesidad de estar
conectado el dispositivo fsico y evitar posibles comportamientos destructivos. Es importante que al conectar el dispositivo, se halla hecho una minuciosa inspeccin de validacin
y correspondencia de los datos que retroalimentan al sistema, pues informacin errnea
de este tipo llevar a una animacin errnea y por lo tanto a una respuesta equvoca del
4.4. MODOS DE FUNCIONAMIENTO DE LA APLICACIN
89
Figura 4.11: Opciones del men Modo
Figura 4.12: Opciones del men Animacin

sistema.
4.4.3. Emisin
El modo de emisin es una ampliacin del modo de interpretacin, pues adems de ser
capaz de leer el archivo puente de posiciones, el simulador es capaz de escribir un archivo
puente de posicin deseada mediante la pestaa de Emisin (gura 4.13)en la cual se
ofrecen las opciones disponibles de elegir dedo, falange y ngulo deseado, mediante el cual
se establece la relacin de movimiento que ha de asignarse para su ejecucin.
Al ingresar los datos, la escritura del archivo puente de emisin se asigna mediante el
botn Ingresar e inmediatamente se asignan las variables por medio de un multiplexor
programado en la aplicacin del controlador (dependiendo de la estructura del controlador).
90
Figura 4.13: Pestaa para la asignacin de datos para Emisin
Captulo
Pruebas y Validacin del Sistema

Las pruebas del sistema consistieron bsicamente en elegir algunas secuencias de control para ser ejecutados por el prototipo fsico y cotejar su resultado con lo ocurrido en el
simulador.
Tomando el prototipo fsico en su estado actual se hicieron las pruebas, las cuales aunque limitadas arrojaron los resultados necesarios para determinar que la efectividad de
la herramienta es la adecuada para ser implementada en otros tipos de controladores los
cuales hayan sido desarrollados en LabVIEW, sin ser limitativa a esta plataforma, pues
drivers virtuales pueden ser implementados en otros lenguajes o plataformas nicamente
respetando los formatos de los archivos puente y haciendo las consideraciones necesarias
en caso de los desfases.
5.1. Modo simulacin

En el modo de simulacin las pruebas se centraron en asignar distintos scripts de movimiento y vericar que las acciones se hicieran en el tiempo descrito y en la cantidad
adecuada, tambin se busc que el detector de errores emitiera las alertas correspondientes en cada caso respectivo segn se documenta en el captulo 2.
5.1.1. Pruebas al modo simulacin

Dos pruebas signicativas se realizaron utilizando un script de movimiento y la lnea
de comando,para efectos ilustrativos solo se se mostrar aquella prueba realizada con los
scripts de movimiento.
El protocolo para la realizacin de las pruebas en modo de simulacin fue el siguiente:
1. Asignacin de ngulos representativos (30 , 45 y 90 ) para las falanges a ser probadas.
91
92
CAPTULO 5. PRUEBAS Y VALIDACIN DEL SISTEMA

2. Ejecucin de la asignacin correspondiente.
3. Inspeccin de los ngulos alcanzados por la animacin.
En el script de movimiento se asignaba una tarea compleja y dependiendo del estado

actual de la mano, ste tendra que encontrar las posiciones asignadas en el tiempo determinado contando con la particularidad de poder hacer varios movimientos a la vez por el
parmetro de grupo de movimiento.
En el listado 5.1 y 5.2 se observan los scripts utilizados para realizar una tarea simple
que consiste en cerrar la mano en forma de puo y hacer una cuenta con los dedos del 1 al
3, en la gura 5.1 se observa en distintos instantes de tiempo la ejecucin de la animacin,
correspondiendo nalmente a las posiciones asignadas por los scripts.
Listado 5.1: Ejemplo de script en modo de simulacin (puo)
mov( p u l g a r , proximal , 0 , 1 , 1 )
mov( medio , proximal , 0 , 1 , 1 )
mov( i n d i c e , proximal , 0 , 1 , 1 )
mov( a n u l a r , proximal , 0 , 1 , 1 )
mov( p u l g a r , d i s t a l , 9 0 , 1 , 1 )
mov( medio , d i s t a l , 9 0 , 1 , 1 )
mov( i n d i c e , d i s t a l , 9 0 , 1 , 1 )
mov( a n u l a r , d i s t a l , 9 0 , 1 , 1 )
mov( p u l g a r , media , 9 0 , 1 , 1 )
mov( medio , media , 9 0 , 1 , 1 )
mov( i n d i c e , media , 9 0 , 1 , 1 )
mov( a n u l a r , media , 9 0 , 1 , 1 )
mov( p u l g a r , abduccion , 0 , 1 , 1 )
mov( medio , abduccion , 0 , 1 , 1 )
mov( i n d i c e , abduccion , 0 , 1 , 1 )
mov( a n u l a r , abduccion , 0 , 1 , 1 )
Listado 5.2: Ejemplo de script en modo de simulacin (cuenta 1-2-3)
mov( i n d i c e , media , 0 , 1 , 2 )
mov( i n d i c e , d i s t a l , 0 , 1 , 2 )
mov( i n d i c e , proximal , 9 0 , 1 , 2 )
mov( medio , media , 0 , 1 , 3 )
mov( medio , d i s t a l , 0 , 1 , 3 )
mov( medio , proximal , 9 0 , 1 , 3 )
mov( a n u l a r , media , 0 , 1 , 4 )
mov( a n u l a r , d i s t a l , 0 , 1 , 4 )
mov( a n u l a r , proximal , 9 0 , 1 , 4 )
mov( a n u l a r , abduccion , 0 , 1 , 1 )
5.1. MODO SIMULACIN
0 segundos
93
1 segundo
3 segundos
2 segundos
4 segundos
Figura 5.1: Resultado de los Scripts descritos en los listados 5.1 y 5.2
5.1.2. Validacin al modo simulacin

Mediante scripts con errores se veric la correcta funcionalidad del compilador, y con
las pruebas realizadas tanto con los scripts y asignando en lnea de comando funciones a
realizar se pudo constatar la efectividad de la aplicacin, validando as la funcionalidad
del mismo.
Utilizando ngulos representativos como 30 , 45 y 90 en todos los dedos y falanges
se pudo validar que los ngulos asignados al ejecutarse la aplicacin eran correctos, as
como al utilizar periodos de tiempo, los cuales se pudieran medir de forma externa, se
corrobor que la asignacin hecha corresponde de forma directa.
94
5.2. Modo interpretacin

Para el modo de interpretacin fue utilizado el simulador de movimientos programado
en LabVIEW as como se hicieron pruebas con el dispositivo fsico para comprobar su
conabilidad.
En este modo dado que la computadora residente de las tarjetas de adquisicin de
datos es de caractersticas modestas (inferiores a las recomendadas para la ejecucin de
un sistema en tiempo real [9]), se reportaron ciertos desfases con la animacin, sin embargo se pudieron documentar que pese a esto la animacin es el de lo que sucede en el
prototipo fsico.
La conguracin realizada al sistema para funcionar de forma correcta en este modo
consisti en interconectar el mdulo de LabView del driver virtual al controlador del prototipo robtico implementado en [24]. La interconexin del mdulo se encuentra ilustrado
en la parte nal del apndice A y esta constituido por un Sub-VI que recibe la actualizacin del ngulo estimado que producen los servomotores a cada falange de la mano.
5.2.1. Pruebas y validacin al modo interpretacin

Mediante la asignacin de objetivos de control introducidos en la aplicacin realizada
en otro trabajo de tesis [24] se pudieron hacer las pruebas correspondientes al modo de
interpretacin.
En la gura 5.2 se muestra un extracto del video obtenido como respuesta a objetivos
de control asignados, el cual a su vez est siendo representado por el simulador grco en
modo de interpretacin, en donde se puede observar que los resultados son aproximados
a lo que se obtiene en la realidad.
En la prueba se observa que la falange distal del prototipo esta exionada mientras en
el simulador no, esto es debido a que el prototipo fsico no se encuentra tensado adecuadamente al estar acoplado al servomotor que lo controla, ello signica que la calibracin
del prototipo fsico con respecto a sus efectores, tiene repercusiones en la correspondencia
de la animacin as como la tiene en el control que realiza.
Se realizaron 15 pruebas en donde se involucraban distintas rutinas. Por el estado actual del prototipo fsico las pruebas consistieron en la interaccin mxima de dos dedos,
en las cuales se obtuvieron resultados similares al mostrado en la prueba ilustrada en la
gura 5.2 calicados como satisfactorios al obtener una correspondencia prcticamente
igual a la obtenida por el prototipo fsico.
5.3. MODO EMISIN
95
Figura 5.2: Prueba en modo interpretacin.
5.3. Modo emisin

El modo de emisin present un comportamiento peculiar, al asignar la posicin el
prototipo fsico reaccion instantneamente a la orden asignada y demor un tiempo en
actualizar la animacin, desfase atribuido nuevamente a las caractersticas modestas de
la computadora residente.
5.3.1. Pruebas y validacin al modo emisin

Las pruebas consistieron en asignar distintos valores angulares a los eslabones habilitados y conseguir la actuacin del dispositivo y su representacin en el simulador grco,
lo que se obtuvo de forma satisfactoria.
Mediante un multiplexor que selecciona cul de los eslabones es el que ejecutar la
accin de control al alcanzar un ngulo asignado. Este parmetro se lee del archivo puente
asignado.
En la gura 5.3 se muestra un extracto del video que se capt al hacer las pruebas de
emisin en donde se ingresa el dedo y la falange deseada con un ngulo a ser alcanzado, se
ejecuta la accin indicada instantneamente y posteriormente a un desfase de 3 segundos
comienza la correspondiente animacin en el simulador grco.
El ngulo alcanzado corresponde exactamente al asignado, teniendo la misma consi-
96
deracin que la prueba en el modo de emisin de la falange distal.

Una serie de 5 pruebas de este tipo fueron realizadas en donde los resultados fueron
similares, es importante mencionar que los errores producidos por las partes mecnicas
pueden ser corregidos con materiales de mejores caractersticas (cables que presenten menor deformacin a la tensin), pero esto representa un gasto mayor y sin duda un rediseo
considerable.
5.3. MODO EMISIN
97
Instante antes de la asignacin

del comando de movimiento
Instante de la asignacin
del movimiento
Instante de la respresentacin
del movimiento en el simulador
Figura 5.3: Prueba en modo emisin.
98
Captulo
Conclusiones y Observaciones
6.1. Observaciones
El presente trabajo de tesis sufri diversas modicaciones, desde aquellas que pretendieron convertirlo en una herramienta genrica de simulacin de robots articulados hasta
la ltima acotacin que deni la estructura de un simulador jo para el prototipo fsico
de la mano CENIDET.
Mediante futuras implementaciones es posible convertir la aplicacin en una herramienta genrica, modicando la estructura general de la misma hacindola ya sea en
forma de formularios o con una estructura de scripts mucho ms compleja que pueda
albergar (como se consideraba inicialmente) la conguracin en parmetros de DenavitHartenberg completa del robot.
6.2. Conclusiones
El simulador grco se limit mediante formas simples, a la representacin de una
mano humana sin dedo meique. Esta es la forma que tiene el prototipo fsico de la mano
CENIDET y que en conjunto tiene un total de 16 grados de libertad.
Mediante la librera de grcos que une los eslabones mediante los parmetros de
Denavit-Hartenberg es posible describir otra conguracin robtica con la limitante que
debe ser un robot que conste completamente de articulaciones cilndricas.
El interprete es capaz de recibir instrucciones para ejecutar movimientos vlidos del
robot mano CENIDET en una secuencia de hasta 100 movimientos por vez, siendo esto
modicable en tiempo de ejecucin.
El driver virtual fue diseado para incluir las seales en forma paralela de un arreglo
de variables, pero en determinado caso es posible pasar los parmetros de forma serial de
99
100
CAPTULO 6. CONCLUSIONES Y OBSERVACIONES
modo de requerir menos terminales en caso de contar con dispositivos limitados en sus
terminales de control, o con buses reducidos, lo que observarn futuras implementaciones
optimizadas en su interfaz electrnica.
En la implementacin de controladores desarrollados en LabVIEW se puede abstraer
de forma ms simple lo sucedido; observando las grcas de movimiento con respecto al
tiempo, da una mejor referencia del desarrollo hecho.
Al hacer pruebas con el simulador se evitan posibles comportamientos destructivos al
prototipo pues se analiza de forma ms directa el comportamiento del controlador, siempre y cuando las caractersticas mecnicas estn en buenas condiciones.
6.2.1. Acerca del intrprete

El intrprete constitua la parte central del sistema en la concepcin original del proyecto como una parte autnoma del mismo, sin embargo por diversas complicaciones se
integr a la aplicacin de forma mucho ms acotada.
La integracin del intrprete a la aplicacin como una instancia ms, represent la
simplicacin en el desarrollo y la desercin de la utilizacin de un generador de autmatas; sin embargo, la programacin de un autmata otorgara mucha ms exibilidad
a la aplicacin hacindola una herramienta integral para la ejecucin de simulaciones a
cualquier representacin robtica representada por los parmetros de Denavit-Hartenberg
sin necesidad de modicar el cdigo fuente.
Existen diversos esquemas para la creacin de autmatas, y un estudio detallado a
stos esquemas podra orientar adecuadamente lo que se hubiera tenido que incluir en la
planeacin de la aplicacin ste estudio para tener una herramienta tericamente respaldada bajo un argumento informtico. Sin embargo, la carga del proceso es relativamente
baja para las capacidades de las computadoras actuales y esto al nal, en sta aplicacin
no represent un problema sustancial despus de la acotacin.
El propsito nal del intrprete se centr en descifrar los posibles movimientos, calculndolos de forma lineal en base a parmetros de tiempo y coordenadas espaciales; de
esta forma solo es posible asignarles una velocidad en intervalos pequeos de tiempo, por
lo que en determinado momento en el arranque del movimiento se encontrarn por un
instante con una inconsistencia correspondiente a una aceleracin innita.
Al obtener el control de forma externa no se hizo un trabajo profundo en el clculo de
las variables de aceleracin, ya que la representacin del prototipo en un entorno virtual
de visualizacin con caractersticas aproximadas, fue lo principalmente buscado en este
trabajo de tesis.
6.2. CONCLUSIONES
101
6.2.2. Acerca del simulador grco

OpenGL ofrece la posibilidad de obtener grcos con un detalle muy no, es en si
la base de muchos juegos de video diseados para PC y otras plataformas, su estudio
demanda mucha bibliografa y experiencia en la generacin de estos grcos los cuales tienen la virtud de relacionarse de forma vectorial. En sta aplicacin solo se emplearon las
primitivas ms bsicas que OpenGL ofrece para la generacin de grcos en un ambiente
virtual de 3 dimensiones.
Funciones especcas fueron programadas para la generacin de los grcos empleados
en la representacin del prototipo dentro del simulador y estas sirvieron para eliminar
sentencias repetitivas en el entorno.
Todas las funciones fueron descritas en la seccin correspondiente con el propsito
de servir como base en desarrollos ms complejos, en donde bsicamente consisten en
la inicializacin y manipulacin de los arreglos que denen los elementos vectoriales que
representan las formas.
Los arreglos denidos en el inicio del cdigo fuente estn directamente relacionados
con la representacin grca que se obtiene de la aplicacin, y su modicacin en esta
versin de la aplicacin actualiza el entorno visualizado, sin embargo para lograr la interaccin de esta animacin con un controlador es necesario hacer cambios al cdigo para
ligar los elementos denidos con los del controlador. Tambin son necesarios cambios en
el controlador para hacer la correspondencia correcta.
Todos los cambios necesarios pueden hacerse empleando analogas entre lo que esta
implementado y la conguracin que se desea.
6.2.3. Acerca del manejo de seales

Al ser sistemas con un tiempo de respuesta poco crtico el sistema de archivos puente
funciona de forma satisfactoria en equipos de cmputo con caractersticas actuales (Procesador Intel Core 2 a 2GHz, 4Gb de Memoria RAM, y 200 Gb de Disco Duro). En equipos
anteriores el desempeo se ve afectado con un retraso de 3 segundos aproximadamente.
La tarjeta PCI de adquisicin de datos se considera la adecuada, ya que la obtencin
de los datos y el tiempo de respuesta es satisfactoria, sin embargo esto va ligado a las
caractersticas de la PC residente de que debe tener caractersticas como las mencionadas
anteriormente para un desempeo ptimo.
El sistema de archivos puente puede ser empleado para generar controladores con
diferentes softwares de propsito matemtico como MatLab, Mathematica, etctera, e inclusive pueden ser implementados en cualquier tipo de lenguajes como el mismo C++, C,
Visual Basic, Fortran o cualquier otro, lo que permite sea una plataforma exible.
102
Mediante el sistema de archivos puente es posible tambin la implementacin de un

driver personalizado para el uso de tarjetas independientes, o bien para trabajar directamente con los puertos de la PC.
6.3. Trabajo futuro

Existen varios puntos en las tres partes de este simulador que pueden ser implementadas en un trabajo futuro, de modo que sea una aplicacin integral que represente una
herramienta completa para la simulacin de sistemas robticos cinemticos con cualquier
conguracin.
6.3.1. Grcos
Los grcos pueden ser enriquecidos con los siguientes aspectos para su mayor aprovechamiento:
1. Implementacin de texturas para sobresaltar un mayor realismo en las animaciones.
2. Implementacin de fondos que representen escenarios ms complejos.
3. Implementacin de slidos generados con polgonos tridimensionales, los cuales se
acerquen ms a la forma real de los robots representados.
4. Enriquecimiento del entorno por medio de iluminacin dirigida y la generacin de
sombras respecto a los puntos de iluminacin.
6.3.2. Intrprete
Mediante el intrprete el simulador se puede convertir en una herramienta muy poderosa. Un compilador completo depende de la capacidad de anlisis y depuracin. Para
darle esa versatilidad existen herramientas las cuales mediante la denicin de alfabetos
y sintaxis generan un compilador con nes especcos; herramientas como stas son llamadas parsers y son la herramienta precisa para la creacin de un intrprete completo y
eciente. Sin embargo es necesario un conocimiento profundo de stos, as como de materias especializadas como lo son la construccin de compiladores para poder emplearlos
de forma adecuada.
Un intrprete que sea capaz de denir una conguracin robtica cualquiera y poder
extraer los elementos para asignarle movimiento al robot descrito es fundamental para
6.3. TRABAJO FUTURO
103
contar con una herramienta poderosa de simulacin, lo que constituira ms que trabajo
futuro de ste tema de tesis, un trabajo completo de un grado superior al de maestra.
6.3.3. Driver virtual

La implementacin en otros lenguajes de programacin en donde se pueden simular
controladores es una interesante opcin para mostrar la implementacin del simulador.
Un driver virtual con una lista de parmetros en donde sea modicable la magnitud
de los movimientos es una herramienta que puede representar una utilidad signicativa
para la sintonizacin de los mismos controladores.
La obtencin de los parmetros mediante la lectura directa de los puertos aislara de
la ejecucin de un programa extra siendo que en una tarjeta de adquisicin se est recuperando la informacin y est siendo controlado por una aplicacin embebida en un FPGA
o un microcontrolador externo.
104
Bibliografa
[1] C.X. Chen, M.M. Trivedi, and C.R. Bidlack. Simulation and graphical interface for
programming and visualization of sensor-based robot operation. Proceedings of IEEE
International Conference on Robotics and Automation, 2:1095 1101, 1992.
[2] B.K. Christensen and L.M. Desjarlais. A graphical interface for robotic remediation of underground storage tanks. Proceedings of the First IEEE Conference on
Visualization, pages 449 456, 1990.
[3] H. Cimedevilla and J.G. Herrera. Diseo de un sistema articulado emulando el
movimiento de una mano. Master's thesis, CENIDET, 2006.
[4] G.E. Cook, C. Biegl, J.F. Springeld, and K.R. Fernandez. An intelligent robotics
simulator. Conference Record of the 1994 IEEE Industry Applications Society Annual
Meeting, 3:1793 1800, Oct. 1994.
[5] John J. Craig. Robtica. Pearson Prentice Hall, 3ra. edition, 2006.
[6] Jackie Neider Tom Davis Dave Shreiner, Mason Woo. OpenGL Programming Guide:
The Ocial Guide to Learning OpenGL. Addison-Wesley Professional, fth edition,
2005.
[7] et al. OpenGL Reference Manual (Blue Book). Addison-Wesley Publishing Company,
1994.
[8] et al. LabVIEW User Manual. National Instrument Corporation, Jan. 1998.
[9] et al. LabVIEW Real.Time Module User Manual. National Instrument Corporation,
Apr. 2004.
[10] Donald Hearn and M. Pauline Baker. Computer Graphics with OpenGL. Pearson
Prentice Hall, third edition, 2004.
[11] J. Ibanez-Guzman. A robotics and automation teaching laboratory. IEE Colloquium
on Robotics and Education,, pages 5/15/4, 1997.
105
106
BIBLIOGRAFA
[12] K. Ikuta, H. Ishii, and M. Nokata. Development of robot simulator (safe-cad) for
safety design and control. Proceedings of 2001 International Symposium on Micromechatronics and Human Science, pages 161 167, 2001.
[13] A. Infantino, I.and Chella, H. Dzindo, and I. Macaluso. Visual control of a robotic
hand. Proceedings. 2003 IEEE/RSJ International Conference on Intelligent Robots
and Systems., 2:1266 1271, 2003.
[14] Rafael Kelly and Sergio Santibaez. Contro de Movimiento de Robots Manipuladores.
Pearson Prentice Hall, 2003.
[15] W.S. Kim. Graphical operator interface for space telerobotics. In IEEE International
Conference on Robotics and Automation, volume 3, pages 761 768, May 1993.
[16] D. Kragic, A.T. Miller, and P.K. Allen. Real-time tracking meets online grasp planning. Proceedings 2001 ICRA. IEEE International Conference on Robotics and Automation, 3:2460 2465, 2001.
[17] T.P. Kurpjuhn, K. Nickels, A. Hauck, and S. Hutchinson. Development of a visual space-mouse. Proceedings of IEEE International Conference on Robotics and
Automation, 4:2527 2532, 1999.
[18] P.U. Lee, D.C. Ruspini, and O. Khatib. Dynamic simulation of interactive robotic
environment. IEEE International Conference on Robotics and Automation, Proceedings, 2:11471152, 1994.
[19] Juan Gabriel Lpez. Detallador de tareas de visin robtica. Master's thesis, CENIDET, 2003.
[20] Max Meng., D. Lingman, and Xi-Ning Li. A real-time generic animated simulator for
robot manipulators. Canadian Conference on Electrical and Computer Engineering,
2:1077 1080, 1993.
[21] M.Q.-H. Meng, S. Dillen, and M. Koob. A 3-d animated simulator for robot manipulators. Canadian Conference on Electrical and Computer Engineering, 2:574 577,
1996.
[22] A.T. Miller, S. Knoop, H.I. Christensen, and P.K.; Allen. Automatic grasp planning
using shape primitives. Proceedings. ICRA '03. IEEE International Conference on
Robotics and Automation, 2003., 2:1824 1829, Sept. 2003.
[23] P. Montagnier and S.J.; Steiner. Design of a graphical user interface (gui) between
a pc-based cad system and a exible assembly robotic cell. In Fifth International
Conference on Factory 2000 - The Technology Exploitation Process, number 435,
pages 162 169, April 1997.
[24] C. Morales. Simulacin y validacin experimental de un control no lineal aplicado a un
efector reproducioendo algunos movimientos de la mano. Master's thesis, CENIDET,
2008.
BIBLIOGRAFA
107
[25] T. Raz. Graphics robot simulator for teaching introductory robotics. IEEE Transactions on Education, 32:153159, 1989.
[26] Nicholas Haemel Richard S. Wright, Benjamin Lipchak. OpenGL SuperBible: Comprehensive Tutorial and Reference. Addison-Wesley Professional, Jun. 2007.
[27] D.N. Rocheleau and C.D. Crane. Development of a graphical interface for robotic
operation in a hazardous environment. IEEE International Conference on Systems,
Man, and Cybernetics. 'Decision Aiding for Complex Systems, Conference Proceedings., 2:1077 1081, 1991.
[28] M. Rodriguez and A. Codourey. Graphical user interface to manipulate objects in
the micro world with a high precision robot. Proceedings of IEEE International
Conference on Robotics and Automation, 4:3031 3036, 1997.
[29] E. Ueda, Y. Matsumoto, M. Imai, and T. Ogasawara. A hand-pose estimation for
vision-based human interfaces. IEEE Transactions on Industrial Electronics, 50:676
684, 2003.
[30] R.B. White, R.K. Read, M.W. Koch, and R.J. Schilling. A graphics simulator for a
robotic arm. IEEE Transactions on Education, 32:417 429, Nov. 1989.
108
BIBLIOGRAFA

Apendice
Manual de Usuario
El presente manual de usuario busca dar al usuario una breve introduccin al simulador. Desde su proceso de instalacin hasta la utilizacin del mismo y de todas las
herramientas que ste posee.
A.1. Instalacin
El proceso de instalacin consiste en instalar el compilador de Borland C++. Posteriormente debe seguirse el Apndice A para instalar las libreras de OpenGL y el componente
para Borland C++, una vez hecho lo anterior debe copiarse la carpeta de la aplicacin el
directorio C:Simulador.
Una vez hecho esto debe abrirse el proyecto y compilarse la aplicacin.
El proceso de la anexin del driver virtual al programa controlador del dispositivo
fsico se explica en la seccin Driver de este apndice.
A.2. Grcos
Los grcos generados en la aplicacin corresponden a una representacin con guras
simples del robot denominado Mano CENIDET el cual es controlado a travs de una
tarjeta de adquisicin de datos de National Instruments, la cual a su vez es controlada y
programada desde el lenguaje de programacin grca LabVIEW.
La interfaz grca est compuesta principalmente de cuatro partes las cuales se sealan
en la gura A.1 las cuales son:
1. Mens
2. Pestaas de entradas y salidas
109
110
APNDICE A. MANUAL DE USUARIO
3. rea de gracacin
4. Barra de noticaciones
1
2
4
Figura A.1: Partes del simulador grco
En este caso lo referente a los grcos se ejecuta en el apartado 3 del la gura A.1 y
pueden modicarse mediante Ver, el menu contextual que se ejecuta al hacer click derecho
en el area de gracacin y mediante la pestaa de colores que se encargan de modicar
el entorno.
A.2.1. Navegacin
En el entorno de navegacin pueden modicarse los parmetros de:
1. Rotacin
2. Traslacin
3. Zoom
A.3. MODOS
111
Estos parmetros pueden ser modicados desde el men contextual que aparece al
hacer click derecho sobre el area de gracacin. Al accionar cada uno de los modos es
posible mover el punto de vista del observador mediante el arrastre del ratn en la zona
de gracacin logrando as el efecto deseado.
A.2.2. Entorno
Las variables de entorno que pueden ser modicables son las de el color de la luz y
el color del fondo. Estos parmetros son accesibles desde la pestaa de entrada y salida
llamada Colores. Mediante sta se modican ambas variables mediante la paleta colores
en la cual se puede seleccionar cualquiera que sea de eleccin del usuario.
A.3. Modos
Los modos en los cuales el simulador puede operar se reere al ujo y al origen de la
informacin que es requerida para ejecutar la simulacin. Mediante la eleccin del modo
se selecciona el origen y los efectos que la animacin mostrar.
A.3.1. Simulacin
El modo por defecto es el de simulacin, en el cual es posible introducir secuencias
de movimiento en donde la simulacin solo tomar parte en el la interfaz grca y no
repercutir en el prototipo fsico de ninguna forma.
El modo simulacin cuenta con un depurador de movimientos, el cual indica cuando
un movimiento requerido sobrepasa las limitaciones fsicas estimadas previamente (valores
que pueden ser modicados en tiempo de diseo).
Al estar en modo de Simulacin estn habilitados los scripts y las instrucciones va
lnea de comando, las cuales sern ejecutadas instantneamente despus de haber sido
ingresadas. En el caso de los scripts ser necesario habilitar la animacin desde el men Animacin en su opcin de Ejecutar, siendo posible detenerla con la opcin Detener,
lo que genera una pausa la cual puede ser restablecida nuevamente con la opcin Ejecutar.
En la seccin Scripts se explicar la sintaxis que debe ser seguida as como la forma
de cargar un script desde un archivo.
A.3.2. Interpretacin
En este modo es posible recuperar los movimientos reportados por una interfaz controladora en LabVIEW y representarlos grcamente en el area de gracacin en tiempo
112
real (dependiendo de las caractersticas de la computadora residente de las aplicaciones).

Al estar este modo activo es necesario contar con el archivo puente disponible, de lo
contrario provocar un error el cual regresar al modo de Simulacin de forma automtica.
A.3.3. Emisin
En el modo de emisin es posible escribir un comando el cual puede ser ledo por la
aplicacin que ejerce el control al robot, adems de contar con las caractersticas del modo
Interpretacin al momento de la ejecucin del controlador.
Ambos modos de interpretacin y de emisin deben contar con correcta interconexin
en la interfaz en el controlador del Driver Virtual para su funcionamiento.
A.4. Scripts
Los scripts utilizados para el modo de simulacin cuentan con una sintaxis simplicada la cual debe encontrarse en archivos de texto plano con la extensin .rmc haciendo
referencia al Robot Mano CENIDET.
A.4.1. Sintaxis
La sintaxis consiste en la secuencia de las instrucciones de movimiento, las cuales a
su ves estn relacionadas en grupos los cuales tienen su inicio de ejecucin en el mismo
instante.
En el listado A.1 se muestra dicha sintaxis la cual es general tanto para la lnea de
comandos como para los archivos descriptivos.
Listado A.1: Sintaxis de orden de movimiento
mov( dedo , f a l a n g e , angulo , tiempo , grupo de movimiento )
A.4.2. Lnea de comandos

Solo es necesario incluir correctamente la descripcin del movimiento segn la sintaxis
mencionada en el listado A.1 y al nal oprimir enter para ingresar el movimiento deseado
y que ste sea ejecutado instantneamente.
En caso de algn error de sintaxis se noticar en el area de entradas y salidas y
ningn movimiento ser ejecutado.
A.5. DRIVER
113
A.4.3. Archivo descriptivo

Mediante un archivo que contenga el listado de los movimientos a ejecutar es posible cargar el arreglo de parmetros a ser ejecutados por el simulador. Mediante el men
Archivo en su opcin Abrir Script, es posible abrir, cargar y compilar una secuencia de
movimientos determinados.
Si llegara a haber uno o varios errores en el listado de instrucciones se ejecutarn
mensajes en el area de entradas y salidas los cuales indicarn los posibles errores y en que
lnea se encuentran.
Al ser cargada correctamente el listado en la barra de noticacin se indicar el nmero de movimientos cargados y el nombre del archivo del cual fue hecha la extraccin.
Para la ejecucin del movimiento debe accionarse la opcin de Ejecutar del men Animacin y esta tomar parte.
A.5. Driver
El Driver de la aplicacin est compuesto de varios programas los cuales interactan
entre ellos generando la escritura y lectura de archivos intermedios los cuales son ledos y
escritos por aplicaciones independientes.
Para que la interaccin sea posible de forma correcta un programa debe ser adicionado
a aquella aplicacin que genera el control de la aplicacin, y en el caso de ser mediante
LabVIEW dicha interaccin, un subVI debe ser la parte que se adiciona al controlador.
A.5.1. Archivo puente

El archivo puente es aquel que genera la interaccin mencionada previamente y ste
debe de localizase en la carpeta de instalacin, el cual se crea automticamente, pero en
caso de no poder crearse de esta forma puede generarse de forma manual.
Estos archivos puentes llevan los nombres respectivamente de: emision.txt, posiciones.txt
y existe un tercer archivo puente el cual habilita los modos el cual lleva el nombre de:
L-E.txt.
A.5.2. SubVI's en el programa de control

El subVI que debe adicionarse tiene 16 entradas correspondientes a todas las posiciones de las falanges en todos los dedos, y 5 salidas correspondientes a los parmetros
asignables para el modo de emisin, la habilitacin de lectura y escritura dependiendo del
114
modo y una seal de terminacin de la aplicacin.

En la gura A.2 se muestra parte de la interconexin que debe tener el subVI para la
generacin de los archivos puente.
Figura A.2: Interconexon del subVI Driver en el simulador de seales de movimiento

Apendice
Cdigo Fuente
B.1. Principal
1
2
3
4
5
6
7
8
9
10
//
#include <v c l . h>

#pragma h d r s t o p
#include
#include
#include
#include
#include
" Unit1 . h"

" G r a f i c o s C l a s e . h"
" I n t e r p r e t e C l a s e . h"
<math . h>
<s t d i o . h>
11
12
13
14
15
//
#pragma package ( s m a r t _ i n i t )
#pragma l i n k "OpenGLPanel"
#pragma r e s o u r c e " . dfm"
16
17
18
TForm1 Form1 ;
19
20
21
22
23
24
25
26
I n t e r p r e t e t x t ; // I n s t a n c i a de c l a s e d e l i n t e r p r e t e
f l o a t RotX , RotY , RotZ , Tx , Ty , Tz , Zoom=100;

f l o a t Mirx =0, Mfrx =0, Miry =0, Mfry =0, Mirz =0, Mfrz =0, Mitx =0,
Mftx =0, Mity =0, Mfty =0, Mitz =0, Mftz =0, Miz=0, Mfz=0;
bool enR , enT , enZ , enM ;
// H a b i l i t a l a s r o t a c i o n e s ,
t r a s l a c c i o n e s , zoom y e l movimiento de camara
int s e c u e n c i a =10 , a n g u l o =10;
camRot Cam;
27
115
116
28
29
30
31
32
33
34
35
36
APNDICE B. CDIGO FUENTE
G r a f i c o s f i g ; // I n s t a n c i a de c l a s e de l o s g r a f i c o s
f l o a t t e t a [ 1 0 0 ] , a l f a [ 1 0 0 ] , anguloOb [ 1 0 0 ] ;
int e j e [ 1 0 0 ] ;
int nC , nCmax , nV , nVa , nVca , nE , nEC ;

oC Origen ;
f l o a t x0 , y0 , z0 , x , y , z ;
parF Temp , Tempm1 ;
// V a r i a b l e s t e m p o r a l e s con parmetros de l o s
grficos
int i , j , k ;
37
38
39
40
41
42
// V a r i a b l e s de I l u m i n a c i o n y Fondo
G L f l o a t Background [ 4 ] ;
G L f l o a t OColor [ 5 ] ;
int QuaStyle ;
43
44
45
46
47
FILE
FILE
FILE
FILE
HabEscritura ;
Driver ;
Script ;
Emision ;
48
49
50
DatosLinea S a l i d a ;
// Datos o b t e n i d o s de l a l i n e a de comando
o de l a l i n e a de a r c h i v o
bool E r r o r C o m p i l a c i o n ; // Error de c o m p i l a c i o n para a s i g n a r
parametros de una l i n e a , f a l s o l i n e a c o r r e c t a , v e r d a d e r o
linea incorrecta
51
52
53
54
55
56
57
// B u f f e r de d a t o s de Movimiento a s e r e j e c u t a d o s
int dedom [ nDatos ] ;
int falangem [ nDatos ] ;
f l o a t angulom [ nDatos ] ;
f l o a t tiempom [ nDatos ] ;
int grupom [ nDatos ] ;
58
59
60
// V a r i a b l e s para Animacin
f l o a t mA[ 1 0 0 ] ; // Movimiento A c t u a l
61
62
63
64
65
66
// GLuint t e x t u r e ;
GLuint s t a r t L i s t ;
GLUquadricObj q o b j ;
//
67
68
_ _ f a s t c a l l TForm1 : : TForm1 ( TComponent Owner )
B.1. PRINCIPAL
69
70
71
72
73
74
75
76
77
78
117
: TForm( Owner )
{
teta [0]=0;
teta [1]=0;
teta [2]=0;
teta [3]=0;
anguloOb [ 1 ] =0;
anguloOb [ 2 ] =0;
// e j e [ 1 ] = EjeX ;
// e j e [ 2 ] = EjeZ ;
79
80
//Mano
81
82
// Anular
83
84
85
86
87
88
89
f i g . DHo( 1 , 0 , 0 , 0 ) ;
f i g .DH( 1 , 0 , 0
,
f i g .DH( 1 , 1 , 0
,
Numero de Vinculo
f i g .DH( 1 , 2 , 30 ,
Numero de Vinculo
f i g .DH( 1 , 3 , 22 ,
Numero de Vinculo
f i g .DH( 1 , 4 , 22 ,
Numero de Vinculo
,
,
,
,
90
90
a,
90
a,
0
a,
0
a,
,
,
alfa
,
alfa
,
alfa
,
alfa
0
0
,
0
,
0
,
0
,
90
90
a,
90
a,
0
a,
0
a,
,
,
alfa
,
alfa
,
alfa
,
alfa
0
0
,
0
,
0
,
0
,
d,
d,
d,
d,
, 90) ;
, 0) ;
teta
, 0) ;
teta
, 0) ;
teta
, 0) ;
teta
//Numero de Cadena ,
90
91
// Medio
92
93
94
95
96
97
98
f i g . DHo( 2 , 0 , 2 0 , 0 ) ;
f i g .DH( 2 , 0 , 0
,
f i g .DH( 2 , 1 , 0
,
Numero de Vinculo
f i g .DH( 2 , 2 , 30 ,
Numero de Vinculo
f i g .DH( 2 , 3 , 22 ,
Numero de Vinculo
f i g .DH( 2 , 4 , 22 ,
Numero de Vinculo
,
,
,
,
d,
d,
d,
d,
, 90) ;
, 0) ;
teta
, 0) ;
teta
, 0) ;
teta
, 0) ;
teta
99
100
// I n d i c e
101
102
103
104
f i g . DHo( 3 , 0 , 4 0 , 0 ) ;
f i g .DH( 3 , 0 , 0
,
90 ,
0
, 90) ;
f i g .DH( 3 , 1 , 0
,
90 ,
0
, 0) ;
Numero de Vinculo , a , a l f a , d , t e t a
118
105
106
107
f i g .DH( 3 , 2 ,
Numero de
f i g .DH( 3 , 3 ,
Numero de
f i g .DH( 3 , 4 ,
Numero de
30 ,
Vinculo
22 ,
Vinculo
22 ,
Vinculo
90 ,
, a , alfa
0 ,
, a , alfa
0 ,
, a , alfa
0
, 0) ;
, d , teta
0
, 0) ;
, d , teta
0
, 0) ;
, d , teta
108
109
// P u l g a r
110
111
112
113
114
115
116
f i g . DHo( 4 , 0 , 4 0 , 4 0 ) ;
f i g .DH( 4 , 0 , 0
,
f i g .DH( 4 , 1 , 0
,
Numero de Vinculo ,
f i g .DH( 4 , 2 , 30 ,
Numero de Vinculo ,
f i g .DH( 4 , 3 , 22 ,
Numero de Vinculo ,
f i g .DH( 4 , 4 , 22 ,
Numero de Vinculo ,
0
90
a,
90
a,
0
a,
0
a,
,
,
alfa
,
alfa
,
alfa
,
alfa
0
0
,
0
,
0
,
0
,
d,
d,
d,
d,
, 90) ;
, 0) ;
teta
, 0) ;
teta
, 0) ;
teta
, 0) ;
teta
117
118
119
//Palma
120
121
122
123
124
125
126
127
fig
/
fig
fig
fig
fig
fig
. Objeto ( 0 , Caja , 5 , 2 0 , 3 0 , 4 5 , 0 , 0 , 4 0 , 1 0 ) ;
. Objeto (0 , Cilindro ,50 , 100 ,50 ,0 ,0 ,0 ,10 ,30) ;

. O b j e t o ( 0 , Cono , 5 0 , 5 0 , 5 0 , 0 , 0 , 0 , 1 0 , 1 0 ) ;
. O b j e t o ( 0 , E s f e ra , 5 0 , 0 , 5 0 , 0 , 0 , 0 , 1 0 ) ;
. O b j e t o ( 0 , Disco , 5 0 , 5 0 , 5 0 , 0 , 0 , 0 , 1 0 , 1 5 ) ;
. O b j e t o ( 0 , Semidisco , 5 0 , 1 0 0 , 5 0 , 0 , 0 , 0 , 1 0 , 1 5 , 1 , 2 7 0 ) ;
128
129
130
}
//
131
132
133
134
135
136
v o i d _ _ f a s t c a l l TForm1 : : OpenGLPanel1Init ( TObject Sender )

{
// D e c l a r a c i n de T e x t u r a s
BMPTexture BMPTex1 ;
137
138
139
140
141
142
// Paremetros Para G r a f i c a c i n
glPolygonMode (GL_FRONT_AND_BACK, GL_FILL) ;
glShadeModel (GL_SMOOTH) ;
g l E n a b l e (GL_LINE_SMOOTH) ;
g l E n a b l e (GL_BLEND) ;
B.1. PRINCIPAL
143
144
145
119
glBlendFunc (GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA) ;
g l H i n t (GL_LINE_SMOOTH_HINT,GL_NICEST) ;
glLineWidth ( 1 . 5 ) ;
146
147
148
149
// g l E n a b l e (GL_TEXTURE_2D) ;
g l E n a b l e (GL_NORMALIZE) ;
glClearDepth ( 1.0 ) ;
150
151
152
153
154
155
156
157
G L f l o a t Ambient [ 4 ] ;
Ambient [ 0 ] = GetRValue ( ColorToRGB ( L i g h t C o l o r >Brush >Color ) )
/255.0 f ;
Ambient [ 1 ] = GetGValue ( ColorToRGB ( L i g h t C o l o r >Brush >Color ) )
/255.0 f ;
Ambient [ 2 ] = GetBValue ( ColorToRGB ( L i g h t C o l o r >Brush >Color ) )
/255.0 f ;
Ambient [ 3 ] = 1 . 0 ;
GLfloat Diffuse [ ] = {0.8 f , 0.8 f , 0.8 f , 1.0 f };
GLfloat Specular []= {1.0 f , 1.0 f , 1.0 f , 1.0 f };
158
159
160
161
162
g l L i g h t f v ( GL_LIGHT0, GL_AMBIENT, Ambient ) ;

g l L i g h t f v ( GL_LIGHT0, GL_DIFFUSE, D i f f u s e ) ;
g l L i g h t f v ( GL_LIGHT0, GL_SPECULAR, S p e c u l a r ) ;
g l L i g h t M o d e l f (GL_LIGHT_MODEL_TWO_SIDE, 1 . 0 ) ;
163
164
165
g l E n a b l e (GL_LIGHT0) ;
g l E n a b l e (GL_LIGHTING) ;
166
167
168
169
170
Background [ 0 ] = GetRValue ( ColorToRGB ( BackgroundColor >Brush >Color

) ) /255.0 f ;
Background [ 1 ] = GetGValue ( ColorToRGB ( BackgroundColor >Brush >Color
) ) /255.0 f ; ;
Background [ 2 ] = GetBValue ( ColorToRGB ( BackgroundColor >Brush >Color
) ) /255.0 f ; ;
Background [ 3 ] = 1 . 0 ;
171
172
173
174
175
OColor [ 0 ] =
/255.0 f ;
OColor [ 1 ] =
/255.0 f ;
OColor [ 2 ] =
/255.0 f ;
OColor [ 3 ] =
GetRValue ( ColorToRGB ( O b j e c t C o l o r >Brush >Color ) )

GetGValue ( ColorToRGB ( O b j e c t C o l o r >Brush >Color ) )
GetBValue ( ColorToRGB ( O b j e c t C o l o r >Brush >Color ) )
1.0 f ;
176
177
178
g l H i n t (GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST) ;
120
179
BMPTex1=OpenGLPanel1>LoadBMPTexture (" e a r t h . bmp" , t r u e ) ;
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
i f (BMPTex1)
{
BMPTex1>S e t Al p h a ( 1 2 8 ) ;
g l P i x e l S t o r e i (GL_UNPACK_ALIGNMENT, 1) ;
g l T e x P a r a m e t e r i (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP
);
g l T e x P a r a m e t e r i (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP
);
g l T e x P a r a m e t e r i (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
GL_LINEAR) ;
g l T e x P a r a m e t e r i (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
GL_LINEAR) ;
g l T e x E n v i (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL) ;
glTexImage2D (GL_TEXTURE_2D, 0 , BMPTex1>GetComponents ( ) ,
BMPTex1>GetWidth ( ) , BMPTex1>G e t H e i g h t ( ) , 0 ,
BMPTex1>GetFormat ( ) ,BMPTex1>GetType ( ) ,
BMPTex1>G e t P i x e l s ( ) ) ;
}
195
196
197
198
199
200
201
202
203
// GLUquadricObj q o b j ;
G L f l o a t mat_ambient [ ] = { 0 . 5 , 0 . 5 , 0 . 5 , 1 . 0 } ;
G L f l o a t mat_specular [ ] = { 1 . 0 , 1 . 0 , 1 . 0 , 1 . 0 } ;
GLfloat mat_shininess [ ] = { 50.0 };
GLfloat l i g h t _ p o s i t i o n [ ] = { 1.0 , 1.0 , 1.0 , 0.0 };
G L f l o a t model_ambient [ ] = { 0 . 5 , 0 . 5 , 0 . 5 , 1 . 0 } ;
204
205
206
glClearColor (0.2 , 0.2 , 0.2 , 1.0) ;
207
208
209
210
211
212
213
214
215
g l M a t e r i a l f v (GL_FRONT, GL_AMBIENT, mat_ambient ) ;

g l M a t e r i a l f v (GL_FRONT, GL_SPECULAR, mat_specular ) ;
g l M a t e r i a l f v (GL_FRONT, GL_SHININESS, m a t _ s h i n i n e s s ) ;
g l L i g h t f v (GL_LIGHT0, GL_POSITION, l i g h t _ p o s i t i o n ) ;
g l L i g h t M o d e l f v (GL_LIGHT_MODEL_AMBIENT, model_ambient ) ;
g l E n a b l e (GL_LIGHT0) ;
g l E n a b l e (GL_DEPTH_TEST) ;
216
217
218
219
s t a r t L i s t = glGenLists (101) ;
q o b j = gluNewQuadric ( ) ;
B.1. PRINCIPAL
220
221
222
121
g l u Q u a d r i c D r a w S t y l e ( q o b j , GLU_FILL) ;
gluQuadricNormals ( q o b j , GLU_SMOOTH) ;
g l u Q u a d r i c T e x t u r e ( q o b j , GL_TRUE) ;
223
224
225
226
/ D e f i n i c i o n de l a s formas
/
//Formas para cadena
227
228
229
230
231
232
nEC=f i g . nElementosCadenas ( ) ;
for ( i =0; i <nEC ; i ++)
{
Temp = f i g . Cadena ( i ) ;
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
// D e f i n i e n d o Formas para cadena , e s f e r a s de codos y

c i l i n d r o s de b r a z o s
i f (Temp . Tipo == E s f e r a )
{
g l N e w L i s t ( s t a r t L i s t+i , GL_COMPILE) ;
g l u S p h e r e ( qobj , 5 , 1 5 , 5 ) ;
glEndList () ;
}
i f (Temp . Tipo == C i l i n d r o )
{
g l u C y l i n d e r ( qobj , 5 , 5 , Temp . par1 , 1 5 , 5 ) ;
// par1
largo del cilindro
glEndList () ;
// r a d i o s
fijos
}
}
249
250
251
252
253
254
//Formas para o b j e t o s i n d e p e n d i e n t e s
for ( i=nEC ; i <100; i ++)
{
Temp = f i g . G r a f i c a r O b j e t o ( i ) ;
255
256
257
258
259
260
// D e f i n i e n d o Formas
i f (Temp . Tipo == E s f e r a )
{
g l u S p h e r e ( qobj , Temp . par1 , 5 0 , 1 5 ) ;
// par1 r a d i o
122
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297

glEndList () ;
}
e l s e i f (Temp . Tipo == C i l i n d r o )
{
g l u C y l i n d e r ( qobj , Temp . par1 , Temp . par1 , Temp . par2 , 5 0 , 5 ) ;
// par1 r a d i o , par2 a l t o
glEndList () ;
}
e l s e i f (Temp . Tipo == Caja )
{
g l u C y l i n d e r ( qobj , Temp . par1 , Temp . par1 , Temp . par2 , 4 , 5 ) ;
// par1 l a d o , par2 a l t o
glEndList () ;
}
e l s e i f (Temp . Tipo == Cono )
{
g l u C y l i n d e r ( qobj , Temp . par1 , 0 , Temp . par2 , 5 0 , 5 ) ;
//
par1 r a d i o , par2 a l t o
glEndList () ;
}
e l s e i f (Temp . Tipo == Piramide )
{
g l u C y l i n d e r ( qobj , Temp . par1 , 0 , Temp . par2 , 3 , 5 ) ;
//
par1 l a d o , par2 a l t o
glEndList () ;
}
e l s e i f (Temp . Tipo == D i s c o )
{
g l u D i s k ( qobj , Temp . par1 , Temp . par2 , 5 0 , 4 0 ) ;
// par1
r a d i o i n t e r i o r , par2 r a d i o e x t e r i o r
glEndList () ;
}
e l s e i f (Temp . Tipo == S e m i d i s c o )
{
g l u P a r t i a l D i s k ( qobj , Temp . par1 , Temp . par2 , 5 0 , 5 , Temp . par3
, Temp . par4 ) ;
// par1 r a d i o i n t e r i o r , par2 r a d i o
e x t e r i o r , par3
a n g u l o i n i c i a l , par4 p o r c i o n d e l d i s c o
en a n g u l o
glEndList () ;
B.1. PRINCIPAL
123
298
299
300
301
302
// E s f e r a de a r t i c u l a c i o n
303
304
305
306
g l N e w L i s t ( s t a r t L i s t +100 , GL_COMPILE) ;
g l u S p h e r e ( qobj , 5 , 1 5 , 5 ) ;
glEndList () ;
307
308
309
310
311
312
313
314
315
}
//
void _ _ f a s t c a l l TForm1 : : OpenGLPanel1Paint ( TObject Sender )
{
g l C l e a r (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) ;
g l C l e a r C o l o r ( Background [ 0 ] , Background [ 1 ] , Background [ 2 ] ,
Background [ 3 ] ) ;
g l C l e a r (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) ;
316
317
318
319
glPushMatrix ( ) ;
/ Navegacin de l a camara v i r t u a l
/
320
321
322
323
324
325
326
g l R o t a t e f (RotX , 1 . 0 , 0 . 0 , 0 . 0 ) ;
// Rotacion en e l e j e x
g l R o t a t e f (RotY , 0 . 0 , 1 . 0 , 0 . 0 ) ;
// Rotacion en e l e j e y
g l R o t a t e f ( RotZ , 0 . 0 , 0 . 0 , 1 . 0 ) ;
// Rotacion en e l e j e z
g l T r a n s l a t e f (Tx , Ty , Tz ) ;
// T r a s l a c i o n xy
g l S c a l e f (Zoom/ 1 0 0 ,Zoom/ 1 0 0 ,Zoom/ 1 0 0 ) ; //Zoom
g l C o l o r 4 f ( OColor [ 0 ] , OColor [ 1 ] , OColor [ 2 ] , OColor [ 3 ] ) ;
327
328
329
330
331
332
333
334
/ Ejes
/
/
g l B e g i n (GL_LINES) ;
glVertex3i (0.0 ,0.0 ,0.0) ;
glVertex3i (100.0 ,0.0 ,0.0) ;
glColor3f (1.0 ,0.0 ,0.0) ;
glEnd ( ) ;
335
336
337
338
339
glClearColor (1.0 ,1.0 ,0.0 ,0.0) ;
glVertex3i (0.0 ,0.0 ,0.0) ;
glVertex3i (0.0 ,100.0 ,0.0) ;
124
glEnd ( ) ;
340
341
342
343
344
345
346
347
348
glColor3f (0.0 ,0.0 ,1.0) ;
glVertex3i (0.0 ,0.0 ,0.0) ;
glVertex3i (0.0 ,0.0 ,100.0) ;
glEnd ( ) ;
/
/ Dibujado de l a s Formas
/
349
350
351
352
glShadeModel (GL_SMOOTH) ;
353
354
355
/ Dibujado de Cadenas
/
356
357
358
nCmax = f i g . nCa ( ) ;
359
for (nC=1; nC<=nCmax ; nC++)
360
361
dibujada
nVca = f i g . nVC(nC) ;
en l a cadena
//nmero de l a cadena
// C a l c u l o de numero de v i n c u l o s
362
363
364
365
366
367
368
369
370
371
372
373
glPushMatrix ( ) ;
for (nV=1; nV<=nVca ; nV++)
//nVa numero de v i n c u l o
a c t u a l ; nVca numero de v i n c u l o s de l a cadena a c t u a l
{
nE = f i g . nElemento (nC , nV) ;
i f (nV == 1 )
{
Origen = f i g . GetO (nC) ;
g l T r a n s l a t e f ( Origen . y , Origen . z , Origen . x ) ;
Coordenada i n i c i a l de l a cadena
}
374
375
Temp = f i g . Cadena (nE1) ;
376
377
378
g l R o t a t e f (Temp . par2 , 0 . 0 , 0 . 0 , 1 . 0 ) ;
g l T r a n s l a t e f ( 0 , 0 , Temp . par1 ) ;
// a l f a ( x )
// a ( x )
//
B.1. PRINCIPAL
g l T r a n s l a t e f ( 0 , Temp . par3 , 0 ) ;
g l R o t a t e f (Temp . par4 , 0 . 0 , 1 . 0 , 0 . 0 ) ;
379
380
125
// d ( z )
// t e t a ( z )
381
g l C a l l L i s t ( s t a r t L i s t+nE) ;
g l C a l l L i s t ( s t a r t L i s t +100) ;
// O b j e t o 100 e s f e r a de
enlace entre vinculos
gl u Q ua d r ic D r aw S t y le ( qobj , GLU_FILL) ;
gluQuadricNormals ( qobj , GLU_SMOOTH) ;
g l u Q u a d r i c T e x t u r e ( qobj , GL_TRUE) ;
382
383
384
385
386
387
i f (nV == nVca )
388
389
390
391
392
393
{
g l T r a n s l a t e f ( 0 , Temp . par3 , Temp . par1 ) ;
esfera del ultimo eslabon
g l C a l l L i s t ( s t a r t L i s t +100) ;
}
//
394
glPopMatrix ( ) ;
395
396
397
/ Dibujado de O b j e t o s Simples
/
398
399
400
401
402
k = f i g . nElementosCadenas ( ) ;
for ( k ; k<=99 ; k++)
// o > numero de O b j e t o d i b u j a d o
{
Temp = f i g . G r a f i c a r O b j e t o ( k ) ;
403
404
405
406
407
408
409
410
411
glPushMatrix ( ) ;
g l T r a n s l a t e f (Temp . y , Temp . z , Temp . x ) ;
Coordenada d e l o b j e t o
g l R o t a t e f (Temp . Rx , 0 . 0 , 0 . 0 , 1 . 0 ) ;
Giro s o b r e e j e x
g l R o t a t e f (Temp . Ry , 1 . 0 , 0 . 0 , 0 . 0 ) ;
Giro s o b r e e j e y
g l R o t a t e f (Temp . Rz , 0 . 0 , 1 . 0 , 0 . 0 ) ;
Giro s o b r e e j e z
g l C a l l L i s t ( s t a r t L i s t+k ) ;
glPopMatrix ( ) ;
412
413
/ Tapas de l a Palma /
414
415
416
g l V e r t e x 3 i ( 8 , 2 ,5) ;
//
//
//
//
126

g l V e r t e x 3 i (48 , 2 ,5) ;
g l V e r t e x 3 i (48 , 58 ,5) ;
g l V e r t e x 3 i ( 8 , 58 ,5) ;
glEnd ( ) ;
417
418
419
420
421
g l V e r t e x 3 i ( 8, 2, 5) ;
g l V e r t e x 3 i (48 , 2 , 5) ;
g l V e r t e x 3 i (48 , 58 , 5) ;
g l V e r t e x 3 i ( 8 , 58 , 5) ;
glEnd ( ) ;
}
422
423
424
425
426
427
428
429
430
// Piso de r e j i l l a
431
432
GLfloat fExtent = 500.0 f ;

GLfloat fStep = 10.0 f ;
G L f l o a t y = 80.0 f ;
GLint i L i n e ;
433
434
435
436
437
for ( i L i n e = f E x t e n t ; i L i n e <= f E x t e n t ; i L i n e += f S t e p )
{
glVertex3f ( iLine , y , fExtent ) ;
g l V e r t e x 3 f ( i L i n e , y, f E x t e n t ) ;
438
439
440
441
442
443
g l V e r t e x 3 f ( fExtent , y , i L i n e ) ;
g l V e r t e x 3 f ( f E x t e n t , y , i L i n e ) ;
444
445
}
glEnd ( ) ;
446
447
448
449
450
451
452
453
454
455
456
457
458
459
glPopMatrix ( ) ;
glFlush () ;
}
//
void _ _ f a s t c a l l TForm1 : : OpenGLPanel1Resize ( TObject Sender )
int w, h ;
w = OpenGLPanel1>Width ;
h = OpenGLPanel1>Height ;
460
461
g l V i e w p o r t ( 0 , 0 , ( G L s i z e i ) w, ( G L s i z e i ) h ) ;
B.1. PRINCIPAL
462
463
464
465
glMatrixMode (GL_PROJECTION) ;
glLoadIdentity () ;
i f (w <= h )
g l O r t h o ( 150 , 1 5 0 , 150 ( G L f l o a t ) h / ( G L f l o a t )w, 1 5 0 ( G L f l o a t ) h

/ ( G L f l o a t )w, 500.0 , 5 0 0 . 0 ) ;
466
467
127
else
g l O r t h o ( 150 ( G L f l o a t )w/ ( G L f l o a t ) h , 1 5 0 ( G L f l o a t )w/ ( G L f l o a t ) h ,

150 , 1 5 0 , 500.0 , 5 0 0 . 0 ) ;
468
469
470
471
472
473
glMatrixMode (GL_MODELVIEW) ;
glLoadIdentity () ;
}
//
474
475
476
477
478
479
480
481
482
void _ _ f a s t c a l l TForm1 : : R ot xC l ic k ( TObject Sender )
{
enR = on ;
enT = o f f ;
enZ = o f f ;
f i g . Camara (LIBRE) ;
}
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
//
void _ _ f a s t c a l l TForm1 : : OpenGLPanel1MouseDown ( TObject Sender ,

TMouseButton Button , T S h i f t S t a t e S h i f t , int X, int Y)
enM = on ;
i f ( enR == on )
{
Mirx = Mfrx + Y;
Miry = Mfry + X;
// Mirz = Mfrz + Y s i n ( Mfrx RADtoDEG) + X s i n ( Mfry RADtoDEG) ;
Form1>StatusBar1 >Panels >Items [0] > Text = " Rotando " ;
}
i f ( enT == on )
{
Mitx
=
Mity
=
= Mftx
Mftx +
= Mfty
Mfty +
+
X
+
Y
X;
// c o s ( RotY DOSPI/360) >= 0 ? Mitx
: Mitx = Mftx X;
Y;
// c o s ( RotX DOSPI/360) >= 0 ? Mity
: Mity = Mfty Y;
128
Mitz = Mftz + X s i n ( RotY DOSPI/ 3 6 0 ) + Y s i n ( RotX DOSPI/ 3 6 0 ) ;

Form1>StatusBar1 >Panels >Items [0] > Text = " Trasladando " ;
}
503
504
505
506
507
i f ( enZ == on )
{
Miz = Y + Mfz ;
Form1>StatusBar1 >Panels >Items [0] > Text = "Zoom" ;
}
508
509
510
511
512
513
514
515
516
517
518
519
520
521
}
//
void _ _ f a s t c a l l TForm1 : : OpenGLPanel1MouseMove ( TObject Sender ,

T S h i f t S t a t e S h i f t , int X, int Y)
i f (enM == on && enR == on )

{
522
523
524
RotX = Mirx Y; //Y s i n ( RotX RADtoDEG) Y0 ;

RotY = Miry X; //X s i n ( RotY RADtoDEG) X0 ;
// RotZ = Mirz Y s i n ( RotX RADtoDEG) X s i n ( RotY RADtoDEG
);
525
Mfrx = RotX ;
Mfry = RotY ;
// Mfrz = RotZ ;
526
527
528
529
530
531
532
533
534
535
536
OpenGLPanel1>Repaint ( ) ;
Form1>StatusBar1 >Panels >Items [3] > Text = " P o s i c i n d e l
Eje ( " + F l o a t T o S t r (Tx) + " , " + F l o a t T o S t r (Ty) + " , "
+ F l o a t T o S t r ( Tz ) + " ) " ;
Form1>StatusBar1 >Panels >Items [2] > Text = " ngulo d e l
Eje ( " + F l o a t T o S t r ( RotX ) + " , " + F l o a t T o S t r ( RotY ) + "
, " + F l o a t T o S t r ( RotZ ) + " ) " ;
i f (enM == on && enT == on )
537
538
539
540
c o s ( RotY DOSPI/ 3 6 0 ) >= 0 ? Tx = Mitx X : Tx = Mitx + X;

c o s ( RotX DOSPI/ 3 6 0 ) >= 0 ? Ty = Mity Y : Ty = Mitx + Y;
Tz = Mitz X s i n ( RotY DOSPI/ 3 6 0 ) Y s i n ( RotX DOSPI/ 3 6 0 ) ;
541
542
c o s ( RotY DOSPI/ 3 6 0 ) >= 0 ? Mftx = Tx : Mftx = Tx ;
B.1. PRINCIPAL
129
c o s ( RotX DOSPI/ 3 6 0 ) >= 0 ? Mfty = Ty : Mfty = Ty ;

Mftz=Tz ;
543
544
545
Form1>StatusBar1 >Panels >Items [3] > Text = " P o s i c i n de
Cmara ( " + F l o a t T o S t r (Tx) + " , " + F l o a t T o S t r (Ty) + " , "
+ F l o a t T o S t r ( Tz ) + " ) " ;
Form1>StatusBar1 >Panels >Items [2] > Text = " ngulo de
Cmara ( " + F l o a t T o S t r ( RotX ) + " , " + F l o a t T o S t r ( RotY ) +
")" ;
546
547
548
549
550
551
i f (enM == on && enZ == on )
552
553
554
556
557
558
559
else
560
{
Zoom = 0 . 1 ;
Mfz = Zoom ;
}
Form1>StatusBar1 >Panels >Items [3] > Text = "Zoom : " +
F l o a t T o S t r (Zoom/ 1 0 0 ) + "x" ;
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
i f ( Mfz > 0 )
{
Miz Y < 0 ? Zoom = 0 : Zoom = MizY;
Mfz = Zoom ;
}
555
}
}
//
void _ _ f a s t c a l l TForm1 : : OpenGLPanel1MouseUp ( TObject Sender ,

enM = o f f ;
RotX = int ( RotX ) % 3 6 0 ;
RotY = int ( RotY ) % 3 6 0 ;
RotZ = int ( RotZ ) % 3 6 0 ;
Mfrx = RotX ;
Mfry = RotY ;
Mfrz = RotZ ;
580
581
582
Form1>StatusBar1 >Panels >Items [0] > Text = "" ;
130
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603

}
//
void _ _ f a s t c a l l TForm1 : : Zoom2Click ( TObject Sender )
{
enR = o f f ;
enT = o f f ;
enZ = on ;
}
//
void _ _ f a s t c a l l TForm1 : : Timer1Timer ( TObject Sender )
{
/ Encargado de Generar l o s i n t e r v a l o s de animacin y de
redibujar las posiciones
a c t u a l e s en modo de S i m u l a c i n /
int n=0;
//Nmero e l e m e n t o de movimento
int gMa=1;
//Grupo de Movimiento A c t u a l
f l o a t d i f f = 0 ; //Rango de d i f e r e n c i a e n t r e e l a n g u l o o b t e n i d o
para d e t e n e r animacin
604
605
606
607
608
609
Timer1>I n t e r v a l = TA;
for ( n=0;n <100;n++)

{
i f ( grupom [ n]==gMa)
{
f i g . MovimientoTeta ( dedom [ n ] , falangem [ n ] ,mA[ n ] , tiempom [ n ] ,
grupom [ n ] ) ;
d i f f = abs ( angulom [ n] mA[ n ] ) ;
/ Form1>StatusBar1 >Panels >Items [0] > Text = d i f f ;
Form1>StatusBar1 >Panels >Items [1] > Text = mA[ n ] ;
Form1>StatusBar1 >Panels >Items [2] > Text = grupom [ n ] ;
Form1>StatusBar1 >Panels >Items [3] > Text = gMa ;
/
610
611
612
613
614
615
616
617
i f ( d i f f > STOPANI)
618
mA[ n]= mA[ n ] + tiempom [ n ] ; // Incremento de n g u l o

c o r r e s p o n d i e n t e a l tiempo e l e g i d o para a c t u a r
619
else
620
621
622
623
gMa++;
B.1. PRINCIPAL
624
625
626
627
628
629
}
//
void _ _ f a s t c a l l TForm1 : : F r o n t a l 2 C l i c k ( TObject Sender )
630
631
632
633
634
635
636
void _ _ f a s t c a l l TForm1 : : P o s t e r i o r 2 C l i c k ( TObject Sender )
638
640
641
642
643
Form1>StatusBar1 >Panels >Items [3] > Text = " V i s t a

Posterior " ;
f i g . Camara (POSTERIOR) ;
}
//
void _ _ f a s t c a l l TForm1 : : S u p e r i o r 2 C l i c k ( TObject Sender )
644
645
646

Frontal " ;
f i g . Camara (FRONTAL) ;
}
//
637
639
131

Superior " ;
f i g . Camara (SUPERIOR) ;
647
648
649
650
651
//
void _ _ f a s t c a l l TForm1 : : I n f e r i o r 2 C l i c k ( TObject Sender )
652
653
654
655
656
657
658
659
660
661
662
663

Inferior" ;
f i g . Camara (INFERIOR) ;
}
//
void _ _ f a s t c a l l TForm1 : : L a t e r a l D e r e c h a 2 C l i c k ( TObject Sender )

L a t e r a l Derecha " ;
f i g . Camara (DERECHA) ;
}
//
132
664
665
void _ _ f a s t c a l l TForm1 : : L a t e r a l I z q u i e r d a 2 C l i c k ( TObject Sender )
666
667
668
669
670
671
672
void _ _ f a s t c a l l TForm1 : : I s o m e t r i c a C l i c k ( TObject Sender )
674
676
677
678
679
680
681

Lateral Izquierda " ;
f i g . Camara (DERECHA) ;
}
//
673
675

Isomtrica " ;
f i g . Camara (ISOMETRICA) ;
}
//
void _ _ f a s t c a l l TForm1 : : D i m t r i c a 1 C l i c k ( TObject Sender )
{
Dimtrica " ;
f i g . Camara (DIMETRICA) ;
}
682
683
684
685
//
void _ _ f a s t c a l l TForm1 : : T r m e t r i c a 1 C l i c k ( TObject Sender )
686
687
688
689
690
691
692
693
694
695
696
697
698
Form1>StatusBar1 >Panels >Items [3] > Text = " V i s t a T r i m t r i c a "

;
f i g . Camara (TRIMETRICA) ;
}
//
void _ _ f a s t c a l l TForm1 : : T r a s l a d a r 2 C l i c k ( TObject Sender )
{
enR = o f f ;
enT = on ;
enZ = o f f ;
}
//
699
700
701
702
703
704
void _ _ f a s t c a l l TForm1 : : TimerVistasTimer ( TObject Sender )
int V i s t a ;
Cam = f i g . Camara ( ) ;
B.1. PRINCIPAL
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
V i s t a = Cam.V;
i f ( V i s t a == FRONTAL)
i f ( RotX < 0 )
RotX++;
i f ( RotX > 0 )
RotX;
i f ( RotY < 0 )
RotY++;
i f ( RotY > 0 )
RotY;
i f ( RotZ < 0 )
RotZ++;
i f ( RotZ > 0 )
RotZ ;
Mfrx = RotX ;
Mfry = RotY ;
}
i f ( V i s t a == POSTERIOR)
{
i f ( RotX < 0 )
RotX++;
i f ( RotX > 0 )
RotX;
i f ( RotY < 1 8 0 )
RotY++;
i f ( RotY > 1 8 0 )
RotY;
i f ( RotZ < 0 )
RotZ++;
i f ( RotZ > 0 )
RotZ ;
Mfrx = RotX ;
Mfry = RotY ;
}
i f ( V i s t a == SUPERIOR)
{
i f ( RotX < 9 0 )
RotX++;
i f ( RotX > 9 0 )
RotX;
i f ( RotY < 0 )
133
134
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
RotY++;
i f ( RotY > 0 )
RotY;
i f ( RotZ < 0 )
RotZ++;
i f ( RotZ > 0 )
RotZ ;
Mfrx = RotX ;
Mfry = RotY ;
}
i f ( V i s t a == INFERIOR)
{
i f ( RotX < 90)
RotX++;
i f ( RotX > 90)
RotX;
i f ( RotY < 0 )
RotY++;
i f ( RotY > 0 )
RotY;
i f ( RotZ < 0 )
RotZ++;
i f ( RotZ > 0 )
RotZ ;
Mfrx = RotX ;
Mfry = RotY ;
}
i f ( V i s t a == DERECHA)
{
i f ( RotX < 0 )
RotX++;
i f ( RotX > 0 )
RotX;
i f ( RotY < 9 0 )
RotY++;
i f ( RotY > 9 0 )
RotY;
i f ( RotZ < 0 )
RotZ++;
i f ( RotZ > 0 )
RotZ ;
Mfrx = RotX ;
Mfry = RotY ;
B.1. PRINCIPAL
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
}
i f ( V i s t a == IZQUIERDA)
{
i f ( RotX < 0 )
RotX++;
i f ( RotX > 0 )
RotX;
i f ( RotY < 90)
RotY++;
i f ( RotY > 90)
RotY;
i f ( RotZ < 0 )
RotZ++;
i f ( RotZ > 0 )
RotZ ;
Mfrx = RotX ;
Mfry = RotY ;
}
i f ( V i s t a == ISOMETRICA)
{
i f ( RotX < 30)
RotX++;
i f ( RotX > 30)
RotX;
i f ( RotY < 4 5 )
RotY++;
i f ( RotY > 4 5 )
RotY;
i f ( RotZ < 0 )
RotZ++;
i f ( RotZ > 0 )
RotZ ;
Mfrx = RotX ;
Mfry = RotY ;
}
i f ( V i s t a == DIMETRICA)
i f ( RotX < 10)

RotX++;
i f ( RotX > 10)
RotX;
135
136
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
i f ( RotY < 3 0 )
RotY++;
i f ( RotY > 3 0 )
RotY;
i f ( RotZ < 0 )
RotZ++;
i f ( RotZ > 0 )
RotZ ;
Mfrx = RotX ;
Mfry = RotY ;
}
i f ( V i s t a == TRIMETRICA)
{
i f ( RotX < 20)
RotX++;
i f ( RotX > 20)
RotX;
i f ( RotY < 2 0 )
RotY++;
i f ( RotY > 2 0 )
RotY;
i f ( RotZ < 0 )
RotZ++;
i f ( RotZ > 0 )
RotZ ;
Mfrx = RotX ;
Mfry = RotY ;
}
870
871
872
}
//
873
874
875
876
877
878
879
880
881
882
883
884
void _ _ f a s t c a l l TForm1 : : Animacion1Click ( TObject Sender )

{
teta [0]=0;
teta [1]=90;
teta [2]=0;
teta [3]=0;
teta [4]=0;
teta [5]=0;
f i g . MovimientoTeta ( 1 , 0 , t e t a [ 0 ] , 0 , 0 ) ;
B.1. PRINCIPAL
885
886
887
888
889
fig
fig
fig
fig
fig
. MovimientoTeta ( 1 , 2 , t e t a [ 2 ]
137
,0
,0
,0
,0
,0
,0)
,0)
,0)
,0)
,0)
;
;
;
;
;
890
891
secuencia = 1;
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
}
//
void _ _ f a s t c a l l TForm1 : : I n i c i a l 1 C l i c k ( TObject Sender )

{
teta [0]=0;
teta [1]=90;
teta [2]=0;
teta [3]=0;
teta [4]=0;
teta [5]=0;
912
913
914
915
}
916
917
918
919
920
921
922
923
924
925
926
927
//
void _ _ f a s t c a l l TForm1 : : A b r i r S c r i p t C l i c k ( TObject Sender )
{
i f ( S i m u l a c i o n >Checked )
{
A n s i S t r i n g Path , n E r r o r e s ;
i =0;
int n E r r o r e s i n t =0; //Numero de E r r o r e s e n c o n t r a d o s
int lAc =0;
// Linea A c t u a l
char l i n e a [ 5 0 ] ; // B u f f e r de Linea A c t u a l
ErrorCompilacion = false ;
928
929
t x t . i n i D a t o s ( dedom , falangem , angulom , tiempom , grupom ) ;
//
138
I n i c i a l i z a l o s parametros para e l movimiento

930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
i f ( OpenDialog1 >Execute ( ) )
{
Path = OpenDialog1 >FileName ;
d e l Archivo a Path
// Asigna l a D i r e c c i n
i f ( ( S c r i p t = f o p e n ( Path . c _ s t r ( ) , " r " ) ) == NULL)
Se v e r i f i c a que l a d i r e c c i n d e l a r c h i v o s e a v l i d a
RichEdit1 >L i n e s >Add( ">>El a r c h i v o " + Path + " no
pudo s e r a b i e r t o " ) ;
//
else
{
RichEdit1 >L i n e s >Add( ">>El a r c h i v o " + Path + " ha
sido abierto ") ;
while ( ! f e o f ( S c r i p t ) )
// Rutina
para e x t r a e r l a s l i n e a s de un a r c h i v o una por una
{
lAc++;
fgets ( linea ,50 , Script ) ;
S a l i d a = t x t . mov( l i n e a ) ;
//
Funcion d e l I n t e r p r e t e
i f ( S a l i d a . p a l a b r a == 1)
{
RichEdit1 >L i n e s >Add( " E r r o r : Comando o
s i n t x i s i n v l i d a en l n e a " + I n t T o S t r (
lAc ) ) ;
E r r o r C o m p i l a c i o n = true ;
n E r r o r e s i n t ++;
}
i f ( S a l i d a . dedo == 0 )
{
RichEdit1 >L i n e s >Add( " E r r o r : Nombre de dedo
i n v l i d o en l n e a " + I n t T o S t r ( lAc ) ) ;
}
i f ( S a l i d a . f a l a n g e == 0 )
{
RichEdit1 >L i n e s >Add( " E r r o r : Nombre de
f a l a n g e i n v l i d o en l n e a " + I n t T o S t r (
lAc ) ) ;
B.1. PRINCIPAL
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
139
}
i f ( S a l i d a . a n g u l o == 1 0 0 0 0 0 0 )
{
RichEdit1 >L i n e s >Add( " E r r o r : Valor de n g u l o
}
i f ( S a l i d a . tiempo == 1 0 0 0 0 0 0 )
{
RichEdit1 >L i n e s >Add( " E r r o r : Valor de tiempo
}
i f ( S a l i d a . grupo == 1 0 0 0 0 0 0 )
{
RichEdit1 >L i n e s >Add( " E r r o r : Valor de grupo
}
i f ( S a l i d a . f a l a n g e == p r o x i m a l && ( S a l i d a . a n g u l o
> MaxProximal | | S a l i d a . a n g u l o < MinProximal )

)
// C o n d i c i o n e s de Angulos mximos por
cada f a l a n g e
{
RichEdit1 >L i n e s >Add( " E r r o r : No e s p o s i b l e
a l c a n z a r e s e n g u l o en l n e a " + I n t T o S t r
( lAc ) ) ;
}
i f ( S a l i d a . f a l a n g e == media && ( S a l i d a . a n g u l o >
MaxMedia | | S a l i d a . a n g u l o < MinMedia ) )
{
( lAc ) ) ;
}
i f ( S a l i d a . f a l a n g e == d i s t a l && ( S a l i d a . a n g u l o >
MaxDistal | | S a l i d a . a n g u l o < M i n D i s t a l ) )
140
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011

{
( lAc ) ) ;
}
i f ( S a l i d a . f a l a n g e == a b d u c c i o n && ( S a l i d a .
a n g u l o > MaxAbduccion | | S a l i d a . a n g u l o <
MinAbduccion ) )
{
( lAc ) ) ;
}
i f ( E r r o r C o m p i l a c i o n == f a l s e )
{
f l o a t a0 , d i f f A n g u l o ;
f l o a t I ,M;
f l o a t t a =0; // I n t e r v a l o en s e g u n d o s
1012
1013
t a=TA/ 1 0 0 0 . 0 ;
1014
1015
1016
1017
1018
1019
dedom [ lAc ] = S a l i d a . dedo ;

falangem [ lAc ] = S a l i d a . f a l a n g e ;
angulom [ lAc ] = S a l i d a . a n g u l o ;
tiempom [ lAc ] = S a l i d a . tiempo ;
grupom [ lAc ] = S a l i d a . grupo ;
1020
1021
1022
1023
1024
1025
1026
a0=f i g . angActual ( dedom [ lAc ] , falangem [ lAc ] ) ;

// Angulo A c t u a l
mA[ lAc ]= a0 ;
// El
movimiento a c t u a l s e i g u a l a a l a n g u l o
inicial
d i f f A n g u l o = angulom [ lAc ] a0 ;
// D i f e r e n c i a de a n g u l o s
I=tiempom [ lAc ] / t a ;
M=d i f f A n g u l o / I ;
tiempom [ lAc ] = M;
// El tiempo s e
c o n v i e r t e en l a c a n t i d a d de movimiento
que d e b e h a b e r por i n t e r v a l o
B.1. PRINCIPAL
}
I n s t r u c c i o n >Text = " " ;
} // w h i l e
fclose ( Script ) ;
} // e l s e
} // i f que a b r e e l open d i a l o g
1027
1028
1029
1030
1031
1032
1033
i f ( E r r o r C o m p i l a c i o n == true )
1034
{
nErrores = nErroresint ;
Form1>StatusBar1 >Panels >Items [1] > Text = " E r r o r e s
encontrados : " + nErrores ;
}
1035
1036
1037
1038
1039
1040
else
1041
{
RichEdit1 >L i n e s >Add( " Compilacin E x i t o s a " ) ;
Form1>StatusBar1 >Panels >Items [1] > Text = " S c r i p t " +
Path + " c a r g a d o " ;
Form1>StatusBar1 >Panels >Items [2] > Text = I n t T o S t r ( lAc ) +
" movimientos c a r g a d o s " ;
Form1>Timer1>Enabled= f a l s e ;
}
1042
1043
1044
1045
1046
1047
1048
1049
141
else
RichEdit1 >L i n e s >Add( " A d v e r t e n c i a : Modo de i n t e r p r e t a c i n

a c t i v a d o , no e s p o s i b l e c a r g a r S c r i p t " ) ;
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
void _ _ f a s t c a l l TForm1 : : E j e c u t a r C l i c k ( TObject Sender )
Form1>Timer1>Enabled = true ;
}
//
void _ _ f a s t c a l l TForm1 : : D e t e n e r C l i c k ( TObject Sender )
Form1>Timer1>Enabled = f a l s e ;
}
//
1065
1066
1067
void _ _ f a s t c a l l TForm1 : : FondoClick ( TObject Sender )
142
1068
1069
1070
i f ( C o l o r D i a l o g 1 >Execute ( ) )
1071
1072
1073
1074
1075
glClearColor (1.0 , 1.0 , 0.0 , 0.0) ;

}
}
//
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
void _ _ f a s t c a l l TForm1 : : I n s t r u c c i o n K e y P r e s s ( TObject Sender ,

char &Key )
/ Funciones de Compilador
/
I n i c i a l i z a l o s parametros para e l movimiento
//
i f ( Key == VK_RETURN)
{
i f ( S i m u l a c i o n >Checked )
{
RichEdit1 >L i n e s >Add( ">>" + I n s t r u c c i o n >Text ) ;
char comando = new char [ I n s t r u c c i o n >Text . Length ( ) + 1
];
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
s t r c p y ( comando , I n s t r u c c i o n >Text . c _ s t r ( ) ) ;
// Copia
y c o n v i e r t e a char l a cadena de I n s t r u c c i o n en
comando
S a l i d a = t x t . mov( comando ) ;
//
Funcion d e l I n t e r p r e t e t x t e s l a i n s t a n c i a de c l a s e
i f ( S a l i d a . p a l a b r a == 1)
{
RichEdit1 >L i n e s >Add( " E r r o r : Comando o s i n t x i s
invlida ") ;
}
i f ( S a l i d a . dedo == 0 )
{
RichEdit1 >L i n e s >Add( " E r r o r : Nombre de dedo i n v l i d o "
);
}
B.1. PRINCIPAL
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
143
i f ( S a l i d a . f a l a n g e == 0 )
{
RichEdit1 >L i n e s >Add( " E r r o r : Nombre de f a l a n g e
invlido ") ;
}
i f ( S a l i d a . a n g u l o == 1 0 0 0 0 0 0 )
{
RichEdit1 >L i n e s >Add( " E r r o r : Valor de n g u l o i n v l i d o
") ;
}
i f ( S a l i d a . tiempo == 1 0 0 0 0 0 0 )
{
RichEdit1 >L i n e s >Add( " E r r o r : Valor de tiempo i n v l i d o
") ;
}
i f ( S a l i d a . grupo == 1 0 0 0 0 0 0 )
{
RichEdit1 >L i n e s >Add( " E r r o r : Valor de grupo i n v l i d o "
);
}
i f ( S a l i d a . f a l a n g e == p r o x i m a l && ( S a l i d a . a n g u l o >
MaxProximal | | S a l i d a . a n g u l o < MinProximal ) )

// C o n d i c i o n e s de Angulos mximos por cada f a l a n g e
{
RichEdit1 >L i n e s >Add( " E r r o r : No e s p o s i b l e a l c a n z a r
ese ngulo " ) ;
}
i f ( S a l i d a . f a l a n g e == media && ( S a l i d a . a n g u l o > MaxMedia
| | S a l i d a . a n g u l o < MinMedia ) )
{
ese ngulo " ) ;
}
i f ( S a l i d a . f a l a n g e == d i s t a l && ( S a l i d a . a n g u l o >
MaxDistal | | S a l i d a . a n g u l o < M i n D i s t a l ) )
{
ese ngulo " ) ;
144
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150

}
i f ( S a l i d a . f a l a n g e == a b d u c c i o n && ( S a l i d a . a n g u l o >
MaxAbduccion | | S a l i d a . a n g u l o < MinAbduccion ) )
{
ese ngulo " ) ;
}
{
f l o a t a0 , d i f f A n g u l o ;
f l o a t I ,M;
f l o a t t a =0; // I n t e r v a l o en s e g u n d o s
1151
1152
t a=TA/ 1 0 0 0 . 0 ;
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
RichEdit1 >L i n e s >Add( S a l i d a . dedo ) ;

RichEdit1 >L i n e s >Add( S a l i d a . f a l a n g e ) ;
RichEdit1 >L i n e s >Add( S a l i d a . a n g u l o ) ;
RichEdit1 >L i n e s >Add( S a l i d a . tiempo ) ;
RichEdit1 >L i n e s >Add( S a l i d a . grupo ) ;
dedom [ 0 ] = S a l i d a . dedo ;
falangem [ 0 ] = S a l i d a . f a l a n g e ;
angulom [ 0 ] = S a l i d a . a n g u l o ;
tiempom [ 0 ] = S a l i d a . tiempo ;
grupom [ 0 ] = S a l i d a . grupo ;
1164
1165
1166
1167
1168
1169
1170
1171
1172
a0=f i g . angActual ( dedom [ 0 ] , falangem [ 0 ] ) ; // Angulo

Actual
mA[ 0 ] = a0 ;
// El movimiento
act ual se i g u a l a a l angulo i n i c i a l
d i f f A n g u l o = angulom [0] a0 ;
// D i f e r e n c i a de
angulos
I=tiempom [ 0 ] / t a ;
M=d i f f A n g u l o / I ;
tiempom [ 0 ] = M; // El tiempo s e c o n v i e r t e en l a
c a n t i d a d de movimiento que d e b e h a b e r por
intervalo
}
1173
1174
1175
I n s t r u c c i o n >Text = " " ;

}
B.1. PRINCIPAL
else
1176
RichEdit1 >L i n e s >Add( " A d v e r t e n c i a : Modo de

i n t e r p r e t a c i n a c t i v a d o , no e s p o s i b l e e j e c u t a r
instruccin ") ;
1177
}
1178
1179
1180
1181
1182
1183
1184
1185
}
//
void _ _ f a s t c a l l TForm1 : : LightColorMouseUp ( TObject Sender ,

1186
{
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1205
1206
1207
1208
1209
1210
1211
GLfloat
Ambient [ 4 ] ;
L i g h t C o l o r >Brush>C o l o r = C o l o r D i a l o g 1 >C o l o r ;
Ambient [ 0 ] = GetRValue ( ColorToRGB ( L i g h t C o l o r >Brush>C o l o r ) )
/255.0 f ;
Ambient [ 1 ] = GetGValue ( ColorToRGB ( L i g h t C o l o r >Brush>C o l o r ) )
/255.0 f ;
Ambient [ 2 ] = GetBValue ( ColorToRGB ( L i g h t C o l o r >Brush>C o l o r ) )
/255.0 f ;
Ambient [ 3 ] = 1 . 0 f ;
OpenGLPanel1>MakeOpenGLPanelCurrent ( ) ;
g l L i g h t f v ( GL_LIGHT0, GL_AMBIENT, Ambient ) ;
OpenGLPanel1>MakeOpenGLPanelNotCurrent ( ) ;
}
}
//
void _ _ f a s t c a l l TForm1 : : ObjectColorMouseUp ( TObject Sender ,
1203
1204
145
TMouseButton Button ,
T S h i f t S t a t e S h i f t , int X, int Y)
{
Obj ec tCo lo r >Brush>C o l o r = C o l o r D i a l o g 1 >C o l o r ;

OColor [ 0 ] = GetRValue ( ColorToRGB ( O bj ec tC ol or >Brush>C o l o r )
) /255.0 f ;
OColor [ 1 ] = GetGValue ( ColorToRGB ( Ob je ct Co lo r >Brush>C o l o r )
) /255.0 f ;
OColor [ 2 ] = GetBValue ( ColorToRGB ( Ob je ct Col or >Brush>C o l o r )
) /255.0 f ;
OColor [ 3 ] = 1 . 0 f ;
146
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
}
//
void _ _ f a s t c a l l TForm1 : : BackgroundColorMouseUp ( TObject Sender ,

{
1222
1223
1224
1225
1226
1227
1228
1229
1230
BackgroundColor >Brush>C o l o r = C o l o r D i a l o g 1 >C o l o r ;

Background [ 0 ] = GetRValue ( ColorToRGB ( BackgroundColor >Brush
>C o l o r ) ) / 2 5 5 . 0 f ;
Background [ 1 ] = GetGValue ( ColorToRGB ( BackgroundColor >Brush
>C o l o r ) ) / 2 5 5 . 0 f ;
Background [ 2 ] = GetBValue ( ColorToRGB ( BackgroundColor >Brush
>C o l o r ) ) / 2 5 5 . 0 f ;
Background [ 3 ] = 1 . 0 f ;
}
//
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
void _ _ f a s t c a l l TForm1 : : S i m u l a c i o n C l i c k ( TObject Sender )
{
S i m u l a c i o n >Checked = True ;
I n t e r p r e t a c i o n >Checked = F a l s e ;
Generacion >Checked =F a l s e ;
Animacion >Enabled = True ;
I n t e r p r e t a c i o n T i m e r >Enabled = F a l s e ;
TabSheet3 >Enabled=F a l s e ;
i f ( ( H a b E s c r i t u r a = f o p e n ( "C: \ \ Simulador \\LE . t x t " , "w+" ) ) ==

NULL)
RichEdit1 >L i n e s >Add( " E r r o r a l Generar Archivo de
Habilitacin ") ;
else
1247
1248
1249
1250
1251
f p u t s ( "0" , HabEscritura ) ;
f c l o s e ( HabEscritura ) ;
}
//
B.1. PRINCIPAL
1252
1253
1254
1255
1256
1257
1258
1259
1260
void _ _ f a s t c a l l TForm1 : : I n t e r p r e t a c i o n C l i c k ( TObject Sender )
{
I n t e r p r e t a c i o n >Checked = True ;
S i m u l a c i o n >Checked = F a l s e ;
Animacion >Enabled = F a l s e ;
I n t e r p r e t a c i o n T i m e r >Enabled = True ;
TabSheet3 >Enabled=F a l s e ;
1261
1262
NULL)
Habilitacin ") ;
1263
else
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
147
}
//
void _ _ f a s t c a l l TForm1 : : G e n e r a c i o n C l i c k ( TObject Sender )

{
S i m u l a c i o n >Checked = F a l s e ;
Generacion >Checked =True ;
Animacion >Enabled = F a l s e ;
TabSheet3 >Enabled=True ;
I n t e r p r e t a c i o n T i m e r >Enabled = True ;
ComboDedo>ItemIndex =0;
ComboFalange>ItemIndex =0;
1282
1283
1284
1285
1286
PageControl1 >A c t iv e P ag e I n de x =2;

}
//
1287
void _ _ f a s t c a l l TForm1 : : I n t e r p r e t a c i o n T i m e r T i m e r ( TObject Sender
1288
1289
1290
1291
1292
1293
// Leer Archivo de P o s i c i o n e s de LabView
int lAcD=0;
// Linea a c t u a l d e l D r i v e r
char l i n e a [ 5 0 ] ;
// B u f f e r de Linea A c t u a l
f l o a t Angulo [ 1 6 ] = { 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 } ;
//
148
1294
Angulos r e c u p e r a d o d e l a r c h i v o generado por l a b v i e w

char i n s t r u c c i o n ; // Generacion de l a i n s t r u c c i n para g e n e r a r
animacin
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
I n t e r p r e t a c i o n T i m e r >I n t e r v a l = 3 3 ;
i f ( ( D r i v e r = f o p e n ( "C: \ \ Simulador \\ P o s i c i o n e s . t x t " , " r " ) ) ==

NULL)
{
Form1>StatusBar1 >Panels >Items [3] > Text = "No hay
d i s p o s i t i v o Conectado " ;
S i m u l a c i o n >Checked = True ;
Animacion >Enabled = True ;
I n t e r p r e t a c i o n T i m e r >Enabled = F a l s e ;
}
else
{
Form1>StatusBar1 >Panels >Items [3] > Text = " D i s p o s i t i v o en
L ne a " ;
while ( ! f e o f ( D r i v e r ) )
// Rutina para
e x t r a e r l a s l i n e a s de un a r c h i v o una por una
{
f g e t s ( linea ,50 , Driver ) ;
Angulo [ lAcD ] = t x t . pos ( l i n e a ) ;
S a l i d a = t x t . puente ( lAcD , Angulo [ lAcD ] ) ;
// I n g r e s o de d a t o s a l a r r e g l o de e j e c u c i o n a c t u a l
dedom [ lAcD ] = S a l i d a . dedo ;
falangem [ lAcD ] = S a l i d a . f a l a n g e ;
angulom [ lAcD ] = S a l i d a . a n g u l o ;
tiempom [ lAcD ] = S a l i d a . tiempo ;
grupom [ lAcD ] = S a l i d a . grupo ;
f i g . MovimientoTeta ( dedom [ lAcD ] , falangem [ lAcD ] , angulom [
lAcD ] , tiempom [ lAcD ] , grupom [ lAcD ] ) ;
lAcD++;
}
}
f c l o s e ( Driver ) ;
i f ( lAcD == 1 6 )
}
//
B.1. PRINCIPAL
1332
1333
1334
1335
1336
1337
149
void _ _ f a s t c a l l TForm1 : : I n g r e s a r _ E m i s i o n C l i c k ( TObject Sender )
char tempangulochar ;
float tempangulofloat ;
1338
1339
1340
tempangulochar = AnguloEmision >Text . c _ s t r ( ) ;

t e m p a n g u l o f l o a t = a t o f ( tempangulochar ) ;
1341
1342
1343
1344
1345
1346
dedom [ 0 ] = ComboDedo>ItemIndex +1;

falangem [ 0 ] = ComboFalange>ItemIndex +1;
angulom [ 0 ] = t e m p a n g u l o f l o a t ;
tiempom [ 0 ] = 0 ;
grupom [ 0 ] = 0 ;
1347
1348
1349
i f ( falangem [ 0 ] < 4 && ( angulom [ 0 ] > MaxProximal | | angulom [ 0 ] <

MinProximal ) )
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
{
RichEdit1 >L i n e s >Add( " E r r o r : No e s p o s i b l e a l c a n z a r e s e
ngulo " ) ;
}
i f ( falangem [ 0 ] == 4 && ( angulom [ 0 ] > MaxAbduccion | | angulom [ 0 ]
< MinAbduccion ) )
{
RichEdit1 >L i n e s >Add( " E r r o r : No e s p o s i b l e a l c a n z a r e s e
ngulo " ) ;
}
else
{
RichEdit1 >L i n e s >Add( " P o s i c i n Asignada " ) ;
}
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370

NULL)
Habilitacin ") ;
else
150
1371
1372
1373
1374
1375
i f ( ( Emision = f o p e n ( "C: \ \ Simulador \\ Emision . t x t " , "w+" ) ) ==

NULL)
Emisin " ) ;
1376
1377
else
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
f p u t s ( F l o a t T o S t r ( angulom [ 0 ] ) . c _ s t r ( ) , Emision ) ;
f p u t s ( " \ t " , Emision ) ;
f p u t s ( I n t T o S t r ( dedom [ 0 ] ) . c _ s t r ( ) , Emision ) ;
f p u t s ( " \ t " , Emision ) ;
f p u t s ( I n t T o S t r ( falangem [ 0 ] ) . c _ s t r ( ) , Emision ) ;
f p u t s ( " \ t " , Emision ) ;
f c l o s e ( Emision ) ;
1388
1389
PageControl1 >A c t iv e P ag e I n de x =0;
1390
1391
1392
}
//
B.2. Clase para los grcos

B.2.1. Gracos.cpp
1
2
#include <c o n i o . h> #include <i o s t r e a m . h> #include <math . h>

#include " G r a f i c o s C l a s e . h"
3
4
5
6
7
8
9
10
11
12
13
14
15
16
G r a f i c o s : : G r a f i c o s ( ) { int i ; for ( i =0; i <100; i ++)

{
e l e m e n t o [ i ] . nC=0;
e l e m e n t o [ i ] . nV=0;
e l e m e n t o [ i ] . a =0;
e l e m e n t o [ i ] . a l f a =0;
e l e m e n t o [ i ] . d=0;
e l e m e n t o [ i ] . t e t a =0;
ob [ i ] . Tipo = 0 ;
ob [ i ] . par1 = 0 ;
ob [ i ] . par2 = 0 ;
ob [ i ] . par3 = 0 ;
B.2. CLASE PARA LOS GRFICOS

17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
151
ob [ i ] . par4 = 0 ;
ob [ i ] . x = 0 ;
ob [ i ] . y = 0 ;
ob [ i ] . z = 0 ;
ob [ i ] . Rx = 0 ;
ob [ i ] . Ry = 0 ;
ob [ i ] . Rz = 0 ;
Cam. Rx = 0 ;
Cam. Ry = 0 ;
Cam. Rz = 0 ;
Cam. x = 0 ;
Cam. y = 0 ;
Cam. z = 0 ;
Cam. Zoom = 1 0 0 ;
Cam.V = ISOMETRICA ;
o r i g e n [ i ] . x=0;
o r i g e n [ i ] . y=0;
o r i g e n [ i ] . z =0;
}
nE=0; }
37
38
39
40
41
42
43
// Funcion para i n g r e s a r c o o r d e n a d a s de o r i g e n de una cadena

void G r a f i c o s : : DHo( int nC , f l o a t x , f l o a t y , f l o a t z ) {
o r i g e n [ nC ] . x = x ; o r i g e n [ nC ] . y = y ; o r i g e n [ nC ] . z = z ; }
oC G r a f i c o s : : GetO ( int nC) { oC Origen ; Origen . x = o r i g e n [ nC ] . x ;
Origen . y = o r i g e n [ nC ] . y ; Origen . z = o r i g e n [ nC ] . z ; return Origen ;
}
44
45
46
47
48
49
50
// Funcion para i n g r e s a r l o s d a t o s DH a e l e m e n t o s
int G r a f i c o s : : DH( int nC , int nV , f l o a t a , f l o a t a l f a , f l o a t d ,
f l o a t t e t a ) { e l e m e n t o [ nE ] . nC=nC ; e l e m e n t o [ nE ] . nV=nV ;
e l e m e n t o [ nE ] . a=a ; e l e m e n t o [ nE ] . a l f a=a l f a ; e l e m e n t o [ nE ] . d=d ;
e l e m e n t o [ nE ] . t e t a=t e t a ; nE++; return nE 1;
// Regresa e l numero
de e l e m e n t o i n g r e s a d o }
51
52
53
54
// Funcion que t r a n s f o r m a l o s parametros DH y e n t r a g a l o s

parametros para d i b u j a r l a f i g u r a en una cadena de e l e m e n t o s
parF G r a f i c o s : : Cadena ( int nE) { parF F i g u r a ; oC o r i g e n A c t u a l ;
defDH e l e m e n t o A c t u a l ;
55
56
e l e m e n t o A c t u a l = e l e m e n t o [ nE ] ;
57
58
59
F i g u r a . Tipo = C i l i n d r o ; F i g u r a . par1 = e l e m e n t o A c t u a l . a ;
// Parametro a DH <L o n g i t u d d e l e s l a b n > D i s t a n c i a Sobre e l e j e
152
60
61
62
63
64
65
66
67
x
F i g u r a . par2 = e l e m e n t o A c t u a l . a l f a ;
// Parametro a l f a DH
Angulo s o b r e e l e j e x F i g u r a . par3 = e l e m e n t o A c t u a l . d ;
//
Paremetro d DH D i s t a n c i a Sobre e l e j e z F i g u r a . par4 =
elementoActual . teta ;
// Parametro t e t a DH <Angulo i n i c i a l >
Angulo Sobre e l e j e z
return F i g u r a ; }
68
void G r a f i c o s : : Objeto ( int id , int t i p o , f l o a t x , f l o a t y , f l o a t
69
f l o a t rx , f l o a t ry , f l o a t rz , f l o a t par1 ) {
z,
70
71
72
73
74
75
76
77
78
79
80
81
ob [ nE ] . i d = i d ;
ob [ nE ] . Tipo = t i p o ;
ob [ nE ] . x = x ;
ob [ nE ] . y = y ;
ob [ nE ] . z = z ;
ob [ nE ] . Rx = rx ;
ob [ nE ] . Ry = ry ;
ob [ nE ] . Rz = r z ;
ob [ nE ] . par1 = par1 ;
nE++;;
82
83
f l o a t rx , f l o a t ry , f l o a t rz , f l o a t par1 , f l o a t par2 ) {
z,
84
85
86
87
88
89
90
91
92
93
94
95
96
ob [ nE ] . i d = i d ;
ob [ nE ] . x = x ;
ob [ nE ] . y = y ;
ob [ nE ] . z = z ;
ob [ nE ] . Rx = rx ;
ob [ nE ] . Ry = ry ;
ob [ nE ] . Rz = r z ;
nE++;;
97
98
f l o a t rx , f l o a t ry , f l o a t rz , f l o a t par1 , f l o a t par2 , f l o a t par3 )
z,
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
{
ob [ nE ] . i d = i d ;
ob [ nE ] . x = x ;
ob [ nE ] . y = y ;
ob [ nE ] . z = z ;
ob [ nE ] . Rx = rx ;
ob [ nE ] . Ry = ry ;
ob [ nE ] . Rz = r z ;
nE++;;

z,
114
115
f l o a t rx , f l o a t ry , f l o a t rz , f l o a t par1 , f l o a t par2 , f l o a t par3 ,

f l o a t par4 ) {
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
153
ob [ nE ] . i d = i d ;
ob [ nE ] . x = x ;
ob [ nE ] . y = y ;
ob [ nE ] . z = z ;
ob [ nE ] . Rx = rx ;
ob [ nE ] . Ry = ry ;
ob [ nE ] . Rz = r z ;
nE++;;
parF G r a f i c o s : : G r a f i c a r O b j e t o ( int nE) { parF S a l i d a ;

Salida . id
= ob [ nE ] . i d ;
S a l i d a . Tipo = ob [ nE ] . Tipo ;
S a l i d a . par1 = ob [ nE ] . par1 ;
S a l i d a . x = ob [ nE ] . x ;
S a l i d a . y = ob [ nE ] . y ;
S a l i d a . z = ob [ nE ] . z ;
S a l i d a . Rx = ob [ nE ] . Rx ;
154
142
143
144
S a l i d a . Ry = ob [ nE ] . Ry ;
S a l i d a . Rz = ob [ nE ] . Rz ;
return S a l i d a ; }
145
146
147
148
149
150
151
152
void G r a f i c o s : : MovimientoAlfa ( int nC , int nV , f l o a t a l f a , f l o a t

tiempo , int gM) { int nE ; nE=nElemento (nC , nV) ; e l e m e n t o [ nE ] . a l f a
=
alfa ; }
void G r a f i c o s : : MovimientoTeta ( int nC , int nV ,

tiempo , int gM) { int nE ;
float teta , float
153
154
155
nE=nElemento (nC , nV) ;

elemento
// Busqueda d e l numero de
e l e m e n t o [ nE 1 ] . t e t a = t e t a ;
a c t u a l i z a c i o n de a n g u l o
// S e l e c c i n d e l e l e m e n t o y
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
void G r a f i c o s : : MovimientoObjeto ( int id , f l o a t angulo , int e j e ,

int
tiempo ) { int nE ; nE=nElemento ( i d ) ;
i f ( e j e == EjeX )
{
ob [ nE ] . Rx = a n g u l o ;
ob [ nE ] . Ry = 0 ;
ob [ nE ] . Rz = 0 ;
}
i f ( e j e == EjeY )
{
ob [ nE ] . Rx = 0 ;
ob [ nE ] . Ry = a n g u l o ;
ob [ nE ] . Rz = 0 ;
}
i f ( e j e == EjeZ )
{
ob [ nE ] . Rx = 0 ;
ob [ nE ] . Ry = 0 ;
ob [ nE ] . Rz = a n g u l o ;
}
}

185
186
187
188
int G r a f i c o s : : Camara ( int v i s t a ) {
Cam.V = v i s t a ;
return v i s t a ;
}
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
camRot G r a f i c o s : : Camara ( f l o a t Rx , f l o a t Ry , f l o a t Rz , f l o a t x ,
f l o a t y , f l o a t z , f l o a t Zoom) {
Cam. Rx = Rx ;
Cam. Ry = Ry ;
Cam. Rz = Rz ;
Cam. x = x ;
Cam. y = y ;
Cam. z = z ;
Cam. Zoom = Zoom ;
Cam.V = LIBRE ;
return Cam;
}
204
205
206
207
camRot G r a f i c o s : : Camara ( ) {
return Cam;
}
208
209
210
211
212
213
// Regresa e l numero de v i n c u l o s de una cadena

int G r a f i c o s : : nVC( int nC) {
int i , j ;
int nV = 0 ;
214
for ( i =0; i <100; i ++)
215
216
i f ( e l e m e n t o [ i ] . nC == nC)
217
218
for ( j =0; j <100; j ++)
219
220
221
222
223
224
225
226
nV = max(nV , e l e m e n t o [ i ] . nV) ;
return nV ;
227
228
229
// Regresa e l numero de cadenas

int G r a f i c o s : : nCa ( ) {
155
156
int i ;
int nCad = 0 ;
230
231
232
for ( i =0; i <100; i ++)
233
234
235
236
237
238
{
nCad = max( nCad , e l e m e n t o [ i ] . nC) ;
}
return nCad ;
239
240
241
242
243
244
245
246
247
248
249
250
// Regresa e l numero de e l e m e n t o c o r r e s p o n d i e n t e a una cadena (nC

) y un v i n c u l o (nV)
int G r a f i c o s : : nElemento ( int nC , int nV) { int i , nE ;
for ( i =0; i <100; i ++)
{
i f ( e l e m e n t o [ i ] . nC == nC && e l e m e n t o [ i ] . nV == nV)
{
nE = i ;
i = 100;
}
}
return nE ; }
251
252
253
254
255
256
257
258
259
260
261
262
// Regresa e l numero de e l e m e n t o c o r r e s p o n d i e n t e a una forma con

identificador ( id )
int G r a f i c o s : : nElemento ( int i d ) { int i , nE ;
for ( i =0; i <100; i ++)
{
i f ( ob [ i ] . i d == i d )
{
nE = i ;
i = 100;
}
}
return nE ; }
263
264
265
266
267
268
269
270
// Regresa e l numero de e l e m e n t o s que d e f i n e n l a s cadenas
int G r a f i c o s : : nElementosCadenas ( ) { int i =0; int nEC=0;

for ( i =0; i <100; i ++)
i f ( e l e m e n t o [ i ] . nC >= 1 )
271
272
nEC++;

273
274
157
return nEC ; }
275
276
277
278
279
// Regresa e l numero de O b j e t o s
int G r a f i c o s : : nOb ( ) {
int i ;
int nOb = 0 ;
280
for ( i =0; i <100; i ++)
281
282
283
284
285
286
{
nOb = max(nOb , ob [ i ] . i d ) ;
}
return nOb ;
287
288
289
290
// Regresa e l n g u l o d e l v i n c u l o s e l e c c i o n a d o de una cadena
f l o a t G r a f i c o s : : angActual ( int nC , int nV) { int nE ; f l o a t a n g u l o

;
291
292
293
294
nE=nElemento (nC , nV) ; a n g u l o = e l e m e n t o [ nE 1 ] . t e t a ;
return a n g u l o ; }
B.2.2. Gracos.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#ifndef GraficosClase_H
#define GraficosClase_H
typedef struct { int nC ;
//Numero de Cadena Cinemtica
int
nV ;
//Nmero de v i n c u l o o e s l a b n f l o a t a ;
// Parmetro a de DH f l o a t a l f a ;
// Parmetro a l f a de DH f l o a t
d;
// Parmetro d de DH f l o a t t e t a ;
// Parmetro t e t a
de
DH }defDH ;
// D e f i n i c i n D e n a v i t H a r t e n b e r g
typedef struct { f l o a t x ; f l o a t y ; f l o a t z ; }oC ; // Origen de
Cadena
typedef struct { int i d ;
// I d e n t i f i c a d o r de forma i n t
Tipo ;
// Tipo de Forma f l o a t x ;
// Parametros d e l 1 a l 4 c o o r d e n a d a s
y
g i r o s por e j e f l o a t y ; f l o a t z ; f l o a t Rx ; f l o a t Ry ; f l o a t Rz ;
158
16
17
18
19
20
21
22
23
24
f l o a t par1 ; f l o a t par2 ; f l o a t par3 ; f l o a t par4 ; } parF ;
// Parametros de Forma
typedef struct { int V; f l o a t Rx ; f l o a t Ry ; f l o a t Rz ; f l o a t x ;

f l o a t y ; f l o a t z ; f l o a t Zoom ; }camRot ; // Rotacion , t r a s l a c i n y
v i s t a s d e f i n i d a s de l a cmara
typedef struct { f l o a t mA;
// Angulo de movimeinto a c t u a l f l o a t
M;
// I n t e r v a l o de movimiento }parAnim ;
25
26
27
28
29
30
31
32
// D e f i n i c i o n de c o n s t a n t e s para
// V i s t a s
#define LIBRE
100 #define
POSTERIOR
1 #d e f i n e SUPERIOR
2 #d e f i n e
4 #d e f i n e IZQUIERDA
5 #d e f i n e
TRIMETRICA
7 #d e f i n e DIMETRICA
8
las vistas
FRONTAL
0 #define
INFERIOR
ISOMETRICA
3 #d e f i n e DERECHA
6 #d e f i n e
33
34
35
36
37
// D e f i n i c i o n de formas
#define E s f e r a
1 #define C i l i n d r o
#define Cono
4 #define Piramide
#define S e m i d i s c o 7
2 #define Caja
5 #define D i s c o
3
6
38
39
40
// E j e s de r o t a c i o n para o b j e t o s
#define EjeX
1 #define EjeY
2 #define EjeZ
41
42
43
44
45
46
47
48
49
50
51
#define on 1 #define o f f 0
#define TA 50
//Tiempo de a c t u a l i z a c i n para l a animacin

m i l i s e g u n d o s #d e f i n e STOPANI 0 . 1
#define DOSPI 6 . 2 8 3 1 8 5 3 0 7 1 8 #define RADtoDEG 0 . 0 1 7 4 5 3 2 9 2 5 1 9 9 4

c l a s s G r a f i c o s { public :
Graficos () ;
52
void DHo( int nC , f l o a t x , f l o a t y , f l o a t z ) ;
53
oC GetO ( int nC) ;
// Asignar o r i g e n de l a cadena i
Obtener o r i g e n de l a cadena i
54
en
int DH( int nC , int nV , f l o a t a , f l o a t a l f a , f l o a t d , f l o a t
//
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
teta ) ;
// Parmetros de DH
parF Cadena ( int nE) ;
159
//
Parametros de l a forma para una cadena p a r t i e n d o de su
numero de e l e m e n t o
void Objeto ( int id , int t i p o , f l o a t x , f l o a t y , f l o a t z ,
f l o a t Rx , f l o a t Ry , f l o a t Rz , f l o a t par1 ) ; // O b j e t o que
admite un parametro
f l o a t Rx , f l o a t Ry , f l o a t Rz , f l o a t par1 , f l o a t par2 ) ; //
O b j e t o que admite dos parametros
f l o a t Rx , f l o a t Ry , f l o a t Rz , f l o a t par1 , f l o a t par2 , f l o a t
par3 ) ; // O b j e t o que admite t r e s parametros
f l o a t Rx , f l o a t Ry , f l o a t Rz , f l o a t par1 , f l o a t par2 , f l o a t
par3 , f l o a t par4 ) ; // O b j e t o que admite c u a t r o parametros
parF G r a f i c a r O b j e t o ( int nE) ;
// Recupera l o s
parametros de un o b j e t o
void MovimientoAlfa ( int nC , int nV , f l o a t a l f a , f l o a t tiempo ,
int gM) ; // Parmetros para l a animacin
void MovimientoTeta ( int nC , int nV , f l o a t t e t a , f l o a t tiempo ,
int gM) ; // Parmetros para l a animacin
void MovimientoObjeto ( int id , f l o a t angulo , int e j e , int
tiempo ) ;
// Parmetros para l a animacin de o b j e t o s
int Camara ( int v i s t a ) ;
//Cmara
vista fija
camRot Camara ( f l o a t Rx , f l o a t Ry , f l o a t Rz , f l o a t x , f l o a t y ,
f l o a t z , f l o a t Zoom) ; // U b i c a c i n de l a cmara
camRot Camara ( ) ;
int nVC( int nC) ;
//
Encuentra e l numero de v i n c u l o s de una cadena
int nCa ( ) ;
// Encuentra e l numero de cadenas d e f i n i d a s
int nElemento ( int nC , int nV) ;
// Encuentra e l
numero de e l e m e n t o c o r r e s p o n d i e n t e
int nElemento ( int i d ) ;
//
Encuentra e l numero de e l e m e n t o c o r r e s p o n d i e n t e
int nElementosCadenas ( ) ;
160
72
e l numero de e l e m e n t o s que forman cadenas

int nOb ( ) ;
73
f l o a t angActual ( int nC , int nV) ;
// Encuentra
// Encuentra e l numero de o b j e t o s s i m p l e s
// Regresa e l
n g u l o d e l v i n c u l o s e l e c c i o n a d o de una cadena
74
75
private :
76
77
78
79
80
81
defDH e l e m e n t o [ 2 0 ] ; // D e f i n i c i o n e s DH de l o s e l e m e n t o s
oC o r i g e n [ 2 0 ] ;
// Origen de l a s Cadenas
parF ob [ 1 0 0 ] ;
// O b j e t o s G e n e r a l e s
int nE ;
//Nmero de e l e m e n t o a c t u a l g e n e r a l
inidice irrepetible )
camRot Cam;
// Parmetros de l a cmara v i r t u a l
82
83
84
85
};
#endif
B.3. Clase para el intrprete

B.3.1. Interprete.cpp
1
2
3
4
5
6
7
#include <c o n i o . h>

#include <ostream . h>
#include <math . h>
#include <s t r i n g . h>
#include <s t d i o . h>
#include <l o c a l e >
#include " I n t e r p r e t e C l a s e . h"
8
9
10
11
12
13
14
15
16
17
18
19
Interprete : : Interprete () {
s a l i d a . p a l a b r a =0;
s a l i d a . dedo =0;
s a l i d a . f a l a n g e =0;
s a l i d a . a n g u l o =0;
s a l i d a . tiempo =0;
s a l i d a . grupo =0;
}
DatosLinea I n t e r p r e t e : : mov( char cadena ) {
int i =0;
// Contador para l a p o s i c i n a c t u a l d e l c u r s o r
B.3. CLASE PARA EL INTRPRETE

20
21
22
23
24
25
26
27
int l o n p a l [ 6 ] ; // L o g i t u d de p a l a b r a s en l a l n e a a a n a l i z a r
int j =0;
// Contador de p r o p o s i t o g e n e r a l
int A, B, C ;
char b u f f e r ; // B u f f e r de a n a l i s i s de l i n e a
int p a l a b r a , dedo , f a l a n g e ; // I d e n t i f i c a d o r de l a p a l a b r a
reservada
bool n o d i g=true ;
while ( cadena [ i ] != ' ( ' )

reservada
{
i ++;
i f ( i >50)
break ;
}
28
29
30
31
32
33
36
37
38
39
40
41
42
43
44
45
else
46
p a l a b r a = 1;
47
50
51
52
53
54
55
//Numero de c a r a c t e r e s de l a p a l a b r a
{
b u f f e r = ( char ) m a l l o c ( 1 0 0 ) ;
// A s i g n a c i n de
memoria para e l b u f f e r
for ( j =0; j <i ; j ++)
b u f f e r [ j ] = cadena [ j ] ;
// E x t r a c c i n de l a
palabra reservada
b u f f e r [ j ]=0;
i ++;
// S a l t o d e l c a r a c t e r
"("
j = 1;
j = strcmp ( b u f f e r , "mov" ) ;
//En c a s o de que l o
almacenado en b u f f e r s e a mov j s e r 0
j = j ==0?0:1;
// N o r m a l i z a c i o n l o g i c a
de j
p a l a b r a = j ==0?1: 1;
// S i l a comparacion
f u e a t i n a d a e n t o n c e s p a l a b r a s e r e l c a s o de mov
}
35
49
// D e t e c t o r de No d i g i t o
i f ( i <50)
34
48
161
i f ( p a l a b r a ==1)
{
s a l i d a . palabra = 1;
lonpal [ 0 ] = i ;
/ DEDO
/
while ( cadena [ i ] != ' , ' )
{
162
56
57
58
59
60
61
62
63
64
65
66
67

i ++;
i f ( i >255)
{
s a l i d a . p a l a b r a = 1;
break ;
}
}
lonpal [ 1 ] = i lonpal [ 0 ] ;
C a l c u l o de l a l o n g i t u d de p a l a b r a dedo
for ( j =0; j <i l o n p a l [ 0 ] ; j ++)
E x t r a c c i n d e l parametro dedo
b u f f e r [ j ] = cadena [ j+l o n p a l [ 0 ] ] ;
b u f f e r [ j ]=0;
//
//
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
j = 1;
j = strcmp ( b u f f e r , " p u l g a r " ) ;
Pulgar
j = j ==0?0:1;
dedo = j ==0?p u l g a r : 0 ;
i f ( j == 1 )
{
j = strcmp ( b u f f e r , " 1 " ) ;
j = j ==0?0:1;
dedo = j ==0?p u l g a r : 0 ;
}
i f ( j == 1 )
{
j = strcmp ( b u f f e r , " i n d i c e " ) ;
Indice
j = j ==0?0:1;
dedo = j ==0? i n d i c e : 0 ;
}
i f ( j == 1 )
{
j = strcmp ( b u f f e r , " 2 " ) ;
j = j ==0?0:1;
dedo = j ==0? i n d i c e : 0 ;
}
i f ( j == 1 )
{
j = strcmp ( b u f f e r , " medio " ) ;
medio
j = j ==0?0:1;
dedo = j ==0?medio : 0 ;
//Dedo
//Dedo
//Dedo

96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
}
i f ( j == 1 )
{
j = strcmp ( b u f f e r , " 3 " ) ;
j = j ==0?0:1;
dedo = j ==0?medio : 0 ;
}
i f ( j == 1 )
{
//Dedo
Anular
j = strcmp ( b u f f e r , " a n u l a r " ) ;
j = j ==0?0:1;
dedo = j ==0?a n u l a r : 0 ;
}
i f ( j == 1 )
{
j = strcmp ( b u f f e r , " 4 " ) ;
j = j ==0?0:1;
dedo = j ==0?a n u l a r : 0 ;
}
i f ( j == 1 )
{
j = strcmp ( b u f f e r , " meique " ) ;
//Dedo
Meique
j = j ==0?0:1;
dedo = j ==0?menique : 0 ;
}
i f ( j == 1 )
{
j = strcmp ( b u f f e r , " 5 " ) ;
j = j ==0?0:1;
dedo = j ==0?menique : 0 ;
}
i f ( j ==1)
{
s a l i d a . dedo=1;
}
i ++; // S a l t o d e l c a r a c t e r ' , '
s a l i d a . dedo = dedo ;
/ FALANGE
/
while ( cadena [ i ] != ' , ' )
{
i ++;
i f ( i >255)
163
164
138
139
140
141
142
{
break ;
}
143
144
145
146
147
148
149
150
151
152
l o n p a l [1]++;
// Se a g r e g a a l a l o n g i t u d de l a p a l a b r a l a " ,"
lonpal [ 2 ] = i lonpal [ 1 ] lonpal [ 0 ] ;
for ( j =0; j <l o n p a l [ 1 ] ; j ++)

Limpieza de B u f f e r
buffer [ j ] = 0;
//
for ( j =0; j <l o n p a l [ 2 ] ; j ++)
// E x t r a c c i n d e l parametro f a l a n g e
b u f f e r [ j ] = cadena [ j+l o n p a l [ 0 ] + l o n p a l [ 1 ] ] ;
b u f f e r [ j ]= 0 ;
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
j = 1;
j = strcmp ( b u f f e r , " p r o x i m a l " ) ;
// Falange Proximal
j = j ==0?0:1;
f a l a n g e = j ==0?p r o x i m a l : 0 ;
i f ( j == 1 )
{
j = strcmp ( b u f f e r , " 1 " ) ;
j = j ==0?0:1;
f a l a n g e = j ==0?p r o x i m a l : 0 ;
}
i f ( j == 1 )
{
j = strcmp ( b u f f e r , " media " ) ;
Falange media
j = j ==0?0:1;
f a l a n g e = j ==0?media : 0 ;
}
i f ( j == 1 )
{
j = strcmp ( b u f f e r , " 2 " ) ;
j = j ==0?0:1;
f a l a n g e = j ==0?media : 0 ;
}
i f ( j == 1 )
{
//

178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
165
j = strcmp ( b u f f e r , " d i s t a l " ) ;

//
Falange D i s t a l
j = j ==0?0:1;
f a l a n g e = j ==0? d i s t a l : 0 ;
}
i f ( j == 1 )
{
j = strcmp ( b u f f e r , " 3 " ) ;
j = j ==0?0:1;
f a l a n g e = j ==0? d i s t a l : 0 ;
}
i f ( j == 1 )
{
j = strcmp ( b u f f e r , " a b d u c c i o n " ) ;
//
Movimiento de Abduccion
j = j ==0?0:1;
f a l a n g e = j ==0?a b d u c c i o n : 0 ;
}
i f ( j == 1 )
{
j = strcmp ( b u f f e r , " 4 " ) ;
j = j ==0?0:1;
f a l a n g e = j ==0?a b d u c c i o n : 0 ;
}
i f ( j ==1)
{
s a l i d a . f a l a n g e =1;
}
salida . falange = falange ;
/ ANGULO
/
while ( cadena [ i ] != ' , ' )
{
i ++;
i f ( i >255)
{
break ;
}
}
l o n p a l [2]++;
//
Se a g r e g a a l a l o n g i t u d de l a p a l a b r a l a " ,"
l o n p a l [ 3 ] = i l o n p a l [ 2 ] l o n p a l [ 1 ] l o n p a l [ 0 ] ;
166
219
220
221
222
223
224
225
226
227
for ( j =0; j <l o n p a l [ 3 ] ; j ++)
E x t r a c c i n d e l parametro f a l a n g e
b u f f e r [ j ] = cadena [ j+l o n p a l [ 0 ] + l o n p a l [ 1 ] + l o n p a l
[2]];
b u f f e r [ j ]= 0 ;
for ( j =0; j <l o n p a l [ 3 ] ; j ++)
230
231
232
233
234
// D e t e c c i o n de
d i g i t o s en l o s parametros
{
i f ( ( i s d i g i t ( b u f f e r [ j ] ) | | b u f f e r [ j ]== ' . ' | |
b u f f e r [ j ]== ' ' ) && n o d i g == true )
n o d i g=true ;
else
228
229
//
n o d i g= f a l s e ;
i f ( nodig )
else
s a l i d a . angulo = a t o f ( b u f f e r ) ;
s a l i d a . angulo = 1000000;
//Numero mgico
para a s i g n a r e r r o r de numero i n v a l i d o
235
236
237
238
239
240
241
242
243
244
245
246
247

/ TIEMPO
/
n o d i g = true ;
while ( cadena [ i ] != ' , ' )
{
i ++;
i f ( i >255)
{
break ;
}
}
248
249
250
251
252
253
l o n p a l [3]++;
//
lonpal [ 4 ] = i lonpal [ 3 ] lonpal [ 2 ] lonpal [ 1 ]
lonpal [ 0 ] ;
for ( j =0; j <l o n p a l [ 4 ] ; j ++)
[2]+ lonpal [ 3 ] ] ;
//

254
167
b u f f e r [ j ]= 0 ;
255
256
257
258
259
260
261
for ( j =0; j <l o n p a l [ 4 ] ; j ++)
{
i f ( ( i s d i g i t ( b u f f e r [ j ] ) | | b u f f e r [ j ]== ' . ' ) &&
n o d i g == true )
n o d i g=true ;
else
262
263
264
265
266
267
268
i f ( nodig )
else
s a l i d a . tiempo = a t o f ( b u f f e r ) ;
s a l i d a . tiempo = 1 0 0 0 0 0 0 ;
//Numero mgico
269
270
271
272
273
274
275
276
277
278
279
280
281
282

/ GRUPO
/
n o d i g = true ;
while ( cadena [ i ] != ' ) ' )
{
i ++;
i f ( i >255)
{
break ;
}
}
283
284
285
286
287
288
289
290
l o n p a l [4]++;
//
lonpal [ 5 ] = i lonpal [ 4 ] lonpal [ 3 ] lonpal [ 2 ]
lonpal [ 1 ] lonpal [ 0 ] ;
for ( j =0; j <l o n p a l [ 5 ] ; j ++)
[2]+ lonpal [3]+ lonpal [ 4 ] ] ;
b u f f e r [ j ]= 0 ;
//
168
291
for ( j =0; j <l o n p a l [ 5 ] ; j ++)
292
{
i f ( i s d i g i t ( b u f f e r [ j ] ) && n o d i g == true )
n o d i g=true ;
293
294
295
else
296
297
298
299
301
else
302
303
305
306
307
i f ( nodig )
300
304
s a l i d a . grupo = a t o f ( b u f f e r ) ;
s a l i d a . grupo = 1 0 0 0 0 0 0 ;
//Numero mgico
} else
f r e e ( b u f f e r ) ; return s a l i d a ; }
308
309
310
311
312
313
314
315
316
317
318
// Regresa e l nmero maximo de grupo de Movimiento de un a r r e g l o

de d a t o s t i p o DatosLinea
int I n t e r p r e t e : : maxgM( int a r r e g l o ) { int i ; int max=0; int
nA=0; //Numero a c t u a l i n t nP=0;//Numero Pasado
for ( i =0; i <100; i ++)
{
nA = a r r e g l o [ i ] ;
nA>nP ? max = nA : max = nP ;
}
return max ; }
319
320
321
322
323
324
// I n i c i a l i z a e l a r r e g l o de d a t o s de Movimiento
void I n t e r p r e t e : : i n i D a t o s ( int dedo [ nDatos ] , int

f a l a n g e [ nDatos ] , f l o a t a n g u l o [ nDatos ] , f l o a t tiempo [ nDatos ] , int
grupo [ nDatos ] ) { int i =0; for ( i =0; i <nDatos ; i ++)
325
326
327
328
329
330
331
332
{
dedo [ i ] = 0 ;
falange [ i ]=0;
angulo [ i ]=0;
tiempo [ i ] = 0 ;
grupo [ i ] = 0 ;
}

333
334
335
f l o a t I n t e r p r e t e : : pos ( char cadena ) {

float valor ;
336
337
338
v a l o r = a t o f ( cadena ) ;
// C o n v i e r t e e l v a l o r l e i d o en un
nmero de punto f l o t a n t e
return v a l o r ;
// Se r e g r e s a e l v a l o r de punto
flotante
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
DatosLinea I n t e r p r e t e : : puente ( int Elemento , f l o a t Angulo ) {
i f ( Elemento == 0 )
{
s a l i d a . dedo = p u l g a r ;
s a l i d a . f a l a n g e = proximal ;
s a l i d a . a n g u l o = Angulo ;
s a l i d a . tiempo = 0 ;
s a l i d a . grupo = 0 ;
}
{
s a l i d a . f a l a n g e = media ;
}
{
salida . falange = distal ;
}
{
s a l i d a . f a l a n g e = abduccion ;
169
170
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
}
// I n d i c e
{
s a l i d a . dedo = i n d i c e ;
}
{
}
{
}
{
}
// Medio
{
s a l i d a . dedo = medio ;

421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
}
{
}
i f ( Elemento == 1 0 )
{
}
{
}
// Anular
{
s a l i d a . dedo = a n u l a r ;
}
{
171
172
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
}
{
}
{
}
return s a l i d a ; }
B.3.2. Interprete.h
1
2
3
4
5
6
7
8
10
11
12
13
#ifndef I n t e r p r e t e C l a s e _ H
#define I n t e r p r e t e C l a s e _ H
typedef struct {
int
palabra ;
int
dedo ;
int
falange ;
float angulo ;
// I n d i c a l a p a l a b r a r e s e r v a d a
// I n i d i c a e l Dedo a Animar
// I n d i c a l a Falange a Animar
// I n d i c a e l n g u l o f i n a l d e l e l e m e n t o
i n d i c a d o que s e ha de a n c a l z a r
f l o a t tiempo ;
// I n d i c a e l tiempo en que ha de r e a l i z a r e l
movimento
int
grupo ;
// I n d i c a e l grupo de movimiento en e l que s e
hara e l movimiento p o d i e n d o h a c e r movimientos
simuultneos
} DatosLinea ;
// Tipo de d a t o s de que d e f i n e una Linea de
c d i g o de movimiento

14
15
16
17
18
19
20
173
#define error 1
#define
#define
#define
#define
#define
pulgar
indice
medio
anular
menique
#define
#define
#define
#define
proximal
media
distal
abduccion
#define
#define
#define
#define
MaxProximal
MaxMedia
MaxDistal
MaxAbduccion
90
90
90
25
#define
#define
#define
#define
MinProximal
MinMedia
MinDistal
MinAbduccion
0
0
0
25
4
3
2
1
5
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
1
3
4
2
#define nDatos 100 //Numero de d a t o s de movimiento para un

archivo
39
40
41
42
43
44
45
46
47
48
49
50
c l a s s I n t e r p r e t e { public :
Interprete () ;
DatosLinea mov( char cadena ) ;
// Funcion para l a
e x t r a c c i n de i n f o r m a c i n de momiento
int maxgM( int a r r e g l o ) ;
// Regresa e l nmero maximo
de grupo de Movimiento de un a r r e g l o de d a t o s t i p o
DatosLinea
void i n i D a t o s ( int dedo [ nDatos ] , int f a l a n g e [ nDatos ] , f l o a t
a n g u l o [ nDatos ] , f l o a t tiempo [ nDatos ] , int grupo [ nDatos ] ) ;
f l o a t pos ( char cadena ) ; // Funcion d e l D r i v e r que a s i g n a l o s
v a l o r e s de l a s p o s i c i o n e s f i n a l e s en cada i n t e r v a l o de
actualizacin
DatosLinea puente ( int Elemento , f l o a t Angulo ) ; // Genera l a
l i n e a a p a r t i r d e l elemento y e l angulo l e i d o d e l archivo
private :
DatosLinea s a l i d a ;
174
51
52
53
};
#endif
B.4. Programa en LabView

El programa en LabView consta de la parte del panel y del cdigo grco. Ambas
partes se muestran en las guras B.1, B.2 y en B.3. Se muestra el segundo caso de la
estructura case del programa general el cual corresponde al modo de emisin.
Figura B.1: Panel del VI del driver virtual
B.4. PROGRAMA EN LABVIEW
Figura B.2: Cdigo grco en LabVIEW del driver virtual
175
176
Figura B.3: Caso de emisin del driver virtual

Apendice
Instalacin de Paquetes
C.1. Instalacin del panel OpenGL a Bulider C++ 5.0
Para obtener el componente se puede obtener en la siguiente direccin de Internet:
http://www.cobweb.net/ dplakosh/components/OpenGLv0.5BCB5.zip
donde una vez que se descargue el archivo se procede a su descompresin lo que generar
dos carpetas, en la carpeta llamada Component se encuentra una serie de archivos
los cuales son el componente en s y la instalacin se hace siguiendo los pasos que a
continuacin se presentan:
1. Dar doble clic en OpenGLPanel_DP.bpk (este abrir el C++ Builder 5.0)
2. En el men Project de la ventana principal dar clic en Build OpenGLPanel_DP
.
3. En la ventana package dar clic en el botn install.
4. Vea que el componente ha sido instalado y presione ok.
5. En el men le seleccione close all les.
6. Responda Yes a la pregunta Save changes to OpenGLPanel_DP.
7. El componente del Panel OpenGL esta ahora instalado.
8. Copie la carpeta del componente al directorio donde se instalo el C++ Builder
(tpicamente es C:/Archivos de programa/Borland/CBuilder5).
9. Ponga sus rutas de para el Include en BCB5 para incluir la ruta de los archivos
fuente del componente. En el men Project - Options d un clic en la pestaa
Directories/Condicionals (Figura C.1) de un clic en los tres puntos de Include
path y en el campo de nueva direccin (Figura C.2) poner:
177
178
APNDICE C. INSTALACIN DE PAQUETES
Figura C.1: Cuadro de dilogo indicando la pestaa Directories/Conditional

$(BCB)\Component
De un clic en add para agregar la nueva ruta.
10. Se repite el paso 9 ahora para la ruta de Library.
Nota: esto funciona teniendo instalado la versin 5 del Borland Builder C++.
C.2. Instalacin de las libreras GLUT

El kit de herramientas para OpenGL (GLUT por sus siglas en ingls) ayuda a utilizar
de forma ms ecientemente las funciones de OpenGL para instalar estas herramientas se
debe descargar de Internet el archivo glut-3.7.6-bin.zip se descomprime en C:/GLUT/
por simplicidad.
Desde la lnea de comando se debe escribir lo siguiente encontrndose en el directorio
donde se descomprimi:
IMPLIB glut32.lib glut32.dll

Si el comando colapsa cuando se llama de esta forma intentar con:
IMPLIB glut32.lib glut32.def
C.2. INSTALACIN DE LAS LIBRERAS GLUT
179
Figura C.2: Cuadro de Dialogo para agregar directorios de ruta

Usando la distribucin del archivo glut32.def. Ahora nicamente se procede a copiar
el siguiente grupo de archivos en las siguientes rutas:
glut32.dll en el directorio C:/Windows/system32
glut32.lib en el directorio C:/Archivos de programa/Borland/CBuilder5/Lib
glut32.h en el directorio C:/Archivos de programa/Borland/CBuilder5/Include
glut32.def en el directorio C:/Archivos de programa/Borland/CBuilder5/Source/RTL/source/defs
Nota: Se puede si se desea, borrar la carpeta donde se descomprimi la herramienta
180
APNDICE C. INSTALACIN DE PAQUETES

Apendice
Contacto
Para una copia de la aplicacin o cualquier informacin referente a este proyecto dirjase con:
Correo Electrnico: moliver@cenidet.edu.mx
Dr. Ral Pinto Elas
Correo Electrnico: rpinto@cenidet.edu.mx
Correo Electrnico: a.ibarra@ieee.org
181
182
APNDICE D. CONTACTO

50 Alberto Ibarra Domínguez

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

50 Alberto Ibarra Domínguez

Cargado por

Copyright:

Formatos disponibles

cenidet

Centro Nacional de Investigacin y Desarrollo Tecnolgico

TESIS DE MAESTRA EN CIENCIAS

Alberto Ibarra Domnguez

Cuernavaca, Morelos, Mxico.

TESIS DE MAESTRA EN CIENCIAS

Alberto Ibarra Domnguez

Cuernavaca, Morelos, Mxico.

Dedicado a Marxa, una en 6,774 millones, la

1.1. Descripcin del problema . . . . . . .

2.1. Scripts descriptivos . . . . . . . . . . . . . .

3.1. Herramientas generales . . . . . . . . . .

4. Manejo de las Seales

4.1. LabView como interfaz entre C++ y puertos fsicos . . . . . . . . . . . .

5. Pruebas y Validacin del Sistema

C.1. Instalacin del panel OpenGL a Bulider C++ 5.0 . . . . . . . . . . . . . . 177

1.1. Comparacin entre los diferentes generadores de parsers de fuente libre

2.1. Parmetros admisibles en una instruccin para generar movimiento con la

Diagrama de bloques del sistema . . . . . . . . . . . . . . . . . . . . . . .

Representacin general de la sintxis . . . . . . . . . . .

3.1. Representacin grca del cdigo representado en el listado 3.2 en el

3.8. Imgenes obervadas en la ejecucin de una animacin en distintos instantes

5.1. Resultado de los Scripts descritos en los listados 5.1 y 5.2 . . . . . . . . . . 93

2.1. Ejemplo de Script que describe los movimientos de la mano . . .

1.1. Descripcin del problema

necesidad de contar fsicamente con el prototipo robtico.

Instrucciones a los FPGA's

1.1. DESCRIPCIN DEL PROBLEMA

1. Modo de Interpretacin: A partir de las seales recibidas del controlador el simulador

Instrucciones a los FPGA's

Figura 1.2: Flujo de la informacin en modo de interpretacin

Instrucciones a los FPGA's

Figura 1.3: Flujo de la informacin en modo de simulacin

El funcionamiento del modo emisin se ilustra en la gura 1.4 y consiste en obtener la

1.2. PLANTEAMIENTO DE UNA SOLUCIN

Instrucciones a los FPGA's

Figura 1.4: Flujo de la informacin en modo de emisin

1.2. Planteamiento de una solucin

o de sensores que lo monitoreen.

1.2. PLANTEAMIENTO DE UNA SOLUCIN

El simulador puede recibir conguraciones de robots con articulaciones de un grado de

1.3. ESTADO DEL ARTE

Diseo de la estructura a utilizar por los scripts mediante la interpretacin de

1.3. Estado del arte

1.3.1. Interfaces grcas robticas

1.3. ESTADO DEL ARTE

Figura 1.5: Estructura del sistema del ratn espacial

1.3.2. Simuladores grcos de robots articulados

La empresa de software Microsoft en conjunto con la NASA desarrollaron un simulador

1.3. ESTADO DEL ARTE

1.3.3. Simuladores de manos

1.3. ESTADO DEL ARTE

Figura 1.8: Transformacin a guras geomtricas simples de una taza

En la Universidad de Palermo en Italia, se ha desarrollado un sistema control mediante

trmino en ingls Diseo Asistido por Computadora es la representacin computacional de algn

1.3.4. Libreras para generar grcos

1.3.5. Analizadores lxico-sintcticos

1.3. ESTADO DEL ARTE

los parsers, en el caso de ANTLR es java la plataforma en la que se compila, compilador

1.3.6. Herramientas de desarrollo

Borland Builder C++ 5

C++, C#, Java,

Irix, Linux, Solaris, Win32

C++, C#, Java

3.1. Representacin grca del cdigo representado en el listado 3.2 en el

El funcionamiento del modo emisin se ilustra en la gura 1.4 y consiste en obtener la

El simulador puede recibir conguraciones de robots con articulaciones de un grado de

1.3.1. Interfaces grcas robticas

1.3.2. Simuladores grcos de robots articulados

Figura 1.8: Transformacin a guras geomtricas simples de una taza

1.3.4. Libreras para generar grcos

mtodos y eventos que se encarguen de operaciones especcas en la generacin de pixeles,

1.4. Especicacin del sistema

De manera general es de esta forma (gura 1.9)como queda constituido el sistema

a. Decodicador de seales de LabView

e. Generador de informacin para grcos

1.4.2. Simulador grco

Figura 1.11: Diagrama interno del simulador grco

a. Selector de control de ujo

Figura 2.6: Diagrama de ujo del algoritmo para compilar un archivo

Figura 2.7: Partes de la interfaz grca concernientes al intrprete