Prácticas y comportamientos religiosos de los romanos durante la segunda Guerra Púnica
Navegación Local de Robots Móviles en ambientes desconocidos utilizando Programación Orientada a...
101
UNIVERSIDAD CATÓLICA DEL NORTE FACULTAD DE INGENIERÍA Y CIENCIAS GEOLÓGICAS DEPARTAMENTO DE INGENIERÍA DE SISTEMAS Y COMPUTACIÓN Navegación Local de Robots Móviles en ambientes desconocidos utilizando Programación Orientada a Comportamientos. Tesis para optar al Título de Ingeniero de Ejecución en Computación e Informática Harold Alberto Valdés Tapia Profesor Guía: Ricardo Pérez Sánchez Antofagasta, Chile Abril del 2013
Transcript of Navegación Local de Robots Móviles en ambientes desconocidos utilizando Programación Orientada a...
UNIVERSIDAD CATÓLICA DEL NORTE
FACULTAD DE INGENIERÍA Y CIENCIAS GEOLÓGICAS
DEPARTAMENTO DE INGENIERÍA DE SISTEMAS Y COMPUTACIÓN
Navegación Local de Robots Móviles en ambientes desconocidos
utilizando Programación Orientada a Comportamientos.
Tesis para optar al Título de Ingeniero de Ejecución en Computación e
Informática
Harold Alberto Valdés Tapia
Profesor Guía:
Ricardo Pérez Sánchez
Antofagasta, Chile
Abril del 2013
ii
Agradecimientos
Al terminar esta etapa de mi carrera no me queda más que agradecer a todas
las personas que me ayudaron a cumplir mi objetivo.
En primer lugar quisiera agradecer a mi madre, que sin su apoyo incondicional y
su confianza plena no hubiera podido lograr mi sueño. Gracias por tomarme de
la mano y ayudarme a caminar en este sendero tan difícil de cruzar. Quisiera
agradecer a mi padre. Gracias por iluminar mi camino y enseñarme que con
esfuerzo y dedicación puedo lograr cualquier meta que me proponga.
Asimismo quisiera agradecer a mis hermanas, quienes con sus ánimos y cariño
incondicional permitieron que llevara este proyecto a buen término.
Además, quisiera agradecer a Persy Alfaro Silva y a Eduardo Ángel Lanas,
quienes me apoyaron con sus alientos y grandes consejos los cuales atesoraré
de por vida.
Y finalmente y no menos importante, quisiera agradecer a mi profesor guía, que
gracias a su apoyo y confianza pude realizar con éxito este proyecto. Gracias
por darme a conocer este tema tan fantástico y hermoso como lo es la robótica.
iii
Tabla de contenidos
Páginas
Índice de Figuras ________________________________________________ v
Resumen _____________________________________________________ vii
Capítulo I Introducción __________________________________________ 1
1.1 Descripción _________________________________________________ 2
1.2 Objetivos ___________________________________________________ 2
1.2.1 Objetivo General ________________________________________ 2
1.2.2 Objetivos Específicos _____________________________________ 3
Capítulo II Marco Teórico _______________________________________ 4
2.1. Historia de la robótica ______________________________________ 4
2.2.- Tipos de Robots _________________________________________ 6
2.2.1.- Robótica Industrial ____________________________________ 7
2.2.2- Robótica De Servicio. ___________________________________ 7
2.2.3- Robótica Móvil ________________________________________ 8
2.3.- Navegación en robots móviles. _____________________________ 10
2.3.1- Navegación Local. ____________________________________ 14
2.4.- Programación orientada a comportamientos. __________________ 15
2.5 LOGICA DIFUSA ________________________________________ 16
2.5.1 Fundamentos de la lógica difusa __________________________ 16
2.5.2 Conjuntos difusos _____________________________________ 17
2.5.3 Función Membresía ____________________________________ 20
2.5.3.1 Función Triangular __________________________________ 21
2.5.3.2 Función Trapezoidal ________________________________ 22
2.5.3.3 Función Gaussiana _________________________________ 23
2.5.4 Operaciones sobre conjuntos difusos ______________________ 23
2.5.4.1 Reglas si-entonces _________________________________ 25
2.5.5 Sistema de Inferencia Difuso _____________________________ 27
2.5.6 Proceso de inferencia difuso _____________________________ 29
2.5.7 Desfusificación _______________________________________ 32
2.5.7.1 Otros métodos desfusificadores _______________________ 33
Capítulo III Estado del arte _______________________________________ 36
3.1 Navegación Local Basada en Fuerzas vectoriales ______________ 36
3.2 Navegación Local Basada en sensores _______________________ 37
iv
3.2.1 Bug 1 y Bug2 _________________________________________ 38
3.3 Tangent Bug ____________________________________________ 41
3.3.1. Funcionamiento del Tangent Bug _________________________ 41
3.3.2 Algoritmo ____________________________________________ 42
Capítulo IV Presentación y discusión bibliográfica del problema ___________ 47
4.1 Introducción _____________________________________________ 47
4.2 ventajas y desventajas en algunos algoritmos __________________ 47
4.3 Consideraciones físicas del robot. ____________________________ 50
Capítulo V Desarrollo ____________________________________________ 53
5.1 Introducción _____________________________________________ 53
5.2 Plataforma de trabajo _____________________________________ 53
5.3 Simulaciones. ___________________________________________ 54
5.3.1 MotionToGoal. ________________________________________ 56
5.3.2 Seguir la Pared. _______________________________________ 60
5.3.2.1 Modelo Difuso _____________________________________ 61
5.3.2.2 Operadores Lógicos ________________________________ 62
5.3.2.3 Método de Implicación _______________________________ 62
5.3.2.4 Método de Agregación ______________________________ 62
5.3.2.5 Método de Desfusificación ___________________________ 63
5.3.2.6 Entradas Difusas ___________________________________ 63
5.3.2.7 Salidas Difusas ____________________________________ 64
5.3.2.8 Funciones de membresía ____________________________ 65
5.3.2.9 Reglas de Inferencia Difusas __________________________ 67
5.4 Proceso de Inferencia Difusa (PID) ___________________________ 68
5.4.1 Entradas difusas ______________________________________ 69
5.4.2 Operadores difusos ____________________________________ 71
5.4.3 Inferencia Difusa ______________________________________ 73
Capítulo VI Resultados __________________________________________ 74
Capítulo VII Conclusión _________________________________________ 78
Referencias Bibliográficas ________________________________________ 79
Anexos _______________________________________________________ 81
Anexo A. Código del comportamiento Tangent Bug. ____________________ 82
v
Índice de Figuras
Figura 2.1 Diagrama de clasificación de Robots ................................................ 6
Figura 2.2 Robot industria automotriz ................................................................. 7
Figura 2.3 Robot de servicio hospitalario ............................................................ 8
Figura 2.4 Robots Trilobites ................................................................................ 9
Figura 2.5 Robot de la empresa PARALLAX ...................................................... 9
Figura 2.6 Tipos de navegación en la robótica móvil ........................................ 11
Figura 2.7 Niveles de control en un Robot Móvil Autónomo ............................. 12
Figura 2.8 Conjunto Nítido ................................................................................ 18
Figura 2.9 Conjunto difuso "flaco" ..................................................................... 19
Figura 2.10 Curva Triangular. Membresía v/s entradas .................................... 21
Figura 2.11 Función Trapezoidal. Membresía v/s entrada. ............................... 22
Figura 2.12 Función Gaussiana. Membresía v/s entrada ................................. 23
Figura 2.13 Operaciones sobre conjuntos nítidos y difusos .............................. 24
Figura 2.14 Sistema de inferencia difuso con pre y post procesamiento .......... 28
Figura 2.15 Superficie de control ...................................................................... 29
Figura 2.16 Proceso de inferencia difuso .......................................................... 31
Figura 2.17 Centro de gravedad en el conjunto difuso de salida ...................... 33
Figura 2.18 Método de desfusificación del máximo .......................................... 34
Figura 2.19 Método de desfusificación de la media de los máximos ................ 35
Figura 3.1 Ejemplo de navegación con VFF ..................................................... 37
Figura 3.2 Bug 1 ............................................................................................... 38
Figura 3.3 Pseudocódigo para el Bug 1 ............................................................ 39
Figura 3.4 Bug 2 ............................................................................................... 40
Figura 3.5 Pseudocódigo para el algoritmo Bug 2 ............................................ 40
Figura 3.6 Datos iniciales de algoritmo ............................................................. 42
Figura 3.7 El robot detectó un obstáculo a través de los sensores B7 y B8 ..... 43
vi
Figura 3.8 dfollowed y dreach ........................................................................... 44
Figura 3.9 Ejemplo de recorrido hecho con Tangent Bug ................................. 45
Figura 3.10 Código fuente comportamiento Tangent Bug ................................ 46
Figura 4.1 Esqueleto del robot AMADEUS ....................................................... 50
Figura 4.2 Sensores de movimiento PING))) .................................................... 51
Figura 4.3 robot AMADEUS empleado en el proyecto ...................................... 52
Figura 5.1 PropellerTool ................................................................................... 53
Figura 5.2 Código Inicial de los sensores ......................................................... 54
Figura 5.3 Posición inicial del Robot. ................................................................ 54
Figura 5.4 Códigos avance del robot ................................................................ 55
Figura 5.5. Simulación del MotionToGoal. ........................................................ 56
Figura 5.6. Códigos del MotionToGoal ............................................................. 57
Figura 5.7.Robot buscando objetivo ................................................................. 57
Figura 5.8.Robot se dirige al punto final. .......................................................... 58
Figura 5.9.Distancia entre sensores 2 y 5 ......................................................... 59
Figura 5.10.Códigos para pasar entre 2 obstáculos. ........................................ 59
Figura 5.11.Robot se dirige a la meta ............................................................... 60
Figura 5.12.Robot encuentra obstáculo ............................................................ 60
Figura 5.13 Modelo de sistema de inferencia difusa Mamdani ......................... 61
Figura 5.14 Sensores 1,3 y 5 utilizados para el sistema difuso ........................ 63
Figura 6.1. Ambiente de prueba para el comportamiento Tangent Bug ............ 74
Figura 6.2. Trayectoria sin obstáculos .............................................................. 75
Figura 6.3. Trayectoria para el primer obstáculo............................................... 76
Figura 6.4. Trayectoria final del robot ............................................................... 77
vii
Resumen
El objetivo de esta memoria es proporcionarle a un robot comportamientos
idóneos para su navegación local, para que éste pueda esquivar obstáculos
imprevistos en su camino ya que, sin estos comportamientos, tendría
demasiadas dificultades para encontrar su meta final.
Para lograr este objetivo se comenzó por analizar los distintos comportamientos
que existen en la actualidad para la evasión de obstáculos. Luego, una vez ya
claro cómo funcionan cada uno de estos, elegir el más idóneo para el robot con
el cual se quiere trabajar.
Luego, se programó el comportamiento elegido en un microcontrolador llamado
PROPELLER con el cual está provisto el robot. Los códigos están programados
en un lenguaje llamado SPIN.
Finalmente, para verificar el correcto funcionamiento del Robot, se creó un
ambiente estructurado de 10x10 metros con obstáculos predeterminados y con
otros colocados en forma de azar para así observar el comportamiento de este.
1
Capítulo I Introducción
En el estudio de la robótica, uno de los temas más investigados es la robótica
móvil. Un robot móvil es una máquina automática que es capaz de realizar
movimientos en una superficie predeterminada. A diferencia de los robots
industriales, estos pueden moverse a través de todo su entorno y no están fijos
en alguna ubicación física (como por ejemplo los brazos articulados).
Es posible que el aspecto más relevante en la robótica móvil, sea la
navegación, punto en el cual se enfoca esta memoria. La navegación es la
capacidad de un robot móvil de desplazarse desde un punto “A” a un punto “B”,
en forma autónoma, sin colisionar con los obstáculos de un ambiente que
puede ser parcialmente o totalmente desconocido. Tanto las capacidades
motrices como sensoriales restringen las estrategias de navegación, las que se
han extendido de tal manera que hoy se dividen en estrategias de navegación
en ambientes exteriores e interiores. Los ambientes exteriores, por lo general,
son terrenos irregulares y las capacidades motrices del robot deben ser muy
específicas, así como su sistema sensorial, que por lo general debe estar
formado por una cámara que captura imágenes del entorno. En el caso de la
navegación en ambientes interiores, el entorno está más estructurado, existe
algún conocimiento de él y la navegación se centra en evadir obstáculos en la
forma más eficiente posible.
En resume, Un robot móvil con desplazamiento autónomo, debe ser capaz de
desplazarse desde un punto de origen a un punto de destino, en un ambiente
parcialmente estructurado, sin colisionar con obstáculos desconocidos. Para
esto último existen diversos tipos de métodos de navegación local, pero pocos
de estos métodos están probados para un robot que cuente con un
microcontrolador específico llamado PROPELLER (Propeller, 2006) modelo con
el cual se trabajó en esta memoria.
2
1.1 Descripción
El desarrollo de la tesis se encuentra dividido en tres partes. La primera
corresponde al estudio de variados comportamientos con los cuales el robot
pueda reaccionar cuando se le presente un obstáculo, luego, se elegirán los
más idóneos para la experiencia a realizar. La segunda fase consiste en
programar dichos comportamientos en el lenguaje SPIN (lenguaje de bajo nivel
con el que opera el microcontrolador Propeller). Y en la última fase se procede
a instalar el microcontrolador ya programado a un robot (en este caso, el robot
AMADEUS, perteneciente a la Universidad Católica del Norte) y así comprobar
la efectividad de lo programado.
1.2 Objetivos
En esta sección se especificará de manera clara el objetivo general y los
objetivos específicos necesarios para el desarrollo correcto del trabajo de
titulación.
1.2.1 Objetivo General
Programar comportamientos robóticos en un lenguaje de bajo nivel y validarlos
través de un robot móvil con el fin de que es éste esquive obstáculos
imprevistos detectados por sus sensores ultrasónicos sin que pierda su ruta
principal para llegar a su objetivo final.
3
1.2.2 Objetivos Específicos
Como objetivos específicos están:
Analizar variados comportamientos para la reacción de un robot cuando
a éste se le presenten obstáculos imprevistos y seleccionar los más
idóneos.
Programar y generar un código que transforme los comportamientos
seleccionados a un lenguaje de bajo nivel para ingresarlo a un
microcontrolador PROPELLER y que este pueda generar las
instrucciones necesarias al robot.
Verificar los códigos creados en un robot real y que éste cumpla los
objetivos planteados.
4
Capítulo II Marco Teórico
2.1. Historia de la robótica
Por siglos, el ser humano ha construido máquinas que imitan partes del cuerpo
humano. Los antiguos egipcios unieron brazos mecánicos a las estatuas de sus
dioses; los griegos construyeron estatuas que operaban con sistemas
hidráulicos, los cuales eran utilizados para fascinar a los adoradores de los
templos. El inicio de la robótica actual puede fijarse en la industria textil del siglo
XVIII, cuando Joseph Jacquard inventa en 1801 una máquina textil programable
mediante tarjetas perforadas. Luego, la Revolución Industrial impulsó el
desarrollo de estos agentes mecánicos. Además de éstos, durante los siglos
XVII y XVIII en Europa fueron construidos muñecos mecánicos muy ingeniosos
que tenían algunas características de robots. Jacques de Vauncansos
construyó varios músicos de tamaño humano a mediados del siglo XVIII. En
1805, Henri Maillardert construyó una muñeca mecánica que era capaz de
hacer dibujos. La palabra robot se utilizó por primera vez en 1920 en una obra
llamada "Los Robots Universales de Rossum", escrita por el dramaturgo checo
KarelCapek. Su trama trataba sobre un hombre que fabricó un robot y luego
este último mata al hombre. La palabra checa 'Robota' significa servidumbre o
trabajado forzado, y cuando se tradujo al inglés se convirtió en el término robot.
Luego, Isaac Asimov comenzó en 1939 a contribuir con varias relaciones
referidas a robots y a él se le atribuye el acuñamiento del término Robótica y
con el surgen las denominadas "Tres Leyes de Robótica" que son las
siguientes:
1. Un robot no puede actuar contra un ser humano o, mediante la inacción,
que un ser humano sufra daños.
5
2. Un robot debe de obedecer las órdenes dadas por los seres humanos,
salvo que estén en conflictos con la primera ley.
3. Un robot debe proteger su propia existencia, a no ser que esté en
conflicto con las dos primeras leyes.
Actualmente, el estudio de la 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.
En la actualidad, la robótica ha evolucionado hasta lograr modelos sumamente
ambiciosos, como es el caso del IT, diseñado para expresar emociones, el COG
(COG, 1993), también conocido como el robot de cuatro sentidos, el famoso
SOJOURNER (SOJOUNER, 1997) usado en el espacio y otros mucho más
específicos como el CYPHER (Cypher, 2006) un helicóptero robot de uso
militar, el guardia de tráfico japonés ANZEN TARO (Anzen, 2010) o los robots
mascotas de Sony.
En general la evolución de la robótica la podemos clasificar en cinco
generaciones: las dos primeras, ya alcanzadas en los ochenta, incluían la
gestión de tareas repetitivas con autonomía muy limitada. La tercera generación
incluiría visión artificial, en lo cual se ha avanzado mucho en los ochenta y
noventa. La cuarta incluye movilidad avanzada en exteriores e interiores y la
quinta entraría en el dominio de la inteligencia artificial en lo cual se está
trabajando actualmente.
6
2.2.- Tipos de Robots
Lograr una clasificación de los robots es una tarea bastante compleja, debido a
que se traslapan algunos que pertenecen a una clasificación al separarlos en
otra. En forma general los diferenciaremos en industriales y de servicios, dentro
de esta última distinguiremos los estáticos de los móviles. Existen otros tipos de
clasificaciones, como por ejemplo los robots autónomos y los teleoperados. En
la figura 2.1 se muestra un diagrama de cómo se clasifican hoy en día.
Figura 2.1.- Diagrama de clasificación de Robots. Fuente: (Pérez, 2011).
7
2.2.1.- Robótica Industrial
Los robots de este tipo pueden ser electrónicos o mecánicos y se los utiliza
para la realización de los procesos de manipulación o fabricación. También se
les llaman robots industriales a aquellos que realizan simultáneamente distintas
operaciones. Un ejemplo seria los brazos robóticos usados en la industria
automotriz (ver figura 2.2).
Figura 2.2- Robot industria automotriz. Fuente: http://pocesosproductivos.com
2.2.2- Robótica De Servicio.
Los robots de servicio se pueden definir como:
“Dispositivos electromecánicos móviles o estacionarios, dotados normalmente
de uno o varios brazos mecánicos independientes, controlados por un programa
ordenador y que realizan tareas no industriales de servicio.”
En esta definición entrarían, entre otros, los robots dedicados a cuidados
médicos (ver figura 2.3), educación, domésticos, uso en oficinas, intervención
8
en ambientes peligrosos, aplicaciones espaciales, aplicaciones submarinas y
agricultura.
Sin embargo, esta definición excluye a los teleoperados, pues estos no se
mueven mediante el control de un programa de computador, sino que están
controlados directamente por el operador humano.
Figura 2.3- Robot de servicio hospitalario. Fuente: hospital General de Valencia
2.2.3- Robótica Móvil
Se define robot móvil a un dispositivo compuesto por componentes físicos y
computacionales, formados por cuatro subsistemas:
Locomoción
Percepción
Razonamiento
Comunicación
Los robots móviles terrestres poseen diversas aplicaciones en la industria, tales
como el bodegaje, inspección y control de producción a distancia, diversas
aplicaciones en la minería y en el transporte en general.
9
También, en el contexto de robots de servicio, los robots móviles se han
introducido recientemente en la forma de aspiradoras para el hogar como el
TrilobiteElectrolux (Trilobite, 2007) (ver figura 2.4).
Actualmente, en la Universidad Católica del Norte, se trabaja en un proyecto de
robótica avanzada, el cual consiste en la creación de un robot de servicios
llamado AMADEUS con una estructura base suministrada por la empresa
PARALLAX . Este trabaja con sensores ultrasónicos (ver figura 2.5).
Figura 2.4- Robots Trilobite. Fuente: http://www.gizmag.com/go/2829/.
.
Figura 2.5- Robot móvil con sensores ultrasónicos. Fuente
http://www.parallax.com/
10
En los últimos años la investigación sobre robots móviles está adquiriendo gran
desarrollo. Ello se debe, en parte, a la disminución del costo del hardware
necesario para su construcción, como también a la nueva concepción industrial
de celda flexible de fabricación, que requiere la reconfiguración de la secuencia
de acciones necesarias para una producción variada, lo que a su vez exige
facilidad de desplazamiento de los materiales entre cualquier punto de la
factoría.
2.3.- Navegación en robots móviles.
Como se mencionó anteriormente, uno de los aspectos más relevantes en la
robótica móvil es la navegación. Un robot móvil debe resolver en todo instante
las preguntas ¿dónde estoy?, ¿dónde voy? y ¿Cómo llego? (Borenstein J,
1996). La primera pregunta se resuelve con los sensores instalados en el robot
y/o con sensores ubicados en el ambiente de operación. Existen muchas
técnicas para hacerlo, como utilizar sensores isométricos, sensores de
proximidad, cámaras de video o marcas en el camino. La segunda pregunta se
responde con una estrategia global de navegación y la tercera pregunta la
responde una estrategia de navegación local, que puede corresponder a una
acción puramente reactiva o incorporar capacidades deliberativas que optimicen
la evasión de obstáculos.
Considerando todas las formas de navegación posible, se puede describir los
tipos de navegación como lo hace Job Zondag en el evento “Cognitive Robotics
Presentations ” (Zondag J, 2009), y que las resume en el siguiente esquema:
11
Figura 2.6.-. Tipos de navegación en la robótica móvil, fuente: “Cognitive
Robotics Presentations 2008/2009”, (Zondag J, 2009).
Basado en lo anterior, se puede diseñar un robot móvil autónomo a través de un
modelo de 4 capas, tal como se explica en la revista RIAI, ISSN 1697-7912
(Raffo G, 2009) y que se presenta en la figura 2.7.
12
Figura 2.7.-. Niveles de control en un Robot Móvil Autónomo, fuente: (Raffo G,
2009).
Los dos niveles superiores son de especial interés, ya que proporcionan la
inteligencia para una navegación óptima, aunque son los que consumen la
mayor parte del costo computacional.
La Planificación Global de Caminos (PGC) o Navegación Global (NG), consiste
en la obtención de un camino geométrico que enlace la posición inicial del robot
con la final y que esté libre de colisiones con el entorno. Si este camino está
parametrizado en el tiempo se denomina planificación de trayectorias, donde el
camino global está compuesto por un conjunto de caminos menores definidos
para sortear los obstáculos intermedios, donde estas trayectorias pueden ser
calculadas al comienzo y no recalcularse o pueden ser dinámicas dependiendo
del nuevo conocimiento del camino. Esta trayectoria global puede estar formada
por un conjunto de puntos secuenciales (objetivos intermedios) o por un
conjunto de tramos de diversas geometrías como curvas y rectas.
13
En esta fase no se consideran aspectos dinámicos como curvatura máxima
admisible o máxima velocidad de los motores, además no siempre es posible
que exista una planificación global del camino, fundamentalmente por las
incertidumbres en el conocimiento del entorno del robot.
La navegación Local (NL) o guiada, es la encargada de ejecutar los
movimientos del robot siguiendo un camino previamente calculado por el
planificador global o buscando de forma reactiva la posición final del robot, en
ambos casos evitando colisiones con el entorno, lo que implica que este nivel
debe alimentarse del sistema sensorial del robot. En este nivel se considera la
dinámica del robot y las limitaciones que ésta establece para realizar las
acciones de control, es aquí donde se focaliza esta tesis, por lo que en
siguiente capítulo se presenta este tema con mayor profundidad.
El Nivel de percepción y control, es el primer nivel donde existe control del
movimiento del robot. A diferencia de los anteriores niveles, en éste no existe
inteligencia. El único control que se puede implementar aquí es uno reactivo,
por ejemplo, que envíe señales a los servomotores si es que se activó el sensor
óptico delantero izquierdo o si el codificador rotatorio derecho ha detectado 5
vueltas. La robótica móvil educativa orientada a enseñar algoritmos básicos de
control se enfoca en este nivel. Lo normal es que la reacción del robot sea
generada por el trabajo de los niveles anteriores cuando éstos existen.
Finalmente el nivel de sensores y actuadores es el hardware del robot, en
mayor medida electrónica y mecánica, destinada a capturar las señales del
entorno y entregar la tracción a las ruedas del robot.
14
2.3.1- Navegación Local.
En las soluciones al PGC analizadas hasta ahora, independientes de si los
obstáculos son móviles o fijos, siempre se supone que el entorno de operación
está absolutamente conocido y gracias a ello es posible la planificación previa
del camino global. Pero en la práctica rara vez es así, los entornos de trabajo
son mediana o totalmente desconocidos, a estos se les denomina comúnmente
como entorno no estructurado.
Si la incertidumbre del entorno es pequeña, se justifica una planificación global
previa, pero si la incertidumbre es completa, no tiene sentido planificar antes un
camino global y el problema de la navegación se reduce a solo navegación local
orientada al punto de destino. La existencia de la planificación previa permite
estudiar la navegación local desde dos puntos de vistas:
Métodos basados en una planificación previa, donde la navegación se
reduce a los aspectos del control de los movimientos del robot y a un
sistema de evitación de obstáculos.
Métodos puramente reactivos, donde no hay camino de referencia y el
robot solo dispone de la información sensorial para alcanzar su posición
objetivo, de manera que es el propio sistema de navegación local el que
debe encontrar el camino desde la configuración inicial hasta la
configuración final. Estos métodos son más ineficientes que los basados
en una planificación cuando se quiere obtener un camino óptimo, pero
son más fáciles de implementar, más rápidos de funcionar y más
flexibles respecto a la forma del entorno.
15
2.4.- Programación orientada a comportamientos.
Existen varios métodos de programación, más o menos efectivos dependiendo
del robot que se quiera implementar. El método de programación mediante
comportamientos, tal como dice su nombre, es un método modular en el cuál se
van creando y añadiendo distintos comportamientos (seguir una línea, coger
una pelota, rotar en cierto ángulo, etc.) y estos, a la vez, son independientes
unos de otros. La programación por comportamientos se basa en que hay un
árbitro el cual decide cómo actuar en cada momento, dependiendo de las
mediciones que tomen los sensores o de si ya ha terminado la ejecución de otro
comportamiento.
Arbitraje:
El árbitro es el encargado de decir cuál es el comportamiento a ejecutar en
cada momento. Sin embargo, para ejecutar uno de estos, es necesario finalizar
previamente el anterior. Los comportamientos deben tener condiciones de
salida implementadas que permitan poder darle el control al árbitro y que éste
decida qué comportamiento ejecutar (Ej.: Seguir la línea hasta que encuentre
un obstáculo a X cm., cambia de comportamiento hasta llegar a cierto punto,
etc.).
Además, los comportamientos están ordenados en un arreglo por orden de
prioridad, y tienen también determinadas condiciones de entrada (Ej.: No iniciar
este comportamiento a menos que el robot esté en reposo). Por tanto, el árbitro
se encargará de recorrer ese arreglo de comportamientos, avanzando uno por
uno, desde el que tiene mayor prioridad hasta el que tiene menos, y escogiendo
el primero cuyas condiciones de entrada se cumplan.
16
2.5 LOGICA DIFUSA
2.5.1 Fundamentos de la lógica difusa
La lógica difusa hace referencia a un lógica multi-valuada, en la que los valores
de calificación no son solo Verdadero y Falso como en la lógica tradicional, sino
que pueden definirse conjuntos con varios valores posibles. Estas lógicas son
utilizadas para modelar condiciones que no están claramente definidas o cuyos
valores de calificación no son deterministas, dando la posibilidad de
aproximarse al razonamiento humano. Es decir, que sirven para describir
formalmente expresiones lingüísticas empleadas por el razonamiento natural
como lo son “alto”, “lento”, “joven” y operar con ellas, dando resultados exactos
a partir de datos imprecisos. El término “difuso” se refiere a que los valores de
calificación tienen una connotación de incertidumbre, ya que es posible utilizar
términos como “muy rápido”, “rápido”, “lento” y “muy lento”, sin necesidad de
precisar el valor exacto.
La lógica difusa surge formalmente de la mano de Lotfi Zadeh, quien describió
la teoría matemática de los conjuntos difusos en su trabajo “Fuzzy sets” de
1965. Anteriormente, Platón había indicado que existía una tercera región entre
lo Verdadero y lo Falso. Fue Lukasiewicz quien propuso un tercer valor entre los
anteriores al que llamó “posible”, creando una alternativa a la lógica bi-valuada
de Aristóteles. Luego, se observó que nada impedía que pudieran existir lógicas
tri-valuadas, cuatro-valuadas o infinitamente valuadas.
Actualmente, la lógica difusa tiene una gran cantidad de aplicaciones, como la
construcción de artefactos electrónicos de uso doméstico, procesamiento de
imágenes, control de procesos industriales y control de consumo de
combustible en cohetes de la NASA.
17
2.5.2 Conjuntos difusos
Un conjunto difuso es una extensión de los conjuntos nítidos, llamados en
inglés “crisp sets”. Para definir entonces un conjunto difuso, se definirá primero
un conjunto nítido.
El universo de discurso es una colección de objetos de los que hablará una
lógica determinada. Un conjunto es una colección de objetos pertenecientes al
universo de discurso tal que es posible decir si un determinado objeto del
universo pertenece o no a dicha colección.
Por ejemplo, dentro del universo de los números Naturales ℕ se define el
conjunto de los menores a 10, lo que se representa por extensión como:
A = {1,2,3,4,5,6,7,8,9} ℕ
También puede representarse como un predicado, diciendo que un natural n ∈
ℕ menor_10(n) es verdadero solo si n es un número dentro de los enumerados
anteriormente en A.
A = { n ∈ ℕ | menor_10(n)}
Otra representación posible da el valor de calificación 1 a todo elemento del
universo que pertenezca a A y el valor 0 a todo aquel que no.
µA = ℕ → {0,1}
18
{
(Ec.2.1)
Esta representación (2.1) constituye una función de membresía determinista, es
decir, el elemento n pertenece o no pertenece al conjunto A. (Figura 2.8)
Figura 2.8 Conjunto Nítido. Fuente (SCHIAFFINO, 2006).
La teoría de conjuntos difusos extiende este concepto definiendo una
membresía parcial. Es decir, que un elemento x del universo de discurso µ
tendrá asociado un valor y = µA(x) que es el grado de pertenencia del elemento
x al conjunto difuso A definido en el intervalo [0,1].
Por ejemplo, si se toma el universo de discurso µ de los pesos de las personas
adultas femeninas, y el conjunto difuso A representa la etiqueta lingüística
“flaco”, se puede decir con seguridad que un peso de 40 [kg] pertenece a ese
conjunto. Esto sería que su grado de pertenencia es 1 o µA(40) = 1. Al mismo
19
tiempo podría asegurarse que un peso de 70 [kg] no pertenece al conjunto
“flaco”, es decir, µA(70) = 0. Pero para un peso de 60 [kg] puede decirse que
pertenece al conjunto A en un grado de 0.5 (µA(60) = 0.5), ya que no es del
todo seguro si pertenece o no al conjunto “flaco”. (Figura 2.9)
Figura 2.9 Conjunto difuso "flaco" del universo de personas adultas femeninas.
Fuente (SCHIAFFINO, 2006).
Entonces, los conjuntos difusos representan expresiones lingüísticas del
lenguaje natural como flaco, gordo, alto, bajo, lento, rápido, joven, viejo, lejos,
cerca, etc. Un elemento del universo puede pertenecer a más de un conjunto
difuso al mismo tiempo con distinto grado de pertenencia.
Un conjunto difuso A del universo µ puede representarse como un
conjunto de pares ordenados, en el que cada par consiste en un elemento
genérico x y su grado de pertenencia a A (Ecuación 2.2 ).
(Ec.2.2)
20
Una variable lingüística x del universo µ se define como la ecuación 2.3.
(Ec.2.3)
Donde T(X) es el conjunto de términos de x, es decir, el conjunto de nombres
de los valores lingüísticos de x, con cada representando un numero difuso
cuya funcion de membresia está definida en [Kulkarni01]. En el ejemplo
anterior, x indicaría pesos y T(x) se referiría a los conjuntos flaco, gordo,
normal.
2.5.3 Función Membresía
Una función membresía es una curva que define qué grado de pertenencia
entre 0 y 1 le corresponde a cada punto del espacio de entrada.
La figura 2.8 muestra una función de membresía de un conjunto nítido, mientras
que la figura 2.9 corresponde a una función de membresía de un conjunto
difuso. Esta última permite observar una transición suave del valor de
pertenencia entre los elementos que pertenecen y los que no pertenecen al
conjunto A. Este concepto puede extenderse a muchos conjuntos difusos.
Existen varios tipos de funciones de membresía, a saber, triangular, trapezoidal,
campana generalizada, gaussiana, sinusoidales, etc. Justamente la diferencia
entre estas es la transición en el grado de pertenencia.
21
2.5.3.1 Función Triangular
Las curvas triangulares dependen de tres parámetros a, b y c y están
definidas por la ecuación 2.4.
{
(Ec.2.4)
Figura 2.10 Curva Triangular. Membresía v/s entradas. Fuente (SCHIAFFINO,
2006).
22
2.5.3.2 Función Trapezoidal
Las curvas trapezoidales dependen de cuatro parámetros a, b, c y d. Se
encuentra definida en la ecuación 2.5.
{
(Ec.2.5)
Figura 2.11 Función Trapezoidal. Membresía v/s entrada. . Fuente
(SCHIAFFINO, 2006).
23
2.5.3.3 Función Gaussiana
Las curvas Gaussianas dependen de dos parámetros, σ y c y se
representa en la ecuación 2.6.
(Ec.2.6)
Figura 2.12 Función Gaussiana. Membresía v/s entrada. Fuente (SCHIAFFINO,
2006).
2.5.4 Operaciones sobre conjuntos difusos
Las operaciones que se pueden realizar con conjuntos difusos son las mismas
que se realizan con conjuntos nítidos. Las operaciones de Unión,
Intersección y Complemento que se llevan a cabo en los conjuntos nítidos,
se corresponden con OR, AND y NOT respectivamente en los conjuntos
difusos (Figura 2.13).
24
Dados los conjuntos A y B µ, se define Unión de A y B como A ∪ B y la
componen todos los elementos que pertenecen a A o a B.
En conjuntos nítidos: µ A ∪ B (x) =1 si x A o x B
En lógica difusa: µ A ∪ B(x) = máx.[µ A(x), µ B(x)]
La intersección entre A y B queda definida como A ∩ B y contiene a todos los
elementos que estén en A y en B simultáneamente.
En conjuntos nítidos: µ A ∩ B (x) =1 si x A y x B
En lógica difusa: µ A ∩ B(x) = min[µ A(x), µ B(x)]
El complemento de A se define como A y lo componen los elementos que no
se encuentran en A.
En conjuntos nítidos: µ A (x) =1 si x ∉ A
En lógica difusa: µ A (x) = 1-µ A(x)
Figura 2.13 Operaciones sobre conjuntos nítidos y difusos Fuente:
(MATHWORKS).
25
2.5.4.1 Reglas si-entonces
Las reglas if-then o sí-entonces son la base del sistema de inferencia difuso ya
que relacionan los conjuntos difusos de entrada con los de salida.
Una regla básica tiene la forma: Si “X es A” entonces “Y es B”. X pertenece al
universo de discurso µ e Y pertenece al conjunto de valores de
calificación. Tiene además una función membresía:
µ A→ B (X, Y) cuyo valor pertenece al intervalo [0,1].
La parte izquierda de la regla “X es A” se denomina antecedente o premisa y
la parte que le sigue al entonces – “Y es B” – se conoce como conclusión
o consecuente.
Para interpretar una regla IF-THEN, primero debe evaluarse el antecedente lo
que implica fusificar las variables de entrada y aplicar cualquier operador
difuso que sea necesario si fueran más de una variable (and, or). En otras
palabras, se examina una variable lingüística de entrada (“temperatura”) y su
grado de pertenencia a un conjunto difuso (“temperaturas altas”). Esto produce
un grado de cumplimento de cada regla. Luego, para obtener la salida de la
regla que es un conjunto difuso completo, se evalúa la implicación entre el
grado de cumplimiento y la función de pertenencia. Es decir, se aplica el
resultado del antecedente al consecuente lo que consiste específicamente en
evaluar la función de membresía. Por lo tanto, el consecuente será cierto en
el mismo grado en que lo es el antecedente, ya que el conjunto difuso de
salida es truncado según el método de implicación utilizado.
26
Existen varias formas de evaluar una función de membresía µ A→ B (x, y) de
una regla IF-THEN, es decir, existen varios métodos de implicación:
Zadeh (1965)
µ A→ B ( x, y) = máx.(min( µ A (x), µ B ( y)),1 − µ A (x))
Mamdani (1977)
µ A→ B ( x, y) = min( µ A (x), µ B ( y))
Larsen (1980)
µ A→ B ( x, y) = µ A ( x).µ B ( y)
Un caso genérico de una regla de implicación es:
Ri = If ( x1 is Tx1. and…, xp is Txp) Then (y1 is Ty1, and…,yp is Typ)
Las reglas SI-ENTONCES pueden interpretarse como sigue:
µ A→ B ,C (x, y, z) = max(min(µ A (x), µ B ( y)), min(1 − µ A (x), µC (z)))
27
2.5.5 Sistema de Inferencia Difuso
Un sistema de inferencia difuso (SID) o fuzzy inference system (FIS)
define una proyección no lineal entre el vector de variables de entrada y el
escalar de salida, a través de la utilización de reglas difusas. El proceso de
proyección involucra funciones de membresía de entrada y salida,
operadores lógicos, reglas if-then, agregación de conjuntos de salida y
desfusificación. Todo esto está incluido en los cuatro componentes de un
SID (Figura 2.14):
bloque fusificador: toma las variables de entrada y determina el
grado de pertenencia a cada conjunto difuso a través de funciones
de membresía.
base de reglas: contiene las reglas lingüísticas if-then.
motor de inferencia: realiza la proyección entre los conjuntos difusos de
entrada y los de salida. Para esto, determina el grado de
cumplimiento del antecedente de cada regla. Si el antecedente
tuviera más de una cláusula se utilizan los operadores lógicos
para obtener un número representativo del resultado de la regla.
Es posible que se disparen varias reglas al mismo tiempo, en ese
caso, deben agregarse. Es decir, se toman los conjuntos difusos de
salida de las reglas disparadas paralelamente y se combinan
obteniendo un único conjunto difuso de salida.
defusificador: toma el conjunto difuso de salida agregado y da como
resultado un número nítido. Esto es posible a través de varios
métodos de desfusificación, como el centro de gravedad, máximo,
media del máximo y height.
28
También es posible, y por lo general se realiza, agregar dos bloques más,
uno de pre-procesamiento y otro de post-procesamiento. Estos permiten,
por ejemplo, la adaptación de las entradas para el control digital difuso a
través de muestreo y retención. También realizan filtrado de ruido de
medición y derivación o integración de la señal de entrada.
Figura 2.14 Sistema de inferencia difuso con pre y post procesamiento. Fuente:
SCHIAFFINO, 2006.
29
2.5.6 Proceso de inferencia difuso
El proceso de inferencia difuso (PID) consiste en cinco pasos que se
describirán a continuación y define una superficie de control y = f(x1,x2)
que se muestra en la figura 2.15
Figura 2.15 Superficie de control y = f(x1,x2). Fuente (SCHIAFFINO,2006).
Paso 1: Fusificación de entradas
Consiste en tomar las variables de entrada y determinar el grado de
pertenencia a cada conjunto difuso a través de la función membresía.
Paso 2: Aplicación de operadores difusos
Con las variables ya fusificadas se conoce el grado de cumplimiento que
otorga esa parte del antecedente a toda la regla. Si una regla tiene más de
una cláusula, se utilizan los operadores difusos que correspondan como and
y or para obtener el grado de cumplimiento de la regla compuesta.
30
Paso 3: Aplicación del método de implicación
Teniendo como entrada el grado de cumplimiento del antecedente, se
procede a obtener la salida de aquellas reglas que fueron disparadas (es
decir, cuyo grado de cumplimiento es mayor a 0). El método de implicación
utilizado puede ser cualquiera de los descritos en la sección 2.5.4, siendo los
más comunes el del producto (Larsen) y el del mínimo (Mamdani). Se obtiene
como resultado un conjunto difuso de salida.
Paso 4: Agregación de salidas
Consiste en la unificación de las salidas de las reglas disparadas. Ocurre
solo una vez por cada variable de salida. La entrada para este proceso de
agregación son los conjuntos de salida obtenidos en el paso anterior y su
resultado es un único conjunto difuso de salida que será utilizado luego
por el paso de desfusificación. Este proceso es conmutativo, es decir, no
importa el orden en que las reglas fueron ejecutadas. El método de
agregación mayormente utilizado es el del máximo definido en la ecuación 2.7:
(Ec.2.7)
Donde y son dos conjuntos difusos de salida y es
el conjunto único de salida resultado de este paso.
Paso 5: Desfusificación
El proceso de desfusificación tiene como entrada el conjunto difuso de salida
agregado obtenido en el paso anterior. Su resultado es un número nítido
que se determina a través de uno de los varios métodos de desfusificación
posibles, como el centro de gravedad, máximo, media del máximo y height.
31
En la figura 2.16 pueden observarse estos cinco pasos a través de un
ejemplo obtenido de [MathWorks] con dos variables de entrada, una de salida
y tres reglas difusas.
Figura 2.16 Proceso de inferencia difuso. Fuente: MATHWORK
32
2.5.7 Desfusificación
El proceso desfusificador es el último paso del proceso de inferencia difusa y
consiste en obtener un número nítido que se utilizará como acción de control
a partir del conjunto difuso retornado por el proceso de agregación. Los
métodos de desfusificación propuestos son varios, pero el más utilizado es
el del Centroide. Los otros son el máximo, media del máximo y height.
Método desfusificador Centroide: Este método desfusificador determina el
centro de gravedad o Centroide yi´ de B, siendo B el conjunto difuso
agregado, y lo utiliza como valor de salida del sistema de inferencia difusa.
El Centroide está dado por la ecuación 2.8:
(Ec.2.8)
S es la superficie µB(y). Para obtener una aproximación de y´ se suele
utilizar variables discretas y la operación de sumatoria en lugar de la integral.
(Ecuación 2.9)
(Ec.2.9)
Este método desfusificador encuentra un punto de balance en la región
difusa que sea la solución calculando el peso medio de la región de salida
difusa (Figura 2.17).
33
Figura 2.17 Centro de gravedad en el conjunto difuso de salida. Fuente
(SCHIAFFINO, 2006).
2.5.7.1 Otros métodos desfusificadores
El método del máximo busca el punto “y” del conjunto de salida agregado
para el cual µB(y) sea el máximo (Figura 2.18).
El método de la media de los máximos busca el punto medio entre los
centros de las cimas más altas de la región difusa de salida (Figura 2.19). El
método Height se encuentra definido en la ecuación (2.10).
34
(Ec.2.10)
Donde m representa el número de conjuntos de salida difusos obtenidos
después de la implicación e “y” representa el Centroide de la región difusa i.
Figura 2.18 Método de desfusificación del máximo. Fuente:
(SCHIAFFINO,2006).
35
Figura 2.19 Método de desfusificación de la media de los máximos. Fuente
(SCHIAFFINO, 2006).
36
Capítulo III Estado del arte
En este capítulo se discutirán los distintos tipos de comportamientos que
existen para la navegación local. Se mostrará cómo algunos han ido
evolucionando a través de diversos estudios, dando las respectivas referencias
científicas. Se especificarán 3 algoritmos principales: El algoritmo VFH y sus
variantes, los algoritmos Bug y por último el Tangent Bug, este último usado
para el proyecto de esta memoria.
3.1 Navegación Local Basada en Fuerzas vectoriales
Uno de los primeros métodos creados para la navegación local,
específicamente a lo que se refiere a la evasión de obstáculos, es el VFF
(Virtual Force Field, campo de fuerzas virtuales) (ver figura 3.1). Nació en 1988
con el planteamiento de Khatib (KHATIB,1985), se basa en los trabajos de
Reynolds(REINS,1986) y funciona de la siguiente manera:
El algoritmo basa su funcionamiento en fuerzas vectoriales. La idea
fundamental de VFF es que los obstáculos alrededor del robot generan fuerzas
virtuales de repulsión Fr, y el destino genera fuerzas virtuales de atracción Fa.
El robot se moverá en todo momento en la dirección de la suma global de
ambas fuerzas, de esta manera puede evitar los obstáculos y a avanzar en la
dirección objetivo.
37
Figura 3.1 Ejemplo de navegación con VFF. Fuente: Diseño Propio
Este método posee varias limitaciones, las más importantes son que recae
continuamente en ciclos o bucles infinitos haciendo este método ineficiente, por
lo que entre 1997 y 1998 se presentaron mejoras a este método llamados VFH
(VFH, 1991) y sus respectivas mejoras VFH+ y VFH* (VFH+,1998).
3.2 Navegación Local Basada en sensores
Otra forma de generar métodos de navegación local es haciendo un muestreo
en tiempo real del entorno y así encontrar los obstáculos a lo largo del trayecto.
Este tipo de navegación se le conoce como navegación basada en sensores y
su principal ventaja es que puede prescindir del conocimiento a priori del mapa.
El entorno se va descubriendo a medida que el robot se desplaza hacia su
destino conforme a la información entregada por los sensores de proximidad.
38
Los algoritmos que más se acomodan a este tipo de navegación son los
llamados Bugs.
3.2.1 Bug 1 y Bug2
Los algoritmos que pertenecen a la familia de los "Bug-type algorithms"
(algoritmos tipo bug) han demostrado una gran eficacia en la navegación
basada en sensores. Diseñado por Lumelsky y Stefanof en 1987, el algoritmo
“Bug 1” ha sido objeto de estudio en muchas publicaciones (BUG, 1987), he
incluso se han producido mejoras como el “Bug 2” (BUG2, 1988). Estos pueden
ser explicados en forma sencilla:
BUG 1
1) Apunta a su objetivo y se dirige a él.
2) Si se encuentra un obstáculo en el camino, circunnavegar este y recordar el
punto más cercano al objetivo.
3) Retornar al punto más cercano recordado y continuar.
El recorrido hecho por un robot programado con Bug1 se puede observar en la
figura 3.2.
Figura 3.2 Bug 1 Fuente: (BUG, 1987).
39
En el libro de Lumelsky y Stefanof se puede apreciar el pseudocódigo usado
para este comportamiento (ver figura 3.3).
Figura 3.3. Pseudocódigo para el Bug 1.Fuente: (BUG, 1987)
BUG2
1) Apuntar al objetivo y dibujar una línea imaginaria hacia este ( s-line).
2) si se encuentra con un obstáculo, circunnavegar este hasta encontrar
nuevamente un punto perteneciente al s-line.
3) continuar desde el último punto encontrado.
El recorrido hecho por un robot programado con Bug2 se puede observar en la
figura 3.4.
40
Figura 3.4 Bug 2 Fuente: (BUG2, 1988).
En otra de las publicaciones de Lumelsky y Stefanof se puede apreciar el
pseudocódigo usado para este comportamiento (ver figura 3.5).
Figura 3.5 Pseudocódigo para el algoritmo Bug 2. Fuente: (BUG2, 1988).
41
3.3 Tangent Bug
Con este comportamiento un robot puede desplazarse desde un punto a otro en
un ambiente desconocido, poblado de obstáculos fijos. Los obstáculos pueden
tener cualquier estructura geométrica, aunque se comporta de mejor forma con
polígonos de segmentos rectos. El Tangent Bug fue creado especialmente para
robots equipados con sensores de distancia.
3.3.1. Funcionamiento del Tangent Bug
Este algoritmo supone al robot en una superficie plana de dos dimensiones, con
obstáculos estacionarios dispersos en todo el mapa.
El algoritmo se basa en dos datos principales ya adquiridos de forma previa: la
posición actual donde se encuentra y el punto al cual se desea llegar. Si el robot
funcionase con ayuda de sensores ultrasónicos, estos proporcionarían al robot
los datos captados por cada uno de estos.
Estos sensores pueden ser modelados de la siguiente forma (Ecuación 3.1):
{
(Ec.3.1)
Donde pR(x, ø) es la distancia más cercana al obstáculo desde un sensor en
particular que emana ondas desde el centro del robot con un grado de ø. El
sensor tiene un rango finito „R‟, y si no hay obstáculos detectados por el sensor,
el pR (x, ø) se vuelve infinito para ese ángulo.
42
El Tangent Bug se basa en dos sub comportamientos principales llamados
"MotionToGoal" (movimiento hacia la meta) y "BoundaryFollowing" (siguiendo el
límite) alternando estos dependiendo de algunos datos heurísticos y
condiciones del entorno.
3.3.2 Algoritmo
La explicación de este algoritmo está basada en la siguiente publicación: (Ishay
Kamon, 1998).
Las variables que ocupa el algoritmo son las siguientes:
x: es la posición actual del robot
goal: es la posición meta.
Bi: es el i-ésimo punto de discontinuidad detectado por los sensores (ver figura
3.6).
Figura 3.6. Datos iniciales de algoritmo. Fuente: (IshayKamon, 1998)
43
En el instante mostrado en la figura 3.6, el robot concluye que puede llegar a la
meta, ya que sus sensores (Bi) no detectan obstáculos que le impidan llegar al
destino (goal).El robot continuará avanzando hasta que llegue a la meta o hasta
que los sensores detecten que encontró un obstáculo en el camino (ver figura
3.7).
Figura 3.7. El robot detectó un obstáculo a través de los sensores B7 y B8.
Fuente: (IshayKamon, 1998).
Una vez detectado el obstáculo, se activa el primer comportamiento
("MotionToGoal") que funciona de la siguiente manera:
1) Se elige el punto Bi que haya detectado un obstáculo y que a su vez tenga la
"distancia Heurística" más corta, siendo esta la suma de las distancias que
corresponden desde "x hasta Bi" y de "Bi hasta goal" . La fórmula estaría dada
por la ecuación 3.2:
(Ec.3.2)
44
2) Se dirige al punto elegido anteriormente.
3) Si se siguen detectando obstáculos, se vuelve al procedimiento 1, si no, se dirige directamente hasta la meta (goal). Pero ¿qué pasa si las distancias heurísticas detectadas comienzan a
aumentar? es aquí donde se activa el segundo comportamiento
("BoundaryFollowing ") que funciona de la siguiente manera:
1) Asigna como punto límite el punto donde comienza a aumentar la distancia
Heurística.
2) El robot comienza a calcular dos parámetros de distancias diferentes
llamados dreach y dfollowed respectivamente. En general, dfollowed es la
distancia más corta entre el punto límite detectado y el punto de destino (goal) y
dreach es la distancia más corta entre todos los puntos detectados por el robot
(sin incluir el punto límite) y el punto de destino. Estos son representados en la
figura 3.8.
figura 3.8 dfollowed y dreach. Fuente: Diseño Propio.
45
3) El Robot apunta hacia la misma dirección del último Bi detectado en el
comportamiento anterior. Con la dirección ya seleccionada, este comienza a
moverse en dirección a la línea tangente. Esta línea tangente es perpendicular
a la línea que conecta el robot y el punto más cercano de este hacia el objetivo.
Este comportamiento continúa ejecutándose hasta que:
Una vez que esto se cumpla, se regresa al comportamiento anterior
(MotionToGoal).
Figura 3.9 Ejemplo de recorrido hecho con Tangent Bug. Fuente:
https://sites.google.com/site/mutlumehmetmetuceng786/
En la imagen Figura 3.9 se muestra un claro ejemplo del recorrido hecho por un
robot con el comportamiento antes mencionado. El bloque negro representa el
obstáculo a esquivar, la línea azul representa el recorrido hecho con el sub
comportamiento MotionToGoal y el recorrido rojo es el realizado con el
BoundaryFollowing. Los círculos verdes indican el dfollowed y el dreach
respectivamente.
46
Para este método en general, el pseudocódigo vendría a ser el siguiente (ver figura 3.10).
Figura 3.10 Código fuente del comportamiento Tangent Bug. Fuente:
(IshayKamon, 1998)
47
Capítulo IV Presentación y discusión bibliográfica del problema
4.1 Introducción
Como se pudo apreciar en el capítulo anterior, existen diversos tipos de
comportamientos los cuales puede seguir un robot, pero es de acuerdo a las
exigencias que existen o la estructura misma del robot que un comportamiento
puede tener mayor o menor eficiencia. Se han elaborado diversos estudios para
crear comportamientos capaces de solventar con mayor generalización los
problemas existentes, es decir, tratar de crear un comportamiento que englobe
todos los demás. A continuación se describirán ventajas y desventajas de
algunos de estos y se explicará por qué Tangent Bug es el más adecuado para
la problemática a resolver en esta tesis.
4.2 ventajas y desventajas en algunos algoritmos
Uno de los métodos mencionados en el capítulo anterior son los vasados en
fuerzas vectoriales (VFF) .Este método posee variadas ventajas y desventajas:
– Ventajas:
• Fuerte formalismo matemático (fácil de extender)
• Fuerte abstracción del tipo de espacio (aplicable a muchos contextos y
espacios distintos)
– Desventajas:
• Conceptual:
Reducción de la información sensorial en un paso a un comando de
movimiento (no interpretación de los datos)
48
• Técnicos:
Atascos en mínimos locales debido al equilibrio de fuerzas. Dificultad
frente a obstáculos en forma de U u obstáculos muy juntos.
Inestabilidades del movimiento por descompensación de fuerzas
Otras dificultades que tienen los comportamientos anteriormente mencionados,
es que necesitan varios datos del entorno global para su funcionamiento (datos
generados por el mapa) en comparación de otros que pueden prescindir casi
del total de estos. Conocer los datos del entorno en forma global requiere de
una carga considerable de recursos computacionales que pueden generar
retardos en la reacción del robot.
Otros de los comportamientos vistos son los llamados Bugs, siendo los más
conocidos: BUG 1, BUG 2 y TANGENT BUG. Estos han sido creados para
cuando el robot sabe los datos exactos de su ubicación, pero desconoce los
datos de los obstáculos que pudieran existir. Con estos comportamientos el
robot es capaz de detectar los obstáculos y puede esquivarlos con mayor o
menor eficiencia dependiendo del comportamiento a usar. Por ejemplo, las
ventajas de los algoritmos Bug 1 y el Bug 2 son:
Bug 1 es un algoritmo de búsqueda exhaustiva. Examina todas las
opciones antes de comprometerse.
Bug 2 es un algoritmo voraz. Toma la primera cosa que ve mejor.
En muchos casos, Bug 2 supera a Bug 1, pero Bug 1 tiene un
rendimiento global más predecible.
49
Una de las problemáticas a resolver en esta tesis, es poder sortear obstáculos
de la forma más eficiente posible. Es aquí donde fallan estos comportamientos,
ya que si bien estos pueden sortear los obstáculos, esta tarea puede tardar
bastante tiempo (en especial en BUG 1, ya que tiene que rodear todo el
obstáculo para poder esquivarlo).
Otro detalle es el tipo de sensor que se utilizará. Los comportamientos antes
mencionado funcionan de manera más eficiente a través de sensores de
contacto, pero los sensores a utilizados en esta memoria son sensores de
distancia (ultrasónicos).
La capacidad de navegar sin colisionar con los obstáculos es un requisito
fundamental para un robot móvil que pretende funcionar de manera autónoma.
Aunque el robot cuente con la posición global y la orientación para alcanzar la
meta en un tiempo razonable, esto puede conllevar a problemas bastantes
diversos (poder sortear obstáculos con formas complejas u obstáculos de gran
tamaño).
Algoritmos como el Bug 1 y el Bug 2 son conocidos por ser los primeros
comportamientos creados para la solucionar de manera rápida y sencilla estos
problemas, garantizando la llegada a la meta del robot que trabaje con estos.
Sin embargo, estos no hacen el mejor uso de los sensores que se les pueda
administrar al robot, en especial si se tratan de sensores ultrasónicos.
El Tangent Bug es una fusión de ambos algoritmos mencionados anteriormente.
Ataca principalmente el problema de los sensores, manejándolos de mejor
forma que los Bugs anteriores, para que el robot pueda llegar a destino de
manera más eficiente y rápida.
50
Aunque este último comportamiento también tiene sus deficiencias:
- Asume una posición global de forma exacta y precisa, que no siempre es
posible tener.
- No asume el porcentaje de error que pueden producir los sensores.
- Los robots actuales poseen una resolución angular limitada.
4.3 Consideraciones físicas del robot.
El robot con el que se trabajó esta memoria tiene algunas características
particulares (ver figura 4.1):
Figura 4.1 Esqueleto del robot AMADEUS. Fuente http://www.parallax.com
El diámetro del robot es de aproximadamente 50 centímetros. Se han hecho
diversos estudios de los comportamientos anteriores, pero siempre basándose
51
en que el robot es un "Punto" en el espacio a trabajar. Esto conlleva a variadas
dificultades ya que al no considerar el diámetro de este puede llevar a errores
de cálculo o de evasión de obstáculos y puede complicar en demasía al
momento de girar en cierto ángulo.
Figura 4.2 Sensores de movimiento PING))). Fuente http://wwwparallax.com
Otra de las características del robot es el uso de los sensores llamados Ping)))
(ver figura 4.2) estos sensores trabajan con ultrasonido y pueden detectar
desde los 2[cm] a los 3[m] de rango.
Esta es otra dificultad para los comportamientos Bug 1 y Bug 2, ya que estos
trabajan mejor con sensores de choque y para usar este tipo de sensores
habría que modificar en demasía los códigos de estos.
Asumiendo todos los detalles antes mencionados, se puede llegar a la
conclusión de que el comportamiento Tangent Bug es la mejor opción para este
robot en particular, ya que a pesar de todas las desventajas que pueda poseer
este comportamiento, es el que mejor trabaja con sensores ultrasónicos y se
puede adaptar de forma más sencilla a las características particulares que
posee el robot con el cual se trabajará. Dicho robot se muestra en la figura 4.3.
52
Figura 4.3 robot AMADEUS empleado en el proyecto. Fuente (diseño propio)
53
Capítulo V Desarrollo
5.1 Introducción
En este capítulo se describe paso a paso el desarrollo del proyecto, explicando
la algoritmia usada para llevar a cabo el comportamiento Tangent Bug. Se
mostrará parte del código programado y la función que cumple éste para algún
movimiento en particular del robot. El código completo se puede observar en el
Anexo A.
5.2 Plataforma de trabajo
El código fue desarrollado en la plataforma PROPELLER TOOL el cual
proporciona las herramientas necesarias para programa en el lenguaje SPIN,
lenguaje con el cual trabaja el microprocesador Propeller (figura 5.1)
Figura 5.1 PropellerTool. Fuente: PROPELLER TOOL MANUAL.
54
5.3 Simulaciones.
Aquí se muestra cada uno de los códigos hechos en PropellerTool en un
simulador llamado Sadly. Este simulador web permite recrear el
comportamiento de un robot implementado con el Tangent Bug.
El robot parte desde la posición (0,0) y luego apunta hacia la meta al cual quiere
llegar.
Figura 5.2 Código Inicial de los sensores. Fuente: Diseño Propio.
La figura 5.2 muestra los códigos necesarios para saber la posición exacta de
cada sensor en cualquier momento. Esto en el simulador estaría representado
en la figura 5.3.
Figura 5.3 Posición inicial del Robot. Fuente: Simulador Sadly.
55
El punto azul representa el robot y el arco al rededor representa el umbral de
visión otorgado por los sensores ultrasónicos. Al comienzo, el robot se dirige
directamente hacia el punto donde desea llegar (punto rojo) creyendo en un
principio que no existen obstáculos en su camino. Para que éste pueda avanzar
hacia la meta se emplean los siguientes códigos (ver figura 5.4).
Figura 5.4 Códigos avance del robot. Fuente: Diseño propio.
El robot avanzará dependiendo de la posición actual de éste y del lugar exacto
al cual se desea llegar. Al primer momento en que el sensor detecte un objeto,
el robot cambiará de comportamiento y se moverá de acuerdo al
"MotionToGoal" (ver figura 5.5)
56
Figura 5.5. Simulación del MotionToGoal. Fuente: Simulador Sadly.
5.3.1 MotionToGoal.
El MotionToGoal funciona de la siguiente manera: Al encontrarse con su primer
obstáculo, el robot empieza a calcular la distancia entre los puntos detectados
que pertenecen al borde del obstáculo y la meta final, a esta distancia se le
llama "distancia heurística". una vez calculadas todas las distancias, elije el
punto que calculó la menor de estas y se dirige a dicho punto. Los códigos
empleados para tal comportamiento son presentados en la figura 5.6.
57
Figura 5.6. Códigos del MotionToGoal. Fuente: Diseño propio.
Primero se pregunta la distancia que detecta cada sensor (DH) para luego
elegir la menor entre todas ellas(DH_actual). El robot continua trabajando con el
mismo patron,llegando cada vez mas cerca de la meta.(ver Figura 5.7)
Figura 5.7.Robot buscando objetivo. Fuente: Fuente: Simulador Sadly.
58
El robot sigue la misma rutina de seguimiento de puntos hasta encontrar que no
existen más obstáculos en el camino (los sensores no detectan obstáculos en
su umbral) por lo que este se dirige directamente a la meta (punto rojo) como se
muestra en la figura 5.8.
Figura 5.8.Robot se dirige al punto final. Fuente: Simulador Sadly.
Aunque no existan más obstáculos en el camino, se puede dar el caso de una
puerta (dos obstáculos separados por una distancia mínima) por el cual el robot
tiene que preguntar en todo momento si es que puede pasar por ella o no. Para
ello el robot calcula la distancia existente entre dos de sus sensores (sensores 2
y 4) como se muestra en la figura 5.9.
59
Figura 5.9.Distancia entre sensores 2 y 5. Fuente: Diseño Propio.
Si esta distancia es mayor al espacio proporcionado por la puerta (espacio entre
los dos objetos), este sigue su camino por ella, si no, el robot toma ese espacio
como si fuera una pared y modifica su comportamiento. Los códigos para dicho
comportamiento se encuentran en la figura 5.10.
Figura 5.10.Códigos para pasar entre 2 obstáculos. Fuente: Diseño Propio.
60
5.3.2 Seguir la Pared.
Ahora se simulará el caso en que el robot se encuentre con una pared. Para
sortear dicho obstáculo con éxito se implementó la lógica Difusa. Como
siempre, el robot comienza su recorrido desde el punto (0.0) y se dirigirá
directamente a la meta. Esto se muestra en la figura 5.11
Figura 5.11. Robot se dirige a la meta. Fuente: Simulador Sadly.
Luego, al encontrarse con el objeto, empieza a calcular las distancias
heurísticas correspondientes, como en el caso del comportamiento anterior.(ver
figura 5.12)
Figura 5.12.Robot encuentra obstáculo. Fuente: Simulador Sadly.
61
Al percatarse que las distancias heurísticas comienzan a aumentar, concluye
inmediatamente que se encuentra frente a una pared, por lo cual cambia su
comportamiento anterior. Para este caso en particular se utilizará lógica difusa.
La razón principal para utilizar esta lógica en el control de navegación del robot
es la habilidad de activar parcialmente el comportamiento y lograr una transición
suave en los cambios de movimiento del robot, permitiendo así una movilidad
continua y con el menor error posible.
Siguiendo los métodos descritos en el capítulo 2.5 se describen a continuación
los pasos seguidos para implementar el comportamiento.
5.3.2.1 Modelo Difuso
Uno de los modelos de sistema de inferencia más utilizado en la robótica es el
modelo de Mamdani. En este proyecto se utilizó dicho modelo (Figura5.13).
Figura 5.13 Modelo de sistema de inferencia difusa Mamdani [MathWork]
62
5.3.2.2 Operadores Lógicos
Para el operador Lógico AND se utiliza la función Mínimo (Ecuación 5.1)
(Ec.5.1)
Para el operador Lógico OR se utiliza la función Máximo (Ecuación 5.2)
(Ec.5.2)
5.3.2.3 Método de Implicación
El método de implicación es el propuesto por Mamdani, es decir, el Mínimo
(Ecuación 5.3)
(Ec.5.3)
5.3.2.4 Método de Agregación
El método de agregación utilizado es el de la Unión de los conjuntos difusos de
salida obtenidos. (Ecuación 5.4)
(Ec.5.4)
63
5.3.2.5 Método de Desfusificación
El método de desfusificación que se utiliza es el del Centroide, es decir, aquel
que encuentra el centro de gravedad de la superficie difusa de salida. La
ecuación 5.5 es una aproximación a dicho método que permite calcularlo más
rápidamente.
(Ec.5.5)
5.3.2.6 Entradas Difusas
Este sistema de inferencia difuso cuenta con tres variables de entrada que
pertenecen a los datos entregados por los sensores. Para ello se utilizaron los
sensores 1,3 y 5. (ver figura 5.14).
Figura 5.14 Sensores 1,3 y 5 utilizados para el sistema difuso. Fuente: Diseño
Propio.
64
Los datos de las entradas pertenecen a la distancia que existe entre el robot y
la pared. Los valores entregados se encuentran en el intervalo [2,50] donde 2
significa que el robot se encuentra muy cerca de la pared y 50 significa muy
lejos.
Las etiquetas lingüísticas usadas para describir que las distancias son: muy
cerca de la pared, cerca de la pared, distancia normal, lejos de la pared y muy
lejos de la pared.
T(E)=[muy_cerca, cerca, normal, lejos, muy_lejos]
Los conjuntos difuso de entrada quedan definidos para todas las variables de
entrada de la siguiente manera:
MUY_CERCA [2,8,12,15]
CERCA[10,14,19,21]
NORMAL[19,22,26,29]
LEJOS[28,32,35,38]
MUY_LEJOS[37,34,47,50]
5.3.2.7 Salidas Difusas
Este sistema de inferencia difuso cuenta solo con una variable de salida, que
corresponde al giro del robot.
Los valores entregados hacen referencia a cuanto tiene que girar el robot una
vez que se encuentre con la pared. Estos valores se encuentran en grados y
varían en el intervalo [0,15] donde 0 significa que no tiene que hacer giro alguno
y 15 significa que tiene que girar unos °15.
65
Las etiquetas lingüísticas usadas son:
T=[no_gira, gira_poco, gira_medio, gira_mucho]
y sus valores son los siguientes:
NO_GIRA[0]
GIRA_POCO[0,5]
GIRA_MEDIO[5,10]
GIRA_MUCHO[10,15]
5.3.2.8 Funciones de membresía
Las funciones membresía para las variables de entrada son de tipo
trapezoidales y quedan definidas de la siguiente manera.
Conjunto Difuso "MUY CERCA"
{
66
Conjunto Difuso "CERCA"
{
Conjunto Difuso "NORMAL"
{
Conjunto Difuso "LEJOS"
{
67
Conjunto Difuso "MUY LEJOS"
{
5.3.2.9 Reglas de Inferencia Difusas
Las reglas de inferencia difusa se encargan de guiar el razonamiento del
Sistema de Inferencia Difuso. Con pocas reglas se puede obtener una función
suavizada sin cambios bruscos ya que un valor cualquiera x puede pertenecer a
varios conjuntos difusos al mismo tiempo lo que permite tener una transición
suave. En otros sistemas de inferencia como la lógica de primer orden, para
obtener una función suavizada se debe definir una gran cantidad de reglas. Se
definen a continuación algunas reglas que permitirán al agente móvil sortear
con éxito la pared.
La base de reglas es la siguiente:
ML := MUY_LEJOS ; L := LEJOS ; NR:= NORMAL ; C := CERCA ; MC := MUY_CERCA
NG:= NO_GIRA ; GP:= GIRA_POCO ; GME:= GIRO_MEDIO ; GMU := GIRA_MUCHO
R1 IF(d1 is L ) and (d2 is L ) and (d3 is L ) then ( NG )
R2 IF(d1 isML ) and (d2 isML ) and (d3 is ML ) then ( NG )
R3 IF(d1 is ML ) and (d2 is ML ) and (d3 is L ) then ( NG )
R4 IF(d1 is C ) and (d2 is L ) and (d3 is L ) then ( NG )
68
R5 IF(d1 is C ) and (d2 is ML ) and (d3 is ML ) then ( NG )
R6 IF(d1 is L ) and (d2 is L ) and (d3 is NR ) then ( NG )
R7 IF(d1 is ML ) and (d2 is ML ) and (d3 is NR ) then ( NG )
R8 IF(d1 is ML ) and (d2 is L ) and (d3 is NR ) then ( NG )
R9 IF(d1 is L ) and (d2 is L ) and (d3 is C ) then ( GMU )
R10 IF(d1 is L ) and (d2 is ML ) and (d3 is C ) then ( GMU )
R11 IF(d1 is ML ) and (d2 is ML ) and (d3 is C ) then ( GMU )
R12 IF(d1 is L ) and (d2 is L ) and (d3 is MC ) then ( GMU )
R13 IF(d1 is L ) and (d2 is ML ) and (d3 is C ) then ( GMU )
R14 IF(d1 is ML ) and (d2 is ML ) and (d3 is MC ) then ( GMU )
R15 IF(d1 is NR ) and (d2 is L ) and (d3 is C ) then ( GME )
R16 IF(d1 is NR ) and (d2 is L ) and (d3 is NR ) then ( GME )
R17 IF(d1 is C ) and (d2 is C ) and (d3 is L ) then ( GP )
R18 IF(d1 is MC ) and (d2 is MC ) and (d3 is C ) then ( GP )
R19 IF(d1 is MC ) and (d2 is MC ) and (d3 is N ) then ( GP )
R20 IF(d1 is C ) and (d2 is C ) and (d3 is L ) then ( GP )
5.4 Proceso de Inferencia Difusa (PID)
Se presentara en el capítulo 5.3.1 un ejemplo completo del proceso de
inferencia difusa donde se mostrarán todos los pasos a seguir para completar el
razonamiento.
69
5.4.1 Entradas difusas
Se tomará como ejemplo el siguiente el conjunto de variables difusas de
entrada:
E = (8; 9; 20).
Ahora se tomaran cada una de estas entradas para determinar a qué conjunto
difuso corresponden y qué valor de membresía tienen cada uno. Para el primer
sensor (d1) el valor es 8, por lo que corresponde al conjunto difuso
MUY_CERCA. Lo mismo pasa con el segundo dato (d2), su valor es 9, por lo
que también corresponde al conjunto difuso MUY CERCA. Distinto es el caso
de la tercera entrada (d3), su valor es 20, por lo que corresponde a dos
conjuntos de membresía a la vez, CERCA y NORMAL.
Utilizando la función membresía del conjunto difuso MUY_CERCA se determina
el valor de pertenencia a este conjunto difuso μd1(8).
Conjunto Difuso "MUY CERCA"
{
En la función membresía se reemplaza mc por el valor de d1, en este caso 8, y
se obtiene el valor f (8;MUY_CERCA) = 1 porque d1 pertenece al intervalo
8<= mc < 012.
Por lo tanto, el valor de pertenencia del conjunto difuso MUY_CERCA para el
valor d1 es μd1(8) = 1.
70
Luego, se utiliza nuevamente la función de membresía del conjunto difuso
MUY_CERCA, pero esta vez se determina el valor de pertenencia para el dato
d2=9, es decir, se busca el μd2(9).
Conjunto Difuso "MUY CERCA"
{
En la función membresía se reemplaza mc por el valor de d2, en este caso 9, y
se obtiene el valor f (9;MUY_CERCA) = 1 porque d2 pertenece al intervalo
8<= mc < 12.
Por lo tanto, el valor de pertenencia del conjunto difuso MUY_CERCA para el
valor d2 es μd2(9) = 1.
Por último se evalúa el valor d3=20. A diferencia de los dos anteriores, este
pertenece a 2 conjuntos difusos (CERCA y NORMAL) por lo que se calcula el
valor de pertenencia correspondiente a ambos conjuntos.
Conjunto Difuso "CERCA"
{
71
Conjunto Difuso "NORMAL"
{
Por lo tanto:
Para el conjunto difuso CERCA: μd3(20) = 0.333.
Para el conjunto difuso NORMAL: μd3(20) = 0.333.
5.4.2 Operadores difusos
Las entradas difusas fusificadas en el paso anterior dieron pertenencia a los
siguientes conjuntos difusos para cada variable:
T1(E)={ d1=MUY_CERCA; d2=MUY_CERCA; d3=CERCA}
T2(E)={ d1=MUY_CERCA; d2=MUY_CERCA; d3=NORMAL}
Por lo tanto, con esta combinación de entradas se activarán las reglas R18 y
R19 ya que sus antecedentes se corresponden.
R18 IF(d1 is MC ) and (d2 is MC ) and (d3 is C ) then ( GP )
R19 IF(d1 is MC ) and (d2 is MC ) and (d3 is N ) then ( GP )
El paso siguiente es utilizar los operadores difusos para calcular el nivel de
activación de los antecedentes:
72
Antecedente R18:
(d1 is MUY_CERCA) and (d2 is MUY_CERCA) and (d3 is MUY_CERCA))
El antecedente se encuentra relacionado por conjunciones por lo cual se utiliza
el operador difuso min() ( Ecuación 5.6) para calcular su valor:
(Ec.5.6)
Los valores de las entradas y el grado de pertenencia para cada variable difusa son:
μd1(8) = 1, μd2(9) =1, μd3(20) = 0.333
Calculando el mínimo se obtiene el grado de cumplimiento del antecedente de la regla 18:
Min[1,1,0.333]
Lo que implica que el antecedente R18: = 0.333
De la misma manera se calculan los antecedentes de las regla R19:
(d1 is Muy_Cerca ) and (d2 is Muy_Cerca ) and (d3 is Normal )
Los valores de las entradas y el grado de pertenencia para cada variable difusa son:
μd1(8) = 1, μd2(9) = 1, μd3(20) = 0.333
Calculando el mínimo se obtiene el grado de cumplimiento del antecedente de la regla 18:
Min[1,1,0.333]
73
Lo que implica que el antecedente R19: = 0.333
5.4.3 Inferencia Difusa
Se utiliza el método de Mamdani como método de implicación (Ecuación 5.6):
(Ec.5.6)
Para la regla 18: Implicación para ENTRADA -> SALIDA El valor de pertenencia de la salida difusa GIRO (ver cap. 5.2.2.7) es de 5
if 0.333 then 5
Min [0.333,5] = 0,333
lo que implica que μE->S(DISTANCIA,GIRO)=0.333
Para la regla 19 tomaría el mismo valor.
5.4.4 Desfusificación Para determinar el valor nítido de los conjuntos de salida GIRO se utilizará la
aproximación del cálculo del centro de gravedad (Ecuación 5.7).
(Ec.5.7)
lo que dará como resultado = 3.2
Lo que implica que el robot girará en un total de 3.2°.
74
Capítulo VI Resultados
Ahora se explicarán los resultados de la experimentación con robot AMADEUS
implementado con el comportamiento TANGENT BUG.
Para corroborar los códigos, se proporcionó un espacio de 3[m]x3[m] con el
robot colocado inicialmente en el punto (0,0) como indica la figura 6.1.
Figura 6.1. Ambiente de prueba para el comportamiento Tangent Bug.
Fuente: Diseño Propio
Luego, se le indicó al robot que fuese al punto (300,300) y este fue el resultado:
Al inicio, al no encontrar ningún obstáculo y gracias al código mostrado en la
figura 5.4, el robot pudo seguir una trayectoria directa hacia el punto de meta,
como se muestra en la figura 6.2, el camino recorrido se indica con azul.
75
Figura 6.2. Trayectoria sin obstáculos. Fuente: Diseño Propio
Al encontrarse con su primer obstáculo, este activa su primer comportamiento
(move to goal). Estos códigos se muestran en la figura 5.6. Estos códigos hacen
que el robot reaccione esquivando el objeto por el lado izquierdo de este y
siguiendo la ruta que se muestra en la figura 6.3.
76
Figura 6.3. Trayectoria para el primer obstáculo. Fuente: Diseño Propio
Al encontrarse con el segundo obstáculo, el robot, gracias a sus sensores, logró
demostrar que se trataba de una pared, por lo que procedió a seguir la lógica
explicada en el capítulo 5.2.2.1. Gracias a esta lógica, el robot sigue la pared
por el lado derecho de esta y sigue la trayectoria indicada en la figura 6.4.
Finalmente, cuando ya no hubo ningún obstáculo que sortear, se dirigió
directamente al punto final solicitado desde un principio (300,300).
77
Figura 6.4. Trayectoria final del robot. Fuente: Diseño Propio
78
Capítulo VII Conclusión
En esta tesis se pudo corroborar la necesidad de implementar comportamientos
a un robot que pretende evadir obstáculos que no se encuentran previamente
definidos.
Se generaron dos comportamientos, "Move To Goal”, que pertenece a un
comportamiento más general llamado "Tangent Bug", y el "SIGUE LA PARED",
el cual se programó con lógica difusa. Estos comportamientos funcionan
independientes uno del otro y gracias a los experimentos que se realizaron
demostraron distintos grados de eficiencia pero ambos con resultados
satisfactorios.
La lógica difusa que se programó en el segundo comportamiento permitió al
robot cambiar de posición de una manera más armónica y precisa. Los tipos de
programación con lógica difusa puede servir también para otro tipo de
comportamientos, como el "cruzar puerta" y para el mismo "Tangent Bug".
Gracias a la experimentación con el robot AMADEUS se pudo comprobar que
tanto el comportamiento "Tangent Bug" como "sigue la pared" son incompletos,
ya que no definen la trayectoria óptima para esquivar obstáculos.
Todos los comportamientos creados y los experimentos que se realizaron, se
generaron bajo un ambiente de objetos fijos, ya que un simple movimiento de
estos objetos generaría un error en el cálculo de la trayectoria.
Una de las mejoras importantes que se pueden proyectar con esta experiencia,
es lograr generar un comportamiento más completo, con trayectorias óptimas,
con objetos en movimiento y que se maneje exclusivamente con lógica difusa.
79
Referencias Bibliográficas
Anzen,(2010) Robot Anzen Taro. Creado para el tráfico vehicular.
http://www.sciencephoto.com/media/345029/enlarge
BUG,(1987) V. J. Lumelsky, A. A. Stepanov. “Path-planning strategies for a point mobile automaton moving amidst obstacles of arbitrary shape”, in Algorithmica, vol. 2,pp. 403-430, 1987. BUG2,(1988).V. J. Lumelsky, T. Skewis. “Incorporating range sensing in the robot navigation function” , in IEEE Transactions on System, Man and Cybernetics, vol. 20.pp. 1058-1068, 1990 COG,(1993) Robot COG. proyecto de creación de un robot autónomo inteligente con forma humana.http://www.ai.mit.edu/projects/humanoid-robotics-group/cog/. Cypher,(2006) Robot Cypher. Robot creado para la seguridad. http://www.globalsecurity.org/intell/systems/cypher.htm ELEC,(2010). Electricbricks. Programación de robots, Mayo 2008. http://blog.electricbricks.com/es/2010/05/programacion-comportamientos. IshayKamon,(1998) TangentBug: A Range-Sensor-Based navigation Algorithm. ElonRomon, and Ehud Rivlin: IJRR 17:934-953. KHATIB,(1985). O. Khatib. “Real-Time Obstacle Avoidance for Manipulators and Mobile Robots”.IEEE International Conference on Robotics and Automation, 1985. Kulkarni,(2001), Computer Vision and Fuzzy-Neural Systems, 1/e, Prentice Hall, University of Texas. MathWork,(2001).The MathWorks Signal Processing Toolbox http://www.mathworks.com Pérez (2011).Ricardo Pérez Sánchez. Navegación de Robots Móviles en ambientes desconocidos utilizando Programación Orientada a Comportamientos. DEPARTAMENTO DE INGENIERÍA DE SISTEMAS Y COMPUTACIÓN. Universidad Católica del norte, Chile.
80
PROP,( 2012). PROPELLER GENERAL INFORMATION.2012 http://www.parallax.com/propeller/ Propeller,(2006) Microcontrolador Propeller y lenguaje Spin. http://es.scribd.com/doc/58905124/40/Elementos-de-Lenguaje-Spin Raffo G, (2009). Control Predictivo en Cascada de una Vehículo Autónomo, Revista RIAI, ISSN 1697-7912, Vol 6, Num 1, Enero 2009, pp. 63-74. REINS,(1986) W. Craig Reynolds. “Steering Behaviors For Autonomous Characters”. Sony Computer Entertainment America, 1986. RIAI, (2008). Revista Iberoamericana de Automática e Informática Industrial. Contenidos del Vol. 5, Núm. 1, Enero 2008. http://www.revista-riai.org SCHIAFFINO, (2006). Navegación autónoma basada en visión estereoscópica y lógica difusa.María Paula Schiaffino.Universidad Nacional de Luján.Argentina SOJOURNER,(1997).Robot SOJOUNER. Robot pionero en el espacio. http://spacepioneers.msu.edu/robot_rovers/sojourner.html Trilobite,(1997) Robot TrilobiteElectrolux. Creado para la limpieza. http://www.gizmag.com/go/2829/ VFH,(1991) J. Borenstein and Y. Koren. “The Vector Field Histogram-Fast Obstacle Avoidance For Mobile Robots”. IEEE Journal of Robotics and Automation, Vol. 7, No. 3, June 1991, pp. 278-288. VFH+,(1998) I. Ulrich and J. Borenstein. “VFH+: Reliable Obstacle Avoidance for Fast Mobile Robots”. Proceedings of the 1998 IEEE International Conference on Robotics and Automation. Leuven, Belgium, May 16-21, 1998, pp. 1572-1577. Zondag, (2009).Job Zondag.Vision for Mobile Robot Navigation. Cognitive Robotics Presentations 2008/2009.
81
Anexos
82
Anexo A. Código del comportamiento Tangent Bug.
''METODO TANGENT BUG"
CON
_clkmode = xtal1 + pll16x
_xinfreq = 5_000_000
Avanza = 65
Giro = 71
Sensores = 83
Pare = 80
Donde_Estoy = 68
Muevase = 77
Adelante = 0
Atras = 1
Izquierda = 0
Derecha = 1
Nulo = 100
VAR
long Stack[20]
long XMAXIMO
long YMAXIMO
''distancias maximas y minimas del
sensor"
long distSenMax
long distSenMin
''distancias dadas por los sensores"
long dp1
long dp2
long dp3
long dp4
long dp5
'' posiciones de x e y de cada uno de los
sensores"
long p1x
long p1y
long p2x
long p2y
long p3x
83
long p3y
long p4x
long p4y
long p5x
long p5y
'' posiciones iniciales y finales de cada
uno de los sensores"
long goalx
long goaly
long inix
long iniy
'' variables auxiliares"
long DatoPrueba
word Resto
word div
word dato
byte Valor
word nuevo_puntox
word nuevo_puntoy
word DH_actual
word DH
long angNuevo
long angNuevo2
long angAux
long angAux2
long hAux
long hAux2
long DC
long RadioRobot
long DiamRobot
long Dfollowed
long Dreach
long Daux
long angPared
long Daux2
long fi
word parametro1
word parametro2
''variables auxiliares para lógica
difusa"
byte d1f
byte d2f
byte d3f
byte d1
byte d2
byte d3
byte d1u
byte d2u
84
byte d3u
byte g
byte Comando "Recibe los comandos a
enviar"
long giroNuevo
byte const1
byte const2
byte const3
byte Rnum1
byte Rnum2
byte Rden
word NG
word GP
word GME
word GMU
word mini
word gfusi
OBJ
''OBJETO PARA OBSERVAR LAS
VARIABLES A TRAVEZ DEL
TERMINAL SERIAL"
pst : "Parallax Serial Terminal"
''OBJETO PARA REALIZAR
CALCULOS MATEMÁTICOS"
F32: "Float32Full"
FS: "FloatString"
Com: "Serial"
Time: "Timing"
PUB TANGENTBUG
F32.start
pst.Start(115200)
distSenMax := 50 '' distancia maxima
asignada a los sensores"
Comando := Nulo
RadioRobot:=24 "Radio del robot en
centímetros mas tolerancia"
DiamRobot:= 2*RadioRobot
goalx := 100
goaly := 100
repeat
DondeEstoy
''punto final al cual hay que llegar
(pedir por parámetro) ,lugar donde me
encuentro (pedir por parametro) y
angulo Fi (pedir por parametro)"
''variables auxiliares
angAux:=0
hAux:=0
hAux2:=0
Daux:=1000
85
DH_ACTUAL:=1000
"posiciones de la deteccion de los
sensores"
p1x:=
inix+(dp1*F32.COS(F32.RADIANS(30
+fi)))
p1y:=
iniy+(dp1*F32.SIN(F32.RADIANS(30
+fi)))
p2x:=
inix+(dp2*F32.COS(F32.RADIANS(60
+fi)))
p2y:=
iniy+(dp2*F32.SIN(F32.RADIANS(60
+fi)))
p3x:=
inix+(dp3*F32.COS(F32.RADIANS(90
+fi)))
p3y:=
iniy+(dp3*F32.SIN(F32.RADIANS(90
+fi)))
p4x:=
inix+(dp4*F32.COS(F32.RADIANS(12
0+fi)))
p4y:=
iniy+(dp4*F32.SIN(F32.RADIANS(120
+fi)))
p5x:=
inix+(dp5*F32.COS(F32.RADIANS(15
0+fi)))
p5y:=
iniy+(dp5*F32.SIN(F32.RADIANS(150
+fi)))
"caso 1: no hay obstaculos.los sensores
indican distancia maxima."
if goalx > inix AND goaly > iniy
hAux:=
DisHeuristica(inix,iniy,goalx,goaly)
hAux2:=hAux
angAux:=F32.ACos(F32.FDIV((goalx-
inix),hAux2))
angAux2:=F32.Degrees(angAux)
Girar(angAux2,0)
AvanzarRecto(5,0)
if goalx < inix AND goaly > iniy
hAux:=
DisHeuristica(goalx,iniy,inix,goaly)
hAux2:=hAux
angAux:=F32.ACos(F32.FDIV((inix-
goalx),hAux2))
angAux2:=F32.Degrees(angAux)
'Girar(180-angAux2,0)
'AvanzarRecto(5,0)
86
if goalx > inix AND goaly < iniy
hAux:=
DisHeuristica(inix,goaly,goalx,iniy)
hAux2:=hAux
angAux:=F32.ACos(F32.FDIV((goalx-
inix),hAux2))
angAux2:=F32.Degrees(angAux)
'Girar(180-angAux2,0)
'AvanzarRecto(5,0)
if goalx < inix AND goaly < iniy
hAux:=
DisHeuristica(goalx,goaly,inix,iniy)
hAux2:=hAux
angAux:=F32.ACos(F32.FDIV((inix-
goalx),hAux2))
angAux2:=F32.Degrees(angAux)
'Girar(angAux2,0)
'AvanzarRecto(5,0) while
dp1>=distSenMax AND
dp2>=distSenMax AND
dp3>=distSenMax AND
dp4>=distSenMax AND
dp5>=distSenMax
"caso 2: encuentra obstaculo"
''INICIAR MOVE TO GO
'' Busco la distancia heuristica que me
entrega cada uno de los puntos y me
muevo al punto que me entregue la DH
menor"
repeat
if dp1<distSenMax
DH:=
DisHeuristica(p1x,p1y,goalx,goaly)
if DH < DH_actual
DH_actual:=DH
nuevo_puntox:=p1x
nuevo_puntoy:=p1
angNuevo:=
F32.ACos(F32.FDIV((goalx-
p1x),DH_actual))
angNuevo2:=F32.Degrees(angNuevo)
if dp2<distSenMax
87
DH:=
DisHeuristica(p2x,p2y,goalx,goaly)
if DH < DH_actual
DH_actual :=DH
nuevo_puntox:=p2x
nuevo_puntoy:=p2y
angNuevo:=
F32.ACos(F32.FDIV((goalx-
p2x),DH_actual))
angNuevo2:=F32.Degrees(angNuevo)
if dp3<distSenMax
DH:=
DisHeuristica(p3x,p3y,goalx,goaly)
if DH < DH_actual
DH_actual:=DH
nuevo_puntox:=p3x
nuevo_puntoy:=p3y
angNuevo:=
F32.ACos(F32.FDIV((goalx-
p3x),DH_actual))
angNuevo2:=F32.Degrees(angNuevo)
if dp4<distSenMax
DH:=
DisHeuristica(p4x,p4y,goalx,goaly)
if DH < DH_actual
DH_actual:=DH
nuevo_puntox:=p4x
nuevo_puntoy:=p4y
angNuevo:=
F32.ACos(F32.FDIV((goalx-
p4x),DH_actual))
angNuevo2:=F32.Degrees(angNuevo)
if dp5<distSenMax
DH:=
DisHeuristica(p5x,p5y,goalx,goaly)
if DH < DH_actual
DH_actual:=DH
nuevo_puntox:=p5x
nuevo_puntoy:=p5y
angNuevo:=
F32.ACos(F32.FDIV((goalx-
p5x),DH_actual))
angNuevo2:=F32.Degrees(angNuevo)
'' Antes de mover a la posicion
nueva,preguntar si puede pasar (cruzar
puerta)"
88
if dp2<distSenMax AND
dp4<distSenMax
DC:=
F32.FSqr((((RadioRobot+dp2)*(RadioR
obot+dp2))+((RadioRobot+dp4)*(Radio
Robot+dp4)))*(F32.Cos(F32.Radians(6
0.0))))
if DC > DiamRobot AND
DH_actual < DH
"Girar(angNuevo2,9)"
"AvanzarRecto(2,0)"
while DC > DiamRobot AND
DH_actual <= DH
"volver a preguntar por las DH mientras no
encuentre una mayor a la anterior
calculada., "
"Caso 3 INICIAR Lógica Difusa "
"constantes de giro (g:=)"
NG:=0
GP:=5
GME:=10
GMU:=15
'inicializacion constantes difusas
d1f:="A"
d2f:="A"
d3f:="A"
'incializacion constantes distancia
d1:=dp1
d2:=dp5
d3:=dp3
'inicializacion grado fuzzy
d1u:=0
d2u:=0
d3u:=0
'inicializacion Numerador y
denominador de la respuesta final
Rnum1:=0
Rnum2:=0
Rden:=0
'inicializacion constantes
const1:=0
const2:=0
const3:=0
'inicializacion constantes funciones
mini:=0
gfusi:=0
'inicia programa fuzzy
89
repeat while (const1:=0 OR const2:=0
OR const3:=0)
d1f:= Fusificar_d(1,d1,d1f)
d2f:= Fusificar_d(2,d2,d2f)
d3f:= Fusificar_d(3,d3,d3f)
d1u:=GradoFuzzy(d1f)
d2u:=GradoFuzzy(d2f)
d3u:=GradoFuzzy(d3f)
if const1:=0 OR const2:=0 OR
const3:=0
mini:=Minimo(d1u,d2u,d3u)
if STRCOMP (d1f,STRING("l"))
and STRCOMP (d2f,STRING("l")) and
STRCOMP (d3f,STRING("l"))
g:=NG
if STRCOMP (d1f,STRING("ml"))
and STRCOMP (d2f,STRING("ml"))
and STRCOMP (d3f,STRING("ml"))
g:=NG
if STRCOMP (d1f,STRING("ml"))
and STRCOMP (d2f,STRING("ml"))
and STRCOMP (d3f,STRING("l"))
g:=NG
if STRCOMP (d1f,STRING("c"))
and STRCOMP (d2f,STRING("l")) and
STRCOMP (d3f,STRING("l"))
g:=NG
if STRCOMP (d1f,STRING("c"))
and STRCOMP (d2f,STRING("ml"))
and STRCOMP (d3f,STRING("ml"))
g:=NG
if STRCOMP (d1f,STRING("l"))
and STRCOMP (d2f,STRING("l")) and
STRCOMP (d3f,STRING("nr"))
g:=NG
if STRCOMP (d1f,STRING("ml"))
and STRCOMP (d2f,STRING("ml"))
and STRCOMP (d3f,STRING("nr"))
g:=NG
if STRCOMP (d1f,STRING("ml"))
and STRCOMP (d2f,STRING("ml"))
and STRCOMP (d3f,STRING("nr"))
g:=NG
if STRCOMP (d1f,STRING("l"))
and STRCOMP (d2f,STRING("l")) and
STRCOMP (d3f,STRING("c"))
g:=GMU
if STRCOMP (d1f,STRING("l"))
and STRCOMP (d2f,STRING("ml"))
and STRCOMP (d3f,STRING("c"))
g:=GMU
90
if STRCOMP (d1f,STRING("ml"))
and STRCOMP (d2f,STRING("ml"))
and STRCOMP (d3f,STRING("c"))
g:=GMU
if STRCOMP (d1f,STRING("l"))
and STRCOMP (d2f,STRING("l")) and
STRCOMP (d3f,STRING("mc"))
g:=GMU
if STRCOMP (d1f,STRING("l"))
and STRCOMP (d2f,STRING("ml"))
and STRCOMP (d3f,STRING("mc"))
g:=GMU
if STRCOMP (d1f,STRING("ml"))
and STRCOMP (d2f,STRING("ml"))
and STRCOMP (d3f,STRING("mc"))
g:=GMU
if STRCOMP (d1f,STRING("nr"))
and STRCOMP (d2f,STRING("l")) and
STRCOMP (d3f,STRING("c"))
g:=GME
if STRCOMP (d1f,STRING("nr"))
and STRCOMP (d2f,STRING("l")) and
STRCOMP (d3f,STRING("nr"))
g:=GME
if STRCOMP (d1f,STRING("c"))
and STRCOMP (d2f,STRING("c")) and
STRCOMP (d3f,STRING("l"))
g:=GP
if STRCOMP (d1f,STRING("Mc"))
and STRCOMP (d2f,STRING("c")) and
STRCOMP (d3f,STRING("l"))
g:=GP
if STRCOMP (d1f,STRING("Mc"))
and STRCOMP (d2f,STRING("Mc"))
and STRCOMP (d3f,STRING("l"))
g:=GP
if STRCOMP (d1f,STRING("c"))
and STRCOMP (d2f,STRING("c")) and
STRCOMP (d3f,STRING("l"))
g:=GP
Rnum1:=Rnum1+(mini*g)
Rden:=Rden+mini
'calculo el giro del robot
giroNuevo:= F32.FDIV(Rnum1,Rden)
'Girar(giro,9)"
'AvanzarRecto(2,0)"
F32.stop
PRI DisHeuristica (hx,hy,gx,gy)
return F32.FSqr(((gx-hx)*(gx-
hx))+((gy-hy)+(gy-hy)))
91
PRI GradoFuzzy(grado)
if STRCOMP (grado,STRING("mc"))
gfusi:=FMuyCerca(grado)
return gfusi
if STRCOMP (grado,STRING("c"))
gfusi:=FCerca(grado)
return gfusi
if STRCOMP (grado,STRING("nr"))
gfusi:=FNormal(grado)
return gfusi
if STRCOMP (grado,STRING("l"))
gfusi:=FLejos(grado)
return gfusi
if STRCOMP (grado,STRING("ml"))
gfusi:=FMuyLejos(grado)
return gfusi
PRI FMuyCerca(mce)
if mce <2
return 0
if mce >= 2 and mce<8
return (F32.FDIV((mce-2),6))
if mce>=8 and mce<12
return 1
if mce>=12 and mce<15
return (F32.FDIV((15-mce),3))
if mce <=15
return 0
PRI FCerca(c)
if c<10
return 0
if c>=10 and c<14
return (F32.FDIV((c-10),4))
if c>=14 and c<19
return 1
if c>=19 and c<21
return (F32.FDIV((21-c),3))
92
if c>=21
return 0
PRI FNormal(nor)
if nor>19
return 0
if nor>=19 and nor<22
return (F32.FDIV((nor-19),3))
if nor>=22 and nor<26
return 1
if nor>=26 and nor<29
return (F32.FDIV((29-nor),3))
if nor>=29
return 0
PRI FLejos(l)
if l<28
return 0
if l>=28 and l<32
return (F32.FDIV((l-28),4))
if l>=32 and l<35
return 1
if l>=35 and l<38
return (F32.FDIV((38-l),3))
if l >=38
return 0
PRI FMuyLejos(ml)
if ml>37
return 0
if ml >=37 and ml<43
return (F32.FDIV((ml-37),6))
if ml>=43 and ml<47
return 1
if ml>=47 and ml<50
return (F32.FDIV((50-ml),3))
if ml>=50
return 0
PUb Fusificar_d(td,d,df)
if d>2 and d<15
df:=STRING("mc")
93
return df
if d>10 and d<=21
df:=STRING("c")
return df
if d>19 and d<=29
df:=STRING("nr")
return df
if d>28 and d<=38
df:=STRING("l")
return df
if d>37 and d<50
df:=STRING("ml")
return df
if td==1
const1++
return df
if td==2
const1++
return df
if td==3
const1++
return df
PUB Minimo (d1uu,d2uu,d3uu)
if d1uu>d2uu and d1uu>d3uu
return d1uu
if d2uu>d1uu and d2uu>d3uu
return d2uu
if d3uu>d2uu and d3uu>d1uu
return d3uu
PRI Girar(param1, param2)
Comando := Giro
parametro1 := param1
parametro2 := param2
94
PRI AvanzarRecto(param1, param2)
Comando := Muevase
parametro1 := param1
parametro2 := param2
