Download INSTITUTO POLITÉCNICO NACIONAL “Brazo Robótico Controlado
Document related concepts
no text concepts found
Transcript
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