Generación y transmisión de órdenes de movimiento a un vehículo tipo Quad

PFC: Generación y Transmisión de órdenes de movimiento a un vehículo autónomo tipo QUAD PROYECTO FINAL DE CARRERA CARMEN ARBONA DE LA ASUNCIÓN DIRIGIDO POR: ENRIQUE JORGE BERNABEU SOLER PFC: Generación y Transmisión de órdenes de movimiento a un vehículo autónomo tipo QUAD 1 A mi Director de Proyecto, Enrique Jorge Bernabeu Soler, por su dedicación y por darme la oportunidad de realizar este proyecto. A mis padres, por el apoyo y la confianza que día tras día han ido depositando en mí dándome todos los medios y facilidades para llegar a este momento. A mi hermana, por haber sido mi referente y modelo a seguir durante toda mi vida y de haber estado ahí siempre que he necesitado el apoyo y cariño de una hermana mayor. A mi novio, por sus consejos, paciencia y sobre todo por haberme regalado momentos tan inolvidables durante estos años. A mis amigos, compañeros de clase y compañera de prácticas, por haberme ayudado a superar los obstáculos que año tras año se iban presentando. Por último, y no menos importante, a aquellas personas que, aún no pudiendo estar presentes, sé que estarían muy orgullosas de mí. PFC: Generación y Transmisión de órdenes de movimiento a un vehículo autónomo tipo QUAD 2 ÍNDICE PARTE I: PROYECTO ---------------------------------------------------------------------------------------------------- 8 1RESUMEN ----------------------------------------------------------------------------------------------------------- 9 2PALABRAS CLAVE ----------------------------------------------------------------------------------------------- 10 3INTRODUCCIÓN ------------------------------------------------------------------------------------------------- 11 3.1Descripción de los objetivos --------------------------------------------------------------------------- 11 3.2Motivación ------------------------------------------------------------------------------------------------- 11 3.3Contenido de la memoria ------------------------------------------------------------------------------ 12 4CONTEXTO DEL PROYECTO----------------------------------------------------------------------------------- 13 4.1Introducción a la Robótica ----------------------------------------------------------------------------- 13 4.1.1Historia de la Robótica --------------------------------------------------------------------------------------- 14 4.1.2Robots móviles autónomos -------------------------------------------------------------------------------- 17 4.1.2.1Robots móviles rodantes ----------------------------------------------------------------------------- 17 4.1.2.2Control cinemático. Estrategia del Punto descentralizado. ---------------------------------- 18 4.2Quad --------------------------------------------------------------------------------------------------------- 19 4.2.1Características ------------------------------------------------------------------------------------------------- 20 4.2.2Inconvenientes ------------------------------------------------------------------------------------------------ 20 4.3Láser --------------------------------------------------------------------------------------------------------- 21 4.3.1Láser en Robótica --------------------------------------------------------------------------------------------- 21 4.3.1.1Láser de Triangulación -------------------------------------------------------------------------------- 22 4.3.1.2Láser de Larga Distancia ------------------------------------------------------------------------------ 22 4.3.1.3Láser Escáner de Perfil -------------------------------------------------------------------------------- 23 5EVALUACIÓN TECNOLÓGICA -------------------------------------------------------------------------------- 24 5.1Java ---------------------------------------------------------------------------------------------------------- 24 5.1.1Programación Orientada a Objetos (POO) -------------------------------------------------------------- 25 5.2Librerías gráficas ----------------------------------------------------------------------------------------- 26 5.2.1Abstract Window Toolkit (AWT) --------------------------------------------------------------------------- 27 5.2.2Java Swing ------------------------------------------------------------------------------------------------------ 28 5.3Entorno de programación ----------------------------------------------------------------------------- 29 5.3.1Eclipse ----------------------------------------------------------------------------------------------------------- 29 5.4HTML -------------------------------------------------------------------------------------------------------- 30 PARTE II: ANÁLISIS Y DISEÑO DE LA HERRAMIENTA-------------------------------------------------------- 31 6ESPECIFICACIÓN DE REQUERIMENTOS ------------------------------------------------------------------- 32 6.1Introducción ----------------------------------------------------------------------------------------------- 32 PFC: Generación y Transmisión de órdenes de movimiento a un vehículo autónomo tipo QUAD 3 6.1.1Propósito -------------------------------------------------------------------------------------------------------- 32 6.1.2Referencias ----------------------------------------------------------------------------------------------------- 32 6.1.3Visión global ---------------------------------------------------------------------------------------------------- 32 6.2Interfaz de usuario --------------------------------------------------------------------------------------- 32 6.3Requerimientos funcionales --------------------------------------------------------------------------- 33 6.3.1Configuración del Quad ------------------------------------------------------------------------------------- 33 6.3.2Configuración del mapa ------------------------------------------------------------------------------------- 33 6.3.3Configuración de la simulación ---------------------------------------------------------------------------- 34 6.3.4Simulación ------------------------------------------------------------------------------------------------------ 35 6.3.5Control Simulación-------------------------------------------------------------------------------------------- 35 6.3.6Otras ------------------------------------------------------------------------------------------------------------- 36 6.4Requerimientos no funcionales----------------------------------------------------------------------- 37 7DIAGRAMAS UML ---------------------------------------------------------------------------------------------- 38 7.1Diagrama de clases -------------------------------------------------------------------------------------- 39 7.2Diagrama de paquetes --------------------------------------------------------------------------------- 40 7.5-Diagramas Casos de Uso ------------------------------------------------------------------------------- 41 7.5.1Actores ---------------------------------------------------------------------------------------------------------- 41 7.5.2Casos de uso --------------------------------------------------------------------------------------------------- 41 7.5.1.1Cargar Fichero ------------------------------------------------------------------------------------------- 42 7.5.1.2Genera Fichero Obstáculos -------------------------------------------------------------------------- 42 7.5.1.3Genera Fichero Datos --------------------------------------------------------------------------------- 43 7.5.1.4Consultar Ayuda ---------------------------------------------------------------------------------------- 43 7.5.1.5Modificar Quad ----------------------------------------------------------------------------------------- 44 7.5.1.6Nuevo Borde --------------------------------------------------------------------------------------------- 44 7.5.1.7Modificar Borde ----------------------------------------------------------------------------------------- 45 7.5.1.8Eliminar Borde------------------------------------------------------------------------------------------- 46 7.5.1.9Nuevo Obstáculo --------------------------------------------------------------------------------------- 46 7.5.1.10Modificar Obstáculo ---------------------------------------------------------------------------------- 47 7.5.1.11Eliminar obstáculo ------------------------------------------------------------------------------------ 48 7.5.1.12Modificar Opciones Simulación ------------------------------------------------------------------- 48 7.5.1.13Consulta Datos Láser --------------------------------------------------------------------------------- 49 7.5.1.14Start ------------------------------------------------------------------------------------------------------ 50 7.5.1.15Stop ------------------------------------------------------------------------------------------------------ 50 7.5.1.16Pausar---------------------------------------------------------------------------------------------------- 51 7.5.1.17Reanudar ------------------------------------------------------------------------------------------------ 51 PARTE III: IMPLEMENTACIÓN ------------------------------------------------------------------------------------- 52 8IMPLEMENTACIÓN --------------------------------------------------------------------------------------------- 53 8.1Introducción ----------------------------------------------------------------------------------------------- 53 8.2Evolución --------------------------------------------------------------------------------------------------- 53 PFC: Generación y Transmisión de órdenes de movimiento a un vehículo autónomo tipo QUAD 4 8.2Obtención de los Datos del Láser -------------------------------------------------------------------- 56 8.3Movimiento. Cinemática Ackerman. ---------------------------------------------------------------- 58 PARTE IV: MANUAL DE USUARIO -------------------------------------------------------------------------------- 61 9INTRODUCCIÓN ------------------------------------------------------------------------------------------------- 62 9.1Descripción general de la Aplicación ---------------------------------------------------------------- 62 9.2Pantalla inicial de la aplicación ---------------------------------------------------------------------- 62 9.3Bloque I: Menú -------------------------------------------------------------------------------------------- 64 9.4Bloque II: Datos Quad ----------------------------------------------------------------------------------- 64 9.5Bloque III: Datos Obstáculos -------------------------------------------------------------------------- 66 9.6Bloque IV: Opciones Simulación ---------------------------------------------------------------------- 68 9.7Bloque V: Resultados Simulación -------------------------------------------------------------------- 70 9.8Bloque VI: Gráfica ---------------------------------------------------------------------------------------- 71 9.9Bloque VII: Control Simulación ----------------------------------------------------------------------- 72 CONCLUSIONES -------------------------------------------------------------------------------------------------------- 74 BIBLIOGRAFÍA ---------------------------------------------------------------------------------------------------------- 75 REFERENCIAS Y FUENTES ------------------------------------------------------------------------------------------- 76 PARTE V: APÉNDICES ------------------------------------------------------------------------------------------------ 77 APÉNDICE A: DESCRIPCIÓN DE CLASES----------------------------------------------------------------------------- 78 Paquete Ayuda --------------------------------------------------------------------------------------------------------- 78 Paquete Datos---------------------------------------------------------------------------------------------------------- 78 Paquete Elementos --------------------------------------------------------------------------------------------------- 78 Paquete Excepciones ------------------------------------------------------------------------------------------------- 78 Paquete Interfaz ------------------------------------------------------------------------------------------------------- 79 Paquete Objects ------------------------------------------------------------------------------------------------------- 80 Paquete Quad ---------------------------------------------------------------------------------------------------------- 80 Paquete Search -------------------------------------------------------------------------------------------------------- 80 APÉNDICE B: CÓDIGO FUENTE ---------------------------------------------------------------------------------- 82 Obtención de los Datos del Láser ---------------------------------------------------------------------------------- 82 Movimiento. Cinemática Ackerman. ----------------------------------------------------------------------------- 86 PFC: Generación y Transmisión de órdenes de movimiento a un vehículo autónomo tipo QUAD 5 ÍNDICE DE IMÁGENES PARTE I: PROYECTO ---------------------------------------------------------------------------------------------------- 8 Imagen 4.1: Pato con aparato digestivo (Vaucanson) --------------------------------------------------- 15 Imagen 4.2: Densidad de robots industriales -------------------------------------------------------------- 16 Imagen 4.3: Configuración Ackerman ------------------------------------------------------------------------ 18 Imagen 4.4: Control Cinemático de un robot móvil ------------------------------------------------------ 18 Imagen 4.5: Quad -------------------------------------------------------------------------------------------------- 19 Imagen 4.6Normativa Vehículo Quad ---------------------------------------------------------------------- 20 Imagen 4.7: Tipos de sensores de distancias. -------------------------------------------------------------- 22 Imagen 4.8: Láser de Triangulación. -------------------------------------------------------------------------- 22 Imagen 4.9: Láser de Larga Distancia------------------------------------------------------------------------- 23 Imagen 4.10: Láser Escáner de Perfil ------------------------------------------------------------------------- 23 Imagen 4.11: Partes Láser Proyecto -------------------------------------------------------------------------- 23 Imagen 5.1: Logotipo de Java ---------------------------------------------------------------------------------- 25 Imagen 5.2: Clases del paquete java.swing ----------------------------------------------------------------- 28 Imagen 5.3:Logotipo Eclipse ------------------------------------------------------------------------------------ 29 PARTE II: ANÁLISIS Y DISEÑO DE LA HERRAMIENTA-------------------------------------------------------- 31 Imagen 7.1. Diagrama de Clases ------------------------------------------------------------------------------- 39 Imagen 7.2. Diagrama de Paquetes --------------------------------------------------------------------------- 40 Imagen 7.4Casos de Uso --------------------------------------------------------------------------------------- 41 PARTE III: IMPLEMENTACIÓN ------------------------------------------------------------------------------------- 52 Imagen 8.3Implementación final ---------------------------------------------------------------------------- 55 Imagen 8.4Variables Láser ------------------------------------------------------------------------------------ 56 Imagen 8.5Ejemplo Mapa ------------------------------------------------------------------------------------- 57 Imagen 8.6-Configuración Ackerman ------------------------------------------------------------------------ 58 Imagen 8.7Ejemplo Movimiento Quad -------------------------------------------------------------------- 60 PARTE IV: MANUAL DE USUARIO -------------------------------------------------------------------------------- 61 Imagen 9.2: Estructura de la pantalla principal. ----------------------------------------------------------- 63 Imagen 9.3: Bloque I: Menú ------------------------------------------------------------------------------------ 64 Imagen 9.4: Bloque II: Datos Quad --------------------------------------------------------------------------- 65 Imagen 9.5: Bloque III: Datos Obstáculos ------------------------------------------------------------------- 66 Imagen 9.6: Bloque III: Borde ---------------------------------------------------------------------------------- 67 PFC: Generación y Transmisión de órdenes de movimiento a un vehículo autónomo tipo QUAD 6 Imagen 9.7: Bloque III: Nuevo Obstáculo ------------------------------------------------------------------- 68 Imagen 9.8: Bloque III: Modifica Obstáculo ---------------------------------------------------------------- 68 Imagen 9.9: Bloque IV: Opciones Simulación -------------------------------------------------------------- 69 Imagen 9.10: Bloque IV: Modificar Opciones Simulación ----------------------------------------------- 69 Imagen 9.12: Bloque IV: Modificar Posición inicial y final ---------------------------------------------- 70 Imagen 9.13: Bloque V: Resultados Simulación ----------------------------------------------------------- 71 Imagen 9.15: Bloque VII: Control Simulación. ------------------------------------------------------------- 72 CONCLUSIONES -------------------------------------------------------------------------------------------------------- 74 BIBLIOGRAFÍA ---------------------------------------------------------------------------------------------------------- 75 REFERENCIAS Y FUENTES ------------------------------------------------------------------------------------------- 76 PARTE V: APÉNDICES ------------------------------------------------------------------------------------------------ 77 PFC: Generación y Transmisión de órdenes de movimiento a un vehículo autónomo tipo QUAD 7 ÍNDICE DE TABLAS PARTE I: PROYECTO -------------------------------------------------------------------------------- 8 Tabla 5.1: Clases de la Librería java.awt ------------------------------------------------------- 27 PARTE II: ANÁLISIS Y DISEÑO DE LA HERRAMIENTA ------------------------------------- 31 Tabla 7.1Clasificación diagramas UML ------------------------------------------------------ 38 PARTE III: IMPLEMENTACIÓN ------------------------------------------------------------------ 52 PARTE IV: MANUAL DE USUARIO -------------------------------------------------------------- 61 Tabla 9.1: Parámetros Datos Quad ------------------------------------------------------------ 65 Tabla 9.2: Parámetros Opciones SImulación ------------------------------------------------ 70 CONCLUSIONES ------------------------------------------------------------------------------------- 74 BIBLIOGRAFÍA --------------------------------------------------------------------------------------- 75 REFERENCIAS Y FUENTES------------------------------------------------------------------------- 76 PARTE V: APÉNDICES ------------------------------------------------------------------------------ 77 PFC: Generación y Transmisión de órdenes de movimiento a un vehículo autónomo tipo QUAD 8 PARTE I: PROYECTO PFC: Generación y Transmisión de órdenes de movimiento a un vehículo autónomo tipo QUAD 15 de 400 partes móviles, y podría batir sus alas, beber agua, digerir grano e incluso defecar. Los alimentos los digería por disolución y eran conducidos por unos tubos hacia el ano, donde había un esfínter que permitía evacuarlos. Vaucanson también construyó otros autómatas, entre los que destaca El Flautista, un pastor que tocaba la flauta capaz de tocar hasta 12 melodías diferentes. Imagen 4.1: Pato con aparato digestivo (Vaucanson) El inicio de la robótica actual se fija a finales del siglo XVIII y principios del siglo XIX, en plena Revolución Industrial, donde se desarrollaron diversos ingenios y máquinas utilizadas principalmente en la industria textil, como por ejemplo, la máquina textil programable mediante tarjetas perforadas (precedente de las máquinas de control numérico), inventada por Joseph Jacquard en 1801. En el siglo XIX se produjo, pues, un auge de los autómatas y se produjeron importantes avances en todas las ramas de la ingeniería. Sin embargo no fue hasta 1920 cuando la palabra robot empezó a utilizarse. Se empleó por primera vez en 1920 en una obra de teatro llamada “Los Robots Universales de Rossum” (R.U.R.) escrita por el dramaturgo checo Karel Capek, cuya trama era: un hombre fábrica un robot, después el hombre mata al hombre. Capek utilizó la palabra checa “Robota” que significa servidumbre o trabajador forzoso, pero al hacer la traducción al inglés, “Robota” pasó a llamarse Robot. A raíz de esta obra, han sido muchas las novelas y películas de ciencia ficción, que han seguido mostrando a los robots como máquinas destructivas y amenazadoras para el hombre. PFC: Generación y Transmisión de órdenes de movimiento a un vehículo autónomo tipo QUAD 16 Isaac Asimov, al cual se le conoce como el padre de la Robótica y al que se le atribuye el nacimiento del término robótica en 1942, escribió las tres leyes de la robótica, que son un conjunto de normas que la mayoría de los robots de sus novelas están diseñados para cumplir. Estas leyes son: 1Un robot no puede hacer daño a un ser humano o, por inacción, permitir que un ser humano sufra daño. 2Un robot debe obedecer las órdenes dadas por los seres humanos, excepto si estas órdenes entrasen en conflicto con la Primera Ley. 3Un robot debe proteger su propia existencia en la medida en que esta protección no entre en conflicto con la Primera o la Segunda Ley. Los primeros robots industriales empezaron a producirse a principios de los años 60 y estaban diseñados principalmente para realizar trabajos mecánicos difíciles y peligrosos. Las áreas donde estos robots tuvieron su aplicación fueron trabajos laboriosos y repetitivos, como la carga y descarga de hornos de fundición. A partir de este momento, los avances en la robótica han sido espectaculares y en los últimos años se pueden encontrar robots en todas las áreas productivas industriales. Se ha evolucionado desde máquinas pesadas, rudas y limitadas a otras más rápidas, precisas y capaces de sustituir al hombre mejorando los resultados de éste. A pesar de la gran evolución que ha caracterizado a la robótica, ésta no se detiene aquí, ya que ofrece aun un amplio campo para el desarrollo y la innovación tecnológica. Una oportunidad que seguro investigadores y aficionados a los Robots no van a desaprovechar, y van a continuar diseñando robots cada vez más evolucionados, complejos y funcionales. En la siguiente imagen se puede observar como la densidad de robots industriales aumenta años tras año a un ritmo muy alto. Imagen 4.2: Densidad de robots industriales PFC: Generación y Transmisión de órdenes de movimiento a un vehículo autónomo tipo QUAD 17 4.1.2Robots móviles autónomos Actualmente, el concepto de robótica ha evolucionado hacia los sistemas móviles autónomos, que son aquellos capaces de desenvolverse por sí mismos en entornos desconocidos y parcialmente cambiantes sin necesidad de supervisión. Los robots móviles, en general, son robots con una gran capacidad de desplazamiento, basada en carros o plataformas y dotados de un sistema locomotor de tipo rodante que permite su movimiento. Siguen su camino por telemando o guiándose por la información recibida de su entorno a través de sus sensores (autónomos). Existen diferentes tipos: rodantes, andantes, reptadores, nadadores, voladores… . La finalidad de este proyecto es la creación de una plataforma software para generación y transmisión de órdenes de movimiento a un vehículo autónomo tipo Quad que pertenece, al tipo de robots móviles rodantes. El Quad lleva incorporado un sensor láser, con el fin de proporcionar al vehículo la información sobre las distancias a los objetos que se encuentran a su alrededor y de esta forma poder evitar las colisiones con los objetos de su entorno y decidir qué camino tomar para llegar al punto destino. 4.1.2.1Robots móviles rodantes Son aquellos robots que se desplazan haciendo uso de ruedas, generalmente con una configuración 2+2 (configuración Ackerman) como las de un vehículo. Existen otras configuraciones como el triciclo (la configuración Ackerman se puede ver como un caso particular de ésta), configuración Oruga, entre otras. Dependiendo del terreno o el entorno es preferible utilizar una configuración u otra. - Configuración Ackerman: Habitualmente solo dos de sus ruedas presentan tracción y las otras dos dirección, de forma que sea posible maniobrar el robot con un solo servomotor. PFC: Generación y Transmisión de órdenes de movimiento a un vehículo autónomo tipo QUAD 18 Imagen 4.3: Configuración Ackerman 4.1.2.2Control cinemático. Estrategia del Punto descentralizado. El control cinemático de robots móviles por punto descentralizado consiste en determinar las acciones del robot necesarias para llevarlo desde su posición actual a una posición final deseada, teniendo en cuenta las velocidades y la orientación. El punto destino está separado a una distancia e del eje de tracción del robot. El vehículo autónomo Quad, objetivo de este proyecto, calcula el punto del camino seguido siguiente mediante esta técnica. Los pasos a seguir desde un punto actual (xm,ym) al punto destino (xp,yp) siguiente son: Imagen 4.4: Control Cinemático de un robot móvil De esta forma se obtiene el punto siguiente al cual tiene que avanzar el Quad, habiendo establecido previamente la inclinación de las ruedas para llegar a esa posición. PFC: Generación y Transmisión de órdenes de movimiento a un vehículo autónomo tipo QUAD 19 4.2Quad Un quad (llamado también cuadrimoto o cuatriciclo) es un vehículo de 4 ruedas (dos delante y dos detrás), sin carrocería y con un sistema de dirección mediante manillar, parecido a una moto que procede de los primeros triciclos o hart-trick, los cuales disponían de dos ruedas traseras y una delantera. Ésta configuración presentaba problemas de estabilidad y seguridad, además de la falta de propulsor. El vehículo Quad como se conoce actualmente, empezó a aparecer a finales de los ’80, principalmente en zonas agrícolas ya que a diferencia de las motocicletas, éstos eran válidos en cualquier terreno y ante condiciones climatológicas más adversas. Pocos años después empezaron a utilizarse en otros ámbitos como en el ocio y en la competición y por ello, cada día es más frecuente ver actividades que incluyen excursiones con ellos y competiciones y exhibiciones con gran afluencia de público. Los Quads se clasifican en tres grupos, en función de las características técnicas que ofrezcan por construcción: vehículos automóviles, vehículos especiales y vehículos ciclomotores. Imagen 4.5: Quad En España se viene observando un enorme crecimiento en la matriculación de estos vehículos. Los primeros que se comercializaron fueron en 1994, y desde entonces, el mercado de este tipo de vehículo se ha incrementado hasta situarse en el entorno de las treinta mil unidades anuales, con un parque estimado en 2006 de más de setenta y cinco mil unidades. PFC: Generación y Transmisión de órdenes de movimiento a un vehículo autónomo tipo QUAD 20 4.2.1Características - Potencia: los quads llegan a cilindradas muy altas. - Agilidad: permite controlar el vehículo para realizar giros con mucha facilidad. - Resistencia: es una característica muy importante, ya que permite aguantar largas carreras. Es un vehículo especial, puesto que está pensado para circular por terrenos muy diversos y su aguante ha de ser enorme. - Ligereza: si no tuviera esta característica sería muy difícil su manejo por lugares muy complicados. - Multifuncional: Se puede circular con él por carrera, por ciudad, por terrenos arenosos, en caminos donde hay varios centímetros cúbicos de agua, etc. - Caja de cambios automática: por lo general todos la usan ya que es mucho más cómodo para circular sin preocupaciones 4.2.2Inconvenientes - Normativa: su regulación no está bien definida y genera muchas dudas a los usuarios en temas tan importantes como : la licencia o permiso de conducción necesario, tipos de vías en los que se puede circular, etc. - Vuelcan con facilidad: el quad aporta una falsa sensación de seguridad al conductor a pesar de que parecen mucho más estables que una motocicleta. En las curvas, las ruedas traseras tienden a levantarse y, si el piloto no es muy diestro, vuelcan con facilidad. Imagen 4.6Normativa Vehículo Quad PFC: Generación y Transmisión de órdenes de movimiento a un vehículo autónomo tipo QUAD 21 4.3Láser Según la definición que proporciona la Real Academia Española el término láser se define como: “Dispositivo electrónico que, basado en la emisión inducida, amplifica de manera extraordinaria un haz de luz monocromático y coherente”. Algunas aplicaciones del Láser son: - Medicina: Operaciones sin sangre, tratamientos quirúrgicos, ayudas a la cicatrización de heridas, tratamientos de piedras en el riñón, operaciones de vista, operaciones odontológicas. - Industria (Robótica) : Cortado, guiado de maquinaria y robots de fabricación, mediciones de distancias precisas mediante láser. - Defensa: Guiado misiles balísticos, alternativa al Radar, cegado a las tropas enemigas. En el caso del Tactical High Energy Laser se está empezando a usar el láser como destructor de blancos. - Ingenieria Civil: Guiado de máquinas tuneladoras en túneles, diferentes aplicaciones en la topografía como mediciones de distancias a lugares inaccesibles o realización de un modelo digital del terreno (MDT). - Arquitectura: catalogación de Patrimonio. - Arqueológico: documentación. - Investigación: Espectroscopía, Interferometría láser, LIDAR, distanciometría. - Desarrollos en productos comerciales: Impresoras láser, CD, ratones ópticos, lectores de código de barras, punteros láser, termómetros, hologramas, aplicaciones en iluminación de espectáculos. - Tratamientos cosméticos y cirugía estética: Tratamientos de Acné, celulitis, tratamiento de las estrías, depilación. 4.3.1Láser en Robótica El láser es utilizado como un sensor que es un dispositivo capaz de transformar magnitudes físicas o químicas, en magnitudes eléctricas. En concreto el láser es un sensor de distancias. PFC: Generación y Transmisión de órdenes de movimiento a un vehículo autónomo tipo QUAD 22 Imagen 4.7: Tipos de sensores de distancias. 4.3.1.1Láser de Triangulación Los láseres de triangulación proyectan un haz de luz sobre la superficie a medir, este haz es reflejado en el fotodetector del aparato con un cierto ángulo de inclinación que variará en función de la distancia medida. Utilizado para la medición de pequeñas distancias (2mm a 500 mm) Imagen 4.8: Láser de Triangulación. 4.3.1.2Láser de Larga Distancia El láser envía un haz de luz con diferentes frecuencias, y compara la señal que se ha reflejado en el objeto a medir con el valor de referencia interno. PFC: Generación y Transmisión de órdenes de movimiento a un vehículo autónomo tipo QUAD 23 Imagen 4.9: Láser de Larga Distancia 4.3.1.3Láser Escáner de Perfil Basado en el principio de funcionamiento del láser de triangulación, pero proyectando un haz de luz transversal en vez de puntual, lo que permite obtener el perfil donde se está reflejando dicho haz. Imagen 4.10: Láser Escáner de Perfil En este proyecto se simula el funcionamiento de este tipo de sensor láser en los que se pueden diferencias las siguientes partes: Imagen 4.11: Partes Láser Proyecto PFC: Generación y Transmisión de órdenes de movimiento a un vehículo autónomo tipo QUAD 24 5EVALUACIÓN TECNOLÓGICA Para la implementación de la aplicación, una de las primeras decisiones importantes fue la elección del lenguaje de programación puesto que tenia total libertad para escoger el tipo de lenguaje que más se adaptara a las exigencias del proyecto. Desde el primer momento tenía claro que el lenguaje iba a ser C++ o Java, puesto que se tratan de los dos lenguajes de programación que más se han estudiado a lo largo de la carrera. Tras estar analizando las posibilidades que ofrecían ambos lenguajes, decliné la opción de C++ debido a su manera de crear interfaces ya que, según mi opinión, con Java se obtienen resultados bastante buenos de una manera sencilla e intuitiva. Otro punto a favor de Java, fue su portabilidad, ya que al realizarlo en Java, el programa podría ser ejecutado en otros sistemas diferentes independientemente del hardware que tengan. Además del lenguaje de programación Java, se ha utilizado el lenguaje HTML para escribir la “Ayuda” de la aplicación. Los principios básicos y características en las que se basan ambos lenguajes vienen detallados a continuación. 5.1Java Java es un lenguaje de programación orientado a objetos (POO), desarrollado por “Sun Microsystems” a principios de los años 90. Su sintaxis está basada en el lenguaje C y C++, pero con un modelo de objetos más simple ya que se eliminan herramientas de bajo nivel como por ejemplo, los punteros o la gestión dinámica de memoria. En Java el Recolector de basura (garbage collector) se encarga de destruir automáticamente los objetos de los que no haya ninguna referencia. En C++, en cambio, la memoria debe desasignarse automáticamente. Además, se trata de un lenguaje fuertemente tipado y robusto porque realiza verificaciones tanto en tiempo de ejecución como en tiempo de compilación. PFC: Generación y Transmisión de órdenes de movimiento a un vehículo autónomo tipo QUAD 31 PARTE II: ANÁLISIS Y DISEÑO DE LA HERRAMIENTA PFC: Generación y Transmisión de órdenes de movimiento a un vehículo autónomo tipo QUAD 32 6ESPECIFICACIÓN DE REQUERIMENTOS 6.1Introducción La especificación de requerimientos es la fase de análisis del ciclo de vida de un programa donde se debe describir lo más detalladamente posible todo lo que se espera de ese software. 6.1.1Propósito El propósito de este apartado es definir cuáles son los requerimientos que debe tener un programa de simulación de generación y transmisión de movimiento a un vehículo autónomo tipo Quad. Este apartado va dirigido a aquellas personas interesadas en conocer y utilizar el producto. 6.1.2Referencias Para la redacción de este apartado se han consultado los siguientes documentos: - Guía de elaboración de ERS según el IEEE830. - Transparencias de la asignatura Ingeniería de Requerimientos. 6.1.3Visión global A continuación, se detallan las funcionalidades básicas de la aplicación (requerimientos funcionales) así como otras características que no dependen del proyecto (requerimientos no funcionales). 6.2Interfaz de usuario El diseño y la usabilidad de la interfaz gráfica de usuario (GUI) tiene mucha importancia en este proyecto ya que debe ser una herramienta para facilitar el estudio de los movimientos PFC: Generación y Transmisión de órdenes de movimiento a un vehículo autónomo tipo QUAD 33 de los vehículos móviles autónomos y por tanto los resultados se deben visualizar de una manera rápida y fácilmente entendibles. Va dirigida principalmente a personas del ámbito de la robótica interesados en la conducción automatizada de vehículos autónomos. 6.3Requerimientos funcionales Los requerimientos funcionales describen, como su nombre indica, la funcionalidad o servicios que se espera que provea el sistema. A continuación se especifican los requisitos funcionales considerados para que la aplicación cumpla los objetivos: 6.3.1Configuración del Quad - REQ1: Modificar características del Quad La aplicación debe permitir cambiar los valores del vehículo tales como el ancho, largo y ángulo máximo de giro ya que debe ser válida para distintas configuraciones de vehículo. - REQ2: Modificar características del láser Se debe poder cambiar los valores de los parámetros que caracterizan al láser como el ángulo de abertura, alcance máximo, ángulo entre haces, etc. 6.3.2Configuración del mapa - REQ3: Insertar Borde Cuando se realizan las pruebas sobre un vehículo real se llevan a cabo en un terreno delimitado y éste no se debe salir de él. Por tanto en la simulación se tiene que delimitar también. Este “terreno simulado” es en realidad un obstáculo con una forma rectangular o cuadrada. - REQ4: Insertar obstáculos Con el fin de dificultar el camino del Quad para comprobar el funcionamiento del láser y del propio vehículo, se deben poder insertar tantos obstáculos como el usuario crea conveniente. Éstos pueden ser circulares o cuadrados con el tamaño y la inclinación deseada. PFC: Generación y Transmisión de órdenes de movimiento a un vehículo autónomo tipo QUAD 34 - REQ5: Modificar obstáculos Ya sea porque a la hora de insertar los parámetros se ha tenido algún error o bien porque se quiere cambiar el tamaño o posición por algún motivo, el programa debe proporcionar la posibilidad de modificar los obstáculos sin necesidad de repetir el proceso. - REQ6: Escalar la vista de dibujo Se debe poder realizar una simulación sobre una superficie cuadrada (o rectangular) de cualquier tamaño y, por ello, para obtener una vista adecuada, la aplicación debe tener los recursos necesarios para escalar el dibujo hasta obtener una representación adecuada. 6.3.3Configuración de la simulación - REQ7: Establecer posiciones iniciales Un buen estudio del funcionamiento de este tipo de vehículos requiere muchas pruebas con trayectorias distintas, por tanto, se debe poder cambiar el punto de salida y el punto de meta. - REQ8: Establecer la Inclinación inicial de las ruedas del Quad Por el mismo motivo que en el REQ7, se debe permitir que el Quad inicie su camino con distintas inclinaciones de sus ruedas. - REQ9: Establecer velocidad inicial Cualquier vehículo puede funcionar a distintas velocidades , por ello, se debe poder cambiar este valor - REQ10: Control de la aceleración Durante la conducción la velocidad no se mantiene constante ya que hay que tener en cuenta la aceleración y el frenado (aceleración negativa). La aplicación debe permitir el control de esta aceleración (cambiar su valor) durante la ejecución de la simulación. PFC: Generación y Transmisión de órdenes de movimiento a un vehículo autónomo tipo QUAD 35 6.3.4Simulación - REQ11: Visualizar el mapa completo Para configurar correctamente el mapa, se debe poder visualizar en todo momento los obstáculos que se han añadido, así como las posiciones iniciales. - REQ12: Visualizar el recorrido Una vez iniciada la simulación la aplicación debe mostrar la trayectoria realizada por el Quad posición a posición. - REQ13: Vista analítica de los resultados Además de los resultados gráficos, se deben mostrar las resultados de una forma más analítica para poder comprender de una manera más exacta el comportamiento del Quad. - REQ14: Comprobar Información Láser Se debe poder visualizar los datos obtenidos por el láser en la posición en la que se encuentra en ese momento de la simulación el Quad. 6.3.5Control Simulación - REQ15: Iniciar la simulación (START) Se debe poder iniciar la simulación - REQ16: Parar la simulación (STOP) Se debe poder parar la simulación en todo momento, cuando ha llegado a la meta pero también aunque no haya llegado. - REQ17: Detener momentáneamente la simulación (PARAR) Con el fin de llevar un mayor control sobre la simulación, ésta se debe poder parar momentáneamente con el fin de cambiar la aceleración, visualizar los datos obtenidos por el láser … PFC: Generación y Transmisión de órdenes de movimiento a un vehículo autónomo tipo QUAD 36 - REQ18: Reanudar la simulación (REANUDAR) Al igual que se debe poder pausar la simulación, se debe poder reanudarla en la misma posición en la que se paró. 6.3.6Otras - REQ19: Guardar Simulación El programa debe aportar la opción de guardar los datos utilizados en la simulación (configuración del quad y de los obstáculos) con el fin de poder utilizar esa misma disposición del mapa en otro momento sin necesidad de volver a configurarlo de nuevo. - REQ20: Abrir Simulación Se deben de poder abrir las configuraciones ya guardadas que cumplan con la estructura del archivo requerida por el programa. - REQ21: Generar Fichero de datos El usuario deberá tener la posibilidad de guardar todos los resultados obtenidos en la simulación en un fichero con un formato adecuado para su utilización en otras aplicaciones como Matlab. - REQ22: Ayuda El programa debe tener una opción para desplegar un tutorial que explique el uso de la aplicación. - REQ23: Salir El programa debe tener una opción para salir del programa. PFC: Generación y Transmisión de órdenes de movimiento a un vehículo autónomo tipo QUAD 37 6.4Requerimientos no funcionales Los requerimientos no funcionales son aquellos requerimientos que no se refieren directamente a las funciones específicas que entre el sistema, sino a las propiedades emergentes de éste. A continuación se especifican los requisitos no funcionales: - Fiabilidad: La fiabilidad de la aplicación depende del funcionamiento que haga el usuario de la misma. - Modificabilidad: El programa se puede modificar a partir del código fuente con el fin de ampliar o mejorar la funcionalidad de la aplicación. - Dependencia de otras partes: No tiene dependencias que otras aplicaciones. - Portabilidad: La aplicación es portable ya que funciona bajo la máquina virtual de Java (JVM). - Tiempo de respuesta: Viene determinado por la capacidad del procesador donde se ejecuta la aplicación. PFC: Generación y Transmisión de órdenes de movimiento a un vehículo autónomo tipo QUAD 38 7DIAGRAMAS UML UML es lenguaje de propósito general para el modelado orientado a objetos y se utiliza para visualizar, especificar, construir y documentar un sistema. Nació debido a la necesidad de una notación uniforme. Es pues, una notación para describir sistemas (no es un método). Imagen 5.1: Logotipo UML Existen una cantidad de diagramas de tipos diferentes (en UML 2.0, hay 13 diferentes), que se pueden clasificar según sean Diagramas de Estructura, Diagramas de Comportamiento o Diagramas de Interacción. Diagramas de Estructura Diagramas de clases Diagramas de componentes Diagramas de objetos Diagramas de estructura compuesta (UML 2.0) Diagrama de despliegue Diagrama de paquetes Diagramas de Comportamiento Diagramas de actividades Diagramas de casos de uso Diagrama de estados Diagramas de Interacción (subtipo de diagramas de comportamiento ) Diagrama de secuencia Diagrama de comunicación Diagrama de tiempos Diagrama global de interacciones Tabla 7.1Clasificación diagramas UML Para este proyecto se han realizado los diagramas marcados en la Tabla 5.1. Para su realización se ha empleado la herramienta MyEclipse9. PFC: Generación y Transmisión de órdenes de movimiento a un vehículo autónomo tipo QUAD 39 7.1Diagrama de clases Muestra las clases del sistema y las relaciones entre las mismas. Sirven para reflejar la estructura estática del sistema. Imagen 7.1. Diagrama de Clases PFC: Generación y Transmisión de órdenes de movimiento a un vehículo autónomo tipo QUAD 40 En el diagrama de clases se han omitido los getters y setters de cada la clase por motivos de espacio. En el Apéndice A se explica la función de cada una de las clase 7.2Diagrama de paquetes Los diagramas de paquetes se usan para reflejar la organización de paquetes y sus elementos. Imagen 7.2. Diagrama de Paquetes PFC: Generación y Transmisión de órdenes de movimiento a un vehículo autónomo tipo QUAD 47 #1 En 3. El usuario cancela y/o cierra la ventana. El sistema no introduce el obstáculo. #2 En 3. El usuario introduce valores incorrectos o deja espacios en blanco. Dependiendo del error, el sistema muestra mensajes de error o escribe un 1.0. #3 En 1. El usuario pulsa sobre el bloque VI: Gráfica en la posición donde desea introducir el obstáculo El sistema muestra la ventana Nuevo Obstáculo estableciendo como centro del obstáculo las coordenadas x,y sobre las que ha hecho clic el usuario #4 En 1. El usuario pulsa sobre el botón “Nuevo Obstáculo” del bloque I: Menú El sistema muestra la ventana Nuevo Obstáculo. 7.5.1.10Modificar Obstáculo CASO DE USO: Modificar Obstáculo Actores Usuario Descripción Permite Modificar el valor del obstáculo seleccionado. USUARIO APLICACIÓN 1Selecciona en el combobox el nombre del obstáculo que desea cambiar y clic en “Modificar” (del bloque III: Obstáculos) 2Mostrar ventana Modificar Obstáculo 3El usuario modifica los campos que desee y confirma los cambios pulsando en el botón “Modificar” 4El sistema modifica el obstáculo y dibuja el obstáculo modificado. CAMINOS ALTERNATIVOS Número USUARIO APLICACIÓN #1 En 3. El usuario cancela y/o cierra la ventana. El sistema no modifica el obstáculo. PFC: Generación y Transmisión de órdenes de movimiento a un vehículo autónomo tipo QUAD 48 #2 En 3. El usuario introduce valores incorrectos o deja espacios en blanco. Dependiendo del error, el sistema muestra mensajes de error o escribe un 1.0. #3 En 1. El usuario pulsa sobre el bloque VI: Gráfica en la posición donde se encuentra el obstáculo a modificar El sistema muestra la ventana Modificar Obstáculo 7.5.1.11Eliminar obstáculo CASO DE USO: Eliminar Obstáculo Actores Usuario Descripción Permite eliminar el obstáculo seleccionado. USUARIO APLICACIÓN 1Selecciona en el combobox el nombre del obstáculo que desea eliminar y clic en “Modificar” (del bloque III: Obstáculos) 2Mostrar ventana Modificar Obstáculo 3El usuario pulsa en el botón “Eliminar” 4El sistema elimina el obstáculo y dibuja el mapa sin el obstáculo eliminado. CAMINOS ALTERNATIVOS Número USUARIO APLICACIÓN #1 En 3. El usuario cancela y/o cierra la ventana. El sistema no elimina obstáculo. #2 En 1. El usuario pulsa sobre el bloque VI: Gráfica en la posición donde se encuentra el obstáculo a eliminar El sistema muestra la ventana Modificar Obstáculo 7.5.1.12Modificar Opciones Simulación CASO DE USO: Modificar Opciones Simulación Actores Usuario Descripción Se encarga de modificar las opciones de la PFC: Generación y Transmisión de órdenes de movimiento a un vehículo autónomo tipo QUAD 49 simulación tales como la velocidad, aceleración, posiciones iniciales… USUARIO APLICACIÓN 1Click en “Modificar” (del bloque IV: Opciones Simulación) 2Mostrar ventana para Modificar dichos valores 3El usuario modifica los campos que desee y confirma los cambios. 4El sistema actualiza la información y redibuja las posiciones actualizadas. CAMINOS ALTERNATIVOS Número USUARIO APLICACIÓN #1 En 3. El usuario introduce datos incorrectos. El sistema muestra un error conforme los datos introducidos son erróneos (si son números) o mantiene los valores anteriores correctos en el caso de introducir valores no numéricos. #2 En 1. El usuario pulsa sobre el botón “Modificar Opciones” del bloque I: Menú El sistema muestra la ventana Modificar Opciones. 7.5.1.13Consulta Datos Láser CASO DE USO: Consulta Datos Láser Actores Usuario Descripción Permite que el usuario pueda comprobar los datos devueltos por el láser para una posición y mapa dados. Precondiciones No haber empezado la simulación o estar pausada. USUARIO APLICACIÓN 1Click en “Obtener Datos Láser” (del bloque V: Resultados Simulación en la pestaña Láser) 2El sistema realiza una llamada a la función “ datos_láser” e imprime los datos obtenidos. PFC: Generación y Transmisión de órdenes de movimiento a un vehículo autónomo tipo QUAD 50 7.5.1.14Start CASO DE USO: Start Actores Usuario Descripción Se encarga de iniciar la simulación. USUARIO APLICACIÓN 1Click en “Start” (del bloque VII: Control Simulación) 2El sistema inicia la búsqueda del camino desde el punto inicial hasta el punto meta. Para cada punto realiza llamadas a dibujar(para las figuras y el camino ya calculado), a imprimirPosicion(imprime las posiciones por las que pasa el quad) y a datos_láser para obtener los nuevos valores devueltos por el sensor. CAMINOS ALTERNATIVOS Número USUARIO APLICACIÓN #1 La posición inicial coincide con la posición final El sistema avisa de esta situación. 7.5.1.15Stop CASO DE USO: Stop Actores Usuario Descripción Se encarga de detener la simulación. USUARIO APLICACIÓN 1Click en “Stop” (del bloque VII: Control Simulación) 2El sistema detiene por completo la búsqueda del camino parando por tanto, la impresión de posiciones y el dibujo de las mismas. PFC: Generación y Transmisión de órdenes de movimiento a un vehículo autónomo tipo QUAD 51 7.5.1.16Pausar CASO DE USO: Pausar Actores Usuario Descripción Se encarga de pausar momentáneamente la simulación. USUARIO APLICACIÓN 1Click en “Pause” (del bloque VII: Control Simulación) 2El sistema detiene momentáneamente la búsqueda del camino parando por tanto, la impresión de posiciones y el dibujo de las mismas. 7.5.1.17Reanudar CASO DE USO: Reanudar Actores Usuario Descripción Se encarga de reanudar la simulación. USUARIO APLICACIÓN 1Click en “Pause” (del bloque VII: Control Simulación) 2El sistema reanuda la búsqueda del camino, continuando por tanto, la impresión de posiciones y el dibujo de las mismas. PFC: Generación y Transmisión de órdenes de movimiento a un vehículo autónomo tipo QUAD 52 PARTE III: IMPLEMENTACIÓN PFC: Generación y Transmisión de órdenes de movimiento a un vehículo autónomo tipo QUAD 53 8IMPLEMENTACIÓN 8.1Introducción Como se ha comentado en el apartado 4 (Evolución Tecnológica), esta aplicación se ha implementado en el lenguaje de programación Java y mediante el entorno de programación Eclipse. Tras realizar el análisis y diseño de la aplicación el siguiente paso consistía en implementarlo, en plasmar todas las ideas y conseguir el resultado deseado, es decir, en poner en práctica todo el estudio previo realizado La finalidad de este apartado es explicar cómo ha ido evolucionando la aplicación y cómo se han resuelto e implementado los principales problemas que planteaba el desarrollo de este software. El código fuente de estas funciones explicadas se pueden encontrar en el Apéndice B. 8.2Evolución Antes de empezar a visualizar los primeros resultados de la elaboración de un proyecto, se debe pasar por distintas fases hasta que se llega a la última y más deseada, el resultado final. La primera fase de este proyecto fue la elaboración de la función que simulaba el funcionamiento de un sensor láser. Este programa no interactuaba con el usuario ni tenía interfaz gráfica, simplemente devolvía por pantalla las distancias calculadas según los obstáculos que se introducían previamente en el código. Una vez que la función ya devolvía los datos correctamente, empecé a crear la interfaz gráfica del usuario, buscando que fuera lo más intuitiva y sencilla de manejar posible. Por ello, la idea fue dividir la pantalla principal en dos, por un lado que permitierar ver los valores de los parámetros introducidos y por otra parte, la visualización del camino seguido por el quad. PFC: Generación y Transmisión de órdenes de movimiento a un vehículo autónomo tipo QUAD 54 Imagen 8.1Primera implementación Tras conseguir que se dibujaran los obstáculos correctamente y poder realizar operaciones sobre ellos como modificar, eliminar, etc empecé a centrarme más en cómo obtener el movimiento del Quad y la planificación del camino. Para poder observar mejor los resultados obtenidos se añadió un área de texto donde se mostraban las posiciones calculadas por el planificador. Además añadí una Ayuda donde poder consultar el manual de usuario de la aplicación. Tras algunos cambios, el resultado obtenido era el siguiente: Imagen 8.2Segunda implementación PFC: Generación y Transmisión de órdenes de movimiento a un vehículo autónomo tipo QUAD 55 Finalmente, y pensando siempre en hacer una aplicación que permita un buen estudio de planificación de caminos, añadí otra área de texto desde donde se pudiera obtener los datos devueltos por el láser desde la posición en las que se encuentra en ese momento el quad. En este momento me di cuenta que la forma de calcular el movimiento del Quad no era correcto y por tanto había que cambiarlo. Debido a que el quad es un vehículo con configuración Ackerman, la forma de calcular los ángulos y velocidad de las ruedas es mediante la cinemática Ackerman. Por último, se ha considerado conveniente que la aplicación permitiera guardar los resultados en un fichero con un formato adecuado para poder visualizar los resultados en otro programa como por ejemplo Matlab. El aspecto final de la aplicación es: Imagen 8.3Implementación final PFC: Generación y Transmisión de órdenes de movimiento a un vehículo autónomo tipo QUAD 56 8.2Obtención de los Datos del Láser Esta función tiene como objetivo simular el funcionamiento del láser incorporado en el Quad, es decir, debe devolver información sobre los objetos que se encuentran alrededor del vehículo. Esta información son las distancias calculadas desde la posición del láser hasta el objeto encontrado o, en el caso de no encontrar obstáculo, la distancia máxima de lectura del láser. Los valores propios del láser como ángulo de abertura, ángulo entre haces, alcance máximo, etc. vienen definidos por defecto, pero el usuario puede decidir cambiarlos si así lo desea. Imagen 8.4Variables Láser Esta función es llamada por el planificador del camino para comprobar la situación alrededor del vehículo y de esa forma decidir la siguiente posición. La posición de láser depende de la posición del Quad, y del mismo modo, la inclinación de éste también afecta al láser. La idea principal es la de recorrer todo los haces del sensor y comprobar si interceptan con algún obstáculo. De ser así, se calcula esa distancia. Con este fin, cada haz es implementado como una recta y la forma de comprobar si existen obstáculos cercanos es mediante intersecciones: para los obstáculos con forma circular se comprueba si existe intersección entre el haz y la circunferencia. Análogamente para los PFC: Generación y Transmisión de órdenes de movimiento a un vehículo autónomo tipo QUAD 63 Imagen 9.1: Pantalla principal de la aplicación Como se puede apreciar en la Imagen 8.1 la interfaz está dividida en siete bloques con el fin de facilitar la comprensión y el manejo de la misma. Se busca que el usuario que está realizando la simulación tenga siempre visible las características más importantes de la misma, es decir, que pueda comprobar el resultado de la simulación (la gráfica) mediante los valores utilizados sin necesidad de ir abriendo nuevas ventanas, facilitando de esta manera, el estudio del resultado obtenido. Imagen 9.2: Estructura de la pantalla principal. PFC: Generación y Transmisión de órdenes de movimiento a un vehículo autónomo tipo QUAD 64 A continuación se explicarán cada una de las partes, su utilidad y su funcionamiento. 9.3Bloque I: Menú El menú está formado por una serie de botones que nos permiten acceder de una manera más rápida a las ventanas desde donde se pueden modificar los valores del Quad, de los obstáculos y de las opciones de la simulación. Mediante los botones Abrir y Guardar se puede salvar y abrir la configuración de una antigua simulación. Además incluye una Ayuda desde donde se puede leer el funcionamiento de la aplicación. Por último se encuentra el botón Salir, que sirve para abandonar la aplicación. Imagen 9.3: Bloque I: Menú 9.4Bloque II: Datos Quad En este bloque se puede apreciar el valor de los parámetros del Quad. Al iniciar la aplicación, el Quad tiene ya establecidos valores por defecto en todos sus parámetros para facilitar al usuario el no tener que ir introduciendo cada vez que ejecuta la aplicación todos los valores, y de esta forma, simplemente tiene que modificar aquellos valores que le interesan. Debido a temas de espacio, no se pueden mostrar todos los parámetros en la pantalla principal, limitándose únicamente a 5. Para poder modificar o ver el resto de valores hay que hacer clic en modificar y nos aparecerá una nueva ventana con los valores actuales del Quad. Otra forma de acceder a esta ventana es mediante el botón del bloqueI: Menú. PFC: Generación y Transmisión de órdenes de movimiento a un vehículo autónomo tipo QUAD 65 Imagen 9.4: Bloque II: Datos Quad El significado de los distintos parámetros son: NOMBRE EXPLICACIÓN DATOS QUAD Nombre : Nombre del Quad. Ancho : Medida Ancho del Quad. Largo : Medida Largo del Quad. Ángulo Máx. Giro : Ángulo Máximo de Giro. DATOS LÁSER Ángulo obertura : Máxima obertura del Láser. Alcance Láser : Alcance máximo del Láser. Por defecto 50. Ángulo entre Haces : Distancia en grados entre los distintos haces del Láser. Este ángulo tiene que ser menor y múltiplo del ángulo de obertura. Distancia Detección Objetos : Distancia utilizada por el Quad para la detección de obstáculos. Si encuentra objetos a una distancia menor que ésta, empieza a reaccionar. Este valor debe ser menor que el Alcance del Láser. Dibujar Haces : Se utiliza para el dibujado de las Haces. Se puede seleccionar “La Primera y Última”, “Todas” o “Ninguna”. Tabla 9.1: Parámetros Datos Quad PFC: Generación y Transmisión de órdenes de movimiento a un vehículo autónomo tipo QUAD 66 Todos los parámetros, a parte de las restricciones mencionadas, deben cumplir la condición de ser mayores de 0. En el caso de que alguna de las restricciones no se cumplan, el programa avisa o se queda con el valor anterior válido 9.5Bloque III: Datos Obstáculos En este bloque se muestran los obstáculos insertados en el mapa con el fin de obstaculizar el paso del vehículo. Imagen 9.5: Bloque III: Datos Obstáculos Cuando se arranca la aplicación, no hay ningún obstáculo por defecto y por tanto es el propio usuario el que debe introducir tantos obstáculos como desee. El primero de ellos debe ser el borde, es decir, los límites del terreno que queremos utilizar para hacer las pruebas. Al pulsar el botón “Borde” nos aparece una nueva ventana para la introducción de los datos. Por tratarse del Borde la mayoría de las variables están ya predefinidas, como es el caso del nombre, del Punto Inicial y la Inclinación. El usuario debe elegir si desea un terreno con una forma cuadrada o rectangular. Según esta elección se deberá introducir únicamente el ancho (para los cuadrados) o el ancho y el largo (para los rectángulos). PFC: Generación y Transmisión de órdenes de movimiento a un vehículo autónomo tipo QUAD 67 Imagen 9.6: Bloque III: Borde Si se desea modificar o incluso eliminar el borde, se debe acceder de nuevo a esta ventana y pulsar sobre el botón correspondiente. Como se puede apreciar en la Imagen 8.5 (Bloque II: Datos Obstáculos), existe una opción que se llama AutoAjustar y cuya función no es más que ajustar el tamaño del borde introducido al tamaño del panel donde se dibuja la gráfica. Por defecto el tamaño del panel está adecuado para valores de Ancho=100, pero con esta opción, se pueden introducir bordes de cualquier tamaño pudiéndolos visualizar correctamente en la pantalla. Se ha añadido además, una slider para ajustar manualmente esta vista, en el caso que el usuario así lo desee. Una vez introducido el borde, se pueden ya insertar los obstáculos. Éstos pueden ser cuadrados o circulares. Para insertar un nuevo obstáculo y por tanto acceder a la ventana de Añadir Obstáculo existen tres formas para hacerlo. 1Mediante el botón “Nuevo” del bloque: Datos Obstáculos. 2Mediante el botón del bloque: Menú. 3Haciendo clic con el botón izquierdo sobre el bloque: Gráfica. Este modo se diferencia de los dos anteriores en que se guarda la posición donde se ha clicado como centro del obstáculo a introducir, facilitando así la inserción de obstáculos. La ventana “Nuevo Obstáculo” está dividida en dos pestañas, según si se desea introducir un Círculo o un Cuadrado. Según esta elección se deben introducir los parámetros correspondientes y pulsar en Añadir. PFC: Generación y Transmisión de órdenes de movimiento a un vehículo autónomo tipo QUAD 68 Imagen 9.7: Bloque III: Nuevo Obstáculo A medida que se van introduciendo los nuevos obstáculos, se van almacenando en un ComboBox. Al seleccionar el ítem de un obstáculo, se mostrarán sus propiedades en el bloqueIII: Datos Obstáculos de la Pantalla Principal. Al igual que en el borde, en los obstáculos también se pueden hacer cambios accediendo a la ventana de “Modificar Obstáculo”. Para ello hay que seleccionar su ítem (el nombre del objeto) y pulsar en Modificar, o bien, pulsar con el botón izquierdo del ratón sobre el objeto en el Bloque:Gráfica. Esta ventana permite también eliminar el objeto. Imagen 9.8: Bloque III: Modifica Obstáculo 9.6Bloque IV: Opciones Simulación Este bloque está pensado para englobar en él aquellos parámetros que no son características propias del quad, sino más bien, para aquellos parámetros que varían las características de la simulación, como por ejemplo, la posición inicial, final, velocidad... PFC: Generación y Transmisión de órdenes de movimiento a un vehículo autónomo tipo QUAD 69 Al igual que con los datos del Quad, al iniciar la aplicación, todas estas opciones de simulación tienen valores por defecto y será el usuario el que decida si cambiarlos o mantenerlos. Para hacer alguna modificación se debe pulsar en “Modificar” Imagen 9.9: Bloque IV: Opciones Simulación Imagen 9.10: Bloque IV: Modificar Opciones Simulación El significado de los distintos parámetros son: NOMBRE EXPLICACIÓN Posición inicial : Primera posición del camino. Posición final : Posición meta. Ángulo inicial : Inclinación inicial de las ruedas del Quad. Velocidad : Velocidad inicial del Quad. Aceleración : Aceleración del Quad en ese momento. Se puede modificar durante la ejecución de la simulación. PFC: Generación y Transmisión de órdenes de movimiento a un vehículo autónomo tipo QUAD 70 Intervalo de tiempo Intervalo de tiempo entre el cálculo de una posición a otra. Tabla 9.2: Parámetros Opciones SImulación Otra forma de introducir la posición inicial y final es mediante el ratón en el bloque VI: Gráfica, ya que basta con pulsar con el botón derecho en el punto donde queremos y saldrá un menú desplegable para elegir entre ambas posiciones. Imagen 9.12: Bloque IV: Modificar Posición inicial y final 9.7Bloque V: Resultados Simulación Observando el dibujo de la simulación, se puede apreciar ya si los resultados son correctos o no, pero no sabemos con exactitud los puntos por los que pasa o cuáles son los valores que devuelve el láser en ese punto. Por ello se ha diseñado este bloque, cuya intención es proporcionar al usuario un resultado más analítico para que pueda interpretar mejor los movimientos del Quad. En el bloque se pueden observar 4 pestañas, con 4 áreas de texto diferentes. - Posiciones: Se van imprimiendo las posiciones actuales del Quad, es decir, se muestran todas las posiciones por las que pasa el Quad desde la posición inicial hasta la posición meta. Se muestra además, la inclinación de las ruedas, la velocidad y la aceleración en ese momento. - Quad: se muestran las características del Quad. - Obstáculos: se muestran todos los obstáculos del mapa actual junto con sus características (posición, centro, lado...). - Láser: esta pestaña tiene la intención de mostrar los resultados que devuelve el láser en esa posición e inclinación en la que se encuentra el Quad. Para ello, primero hay que poner en Pause la simulación y pulsar “Obtener Datos Láser”. PFC: Generación y Transmisión de órdenes de movimiento a un vehículo autónomo tipo QUAD 71 Imagen 9.13: Bloque V: Resultados Simulación Por último, el botón Limpiar sirve para vaciar las 4 áreas de texto (Posiciones, Quad, Obstáculos y Láser), en el caso que el usuario así lo desee. 9.8Bloque VI: Gráfica Este bloque, quizás uno de los más importantes, permite visualizar los resultados de la simulación. Como ya se ha comentado antes, desde este bloque se pueden insertar nuevos obstáculos, modificarlos, eliminarlos y cambiar las posiciones de partida y meta. PFC: Generación y Transmisión de órdenes de movimiento a un vehículo autónomo tipo QUAD 72 Imagen 9.14: Bloque VI: Gráfica - La posición inicial se representa mediante un círculo verde. - La posición final se representa mediante un círculo rojo. - El Quad se representa mediante un rectángulo negro con las medidas (ancho y largo) que se han establecido. - Los haces del láser se representan mediante líneas amarillas - Los obstáculos se representan con el color elegido para cada objeto. - El camino se representa mediante una polilínea azul. 9.9Bloque VII: Control Simulación Esta parte de la aplicación está dividida en dos: por un lado encontramos los botones de control (Start y Stop) y por otro, los botones de debug (Parar, Reanudar). Imagen 9.15: Bloque VII: Control Simulación. PFC: Generación y Transmisión de órdenes de movimiento a un vehículo autónomo tipo QUAD 79 Paquete Interfaz - DBPanelFiguras: Esta clase implementa un hilo de ejecución paralelo a la aplicación que se encarga de dibujar los obstáculos y el camino que va siguiendo el quad. - DBPanelPosiciones: Esta clase implementa otro hilo de ejecución paralelo a la aplicación y tiene la función de mostrar la posición y otras variables del quad en ese instante de tiempo. - FigurasJPanel:Clase que extiende a DBPanelFiguras y es el que interacciona con la clase camino para dibujar el camino. Es el intermediario entre DBPanelFiguras y el resto de clases que solicitan sus métodos. - ImprimirPosiciones: Clase que extiende a DBPanelPosiciones y es el que interacciona con la clase camino para mostrar los datos del quad en ese momento. Es el intermediario entre DBPanelPosiciones y el resto de clases que solicitan sus métodos. Mediante esta clase también se muestran los valores devueltos por el sensor láser en la posición en la que se encuentra en ese instante que el usuario lo solicita. - Main: Esta clase contiene el main() de la aplicación. Implementa además, la interfaz gráfica de usuario con todas sus funcionalidades: abrir archivo, modificar opciones, añadir obstáculos.. A partir de esta interfaz principal se pueden abrir las distintas ventanas que completan la totalidad de la interfaz de usuario. - ModificaObstaculo: Esta clase implementa la ventana desde donde se pueden modificar los distintos parámetros que definen al obstáculo seleccionado. - ModificarOpciones: Esta clase implementa la ventana desde donde se pueden modificar las opciones de simulación como la velocidad, la aceleración, la posición inicia y final, etc. - ModificarQuad: Esta clase implementa la ventana desde donde se pueden modificar las opciones que definen al quad como largo, ancho, ángulo de giro. También se pueden modificar las características de su sensor láser (ángulo de abertura, ángulo entre haces, etc.). - NuevoObstaculo: Esta clase implementa la ventana desde donde se puede añadir el borde en primer lugar, y después el número de obstáculos que el usuario estime oportuno, ya sean cuadrados o círculos. PFC: Generación y Transmisión de órdenes de movimiento a un vehículo autónomo tipo QUAD 80 Paquete Objects - Circulo: Clase que hereda de Object y se utiliza para representar un círculo mediante la ecuación de la circunferencia . Entre los distintos métodos destaca el de hallar los puntos intersección con una recta. - Cuadrado: Clase que hereda, al igual que Círculo, de Object y representa un cuadrado ( o rectángulo, en el caso del borde). Esta representación viene dada por un vector de cuatros rectas que representan los lados, y otro vector de cuatro posiciones que representan los vértices. Se puede también indicar la inclinación del mismo. - GestionObstaculos: clase utilizada para llevar el control de los obstáculos insertados mediante un ArrayList de objetos. Además también controla los dos círculos que se utilizan para representar el inicio y el fin del recorrido. - Object: clase abstracta que representa un obstáculo en sí. Permite diferenciar entre los dos tipos de obstáculos existentes mediante un id (0 para círculos, 1 para cuadrados). Paquete Quad - DatosQuad: clase utilizada para almacenar los resultados que se van obteniendo en cada intervalo de tiempo. - Quad: Mediante esta clase se representa la configuración del vehículo utilizado en la aplicación, definiendo además, las características del sensor láser que lleva incorporado. Tiene una gran cantidad de métodos entre los que se puede destacar el de ackerman, que es el encargado del movimiento del quad, es decir, de calcular la cinemática utilizada para su desplazamiento a partir del ángulo de giro y la velocidad. Paquete Search - Camino: esta clase implementa un hilo de ejecución paralelo a la aplicación que se encarga de calcular el camino que debe seguir el quad. Mediante el método PFC: Generación y Transmisión de órdenes de movimiento a un vehículo autónomo tipo QUAD 81 Buscar_camino va calculando cada posición según los datos obtenidos por el método datos_láser. Una vez se calcula el nuevo punto se llama a la función ackerman del quad para realizar el movimiento y a las clases de FigurasJPanel y ImprimirPosicion para que actualicen tanto el dibujo como los datos que se muestran en los paneles. - CNodo: cada posición por la que ha pasado el quad se representa como un Nodo para llevar un seguimiento de este camino. Las posiciones calculadas como posibles futuras posiciones a partir del nodo actual se almacenan en una cola de prioridad. Este orden lo impone la clase ComparaCPosicion. - ComparaCPosicion: esta clase es utilizada para ordenar la cola de prioridad de las posiciones a las que se puede acceder a partir de la posición actual. Este orden viene dado por la distancia a la meta y por el número de haces del láser libres, es decir, que no interceptan con ningún obstáculo. PFC: Generación y Transmisión de órdenes de movimiento a un vehículo autónomo tipo QUAD 82 APÉNDICE B: CÓDIGO FUENTE Obtención de los Datos del Láser // ---------------------------------------------------------------------------------- /* * Nombre: datos_laser Descripción: Función que calcula los datos obtenidos * por el láser en la posición actual * Argumentos: double posicion: Posición * del Láser (situado en el Quad) desde la cual se quieren hallar los datos * del láser quad quad_aux: quad sobre el cual se encuentra el láser * GestionObstaculos goV_obstaculos: Vector donde se encuentran almacenados * todos los obstáculos del mapa actual Valor devuelto: el vector de * distancias. El tamaño de este vector depende del número de haces del * láser. */ public double[] datos_laser(Posicion posicion, Quad quad_aux, GestionObstaculos goV_obstaculos) { // se calcula el ángulo inicial y final del láser en ese instante double angulo_inicial = quad_aux.getInclinacion()+ quad_aux.getAnguloLaser() / 2; // inclinación double angulo_final = angulo_inicial - quad_aux.getAnguloLaser(); // vector distancias distancias = new double[(int) ((quad_aux.getAnguloLaser()) / quad_aux .getAngulo_entre_haces()) + 1];// lista para // se inicializan todos los elementos del vector al alcance máx del láser for (int i = 0; i < (int) (((quad_aux.getAnguloLaser()) / quad_aux .getAngulo_entre_haces()) + 1); i++) { distancias[i] = quad_aux.getDistancia_max_laser(); } // se recorre todo el vector de obstáculos for (int i = 0; i < goV_obstaculos.getV_Figuras().size(); i++) { // para cada obstáculo se comprueba si alguno de los haces // intercepta con dicho obstáculo if (goV_obstaculos.getV_Figuras().get(i).getId() == 0)// es un // circulo { Circulo c1 = (Circulo) goV_obstaculos.getV_Figuras().get(i); int j1 = -1; for (double i1 = angulo_inicial; i1 >= angulo_final; i1 -= quad_aux .getAngulo_entre_haces()) { j1++; Posicion[] a = new Posicion[2]; Posicion p1 = new Posicion(); // punto calculado sobre el haz con ángulo i1 del láser p1.setX(quad_aux.getPosicion().getX() PFC: Generación y Transmisión de órdenes de movimiento a un vehículo autónomo tipo QUAD 83 + ((quad_aux.getPosicion().getX() + quad_aux .getAvanza_distancia()) - quad_aux .getPosicion().getX()) * Math.cos(Math.toRadians(-i1))); p1.setY(quad_aux.getPosicion().getY() + ((quad_aux.getPosicion().getX() - quad_aux .getAvanza_distancia()) - quad_aux .getPosicion().getX()) * Math.sin(Math.toRadians(-i1))); Recta angu = new Recta(quad_aux.getPosicion(), p1); // recta // creada entre el punto posicion del quad // y el punto de la recta del haz del láser // punto intersección de la recta con el círculo a = (c1).interseccion(angu); if (a[0].getX() != -1 && a[0].getY() != -1) { Double distMax1 = Math.sqrt((Math.pow(a[0].getX() - quad_aux.getPosicion().getX(), 2))+ (Math.pow(a[0].getY() - quad_aux.getPosicion().getY(), 2))); Double distMax2 = Math.sqrt((Math.pow(a[1].getX() - quad_aux.getPosicion().getX(), 2))+ (Math.pow(a[1].getY() - quad_aux.getPosicion().getY(), 2))); // si la distancia del punto p1 al punto interseccion es // mayor que el punto del quad a la interseccion // distancia=50 if (Math.sqrt((Math.pow(a[0].getX() - p1.getX(), 2)) + (Math.pow(a[0].getY() - p1.getY(), 2))) > distMax1) distMax1 = quad_aux.getDistancia_max_laser(); if (Math.sqrt((Math.pow(a[1].getX() - p1.getX(), 2)) + (Math.pow(a[1].getY() - p1.getY(), 2))) > distMax2) distMax2 = quad_aux.getDistancia_max_laser(); if (distMax1.isNaN()) distMax1 = quad_aux.getDistancia_max_laser(); if (distMax2.isNaN()) distMax2 = quad_aux.getDistancia_max_laser(); if (distMax2 < distMax1) distMax1 = distMax2; if (distancias[j1] > distMax1) distancias[j1] = (double) distMax1; } } } else { Cuadrado c1 = (Cuadrado) goV_obstaculos.getV_Figuras().get(i); // ////////////////////CUADRADOS//////////////////////// // ///////////////////////////////// PFC: Generación y Transmisión de órdenes de movimiento a un vehículo autónomo tipo QUAD 84 // ahora analizamos el cuadrado // / C1 -------C2 // / | | // / | | // / | | // / C4 -------C3 // / int j1 = -1; double i1 = 0; for (i1 = angulo_inicial; i1 >= angulo_final; i1 -= quad_aux .getAngulo_entre_haces()) { j1++; boolean arriba = false; boolean derecha = false; Posicion p1 = new Posicion(); p1.setX(quad_aux.getPosicion().getX() + ((quad_aux.getPosicion().getX() + 1) - quad_aux .getPosicion().getX()) * Math.cos(Math.toRadians(-i1))); p1.setY(quad_aux.getPosicion().getY() + ((quad_aux.getPosicion().getX() - 1) - quad_aux .getPosicion().getX()) * Math.sin(Math.toRadians(-i1))); if (p1.getY() > quad_aux.getPosicion().getY()) arriba = true; else arriba = false; if (p1.getX() > quad_aux.getPosicion().getX()) derecha = true; else derecha = false; Recta angu = new Recta(quad_aux.getPosicion(), p1); // recta // creada entre el punto posicion del quad // y el punto de la recta del haz del láser for (int n_recta = 0; n_recta < 4; n_recta++) { // buscar intersecciones con las 4 rectas del // cuadrado Recta r1 = ((Cuadrado) c1).getRectas_lados(n_recta); Posicion inters = r1.Busca_interseccion(angu); if (inters.getX() != -1 && (inters.getY() == ((Cuadrado) c1) .getVertices(n_recta).getY()&& inters.getX() == ((Cuadrado) c1) .getVertices(n_recta).getX()|| inters.getY() == ((Cuadrado) c1) .getVertices((n_recta + 1) % 4).getY()&& inters.getX() == ((Cuadrado) c1).getVertices((n_recta + 1) % 4).getX()|| inters.getY() > ((Cuadrado) c1).getVertices(n_recta).getY()&& inters.getY() < ((Cuadrado) c1) .getVertices((n_recta + 1) % 4).getY()|| inters.getY() < ((Cuadrado) c1) .getVertices(n_recta).getY()&& inters.getY() > ((Cuadrado) c1) .getVertices((n_recta + 1) % 4).getY()|| inters.getX() > ((Cuadrado) c1).getVertices(n_recta).getX()&& inters.getX() < ((Cuadrado) c1) PFC: Generación y Transmisión de órdenes de movimiento a un vehículo autónomo tipo QUAD 85 .getVertices((n_recta + 1) % 4).getX() || inters.getX() < ((Cuadrado) c1).getVertices(n_recta).getX()&& inters.getX() > ((Cuadrado) c1) .getVertices((n_recta + 1) % 4).getX())) { if (!derecha&& (inters.getX() < quad_aux.getPosicion() .getX() && (i1 != 90))|| derecha&& inters.getX() > quad_aux.getPosicion().getX()&& (i1 != 270)|| arriba && inters.getY() > quad_aux.getPosicion().getY()&& (i1 != 180)|| !arriba && inters.getY() < quad_aux.getPosicion() .getY() && (i1 != 0)) { // la intersección está en el cuadrado Double lado_AC = Math.sqrt((Math.pow(inters.getX() - quad_aux.getPosicion().getX(), 2)) + (Math.pow(inters.getY()- quad_aux.getPosicion() .getY(), 2))); if (lado_AC.isNaN()) lado_AC = quad_aux.getDistancia_max_laser(); if (lado_AC < distancias[j1]) distancias[j1] = (double) lado_AC; } } } } } }// fin while return distancias; } //-------------------------------------------------------------------------------------------- PFC: Generación y Transmisión de órdenes de movimiento a un vehículo autónomo tipo QUAD 86 Movimiento. Cinemática Ackerman. // ---------------------------------------------------------------------------------- /* * Nombre: calcula_ang_ruedas * Descripción: Función que calcula los ángulos de giro y velocidades de las ruedas delanteras * Argumentos: * double d_giro: giro realizado por el volante del vehículo * double d_velocidad: velocidad que lleva el quad en ese instante * Valor devuelto: no devuelve ningún valor */ public void calcula_ang_ruedas(double d_giro,double d_velocidad){ double radio=largo*(Math.tan(Math.PI/2-((d_giro)))); double d_angulo_interior = 0; double d_angulo_exterior = 0; if (d_giro != 0) // Si no se desplaza en línea recta { if(d_giro<0){ d_angulo_exterior = Math.atan(largo/(Math.abs(radio)+(ancho/2)))*180/Math.PI; d_angulo_interior = Math.atan(largo/(Math.abs(radio)-(ancho/2)))*180/Math.PI; double d_vtexterior=d_velocidad/Math.cos(Math.abs(d_angulo_exterior*Math.PI/180)); doublé d_vtinterior= d_velocidad/Math.cos(Math.abs(d_angulo_interior*Math.PI/180)); this.m_vd_velocidadesRuedas[0]= (d_vtexterior*Math.sin(d_angulo_exterior*Math.PI/180) )/ ancho; m_vd_velocidadesRuedas[1]= (d_vtinterior*Math.sin(d_angulo_interior*Math.PI/180) )/ ancho; this.m_vd_angulosRuedas[0]=d_angulo_exterior; this.m_vd_angulosRuedas[1]=d_angulo_interior; this.m_vd_angulosRuedas[2]=d_giro; } else{ //giro>0 d_angulo_exterior = Math.atan(largo/(Math.abs(radio)+(ancho/2)))*180/Math.PI; d_angulo_interior = Math.atan(largo/(Math.abs(radio)- (ancho/2)))*180/Math.PI; double d_vtexterior=d_velocidad/Math.cos(Math.abs(d_angulo_exterior*Math.PI/180)); double d_vtinterior=d_velocidad/Math.cos(Math.abs(d_angulo_interior*Math.PI/180)); this.m_vd_velocidadesRuedas[1]= (d_vtexterior*Math.sin(d_angulo_exterior*Math.PI/180) )/ ancho; this.m_vd_velocidadesRuedas[0]= (d_vtinterior*Math.sin(d_angulo_interior*Math.PI/180) )/ ancho; PFC: Generación y Transmisión de órdenes de movimiento a un vehículo autónomo tipo QUAD 87 this.m_vd_angulosRuedas[1]=d_angulo_exterior; this.m_vd_angulosRuedas[0]=d_angulo_interior; this.m_vd_angulosRuedas[2]=d_giro; } } else{ //linea recta this.m_vd_angulosRuedas[0]=0; this.m_vd_angulosRuedas[1]=0; this.m_vd_velocidadesRuedas[1]=this.m_vd_velocidadesRuedas[2]; this.m_vd_velocidadesRuedas[0]=this.m_vd_velocidadesRuedas[2]; } } // ------------------------------------------------------------- /* * Nombre: ackerman * Descripción: Función que calcula la cinemática ackerman para obtener la posición siguiente * Argumentos: * double d_giro: giro realizado por el volante del vehículo * double d_velocidad: velocidad que lleva el quad en ese instante * Valor devuelto: no devuelve ningún valor */ public void ackerman( double d_giro, double d_velocidad){ // 0--------1 // - - // - - // 2--------3 m_d_giroActual=d_giro; //paso radianes d_giro=d_giro*Math.PI/180; //velocidad de la rueda imaginaria delantera double d_vt=d_velocidad/Math.cos(Math.abs(d_giro)); //CALCULAR Ángulos Ruedas this.m_d_velAngular=(d_vt*Math.sin(d_giro) )/ ancho; this.m_vd_velocidadesRuedas[2]=m_d_velAngular; calcula_ang_ruedas(d_giro,d_velocidad); this.setInclinacion(m_d_velAngular+this.getInclinacion()); double d_x=this.getPosicion().getX()+ d_velocidad*this.intervalo_tiempo*Math.cos(this.inclinacion*Math.PI/180); double d_y=this.getPosicion().getY()+d_velocidad*this.intervalo_tiempo *Math.sin(this.inclinacion*Math.PI/180); Posicion p=new Posicion(d_x,d_y); p.setAngulo(this.getInclinacion()); this.setPosicion(p); } // ---------------------------------------------------------------------------------- PFC: Generación y Transmisión de órdenes de movimiento a un vehículo autónomo tipo QUAD 88