Download INSTITUTO POLITÉCNICO NACIONAL “Brazo Robótico Controlado

INSTITUTO POLITÉCNICO NACIONAL
CENTRO DE INNOVACIÓN Y DESARROLLO
TECNOLÓGICO EN CÓMPUTO
“Brazo Robótico Controlado por una Computadora en un Ambiente
de Realidad Virtual”
Tesis que presenta:
Eduardo Eloy Loza Pacheco
Para obtener el grado de Maestro en Ciencias en
Tecnología de Cómputo
Directores:
M en C. Juan Carlos Herrera Lozada
M. en C. Israel Rivera Zárate
México, D.F., julio 2008
1
I
II
Resumen
La realidad virtual se ha venido desarrollando a pasos agigantados gracias a los grandes
avances tecnológicos que presenciamos día con día, además de que es un punto muy
rentable para las compañías de entretenimiento como la de los videojuegos, pero la realidad
virtual además es una herramienta de simulación de mundos, así como de fenómenos a los
que el ojo humano no puede acceder. Una de sus áreas de aplicación es control a distancia
que cada vez se hace más sofisticado. En México este tema ha sido abordado por diversos
trabajos en universidades y por eso el equipamiento de herramientas de realidad virtual es
importante, y es ahí donde este trabajo pretende colaborar con
el equipamiento del
laboratorio de realidad virtual de CIDETEC con el fin de que sirva para propósitos
didácticos.
Este trabajo presenta el modelado de un brazo robótico en Java 3D así como de su control
mediante un microcontrolador, de su control usando Java 2 y finalmente se muestra una
interfaz entre la computadora y el brazo mecánico.
III
Abstract
Virtual Reality has becoming more and more important thanks to the great advantages of
the technology what we can see everyday besides it is a very profitable for entertainment
companies like videogames, but virtual reality is also a tool for simulating worlds or
simulation of physics phenomena that human eyes can not see. One of the application
fields are the distance control and this field is more sophisticated everyday. In Mexico this
themes has been aborded by several works in Universities and for that it is important to
equip them with virtual reality tools. And this work pretends to collaborate with the
equipment of the Virtual Reality laboratory of CIDETEC with the objective of this work
can serve for educational purposes.
This work presents a modeler of a robotic arm in Java3D and its control using a
microcontroller, its control using Java2, finally shows an interface between the computer
and the robotic arm
IV
Agradecimientos
A mi madre, Lourdes Pacheco Reynoso, por el apoyo que me ha brindado durante
toda mi vida y en especial para este proyecto.
A mi hermana, Dulce Lourdes Loza Pacheco, por todo el apoyo brindado.
A mi amigo Rodrigo al que agradezco su amistad y su ayuda en la realización de
esta tesis.
Al M. en C. Juan Carlos Herrera Lozada, por brindarme su apoyo, por las ideas,
ayuda y conocimientos en este proceso.
Al M. en C. Israel Rivera Zárate, por el tiempo, el conocimiento y el apoyo
dedicados para la realización de esta tesis.
Al M. en C. Mauricio Olguín Carvajal, por las ideas, conocimiento y ayuda
brindada para la realización de esta tesis.
Al M. en C. Jesús Antonio Álvarez Cedillo, por la dedicación y apoyo vertidos en
esta tesis.
Al M. en C. Juan Carlos González Robles, por la dedicación y apoyo vertidos en
esta tesis.
Gracias infinitas a la mejor institución a la cual he tenido el privilegio de pertenecer.
Instituto Politécnico Nacional.
V
Índice
Resumen .......................................................................................................................... III
Abstract............................................................................................................................ IV
Índice ............................................................................................................................... VI
Lista de Figuras............................................................................................................. VIII
Lista de Tablas .................................................................................................................. X
Abreviaturas....................................................................................................................... 1
Glosario ............................................................................................................................. 2
Capítulo 1 .......................................................................................................................... 3
Introducción ................................................................................................................... 3
1.1 Importancia de la realidad virtual y del mando a distancia..................................... 3
1.2 Lenguajes de Programación en el diseño de mundos virtuales............................... 4
1.3 Planteamiento del problema .................................................................................. 5
1.4 Objetivo................................................................................................................ 6
1.4.1 Objetivos Particulares .................................................................................... 6
1.6 Justificación.......................................................................................................... 6
1.7 Descripción del proyecto ...................................................................................... 6
1.8 Organización de la tesis ........................................................................................ 7
Capítulo 2 .......................................................................................................................... 8
Marco Teórico................................................................................................................ 8
2.1 Realidad Virtual................................................................................................... 8
2.2 JAVA 2 ................................................................................................................ 8
2.3 Java 3D................................................................................................................. 9
2.4 Brazo Robótico................................................................................................... 11
2.6 Servomotores...................................................................................................... 11
2.6.1 Estructura interna del Servomotor ................................................................ 12
2.6.1.1 Motor de corriente continúa................................................................... 12
2.6.1.2 Circuito de control................................................................................. 12
2.6.1.3 Terminales ............................................................................................ 12
2.7 Puerto Serie ........................................................................................................ 13
2.7.2 Puerto serie tradicional................................................................................. 13
2.7.3 Puertos serie modernos ................................................................................ 14
2.7.4 Tipos de comunicaciones seriales................................................................. 14
2.7.4.1.1 Simplex .............................................................................................. 14
2.7.4.1.2 Duplex, half duplex o semi-duplex ..................................................... 14
2.7.4.1.3 Full Duplex ........................................................................................ 14
2.7.5 Norma RS-232 ............................................................................................. 14
2.8 Microcontroladores PIC.......................................................................................... 15
Capítulo 3 ....................................................................................................................... 17
3.1 Implementación del Brazo Robótico ....................................................................... 17
3.2 Capas de aplicación del Trabajo.............................................................................. 18
3.3 Integración de clases en el proyecto ........................................................................ 18
3.4 Diseño e Implementación del Brazo Robótico Virtual (Aplicación Gráfica)............ 19
3.5 Creación del Universo Virtual ................................................................................ 19
3.6 Rotación en Java 3D ............................................................................................... 23
VI
3.7 Clase Figuras .......................................................................................................... 25
3.7.1 Método DibujarFigurasCili()............................................................................ 25
3.7.2 Método DibujarFigurasCajas()......................................................................... 26
3.7.3 El método app(). .............................................................................................. 26
3.8 Dibujo del Brazo Robótico ..................................................................................... 27
3.9 La clase comportamiento ........................................................................................ 27
3.9.1 El constructor de la clase Comportamiento....................................................... 28
3.9.2 El método initialize y ProcessStimulus............................................................. 29
3.10 Eventos del Teclado.............................................................................................. 29
Capítulo 4 ........................................................................................................................ 31
4.1 Desarrollo de la interfaz de comunicaciones en JAVA ............................................ 31
4.2 Comunicación con un dispositivo externo (Uso de la biblioteca javax.comm)........ 31
4.2.1 acceso al puerto serie ....................................................................................... 32
4.2.2 Fijar los parámetros de comunicación .............................................................. 33
4.2.3 Método escribe().............................................................................................. 34
4.3 Interfaz de control con el brazo robótico (cada uno de los servos)........................... 34
4.3.1 Primer microcontrolador .................................................................................. 34
4.3.2 Segundo microcontrolador ............................................................................... 35
4.4 Esquema del Circuito.............................................................................................. 36
Capítulo 5 ........................................................................................................................ 38
5.1 Pruebas y Resultados .............................................................................................. 38
5.1.1 Primera comunicación a través del puerto serie ................................................ 38
5.1.2 Controlar un servomotor usando el puerto serie................................................ 42
5.1.3 Evolución del brazo robótico ........................................................................... 45
5.2 Conclusiones .......................................................................................................... 47
5.3 Trabajos Futuros..................................................................................................... 48
ANEXO A ....................................................................................................................... 49
ANEXO B........................................................................................................................ 53
ANEXO C........................................................................................................................ 56
ANEXO D ....................................................................................................................... 59
ANEXO C........................................................................................................................ 60
ANEXO D ....................................................................................................................... 62
REFERENCIAS............................................................................................................... 63
VII
Lista de Figuras
Figura 1.1: Proyecto COSMOS [2]..................................................................................... 4
Figura 1.2 Diagrama a bloques ........................................................................................... 7
Figura 2.1 Simbología de Java 3D .................................................................................... 10
Figura 2.2 Flechas de Java 3D ......................................................................................... 10
Figura 2.5 Brazo Robótico Lynx 6................................................................................... 11
Figura 2.3: Servo HI-TEC-322HD.................................................................................... 13
Figura 2.4 Pines del DB9.................................................................................................. 15
Figura 2.5 Arquitectura Interna del PIC16F628 ................................................................ 16
Figura 3.1 Interfaz RIOS 1 ............................................................................................... 17
Figura 3.2 Movimiento de las Extremidades con la Interfaz RIOS.................................... 17
Figura 3.3 Capas de Aplicación del Brazo Robótico ......................................................... 18
Figura 3.4 Relación de Clases........................................................................................... 19
Figura 3.5 “Diagrama de la Escena del Brazo Robótico Virtual” ...................................... 20
Figura 3.6 Rama de Contenido General ............................................................................ 21
Figura 3.7 Rama de Contenido “Figuras que conforman al brazo robótico” ...................... 22
Figura 3.8 Ejes X,Y,Z ...................................................................................................... 23
Figura 3.9 Rotación en X de un cubo................................................................................ 24
Figura 3.10 Rotación de un Cubo en Java 3D a) Imagen sin rotar b) Imagen Rotada 45° .. 24
Figura 3.11 Brazo Robótico Virtual.................................................................................. 27
Figura 4.1 Capas de Comunicación .................................................................................. 31
Figura 4.2 Esquema del Circuito PICA izquierda PICB derecha ...................................... 37
Figura 5.1 Primera Comunicación con le puerto serie ....................................................... 39
Figura 5.2 Diagrama de Flujo de primera comunicación con le Puerto Serie..................... 39
Figura 5.3 Hyperterminal ................................................................................................. 41
Figura 5.5 Diagrama a bloques “Manipulación de ........................................................... 43
un servomotor desde el puerto serie” ................................................................................ 43
Figura 5.6 A) Diagrama de flujo de la comunicación con el puerto Serie enviando un
carácter. B) Microcontrolador PIC recibiendo un carácter x y escribiendo un pulso en el
puerto B de salida............................................................................................................. 43
Figura 5.7 Brazo Robótico Real........................................................................................ 45
Figura 5.8 Brazo Robótico hecho en VRML..................................................................... 45
Figura A.1 Características del Archivo ............................................................................. 49
A.2 Inicio del Proceso de instalación ................................................................................ 49
A.3 Acuerdo de Licencia.................................................................................................. 50
A.4 Selección de Opciones adicionales............................................................................. 50
A.5 Proceso de instalación del JDK.................................................................................. 51
A.6 Opción para la instalación del JRE............................................................................ 51
Figura A.7 Proceso de instalación del JRE........................................................................ 52
Figura A.8 Finalización de la Instalación de Java ............................................................. 52
Figura B.1 Ejecución del Programa de Instalación........................................................... 53
Figura B.2 Acuerdo de Licencia de Java 3D v1.5 ............................................................. 53
Figura B.3 Confirmación de la Instalación........................................................................ 54
Figura B.4 Instalación de Java 3D .................................................................................... 54
Figura B.5 Finalización de la Instalación. ......................................................................... 55
VIII
C.1 Instalación de NetBeans............................................................................................. 56
Figura C.2 A) Instalación de módulos de NetBeans, B) Acuerdo de Licencia................... 56
Figura C.3 Ruta de Instalación de NetBeans y ruta donde se instalo el JDK...................... 57
Figura C.5 Confirmación e Instalación de Netbeans ......................................................... 58
Figura C.6 Confirmación e Instalación de Netbeans ......................................................... 58
IX
Lista de Tablas
Tabla 2.1 Tabla de Fabricantes ......................................................................................... 12
Tabla 3.1 Acciones del Teclado........................................................................................ 29
X
Abreviaturas
JDK Java development Kit
API Application Program Interface
JRE Java Runtime Environment
SDK Software Development Kit
VRML Virtual Reality Model Language
PIC Programmable Interrupt Controller
1
Glosario
Nombre
Definición
Electromecánico
Dicho de un dispositivo o de un aparato mecánico:
Accionado o controlado por medio de corrientes
eléctricas.[14]
Compilador
Un compilador es un programa que traduce un programa
escrito en un lenguaje de programación a otro lenguaje de
programación, generando un programa equivalente que la
máquina será capaz de interpretar. Usualmente el segundo
lenguaje es código máquina, pero también puede ser
simplemente texto. Este proceso de traducción se conoce
como compilación.[13].
Lenguaje de Programación
Un lenguaje de programación es un lenguaje que puede ser
utilizado para controlar el comportamiento de una máquina,
particularmente una computadora. Consiste en un conjunto
de símbolos y reglas sintácticas y semánticas que definen
su estructura y el significado de sus elementos y
expresiones.[13].
Realidad virtual es un sistema informático que genera
entornos artificiales, con una representación de las cosas a
través de medios electrónicos o representaciones de la
realidad.
Es un dispositivo que copia el movimiento de una
extremidad natural.
Es un circuito integrado que incluye las tres unidades
funcionales de una computadoras, cpu, memoria y unidades
de entrada salida.
Conexión física y funcional, entre dos dispositivos o
sistemas independientes.
Manipulación usando extremidades del cuerpo (contacto).
Se le dice realidad virtual aumentada cuando no solo se
interactúa con los entornos virtuales visuales, si no cuando
se emplean mas sentidos que el de la vista.
Realidad Virtual
Brazo Robótico
Microcontrolador
Interfaz
Control háptico
Realidad Virtual aumentada
2
Capítulo 1
Introducción
Hoy en día el campo de la robótica es extenso y multidisciplinario puesto que necesita de
varias ramas de la ciencia y de la tecnología como es el caso de la realidad virtual, cuyo
propósito es el de recrear un entorno existente en el mundo real o bien inexistente. Por otra
parte las aplicaciones de los Brazos robóticos son muy diversas desde la manipulación de
sustancias peligrosas, materiales explosivos o como parte de una línea de ensamblaje hasta
fines académicos y de investigación, entre otros. Finalmente la unión de estos elementos
provee una plataforma para un desarrollo mayor en cuanto a la robótica, sistemas digitales
y realidad virtual. Debido a que los entornos virtuales nos permiten un mejor diseño de los
movimientos de un sistema, brazo robótico, así como de su control remoto.
1.1 Importancia de la realidad virtual y del mando a distancia
Con el paso de los años la realidad virtual se ha vuelto una herramienta cada vez más
importante para el desarrollo de sistemas. Hoy en día el campo de la realidad virtual es una
herramienta muy valiosa en la simulación de fenómenos físicos, electromecánicos, etc.
Otra de sus aplicaciones se encuentra en el control a distancia, pués la realidad virtual tiene
como uno de sus propósitos es recrear un entorno existente en el mundo real o bien
inexistente y así tener una noción más clara del comportamiento de los objetos. En la
actualidad hay dos maneras de comunicarnos con entornos virtuales, la primera es controlar
un entorno virtual desde un elemento físico. Tal es el proyecto que se lleva a cabo en la
Instituto de Tecnología de Georgia el cual consiste en mover un títere y de acuerdo al
movimiento que se le haya inducido habrá un títere virtual con características de
movimiento similares que reaccionará en tiempo real [1] sin embargo la parte medular de
este trabajo está enfocada al control háptico.
El otro lado de la moneda es cuando desde un entorno virtual es posible manipular
elementos que existen en nuestra realidad tal es el caso del proyecto COSMOS que busca
operar un brazo robótico que está a 40 kilómetros de la superficie terrestre con el fin de
realizar misiones espaciales que consistan en la manipulación de objetos y reparación de los
mismos. La realización de este control sugiere la resolución de diversos problemas desde en
la reducción de costos espaciales en entrenamiento de astronautas y reduce riesgos como
que los astronautas reciban radiación solar cuando se encuentren en el espacio. En la figura
1.1 se observa boceto del brazo robótico COSMOS [2].
3
Figura 1.1: Proyecto COSMOS [2]
En este tópico podemos encontrar que también se pueden controlar dispositivos a distancia
orientado a la seguridad como se pretendió en el proyecto de “Tecnologías de Realidad
Virtual Avanzadas aplicadas a la vigilancia y sistemas de seguridad”, en donde se controlan
cámaras de vigilancia en una cabina de inmersión usando realidad virtual aumentada
[3].Finalmente hoy en día se desarrolla en la NASA un robot con características
humanoides, el cual se tiene contemplado enviar como apoyo en las misiones espaciales de
los transbordadores para realizar las tareas más pesadas por ejemplo los que se realizan al
exterior de la nave en las que un astronauta no puede realizar por un periodo muy largo
pues le afecta la radiación estelar y solar. Este robot será controlado desde la tierra. [6].
Ahora bien, la importancia de poder teleoperar objetos se evidencia analizando las
aplicaciones que se pueden desarrollar, como sucede al aumentar la percepción del
controlador para poder tomar decisiones más acertadas como se indica en el trabajo
titulado “Tecnologías de Visualización en 3D para robots teleguiados” que se desarrolló en
la Escuela Superior de Catania de Italia, cuya intención es demostrar la conjunción de dos
tecnologías la utilización de dispositivos de realidad virtual como cascos y la teleoperación
de dispositivos a distancia por medio de ambientes virtuales [4]. Otro de los trabajos que se
han llevado a cabo es en la Universidad de Bio Bio Colombia, es la simulación de un brazo
robótico para reducir costos de aprendizaje y su colaboración con la docencia. Todo esto
gracias a su laboratorio de sistemas Automatizados de Producción [11].
1.2 Lenguajes de Programación en el diseño de mundos virtuales
Hoy en día casi cualquier lenguaje de programación de nivel intermedio puede usarse para
creación de mundos virtuales, claro la efectividad de cada uno de éstos varía debido a que
muchos no están enfocados al manejo de gráficos, por otra parte, hay lenguajes que están
4
enfocados a su manejo o bien a la programación de mundos virtuales tal es el caso de
VRML y de Java.
Una muestra la da el desarrollo de mundos virtuales, que se lleva a cabo en la Universidad
Yuan-Ze, Ahí se tiene como propósito el desarrollo de entornos cabe destácar que el fin de
este desarrollo son los metadatos y el tratamiento que se les puede hacer, como por
ejemplo, el realizar una consulta [5]. Incluso en nuestro país para la programación de
entornos virtuales se ha adoptado VRML por la facilidad que ofrece su licencia tal es el
caso de un trabajo que se llevo a cabo en el CINVESTÁV es una tesis con el nombre
“Robótica Asistida por Tele operación y Realidad Virtual” en la cual se aborda la importancia
de desarrollar un entorno virtual que se pueden considerar la tele operación del mismo
usando Java y VRML.[7]. Por otra parte tenemos la potencia del lenguaje de programación
Java y el desarrollo de una nueva API llamada Java 3D la cual puede graficar escenarios
con una apariencia tridimensional, con el cual se pueden desarrollar varias aplicaciones
como juegos, o bien manipular entornos virtuales usando un dispositivo externos [11].Sin
embargo el usar un lenguaje como Java nos da muchas ventajas debido a la gran potencia
de este lenguaje de programación [9], a diferencia de VRML el cual solo es un lenguaje de
graficación.
1.3 Planteamiento del problema
En los trabajos mencionados anteriormente se abordan diferentes maneras en las que se
puede interactuar con un mundo virtual, la primera en la que este recibe estímulos de un
dispositivo externo. La segunda que se expondrá en este trabajo en que el entorno virtual
controla un elemento físico. Ahora bien este trabajo llevo a cabo la solución de diferentes
problemas tanto físicos como de software. Lo que podemos observar de los trabajos
anteriores es que el lenguaje de programación que ha empleado es VRML combinado con
Java, sin embargo no se había llevado una integración total con Java. Ahí es donde entra
Java 3D el cual siendo una API de Java es posible tener una homogeneidad entre los
módulos. Se plantea la comunicación con un elemento externo, como hemos visto en la
mayoría de las aplicación se usa un dispositivo externo como un robot o bien otros
sistemas. En está tesis se realiza primero una comunicación con un microcontrolador a
través del puerto serie de la PC, para controlar el servo. Finalmente podemos ver que el
microcontrolador se comunicara con cualquier tipo de sistema mientras reciba una entrada
lógica de la computadora tendrá una salida lógica que pude ser utilizado por cualquier
dispositivo en este caso se uso un brazo robótico como ejemplo.
5
1.4 Objetivo
Modelar un brazo robotico y controlarlo mediante un microcontrolador que servirá como interfaz
entre la computadora y el puerto serie.
Este trabajo presenta el modelado de un brazo robótico en Java 3D así como de su control
mediante un microcontrolador, de su control usando Java 2 y finalmente se muestra una
interfaz entre la computadora y el brazo mecánico o bien con otros objetos, o dispositivos.
Finalmente se desarrolló lo siguiente:
1.4.1 Objetivos Particulares
•
•
•
•
Diseño del brazo robótico virtual. Utilizando Java 3D
Diseño de la animación del Brazo Robótico
Diseñar la interfaz en Java que permita la comunicación de la computadora con un
microcontrolador que controle el brazo robótico
Diseño del programa para el PIC y del esquema del circuito que se comunicara con
los servos
1.6 Justificación
El entorno virtual que permitirá el diseño el movimiento del brazo robótico antes de que
estos se realicen y en dado caso identificar problemas dentro de la planificación de
movimiento. Además del control de este mediante la computadora. De acuerdo a lo anterior
será posible la manipulación de objetos a distancia los cuales pueden ser peligrosos o bien
el proceso puede ser repetitivo como para que se realicen por una persona. Los resultados
de este trabajo de tesis, se utilizaran en el laboratorio de realidad virtual
1.7 Descripción del proyecto
Este trabajo presenta el desarrollo de los siguientes bloques. Se recurrió el desarrollo de la
interfaz gráfica, ésta a su vez enviará datos a un lector de datos, el cual le indicará que
extremidad del brazo se deberá mover. El evaluador de datos recibe información del lector
de datos y este evaluara su ese movimiento es válido en el entorno virtual, finalmente se
convertirán los datos y se envían a través del puerto serie. Finalmente la interfaz recibirá
datos del programa de comunicación si son datos validos de movimiento moverá una
extremidad del brazo (véase figura 1.2).
6
Figura 1.2 Diagrama a bloques
1.8 Organización de la tesis
Este trabajo está dividido en cinco capítulos
En el primer capítulo se habla de los trabajos que se han realizado referentes al tema hasta
el momento y las motivaciones que llevaron a desarrollar la tesis, así como una solución
propuestá al problema planteado, en el capítulo dos se abordan temas necesarios para
entender de una manera global lo que es. Los capítulos posteriores están divididos de
manera que cada uno habla específicamente de una funcionalidad propia del prototipo.
En el capítulo tres encontramos se mencionan características físicas del brazo robótico, así
como de sus procedimientos de implementación. Se habla del software nativo que usa el
brazo para realizar sus movimientos. Como primera parte se toca el tema del modelado del
brazo robótico en Java 3D, de igual manera de su entorno virtual así como de las cuestiones
graficas. También se da una explicación al desarrollo de la clase lector de datos la cual
tomara los datos de la clase grafica para poder enviarlos al evaluador de datos. Al final del
capítulo se contempla abordar el tema de la programación de la animación.
El capítulo versa sobre las clases internas necesarias para el control del brazo robótico
desde la computadora como son la clase comunicaciones y la interfaz de comunicación PCmicrocontrolador-brazo robótico, hasta la clase evaluador de datos la cual decide si un
movimiento del brazo robótico es correcto o no. En este capítulo se aborda la programación
de Java 2 y de su relación con las funcionalidades de Java 3D.
El último capítulo aborda las conclusiones a las que se llegaron con este trabajo, las pruebas
y resultados así como su aportación para el desarrollo para trabajos futuros. Además
contiene los trabajos de pruebas y resultados que se llevaron durante la realización del
presente.
7
Capítulo 2
Marco Teórico
El marco teórico está dividido en dos secciones. En la primera se hablará de los
conocimientos básicos de software necesarios para comprender los siguientes capítulos con
definiciones tales como realidad virtual, Java, Java 3D. En la segunda parte de este capítulo
se abordaran los conceptos de hardware, como el uso del brazo robótico, así como lo
referente a los motores que usa.
2.1 Realidad Virtual
Realidad virtual es un sistema informático que genera entornos artificiales, con una
representación de las cosas a través de medios electrónicos o representaciones de la
realidad.
La realidad virtual puede ser de dos tipos: inmersiva y no inmersiva. Los métodos
inmersivos de realidad virtual con frecuencia se ligan a un ambiente tridimensional creado
por una computadora o arreglos de computadoras, el cual se manipula a través de cascos,
guantes u otros dispositivos que capturan la posición y rotación de diferentes partes del
cuerpo humano. La realidad virtual no inmersiva también utiliza la computadora y se vale
de medios como el que actualmente ofrece VRML1, Java 3D o bien algunos sitios de
Internet, en los cuales se interactúa con diferentes personas en espacios y ambientes que en
realidad no existen y no necesitan dispositivos adicionales a la computadora.
La realidad virtual no inmersiva ofrece un nuevo mundo a través de una ventana de
escritorio. Este enfoque tiene varias ventajas sobre el inmersito, como son el bajo costo,
facilidad de uso y rápida aceptación de los usuarios. Los dispositivos inmersivos son de alto
costo y generalmente el usuario prefiere manipular el ambiente virtual por medio de
dispositivos familiares como son el teclado y el ratón que por medio de cascos pesados o
guantes.
2.2 JAVA 2
1
Virtual Reality Modeling Language – Lenguaje de Modelado de realidad
8
Java es un lenguaje de programación orientado a objetos desarrollado por Sun
Microsystems a principios de los años 90. El lenguaje en sí mismo toma mucha de su
sintaxis de C y C++, pero tiene un modelo de objetos más simple y elimina herramientas de
bajo nivel, que suelen inducir a muchos errores, como la manipulación directa de punteros
o memoria.
Java Platform, Enterprise Edition o Java EE (anteriormente conocido como Java 2
Platform, Enterprise Edition o J2EE hasta la versión 1.4), es una plataforma de
programación—parte de la Plataforma Java—para desarrollar y ejecutar software de
aplicaciones en lenguaje de programación Java con arquitectura de n niveles distribuida,
basándose ampliamente en componentes de software modulares ejecutándose sobre un
servidor de aplicaciones.
La plataforma Java EE está definida por una especificación. Similar a otras
especificaciones del Java Community Process, Java EE es también considerada
informalmente como un estándar debido a que los suministradores deben cumplir ciertos
requisitos de conformidad para declarar que sus productos son conformes a Java EE; no
obstante sin un estándar de ISO o ECMA.
2.3 Java 3D
Java 3D es una interfaz de comunicaciones que permite escribir programás para
representar e interactuar con gráficos en tres dimensiones. Java 3 D es la normal extensión
de Java 2D. la API de Java 3D provee de refinados constructores para crear y manipular de
objetos y estructuras en 3D con pocas instrucciones se pueden crear visualizaciones,
animaciones y rederivaciones en 3D.
Java 3D es una sofisticada jerarquía de clases que permite tanto la creación de gráficos
como de sonidos en tres dimensiones, programados a un alto nivel para crear y manipular
datos geométricos en 3D. Estos objetos existen un universo virtual que más tarde son
renderizados (representados). La API se ha diseñado con la flexibilidad suficiente para
crear universos virtuales de gran variedad de tamaños (del grado astronómico al atómico).
Los símbolos que presentamos a continuación se estructuran de la siguiente manera. Los
dos primeros símbolos representan objetos de las clases específicas Universo Virtual
(Virtual Universe) y Local (Local). Las tres siguientes clases representan objetos de Grupo
(Group), Hoja (Leaf) y componentes de nodo (Node Component). Estos tres símbolos
suelen especificarse para indicar subclases de un objeto específico. El último símbolo se
9
usa para representar cualquier otra clase de objeto. La figura 2.1 expresa lo que sería la
simbología de Java 3D.
Nodes y Node Comnponents (objetos)
Virtual Universe
Leaf
Locale
Node
Component
Group
Otros
Objetos
Figura 2.1 Simbología de Java 3D
Además de las clases de objetos también podremos usar dos tipos de flechas. La flecha
continua representaría la relación de dependencia padre hijo (parent-child) entre dos
objetos. La línea punteada hará referencia (referente) a otro tipo de objetos de otras ramás
del árbol. Por lo que el número de flechas que puedan salir de un objeto no están limitadas
a una. La forma en que se dibujan las flechas la podemos ver la figura 2.2. [10][11]
Flechas (relaciones entre objetos)
parent.child link
reference
Figura 2.2 Flechas de Java 3D
10
2.4 Brazo Robótico
Se utilizó un brazo robótico de la compañía Lyxmotion que tiene cinco grados de libertad y
el movimiento una pinza[17].
Figura 2.5 Brazo Robótico Lynx 6
El brazo robótico cuenta con movimientos de hombro, codo, movimiento de la muñeca,
rotación de la muñeca y una pinza. Este brazo robótico es controlado mediante el puerto
serie usando el software RIOS implementado por a compañía Lynx. El brazo incluye cuatro
servomotores HI-TEC HS-475. La base usa un servo motor HS-422. Además de los
servomotores HS-85 y el servo HS-81 el cual es para la pinza.
2.6 Servomotores
Un servomotor es un dispositivo similar a un motor de corriente continua, que tiene la
capacidad de ubicarse en cualquier posición dentro de su rango de operación, y mantenerse
estable en dicha posición. Está conformado por un motor, una caja reductora y un circuito
de control.
11
2.6.1 Estructura interna del Servomotor
2.6.1.1 Motor de corriente continúa
Es el elemento que le brinda movilidad al servo. Cuando se aplica un voltaje a sus dos
terminales, este motor gira en un sentido a su velocidad máxima. Si el voltaje aplicado sus
dos terminales es inverso, el sentido de giro también se invierte.
Engranajes reductores, se encargan de convertir gran parte de la velocidad de giro del
motor de corriente continua en torque.
2.6.1.2 Circuito de control
Este circuito es el encargado del control de la posición del motor. Recibe los pulsos de
entrada y ubica al motor en su nueva posición dependiendo de los pulsos recibidos.
2.6.1.3 Terminales
Los servomotores tienen 3 terminales:
Terminal positivo: Recibe la alimentación del motor (4 a 8 voltios)
Terminal negativo: Referencia tierra del motor (0 voltios)
Entrada de señal: Recibe la señal de control del motor
Los colores del cable de cada terminal varían con cada fabricante: el cable del terminal
positivo siempre es rojo; el del terminal negativo puede ser marrón o negro; y el del
terminal de entrada de señal suele ser de color blanco, naranja o amarillo. A continuación
en la tabla 2.1 podemos ver las diferencias entre colores de terminales de cada uno de los
servos de diferentes compañías.
Fabricante
HI-TEC
Futaba
JR
Airtronics
Fleet
Kraft
Positivo
Rojo
Rojo
Rojo
Rojo
Rojo
Rojo
Negativo
Negro
Negro
Negro
Marron
Negro
Negro
Entrada de señal
Amarillo
Blanco
Naranja
Naranja
Blanco
Naranja
Tabla 2.1 Tabla de Fabricantes
En este caso los servomotores del brazo mecánico implementado son HI-TEC.
Dependiendo del modelo del servo, la tensión de alimentación puede estár comprendida
entre los 4 y 8 voltios. El control de un servo se reduce a indicar su posición mediante una
12
señal cuadrada de voltaje. El ángulo de ubicación del motor depende de la duración del
nivel alto de la señal. Cada servo motor, dependiendo de la marca y modelo utilizado, tiene
sus propios márgenes de operación.
Para bloquear el servomotor en una posición, es necesario enviarle continuamente una señal
con la posición deseada. De está forma el servo conservará su posición y se resistirá a
fuerzas externas que intenten cambiarlo de posición. Si los pulsos no se envían, el
servomotor queda liberado, y cualquier fuerza externa puede cambiarlo de posición
fácilmente. En la figura 2.se aprecia la forma física de un servo de la marca HI-TEC.
Figura 2.3: Servo HI-TEC-322HD
2.7 Puerto Serie
Un puerto de serie es una interfaz de comunicaciones y periféricos en donde la información
es transmitida bit a bit enviando un solo bit a la vez, en contraste con el puerto paralelo que
envía varios bits simultáneamente.
2.7.2 Puerto serie tradicional
El puerto serie RS-232 (también conocido como COM) por excelencia es el que utiliza
cableado simple desde 3 hilos hasta 25 y que conecta computadoras o microcontroladores a
todo tipo de periféricos, desde terminales a impresoras y módems pasando por ratones.
La interfaz entre el RS-232 y el microprocesador generalmente se realiza mediante el
integrado 82C50.
El RS-232 original tenía un conector tipo D de 25 pines, sin embargo la mayoría de dichos
pines no se utilizaban, por lo que IBM incorporó desde su PS/2 un conector más pequeño
de solamente 9 pines que es el que actualmente se utiliza.
13
2.7.3 Puertos serie modernos
Uno de los defectos de los puertos serie iniciales era su lentitud en comparación con los
puertos paralelos -hablamos de 19.2 kbits por segundo- sin embargo, con el paso del
tiempo, están apareciendo multitud de puertos serie de alta velocidad que los hacen muy
interesantes ya que utilizan las ventajas del menor cableado y solucionan el problema de la
velocidad con un mayor apantallamiento, siendo más barato usando la técnica del par
trenzado. Por ello, el puerto RS-232 e incluso multitud de puertos paralelos están siendo
reemplazados por nuevos puertos serie como el USB, el Firewire o el Serial ATA.
2.7.4 Tipos de comunicaciones seriales
2.7.4.1.1 Simplex
En este caso el transmisor y el receptor están perfectamente definidos y la
comunicación es unidireccional. Este tipo de comunicaciones se emplean
usualmente en redes de radiodifusión, donde los receptores no necesitan enviar
ningún tipo de dato al transmisor.
2.7.4.1.2 Duplex, half duplex o semi-duplex
En este caso ambos extremos del sistema de comunicación cumplen funciones de
transmisor y receptor y los datos se desplazan en ambos sentidos pero no
simultáneamente. Este tipo de comunicación se utiliza habitualmente en la
interacción entre terminales y una computadora central.
2.7.4.1.3 Full Duplex
El sistema es similar al duplex, pero los datos se desplazan en ambos sentidos
simultáneamente. Para ello ambos transmisores poseen diferentes frecuencias de
transmisión o dos caminos de comunicación separados, mientras que la
comunicación semi-duplex necesita normalmente uno solo.
2.7.5 8orma RS-232
La Norma RS-232 fue definida para conectar un computadora a un módem. Además de
transmitirse los datos de una forma serie asíncrona son necesarias una serie de señales
adicionales, que se definen en la norma. Las tensiones empleadas están comprendidas entre
+15/-15 voltios. En la figura 2.4 podemos visualizar los pines del DB-9.
14
TX
RX
RS
CTS
|
DSR
Computadora
DCD
Figura 2.4 Norma RS232
DTR
RI
GND
Figura 2.4 Pines del DB9
2.8 Microcontroladores PIC
La arquitectura de los PIC [18] está basada en la arquitectura Harvard1, con memorias de
programa y datos de programa separados. Como en la mayoría de los microcontroladores la
memoria de programa es mucho mayor que la memoria de datos. La memoria de programa
está organizada en palabras de 12, 14 ó 16 bits, mientras que la memoria de datos está
compuestá por registros de 8 bits. El acceso a los diversos dispositivos de entrada y salida
se realiza a través de algunos registros de la memoria de datos, denominados registros de
funciones especiales (SFR: Special Function Register). Muchos microcontroladores PIC
cuentan con una cierta cantidad de memoria EEPROM para el almacenamiento no volátil
de datos.
Desde el punto de vista del programador, el modelo general de los microcontroladores PIC
consta de un registro de trabajo (registro W) y los registros de la memoria de datos. Para las
operaciones aritméticas y lógicas, uno de los operándos debe está en el registro W y el
resultado se obtiene en W o en cualquier registro de la memoria de datos. Las transferencias
de datos se realizan entre algún registro de la memoria de datos y el registro W, aunque en
los PIC de la gama alta se permiten transferencias directas entre registros de la memoria de
datos, sin necesidad de pasar por el registro W. Se dispone de instrucciones para acceder a
cualquier bit de cualquier registro de la memoria de datos.
Todos los microcontroladores PC aplican la técnica del segmentado (pipeline) en ejecución
de las instrucciones, en dos etapas, de modo que las instrucciones se ejecutan en un único
ciclo de
instrucción, equivalente a cuatro ciclos del oscilador principal del
microcontrolador, excepto las instrucciones de transferencia de control que toman dos
ciclos d e instrucción.
1
Arquitectura Harvard - Es aquella que divide los datos y las instrucciones en localidades de datos,
dividiendo los buses de direccionamiento.
15
Otra característica común de los microcontroladores PIC es la forma en que está
implementada la pila. La pila no forma parte de la memoria de datos sino que ocupa un
espacio independiente y tiene además una profundidad limitada, según el modelo de PIC.
En estos microcontroladores no hay un puntero de pila (registro SP: stack pointer), tan
común en la mayoría de los microprocesadores y en muchos microcontroladores.
Muchos microcontroladores PIC pueden ser programados en el propio circuito de
aplicación (ICSP: IN-Circuit Serial Programming), utilizando un pequeño número de líneas
[12].En la figura podemos ver la arquitectura interna del PIC16F628
Figura 2.5 Arquitectura Interna del PIC16F628
16
Capítulo 3
3.1 Implementación del Brazo Robótico
El software nativo del brazo robótico viene con un software llamado RIOS el cual
permite su control (véase figura 3.1).
Figura 3.1 Interfaz RIOS 1
La siguiente interfaz (véase figura 3.2) nos permite tener un control de todos los
servomotores y darles un giro seleccionándolos. Habilitando el motor en este caso, se
puede observar que todos los servos están habilitados, y el movimiento se realiza
deslizando las barras hacia arriba o hacia abajo.
Figura 3.2 Movimiento de las Extremidades con la Interfaz RIOS
17
3.2 Capas de aplicación del Trabajo
Este trabajo está formado por cuatro capas, una donde se encuentra la aplicación gráfica,
otra que controla los eventos del teclado que tendrá la comunicación bidireccional con la
aplicación grafica, una más que se encarga de la comunicación con el puerto serie y
finalmente una capa física que recibe la información del puerto serie y manda información
al brazo robótico tal como lo muestra la figura 3.3.
Aplicación Grafica
(Creación de la Escena)
Eventos del Teclado
Comunicación Serie
Interfaz del Microtontrolador
Figura 3.3 Capas de Aplicación del Brazo Robótico
3.3 Integración de clases en el proyecto
El trabajo está integrado
funcionalidad, la primera de
principal que se encuentra
principal.java. Está clase se
por 3 clases las cuales están divididas de acuerdo a su
ellas es la creación de la escena, el nombre de está clase es
en el archivo principal.class y su código en el archivo
ayuda de dos clases secundarios, una para la creación de la
18
figuras llamado figuras.class, y su código modificable se encuentra en figuras.java.
Finalmente se tiene la clase comportamiento que se encarga de recibir los estímulos por
parte del usuario para darle un movimiento. La integración de estos modulo los podemos
visualizar en la figura 3.4.
Figura 3.4 Relación de Clases
3.4 Diseño e Implementación del Brazo Robótico Virtual
(Aplicación Gráfica)
El brazo robótico está conformado por la unión de varios objetos básicos como cilindros y
cajas estándo organizados de tal manera que le dan forma a un brazo robótico virtual. Sin
embargo para esto es necesario desplazar cada figura y rotarla de tal manera que queden en
la posición deseada.
Después es necesario colorear la figura y agregarle una apariencia. Finalmente a todo el
brazo robótico será necesario agregar una luz direccional para crear en el usuario la
apariencia de que el objeto está siendo iluminado de frente. Finalmente se realiza la
animación del brazo robótico virtual. Está animación se efectuar cuando el usuario realiza
una interacción con está tendrá que moverse de acuerdo al lugar que el usuario especifico.
Todas estás funcionalidades se han dividido en pequeños módulos que realicen esa tarea los
cuales son el dibujo del brazo robótico virtual, la programación del movimiento de acuerdo
a la interacción con el usuario .Estos módulos se dividen en más subtareas básicas que
permiten realizar la programación de una manera más sencilla.
3.5 Creación del Universo Virtual
Por principio es necesario realizar el diseño de la escena de nuestro entorno virtual en la
siguiente figura 3.5 se muestra el diagrama de la escena del brazo robótico. Podemos
observar que el diseño del diagrama del la escena no es muy complejo puesto que contiene
los elementos esenciales de cualquiera. El primer elemento se ve de arriba hacia abajo es
19
un rectángulo con sus esquinas redondeadas además está relleno con líneas transversales y
que está representa nuestro universo virtual de la escena.
A su vez este universo contiene un universo más pequeño que es de ámbito local el cual es
representado por el rombo, más adelante se observa que de este rombo se desprenden dos
ramas, una rama que nos va a representar gráficamente a nuestros objetos (se encarga del
tamaño de la ventana, tipo de soporte grafico dado el sistema operativo etc.) que
conocemos como rama de representación o que llamamos universo simple.
La otra rama se le llama rama de contenido y contiene los objetos. Como son objetos de
transformación, objetos behavior lo cual rige el comportamiento de nuestra figura durante
su ejecución y finalmente hasta abajo un hijo de nuestros objetos de transformación está
nuestro brazo robótico que en como verá más adelante es una suma de varios elementos
básicos como cajas y cilindros. Se verá que cada figura básica contiene una apariencia y
una geometría (véase figura 3.5).
TG
B
Universo
Simple
TG
Brazo
Robótico
Figura 3.5 “Diagrama de la Escena del Brazo Robótico Virtual”
20
El rectángulo del brazo robótico está conformado por varias figuras primitivas, con una
rotación específica su rama de representación se muestra en la figura 3.6 la cual seria la
rama de contenido de nuestro brazo robótico para cada figura primitiva.
BG
Objeto Raíz
(objRoot)
TG
B
Objeto (objSpin)
Transformación
TG
Objeto Traslación
TG
Shape 3D
S
Geometría
Apariencia
Caja o Cilindro
Box o Cylinder
Figura 3.6 Rama de Contenido General
La rama de contenido del brazo robótico está constituida por la suma de varias figuras
primitivas que son cajas y cilindros, ahora bien en la figura anterior se visualizan varios
objetos que constituyen la rama de contenido el primero es un objeto raíz que necesitamos
para interconectar nuestra rama de contenido con el universo virtual, después podemos
observar un Objeto de Transformación sobre el cual vamos a ligar los otros objetos que
tenemos abajo, sobre este objeto va a tener incidencia la clase comportamiento que es la
que nos va a dar un comportamiento de cada objeto en general. Más adelante tenemos un
objetos de Traslación que va a mover a la figura del origen a otro punto en el plano x, y y z
21
(más adelante explicaremos como Java 3D interpreta las coordenadas x ,y , z en el universo
local que es nuestro monitor.).
Como hijo se tiene el objeto de rotación que es el que vamos a rotar sobre las coordenadas
x, y y z. Y como rama final se tiene a nuestra figura 3.7 que depende de la clase
SHAPE3D cuya clase nos proporciona figuras primitivas que nosotros podemos utilizar.
Está debe de tener una geometría y una apariencia para que pueda ser vista por el usuario.
Se usan finalmente ocho cajas y siete cilindros para darle forma al brazo robótico.
Figura 3.7 Rama de Contenido “Figuras que conforman al brazo robótico”
22
3.6 Rotación en Java 3D
Para abordar este tema hay que entender bien primero cómo se efectúa la rotación en Java
3D. Los ejes que usamos son los ejes convencionales de tres dimensión el eje x , el eje y y
el eje z que se usa para darle profundidad a una imagen de dos dimensiones. La percepción
del usuario será que los objetos se moverán de izquierda a derecha, usando el eje x, los
objetos se desplazaran de arriba hacia abajo con el eje y y finalmente tendrá la percepción
de que estos se acercan o alejan con el eje z .En la figura 3.8 podemos ver los ejes
cartesianos usado por Java 3D
y
x
z
Figura 3.8 Ejes X,Y,Z
Ahora bien las rotaciones se harán respecto al eje que se desee rotar ya sea el eje X, y o Z y
sobre ese eje se rotara como se muestra en la siguiente imagen. Además es necesario crear
un objeto de rotación de tipo Transform3d par eso es necesario declara el objeto de rotación
Transform3D rotacion=new Transform3D();
Trás haber creado el objeto de rotación podremos usar el método de rotación rotX, rotY o
bien rotZ
Transform3D rotacion=new Transform3D();
rotacion.rotX(Math.PI/4);
El objeto rotará en radianes, para rotarlo 45° este tendrá que rotar PI/4 y así para todas las
rotaciones. Un ejemplo lo podemos ver en la figura 3.9. y en la figura 3.10 podemos ver
como seria la rotación en Java 3D.
23
y
El objeto girara respecto al eje X
x
z
Figura 3.9 Rotación en X de un cubo
Figura 3.10 Rotación de un Cubo en Java 3D a) Imagen sin rotar b) Imagen Rotada 45°
Finalmente es posible combinar cada rotación usando el método mul como se observa a
continuación, y guardar el resultado de esa multiplicación en el objeto Tranform3D que se
desee.
rotacion.rotX(Math.PI/4);
rotacion2.rotY(Math.PI/3.0d);
//giramos el objeo alrededor del eje y
rotacion.mul(rotacion2);
24
3.7 Clase Figuras
Para realizar el modelado del brazo robótico como se había comentado antes fue necesario
la realización de una clase que dibujará modularmente cada una de sus partes del. Se
aprovecharon las figuras primitivas como son caja (Box) y cilindro (Cylinder). Para esto
fue necesaria la programación de una clase llamada figuras la cual consta de dos métodos,
una para dibujar el cilindro y otra para dibujar la caja, además de un método adicional el
cual es Appearance el cual le va a dar una apariencia a cada una de las figuras que se usen.
3.7.1 Método DibujarFigurasCili()
Este es un método público que devuelve un objeto TransforGroup que más tarde se
agregara a la hoja de nodos de la escena. Los parámetros que recibe este método son, el
radio y el alto del cilindro, así como su traslación en x, en y y en z, también recibirá los
parámetros de rotación en x, y y en z, finalmente recibirá el objeto que la figura tendrá. Más
adelante crearemos un objeto para realizar la traslación del objeto geométrico, este objeto
será de tipo Transform3D se necesitaran otros objetos auxiliares para la rotación de nuestra
figura geométrica.
public TransformGroup DibujarFigurasCili(float radio,float alto,
float traslacion_x,float traslacion_y,float traslacion_z,
double rotacion_x,double rotacion_y,double rotacion_z,
float red,float green, float blue){
Transform3D translateCilindro1=new Transform3D();
Transform3D RotTmp2=new Transform3D();
Transform3D RotTmp2_1=new Transform3D();
Transform3D RotTmpZ=new Transform3D();
translateCilindro1.set(new Vector3f(traslacion_x,traslacion_y,
traslacion_z));
RotTmp2.rotX(rotacion_x);
RotTmp2_1.rotY(rotacion_y);
RotTmpZ.rotZ(rotacion_z);
RotTmp2.mul(RotTmp2_1);
RotTmp2.mul(RotTmpZ)
TransformGroup objTranslate= new TransformGroup(translateCilindro1);
TransformGroup objRotado=new TransformGroup(RotTmp2);
objTranslate.addChild(objRotado);
objRotado.addChild(new Cylinder(radio,alto,app(red,green,blue)));
return objTranslate;
}
25
3.7.2 Método DibujarFigurasCajas()
El método DibujarFigurasCajas, es un método análogo al de dibujar cilindros, su diferencia
radica en el paso de parámetros de sus dimensiones físicas. Ya que recibirá 3 medidas que
corresponden al alto, ancho y largo. Este método devolverá al igual que su método hermano
un objeto TransformGroup
public TransformGroup DibujarFigurasCaja(float medida1,float medida2,
float medida3,
float traslacion_x,float traslacion_y,float traslacion_z,
double rotacion_x,double rotacion_y,double rotacion_z,
float red,float green, float blue ){
Transform3D translateCilindro1=new Transform3D();
Transform3D RotTmp2=new Transform3D();
Transform3D RotTmp2_1=new Transform3D();
Transform3D RotTmpZ=new Transform3D();
translateCilindro1.set(new Vector3f(traslacion_x,traslacion_y,
traslacion_z));
RotTmp2.rotX(rotacion_x);
RotTmp2_1.rotY(rotacion_y);
RotTmpZ.rotZ(rotacion_z);
RotTmp2.mul(RotTmp2_1);
RotTmp2.mul(RotTmpZ);
TransformGroup objTranslate= new TransformGroup(translateCilindro1);
TransformGroup objRotado=new TransformGroup(RotTmp2);
objTranslate.addChild(objRotado);
objRotado.addChild(new Box(medida1,medida2,medida3,
Primitive.GENERATE_TEXTURE_COORDS |
Primitive.ENABLE_GEOMETRY_PICKING,
app(red,green,blue)));
return objTranslate;
}
3.7.3 El método app().
EL método app() devolverá un objeto Appearance y recibirá como parámetro tres flotantes,
estos indicaran el color de la figura. Como en los casos anteriores necesitamos la creación
de un objeto de apariencia, así como crear un objeto ColoringAttributes llamado coloAtt y
como parámetros para su constructor serán sus características de transformación
public Appearance app(float a,float b, float c){
Appearance app= new Appearance();
ColoringAttributes coloAtt=
new ColoringAttributes(a,b,c,
26
ColoringAttributes.ALLOW_COLOR_WRITE);
app.setColoringAttributes(coloAtt);
Material objMaterial = new Material( );
objMaterial.setDiffuseColor( a, b, c );
app.setMaterial( objMaterial );
return app;
}
3.8 Dibujo del Brazo Robótico
Finalmente dibujaremos el brazo robótico llamando en orden a cada uno de los métodos
que dibujan cada una de nuestras figuras, para que quede finalmente de la forma que queda
en la figura 3.11
Figura 3.11 Brazo Robótico Virtual
3.9 La clase comportamiento
Se necesito la clase comportamiento para crear una interacción del usuario con el entorno
virtual y para esto necesitamos crear un objeto behavior. Todo Objeto behavoir deberá
contener un constructor en este caso el constructor recibe el mismo nombre de la clase, el
cual recibe el nombre de comportamiento, además deberá contener dos métodos básicos
para el manejo de los eventos que el usuario introduzca, los cuales son initialize; el cual
inicializará los paramentos, así como un método de respuestá llamado processStimulus este
estimulo lo provocara el usuario.
27
3.9.1 El constructor de la clase Comportamiento
El objeto Comportamiento será creado desde la clase onceavo, en la cual estáblecemos los
parámetros de la escena. Este recibiera todas las hojas de todos los elementos del brazo
robótico, esto con la finalidad para que se puedan mover de manera independiente.
Podemos observar en el siguiente segmento de código que el objeto recibirá 13 hojas de la
escena.
public Comportamiento(TransformGroup modificarTG,
TransformGroup modificar1TG,
TransformGroup modificar2TG,
TransformGroup modificar3TG,
TransformGroup modificar4TG,
TransformGroup modificar5TG,
TransformGroup modificar6TG,
TransformGroup modificar7TG,
TransformGroup modificar8TG,
TransformGroup modificar9TG,
TransformGroup modificar10TG,
TransformGroup modificar11TG,
TransformGroup modificar12TG,
TransformGroup modificar13TG)
El constructor de la clase Comportamiento lo único que realiza es la asignación de las
Variables transformGroup y la creación de un evento para leer la entrada estándar del
teclado. Estos estímulos son controlados por el método WakeupOn.
this.modificarTG=modificarTG;
this.modificar1TG=modificar1TG;
this.modificar2TG=modificar2TG;
this.modificar3TG=modificar3TG;
this.modificar4TG=modificar4TG;
this.modificar5TG=modificar5TG;
this.modificar6TG=modificar6TG;
this.modificar7TG=modificar7TG;
this.modificar8TG=modificar8TG;
this.modificar9TG=modificar9TG;
this.modificar10TG=modificar10TG;
this.modificar11TG=modificar11TG;
this.modificar12TG=modificar12TG;
this.modificar13TG=modificar13TG;
AWTEventCondition = new WakeupOnAWTEvent(KeyEvent.KEY_PRESSED);
28
3.9.2 El método initialize y ProcessStimulus
El método initialize se active soló una vez cuando el usuario pulsa una tecla. Las veces
sucesivas que el usuario pulse una tecla llamará al método ProcessStimulus el cual mandará
una señal al brazo robótico de acuerdo a la tecla qué se pulso que motor debe mover.
public void initialize()
{
this.wakeupOn(AWTEventCondition);
}
3.10 Eventos del Teclado
El método ProcessStimulus es el que se estárá llamando cada que el usuario pulse una tecla
y cada tecla activa un movimiento del brazo robótico como se muestra en la tabla 3.1.
Tecla
q
w
e
r
t
y
u
i
o
p
a
s
Acción
Movimiento de la Base a la Derecha
Movimiento de la Base a la Izquierda
Movimiento del Hombro hacia adelante
Movimiento del Hombro hacia atrás
Movimiento codo hacia abajo
Movimiento codo hacia arriba
Movimiento Muñeca hacia abajo
Movimiento Muñeca hacia arriba
Rotación Muñeca en el sentido del reloj
Rotación Muñeca en el sentido negativo del reloj
Cerrar Pinzas
Abrir Pinzas
Tabla 3.1 Acciones del Teclado
El siguiente fragmento de código nos indica la acción que se obtiene de pulsar en el teclado
la tecla ‘q’ minúscula, el cual activara a una función llamada MoverbrazoRelojPos( )
además de que escribirá en el puerto serie el valor uno el cual lo recibirá el
microcontrolador.
public void processStimulus( java.util.Enumeration enumeration )
{
AWTEvent [] evt =((WakeupOnAWTEvent)AWTEventCondition).getAWTEvent();
29
if (AWTEventCondition.hasTriggered()){
for(int i=0;i<evt.length;i++){
if(((KeyEvent)evt[i]).getKeyChar()=='q'){
moverY=MovebrazoRelojPos( );
System.out.println("Movimiento Base Negativo");
escribe('1');
}
}
this.wakeupOn(AWTEventCondition);
}
30
Capítulo 4
4.1 Desarrollo de la interfaz de comunicaciones en JAVA
Una de las interfazs más usada entre la computadora dispositivos externos con la
computadora es el puerto serie y esto nos permite conectarnos con el mundo exterior. Para
esto usamos un API de comunicaciones de JAVA, constituido por el paquete javax.comm,
que proporciona JavaSoft por lo que este conjunto de clases no forma parte del JDK (Java
Development Kit). Con está API es posible realizar comunicaciones con el puerto serie, un
MODEM o bien manipular el puerto paralelo. La semántica que utiliza está API es similar a
la semántica que se utiliza con las clases de entrada y salida que ya se conocen en JAVA y
que forman parte del JDK básico del conjunto de bibliotecas de JAVA. El API de
javax.comm nos permite enviar y recibir información al puerto serie. Sin embargo en la
aplicación solo se usa una comunicación unidireccional. Para esto es necesario
proporcionar un conjunto de parámetros como son: velocidad de transmisión, bus de datos,
paridad, bits de parada y si usa un control de flujo. Se describirá las capas de
comunicaciones en la figura 4.1.
Figura 4.1 Capas de Comunicación
4.2 Comunicación con un dispositivo externo (Uso de la
biblioteca javax.comm)
El trabajo que se realiza en la capa de comunicaciones son los siguientes: Abrir el
dispositivo y acondicionar la línea a la velocidad, paridad, etc. que se requiera. Escribir o
31
leer algunos datos siguiendo el protocolo especificado. En este caso se le enviarán los
caracteres ‘1’, ‘2’,’3’,’4’,’5’,’6’,’7’,’8’,’A’,’B’,’C’. Finalmente se cerrara el puerto.
4.2.1 acceso al puerto serie
Lo primero que se tendrá que hacer es declarar la variable necesaria para la inicialización
del puerto serie como se muestra a continuación:
Se declarará una variable de tipo Enumeration para insertas todos los posibles puertos que
encontremos como por ejemplo el COM1,COM2, etc.
static Enumeration listaPuertos;
Se declarara una variable CommPortIdentifier que nos servirá para darle un identificador al
puerto que deseemos utilizar.
static CommPortIdentifier idPuerto;
Declararemos una variable tipo SerialPort para nuestro puerto serie que manejaremos
durante toda la ejecución del programa.
static SerialPort puertoSerie;
Necesitamos una variable de tipo OutputStream para escribir en el puerto Serie en el pin de
transmisión.
Static OutputStream salida;
Empezamos buscando todos los puertos que existen en la computadora con el método
getPortIdentifiers de la clase CommPortIdentifier y estos valores se los vamos a asignar a la
matriz que declaramos con anterioridad declarada listaPuertos , como es posible que
encontremos más de un elementos necesitamos almacenar todos ellos en listaPuertos.
Después necesitamos identificar que tipo de puerto usaremos, puerto paralelo o serie nos
valemos del método get.PortType() para identificarlo. Finalmente el puerto que
emplearemos será el COM1, por lo que lo buscaremos en nuestro arreglo.
listaPuertos = CommPortIdentifier.getPortIdentifiers();
while( listaPuertos.hasMoreElements() ) {
idPuerto = (CommPortIdentifier)listaPuertos.nextElement();
if( idPuerto.getPortType() == CommPortIdentifier.PORT_SERIAL ) {
if( idPuerto.getName().equals("COM1") ) {
32
Para abrir el puerto Serie necesitaremos del método open el cual recibirá dos parámetros el
nombre que le daremos a está conexión así como el tiempo que tendrá que esperar por los
datos en este caso 2000 milisegundos.
try {
puertoSerie = ( SerialPort )idPuerto.open("AplEscritura",2000);
} catch( PortInUseException e ) {}
Ahora necesitaremos un canal de salida para poder escribir en el puerto Serie y esto lo
obtenemos con el método getOutputStream que no recibe parámetros y que devolverá el
valor a nuestra variable salida que es de tipo OutputStream.
try {
salida = puertoSerie.getOutputStream();
} catch( IOException e ) {}
4.2.2 Fijar los parámetros de comunicación
Para fijar los parámetro de comunicación usaremos el método setSerialPortParams().El cual
recibirá como parámetros la velocidad de transmisión que sera de 9600 bauds .El segundo
parámetro será el numero de bits que enviaremos, el cual será de ocho. El tercero se refiere
a los bits de parada que será un bit de parada. Y finalmente el ultimo argumento que
recibirá será los bits de paridad, en este caso no fue necesario el uso de bits de paridad.
Además necesitamos estáblecer que no necesitamos estáblecer control de flujo, el cual no
necesitamos usamos el método setFlowControlMode().
try {
puertoSerie.setSerialPortParams( 9600,
SerialPort.DATABITS_8,
SerialPort.STOPBITS_1,
SerialPort.PARITY_8O8E );
puertoSerie.setFlowControlMode(SerialPort.FLOWCO8TROL_8O8E);
} catch( UnsupportedCommOperationException e ) {}
}
}
}
33
4.2.3 Método escribe()
Para escribir en el puerto serie fue necesario la escritura del método escribe() dentro de la
clase comportamiento. Éste recibirá un carácter y lo enviará por el puerto serie hacia el
microcontrolador
public void escribe(char a){
try {
salida.flush();
salida.write(a);
System.out.println(a);
} catch (IOException ex) {
Logger.getLogger(comportamiento.class.getName()).log(Level.SEVERE, null, ex);
} }
4.3 Interfaz de control con el brazo robótico (cada uno de
los servos)
Para el control del servo fue necesario de dos microcontroladores uno que reciben un flujo
de información de la computadora a través del puerto serie y además que controlara el
movimiento de tres servos: el movimiento de la muñeca, el movimiento de la muñeca
cuando rota y finalmente la pinza que abre y que cierra. El segundo microcontrolador
refresca con un ancho de pulso 50Hhz además de que actualizaría sus valores que envía
desde la computadora .Este PIC controla la base, el hombro y el codo.
4.3.1 Primer microcontrolador
El primer microcontrolador recibe la información del puerto Serie y la distribuye la
información de la base, el hombro, el codo y el codo en este caso al segundo
microcontrolador, de la muñeca, de la rotación de la muñeca de la acción abrir y cerrar
pinzas. Todo esto usando un switch-case y sacara las salidas en sus puertos A y B. El
primer microcontrolador sólo controla los movimientos de la muñeca, la rotación de la
muñeca y de abrir y cerrar pinzas los otros tres movimientos se los delega al segundo.
34
Include "modedefs.bas"
i var byte
tiempo var byte
aux var byte
aux2 var byte
aux3 var byte
aux4 var byte
aux5 var byte
aux6 var byte
uno:
PORTA.6=1
PAUSE 25
PORTA.6=0
return
dos: PORTA.7=1
PAUSE 25
PORTA.7=0
RETURN
tres: PORTA.0=1
PAUSE 25
PORTA.0=0
RETURN
cuatro: PORTA.1=1
PAUSE 25
PORTA.1=0
RETURN
cinco: PORTB.6=1
PAUSE 25
PORTB.6=0
RETURN
seis: PORTB.7=1
PAUSE 25
PORTB.7=0
RETURN
siete: IF aux4<250 THEN aux4=aux4+10
pulsout PORTB.3, aux4
RETURN
ocho: IF aux4>50 THEN aux4=aux4-10
pulsout PORTB.3, aux4
RETURN
nueve: IF aux5<250 THEN aux5=aux5+10
pulsout PORTB.4, aux5
RETURN
diez: IF aux5>50 THEN aux5=aux5-10
pulsout PORTB.4, aux5
RETURN
once: IF aux6<250 THEN aux6=aux6+10
pulsout PORTB.5, aux6
RETURN
doce: IF aux6>50 THEN aux6=aux6-10
pulsout PORTB.5, aux6
RETURN
END
dato var byte
CMCON = 7
'Deshabilitación de comparadores
TRISA = $04 'Puerto A2 Como Entrada
TRISB = $00 'Todo el puerto B como salida
aux=150
aux2=150
aux3=150
aux4=150
aux5=150
aux6=150
push: serin PORTA.2, N9600, tiempo
CALL deco
pause 18
goto push
deco: select case tiempo
Case "1": CALL uno '120 x 10 uS,
considerando Osc de 4MHz
Case "2": CALL dos'1 y 2 base
Case "3": CALL tres
Case "4": CALL cuatro'3 y 4 hombro
Case "5": CALL cinco'cinco
Case "6": CALL seis'5 y 6 codo
Case "7": CALL siete
Case "8": CALL ocho '7 y 8 muñeca
Case "9": CALL nueve
Case "A": CALL diez
'9 y A rotacion muñeca
Case "B": CALL once
Case "C": CALL doce ' B y C pinza
end select
RETURN
4.3.2 Segundo microcontrolador
El segundo microcontrolador tiene el control de la Base, el hombro y el codo, esto por que
estás extremidades necesitan forzosamente que estén activas y recibiendo información todo
el tiempo por lo que la finalidad del segundo PIC es estár refrescando la información a
estos tres servos todos el tiempo hasta que reciba una orden del PICA de mover una
35
extremidad que el PICB control. Cabe mencionar que fue necesario esto debido el peso que
soportan estás extremidades impide que se sostengan
@ DEVICE MCLR_OFF, INTRC_OSC, WDT_OFF, LVP_OFF, BOD_OFF, PWRT_OFF, PROTECT_OFF
Include "modedefs.bas"
tiempo var byte
Base var byte
Hombro VAR BYTE
Codo VAR BYTE
CMCON = 7
'Deshabilitación de comparadores
TRISA = $FF
TRISB = $00
Base=150
Hombro=150
Codo=150
push: IF PORTA.0=1 THEN Hombro=Hombro+5'hombro
IF PORTA.1=1 THEN Hombro=Hombro-5'hombro
IF PORTA.2=1 THEN Codo=Codo+5'codo
IF PORTA.3=1 THEN Codo=Codo-5'codo
IF PORTA.6=1 THEN Base=Base+5'Base
IF PORTA.7=1 THEN Base=Base-5'Base
PULSOUT PORTB.0,Base
PULSOUT PORTB.1,Hombro
PULSOUT PORTB.2,Codo
PAUSE 18
goto push
END
4.4 Esquema del Circuito
Finalmente tenemos el esquema de interconexión de los circuitos PICA y PICB de
izquierda a derecha respectivamente.
36
Figura 4.2 Esquema del Circuito PICA izquierda PICB derecha
37
Capítulo 5
5.1 Pruebas y Resultados
Durante el desarrollo del trabajo fue necesario realizar diversas pruebas, a cada una de las
capas del sistema.
5.1.1 Primera comunicación a través del puerto serie
Objetivo
Enviar una cadena de información por el puerto serie usando la biblioteca comm API 2.0 y
recibir la información a través del puerto serie de otra computadora y visualizarlo con el
programa Hyperterminal.
Materiales Hardware
1 Computadoras
1 Cable serial Hembra-Hembra cruzado
Materiales Software
Netbeans 6.0
JDK 1.6
JRE 1.6
Comm API 2.0
Porgrama Hyperterminal de Windows1
Procedimiento
Lo que se realizó fue interconectar con el cable cruzado una computadora con la otra y
mostraremos la interconexión de las computadoras con el siguiente diagrama a bloques de
la figura 5.1.
1
El programa Hyperterminal ya no es incluido en Windows Vista por lo que si requieren realizar prueba en
Windows vista es necesario descargar un programa Hyperterminal gratuito.
38
Figura 5.1 Primera Comunicación con le puerto serie
Ahora a continuación se describe el siguiente diagrama de flujo (Véase Figura 5.2) que nos
da una idea básica de lo que realiza el programa de comunicación. La ejecución del
programa se abre el puerto y envía una cadena y cierra el puerto.
Figura 5.2 Diagrama de Flujo de primera comunicación con le Puerto Serie
En está prueba lo que se hizo fue escribir el código básico para abrir el puerto serie,
estáblecer los parámetro de comunicación tales como velocidad de transmisión el cual será
de 9600 baudios, número de bits de datos que será de ocho, el tipo de paridad que se usara
el cual usaremos la constante SerialPort.PARITY_NONE, los bits de parada que usaremos
que será de un bit y finalmente el control de flujo el cual seleccionamos “ninguno”.
Finalmente teniendo el código como se muestra en el siguiente código.
39
public class PuertoSerial {
static Enumeration listaPuertos;
static CommPortIdentifier idPuerto;
static String mensaje = "Hola Mundo\n";
static SerialPort puertoSerie;
static OutputStream salida;
public static void main( String[] args ) {
listaPuertos = CommPortIdentifier.getPortIdentifiers();
while( listaPuertos.hasMoreElements() ) {
idPuerto = (CommPortIdentifier)listaPuertos.nextElement();
if( idPuerto.getPortType() == CommPortIdentifier.PORT_SERIAL ) {
if( idPuerto.getName().equals("COM1") ) {
try {
puertoSerie = ( SerialPort )idPuerto.open("AplEscritura",2000);
} catch( PortInUseException e ) {}
try {
salida = puertoSerie.getOutputStream();
} catch( IOException e ) {}
try {
puertoSerie.setSerialPortParams( 9600,
SerialPort.DATABITS_8,
SerialPort.STOPBITS_1,
SerialPort.PARITY_NONE );
} catch( UnsupportedCommOperationException e ) {}
try {
salida.write( mensaje.getBytes() );
System.out.println(mensaje);
salida.close();
} catch( IOException e ) {}
}
}
}
}
}
Finalmente se ejecuta el programa Hyperterminal en Windows, Cuando esté abierto
crearemos una nueva conexión y la nombraremos como deseemos en este caso llamamos
“ddd”. Seleccionaremos el botón “Restáurar Predeterminados”, y deberemos verificar que
tenga los mismos valores que maneja nuestro programa en java (véase la figura 5.3).
40
Figura 5.3 Hyperterminal
Observaciones
Se observo que la cadena de caracteres que se envió fue recibida de manera integra por la
hyperterminal.
Resultados
Al ejecutar el programa el programa envió la cadena “Hola Mundo” la cual fue recibida por
la hyperterminal.
Conclusiones
Se envió una cadena de datos e este caso el mensaje que fue enviado fue “Hola Mundo” el
cual para poder enviar este mensaje fue necesario estáblecer los parámetros de
comunicación como son, velocidad de transmisión, control de flujo, paridad, bits de datos,
bits de para y finalmente control de flujo. Se recibió la información usando e programa
Hyperterminal de Windows. Pero paras poder recibir esos datos fue necesario estáblecer los
mismos parámetros antes mencionados. También se descubrió que la aplicación
hyperterminal ya no viene dentro del paquete de aplicación del sistema de Windows vista
por loo que se tuvo que descargar el paquete “Hyperterminal Prívate Edición”
41
5.1.2 Controlar un servomotor usando el puerto serie
Objetivo
Enviar un carácter por el puerto serie, mismo que lo recibirá un microcontrolador y
finalmente moverá el servo moto si este es un dato valido. De lo contrario no realizara
ninguna acción.
Materiales Hardware
1 Computadora
1 Cable serie macho hembra
1 Copler1 Serie
1 PIC 16FC628
1 Servomotor HS-322
1 Terminal Molex2
Cable den numero 22 (telefónico ).
Materiales Software
Netbeans 6.0
JDK 1.6
JRE 1.6
Comm API 2.0
Porgramador universal de PICs3
Compilador PIC Basic PRO
MicroCodeStudio
Procedimiento
Lo que se desea hacer es mandar un carácter a través del puerto serie y este que sea recibido
por el microcontrolador PIC para que sea procesado y de ser valido el carácter este moverá
en alguna dirección el servomotor .En la figura 5.5 vemos el diagrama a bloque de la
aplicación.
1
Un copler serie es una acoplador Serie-Serie tipo Hembra-Hembra.
Una Terminal molex es un puerto de tres terminales
3
Una Terminal molex es un puerto de tres terminales
2
42
Figura 5.5 Diagrama a bloques “Manipulación de
un servomotor desde el puerto serie”
Ahora escribiremos el diagrama de flujo desprograma que se comunica con el puerto serie
(Véase Figura 5.6.A)y el diagrama de flujo del programa del microcontrolador (Véase
Figura 5.6.B.
Inicio
Lectura del Puerto
Serie
NO
¿Carácter
valido?
SI
Escribir en el bit 0
del puerto B
Figura 5.6 A) Diagrama de flujo de la comunicación con el puerto Serie enviando un carácter. B)
Microcontrolador PIC recibiendo un carácter x y escribiendo un pulso en el puerto B de salida
43
A continuación escribiremos u fragmento de código el cual lee una entra del puerto serie y
la procesa, moviendo un servomotor.
tiempo var byte
aux var byte
CMCON = 7
'Deshabilitación de comparadores
TRISA = $04 'Puerti A2 Como Entrada
TRISB = $00 'Todo el puerto B como salida
aux=150
push: serin PORTA.2, N9600, tiempo
IF tiempo=”x” THEN mover
PAUSE 18
GOTO push
mover: IF aux4<250 THEN aux=aux+10
pulsout PORTB.0, aux
RETURN
END
Observaciones
Se pudo observar que al llegar al pulso máximo el servomotor se detuvo
Resultados
Al ejecutar el programa este enviaba un carácter al PIC el cual al recibir en este caso el
carácter x minúscula rotaba el servomotor a la derecha.
Conclusiones
Se envió un carácter por el puerto serie y este fue recibido por el microcontrolador, el cual
al recibir el carácter x minúscula movía el servo a la derecha a la siguiente posición,
44
5.1.3 Evolución del brazo robótico
Durante el trabajo se creo una similitud entre el brazo robótico real y el brazo robótico
virtual. En la figura 5.7 vemos una ilustración del brazo real.
Figura 5.7 Brazo Robótico Real
Lo primero que se hizo fue un modelado en VRML para tener una idea básica de que
partes conformarían el brazo robótico y cómo se interconectaría con figuras básicas en este
caso con cajas y cilindros. En la figura 5.8 vemos una imagen hecha en VRML
Figura 5.8 Brazo Robótico hecho en VRML
Finalmente se tiene el modelado del brazo robótico en Java 3D sin embargo este brazo
robótico no tenia las características de apariencia o de incidencia de la luz de frente,
solamente era un brazo robótico con colores sólidos.
45
La versión final del prototipo fue la creación del método de apariencia así como de la
creación de una luz que incidiera de frente al brazo robótico (véase figura 5.3)
Figura 5.9 Brazo Robótico en Java 3D con luz direccional
46
5.2 Conclusiones
Este trabajo presento un modelado de un brazo robótico en un ambiente virtual usando Java
3D, así como el control de un brazo real externo usando el puerto serie mediante el lenguaje
de programación Java. Se realizo una interfaz entre el microcontrolador entre la
computadora y el brazo robótico.
•
Se modelo el brazo robótico virtual utilizando Java 3D y Java, a través del armado
de figuras primitivas como son caja y cilindro.
•
Se realizo la animación del brazo robótico el cual responde estímulos del teclado de
la PC
•
Se realizo la interfaz en Java que permite la comunicación de la computadora
mediante el puerto serie con un microcontrolador.
•
Se diseño la interfaz que permite la comunicación de la computadora con el servo
esto usando dos microcontroladores PIC16F628
Para la elaboración del control del brazo robótico a través de un brazo virtual fue necesaria
la integración de cuatro módulos. Las dos primeras capas son referentes al control del
mundo virtual, la segunda capa que es la de animación tiene añadida una subcapa que se
comunica con el puerto serie el cual pasa la información al microcontrolador PIC16F628.
Las otras dos capas tienen que ver con la interfaz de puerto serie con el brazo robótico. Para
se uso la API javax.comm además se necesito de PIC para mediar la comunicación entre la
computadora y los servos del brazo robótico.
Se pudo apreciar la diferencia entre la API de Java 3D versión 1.4.* y la versión 1.5 la cual
no es compatible con el NetBeans versión 6. Así como de la maquina virtual 1.6 y el JDK
1.6. Se comprendió la importancia de no actualizar la maquina virtual cuando se está
desarrollando una aplicación pues debido a que teóricamente las versiones posteriores JRE
son más estábles y compatibles con archivos *.class compilados con una versión anterior
de JDK y probados sobre una versión anterior de JRE pueden provocar excepciones no
contempladas. Se encontró que la API comm 2.0 (javax.comm ) es la ultima API liberada
para el control de puerto serie , paralelo hecha para el sistema operativo Windows.
47
5.3 Trabajos Futuros
Dentro de las aplicaciones de este trabajo se pretende obtener una interfaz confiable con la
cual se puedan conectar cualquier dispositivo para ser controlado mediante una
computadora. El entorno virtual que permitirá el diseño el movimiento del brazo robótico
antes de que estos se realicen y en dado caso identificar problemas dentro de la
planificación de movimiento. Además del control de este mediante la computadora. De
acuerdo a lo anterior será posible la manipulación de objetos a distancia los cuales pueden
ser peligrosos o bien el proceso puede ser repetitivo como para que se realicen por una
persona.
Como aplicaciones a futuro el sistema podrá integrar con una serie de brazos robóticos
quizás para formar un autómata o una línea de ensamble como pudiera ser para la soldadura
de una tabla fenolica o bien de dibujar pistas con el brazo. Por otra parte la inmersión del
ambiente virtual pondría enriquecerse con la integración de un guante que manipule el
ambiente virtual, proyecto que actualmente existe en el CIDETEC. Y finalmente como un
aporte al laboratorio de realidad virtual. Por otra parte la inmersión del ambiente virtual
pondría enriquecerse con la integración de un guante que manipule el ambiente virtual,
proyecto que actualmente existe en el CIDETEC.
48
A8EXO A
Instalación del JDK 1.6
Para Windows la aplicación necesaria que se uso fue jdk-6u2-windows-i586-p.exe. Este
archivo ejecutable contiene la maquina virtual 1.6 necesarias para ejecutar archivos *.class
de java .También trae el compilador de java así como diversas bibliotecas necesarias para
programar en Java. A continuación describiremos los pasos necesario para las instalación
del Kit de desarrollo de programadores (JDK).Este entorno se instalo sobre Windows XP y
sobre Windows Vista. El proceso de instalación que se describirá a continuación será para
Windows Vista.
El primer paso de instalación de JDK es descargarlo del sitio de java.sun.com donde
buscaremos la versión JDK 1.6 para Windows, descargaremos el JDK sin la documentación
debido a que este es un archivo muy pesado. El archivo que descarguemos será un archivo
llamado jdk-6u2-windows-i586-p.exe. Lo que no indica que es el JDK versión seis, para
Windows y para procesadores tipo Pentium. Daremos doble clic en el archivo ejecutable
como se muestra en la figura A.1.
Figura A.1 Características del Archivo
Al doble clic sobre la pantalla el archivo ejecutable nos desplegara una pantalla como la de
la figura A.2. Lo que nos indicara que programa está descomprimiendo los archivos
necesarios para la instalación.
A.2 Inicio del Proceso de instalación
A continuación el programa nos pedirá que leamos los acuerdos de la licencia para usar el
software en caso de estár de acuerdo (Figura A.3) daremos clic en aceptar.
49
A.3 Acuerdo de Licencia
Después tendremos la opción de escoger las herramientas que el programador necesitara
dejaremos las opciones predeterminadas como aparece en la figura A.4 y seleccionaremos
el botón “Next” para continuar con la instalación.
A.4 Selección de Opciones adicionales
Finalmente el programa instalara todos los componentes del JDK, está operación tardara
algunos minutos y dependerá de la velocidad del procesador o el tamaño de la memoria
RAM y del numero de aplicaciones que se estén ejecutando junto con nuestro programa de
instalación (Figura A5).
50
A.5 Proceso de instalación del JDK
Cuando haya completado el proceso de instalación del JDK, ahora la aplicación nos pedirá
instalar el ambiente de ejecución de Java (Java Runtime Environment –JRE) como los
podemos ver en la figura A.6. Una vez más dejaremos las opciones predeterminadas y
seleccionáremos la opción siguiente.
A.6 Opción para la instalación del JRE
Finalmente dos desplegara un cuadro de dialogo indicándonos que se están instalando todos
los componentes necesarios para instalar el JRE (Figura A.7).
51
Figura A.7 Proceso de instalación del JRE
Cuando termine de instalar todos los elementos necesarios nos desplegara un cuadro de
dialogo indicándonos que la instalación se concreto satisfactoriamente y seleccionaremos el
botón de finalizar “Finísh” (Figura A.8).
Figura A.8 Finalización de la Instalación de Java
52
A8EXO B
Instalación de Java 3D
Ahora necesitaremos instalar la API de Java 3D, en su versión 1.5 o bien superior pues
solamente está versión es compatible con el entorno de desarrollo NetBeans y con el JDK
1.6 y la maquina virtual 1.6.descararemos Java 3D de la pagina java.sun.com y buscaremos
versión 1.5 para Windows y para procesadores tipo Pentium. El archivo que
descargaremos será como el de la figura B.1.El nombre del archivo indicara en nombre del
programa que será Java 3D, luego la versión, seguido del sistema operativo para el cual
fue compilado y finalmente el tipo de procesador en el que se ejecuta la aplicación.
Ejecutaremos la aplicación y es probable que en el Windows vista nos pida autorización
para ejecutar el programa.
Figura B.1 Ejecución del Programa de Instalación
El programa de instalación nos desplegara el acuerdo de licencia. Seleccionaremos aceptar
“Accept” para continuar la instalación (Figura B.2).
Figura B.2 Acuerdo de Licencia de Java 3D v1.5
Después visualizaremos un cuadro de dialogo de confirmación donde nos indicara la ruta
donde se instalaran las clases y las bibliotecas dinámicas de Java 3D (Figura B.3).Entonces
revisaremos los datos y seleccionáremos el botón de Instalar “Install”.
53
Figura B.3 Confirmación de la Instalación
El programa instalara todos los módulos necesarios, este proceso no durara mucho pero
depende de la capacidad de procesamiento del CPU así como de la memoria RAM libre de
la computadora. La figura B.4 nos ilustra este proceso.
Figura B.4 Instalación de Java 3D
Cuando haya finalizado de instalar e integrar todos los módulos necesarios se desplegara un
cuadro de dialogo que nos indica que la instalación se llevo a cabo de manera exitosa
(Figura B.5).
54
Figura B.5 Finalización de la Instalación.
55
A8EXO C
Instalación de 8etBeans
El entorno de desarrollo fue NetBeans, para su instalación es necesario descargar el archivo
compilado para Windows, Ejecutaremos el archivo y tendremos la siguiente pantalla que se
muestra en la figura C.1
C.1 Instalación de NetBeans
EL recuadro de la figura C.2.A nos indica que módulos serán instalados en la computadora,
es importante que si es la primera vez que se instala este entorno de desarrollo se dejen la
opciones predeterminadas de instalación. En la figura C.2.B nos muestra el cuadro de
dialogó del acuerdo de licencia, seleccionamos el radioboton y damos clic en el botón de
siguiente “Next”.
Figura C.2 A) Instalación de módulos de NetBeans, B) Acuerdo de Licencia
Luego el programa de instalación del Entorno de desarrollo aso como la ruta del JDK que
previamente instalamos en la computadora, verificamos que los datos se encuentres en
orden y damos clic en siguiente (Véase Figura C.3).
56
Figura C.3 Ruta de Instalación de NetBeans y ruta donde se instalo el JDK
Las preguntas siguientes que nos realizar el programa son la ruta de instalación de un
contenedor Web llamado NetBeans así como de la ruta de instalación del compilador Java,
finalmente la contraseña del administrador que adminstara el contenedor Web y los puertos
en el que encontraremos el servidor en la figura C.4 observamos las opciones que se
eligieron
Figura C.4 Instalación del Contenerlo Web
Finalmente se recibirá un cuadro de confirmación de la instalación al que le daremos
siguiente y finalmente se instalaran todos los elementos del entorno de desarrollo. El
proceso de instalación puede durar varios minutos pues es una instalación de un programa
de alrededor 470MB (Véase Figura C.5).
57
Figura C.5 Confirmación e Instalación de Netbeans
Finalmente el programa de instalación nos indicará que la instalación de llevo a cabo de
manera satisfactoria (Véase Figura C.6)
Figura C.6 Confirmación e Instalación de Netbeans
58
A8EXO D
Instalación del comm api 2.0
La biblioteca comm api 2.0 contiene métodos, clases y objetos capaces de manejar el puerto
paralelo por lo que es necesaria su instalación en java o bien en la maquina virtual.Y los
pasos de instalación son los siguientes:
Descomprimir el archivo javacomm20-win32.zip
Copiar el archivo win32com.dl al directorio <JDK>\jre\bin
Copiar el archivo comm.jar al directorio <JDK>\jre\lib
Copiar el archivo javax.comm.propierties al directorio <JDK>\jre\lib
Copiar el archivo win32com.dl al directorio <JDK>\bin
Copiar el archivo comm.jar al directorio <JDK>\lib
Copiar el archivo javax.comm.propierties al directorio <JDK>\lib
Si es que solamente se pretende instalar la aplicación
Copiar el archivo win32com.dl al directorio <JRE>\bin
Copiar el archivo comm.jar al directorio <JRE>\lib
Copiar el archivo javax.comm.propierties al directorio <JRE>\lib
59
A8EXO C
Arquitectura interna de la familia 16FC628.
60
Terminales del PIC16F628
61
A8EXO D
Hoja de especificaciones de los SERVOS HI-TEC
Estos servos se refrescan cada 21 milisegundos.
Su centro se sitúa a 150 milisegundos.
Su extremo superior se sitúa 210 milisegundos.
Su extremo inferior se sitúa a 90 milisegundos.
Recibe un voltaje de entre 4.5 a 6 volts.
62
REFERE8CIAS
[1] Ali Mazalek , Michael Nitsche “Tangible Interfaces for Real-Time 3D Virtual
Environments “ ,Experimental Games Lab, Georgia Institute Technology ,2004
[2]Jean-Francois Lapointe, “Cosmos: VR-Based Proof-of Concept Interface for Advanced
Space Robot Control” Canada ,2004
[2] Jean-François Lapointe ,“COSMOS: A VR-Based Proof-of-Concept Interface for
Advanced Space Robot Control”,Canada,2004
[3] Renaud Ott, Mario Gutierrez ”Advanced Virtual Reality Technologies for
Surveillance and Security Applications”, Virtual Lab Florida ,ITESM Toluca
[4] Renaud Ott, Mario Gutierrez ”Advanced Virtual Reality Technologies for
Surveillance and Security Applications”, Virtual Lab Florida ,ITESM Toluca, Escuela
Superior de Catania Italia,2004
[5] Tien-Lung Sun,Simplified Animation Circuit for Metadata-based Behavior Model
Query and Retrieval , Universidad de Yaun-Ze China
[6]S. M. Goza, R. O. Ambrose,Telepresence Control of the NASA/DARPA Robonaut
on a Mobility Platform,NASA Estádos Unidos,2004
[7]Tien-Lung Sun,”Simplified Animation Circuit for Metadata-based Behavior
Model Query and Retrieval”,Universidad Yuan-Ze Taiwán ,2003
[8] Java I/0 2nd Edition 2006 Elliotte Rusty Harold Editorial O’Reilly
[9] Java 2 Curso de Programacion Fco. Javier Ceballos
[10] Andrew Davidson, Java 6 3D Game Developement ,2005,Appress
[11] Joan J. Pratdepadua , Programación en 3D con Java 3D ,2003, Alfa Omega
[12] Fernando E Valdez Pérez ,Microcontroladores fundamentos y Aplicaciones con PIC
[13] Tony Zhang Aprenda C en 24 Horas , 2001,Prentice Hall
[14] Diccionario de la Real Academia de la Lengua,2005
[13] Tetsuo Sawaragi and Yukio Horiguchi, Ecological Interface Enabling HumanEmbodied cognition Mobiles robot teleoperation.
63
[14] Philip Lamb, Dean Owen, Human performance in Sapace Telerobotic Manipulation
[15] Revista Digital Universitaria – Implementación de Robot SCORBOT ERVRPLUS, para docencia en realidad virtual.- Juan Carlos Parra Márquez y Karina [12]
Pilar Cid Cifuentes-Académicos de la Universidad del Bío-Bío
[16] Java 2 Interfaces graficas y Aplicaciones para Internet
[17] Manual del brazo robótico lynxmotion
[18] Manual del PIC16F62X (microchip.com)
[19] Manual de especificaciones de los Servos HI-TEC
64