Vídeos de resultados

Esta probablemente será la última entrada que publicaré antes de la entrega y presentación de mi PFC; en esta entrada mostraré vídeos en los que se observará resultados de aprendizajes, adelantamientos, persecuciones, bloqueos a rivales, carreras contra rivales y usos de la herramienta gráfica. Serán vídeos en los que me apoyaré durante la defensa de mi proyecto, por lo que tendré especial cuidado en su acabado.
Iré actualizando la entrada con los vídeos que vaya editando con el software Camtasia (que por cierto es genial para hacer presentaciones en vídeos y hacer capturas de pantalla).

Vídeo 1: Aprendizaje en Street1

Aprendizaje

Aunque ya está prácticamente cerrado el PFC, he seguido añadiendo algunas mejoras. La última ha sido incorporarle un sistema de aprendizaje de circuitos. Este sistema es simple, pero muy eficaz. Se basa en tener una tabla hash en la que tengo como clave los puntos kilométricos del circuito, y como objeto asociado a cada clave un booleano que indica si hay peligro en dicho punto o no.
Esta tabla se carga durante la primera vuelta que se da al circuito, y marca como "1" aquellos puntos en los que se produce un incremento de daños (es decir, que se ha dado un porrazo :) ).
En las siguientes vueltas, se comprobará con una antelación de 150 metros si hay algún punto peligroso, y si lo hay, se reduce la velocidad a menos de 100km/h. Cuando se ha pasado el punto peligroso, se vuelve al estilo de conducción normal.

En el siguiente vídeo se puede ver un ejemplo de aplicar esta estrategia. En la primera vuelta que realiza se producen algunos impactos, pero en la siguiente vuelta recuerda dónde se produjeron los impactos y va a menor velocidad en esos puntos.


Vídeo de carrera contra más rivales. Aún no es competitivo, pero se puede observar que al menos ya no tiene problemas de dirección, y se controla decentemente la velocidad. Hay que mejorar los adelantamientos.




PD: Llevo unas 30 páginas de la memoria del PFC escritas de momento.

Controlador PD

He estado trabajando en mejorar el comportamiento de la dirección del vehículo. En las últimas entradas comenté que al modificar la velocidad máxima del cliente ya no funcioaba correctamente el control de dirección que venía por defecto, así que diseñé uno desde cero. Una buena solución fue aplicar un controlador P (controlador proporcional) en el vehículo, con lo que se se conseguía un nivel de giro proporcional a la distancia a los bordes:

giro=giro+Kp*error

Tomé como Kp -0.001, después de probar con varios valores. Aunque existen algunas técnicas, en algunas fuentes de bibliografía recomendaban ajustarla a ojo esta constante mediante pruebas.

Este controlador me proporcionaba unos resultados muy aceptables, pero el vehículo tendía a oscilar un poco rectas, y probé con un controlador PD, que estuve informandome sobre su comportamiento y era muy adcuado para suavizar las salidas del sistema (el giro de volante en nuestro caso).

giro=giro+Kp*error+Kd*(error-error_anterior)

En este caso tomé la misma Kp y como Kd -0.01, y los resultados han sido muy buenos, ya que el coche no se ha salido de la calzada en ningún momento en los circuitos probados (óvalos, ciudades y uno real de Montmeló), y no solo eso, sino que además el coche tiende a ir por el centro de la calzada. Y todo ello de forma suave.

Ajuste de reglas, corrección de errores y finalización del proyecto

Después de varios meses de desarrollo, ha comenzado la fase final del proyecto. En esta etapa mis objetivos serán los siguientes:

- Desarrollo de una máquina de estados, que nos permitirá seleccionar un conjunto de reglas apropiado a la situación del vehículo.
-------------------------------------------------------------------

En principio tendré 3 estados: Inicial, persecución y adelantamiento.

• El estado inicial será el estado básico, y estará asociado a un conjunto de reglas que se seleccionarán siempre que no haya rivales en un radio cercano.
• El estado persecución tendrá como objetivo buscar un hueco entre el rival y el borde de la calzada que sea mayor que la anchura de nuestro vehículo. El objetivo consistirá en posicionarse en paralelo a dicho hueco.
• El estado adelantamiento consistirá en realizar la maniobra de acelerar en paralelo al rival hasta rebasarlo. Esta maniobra se realizará si nos da tiempo antes de que llegue una curva.

Se realizará la transición de estados inicial->persecución cuando se de el evento de que se detecte un vehículo rival.
La transición persecución->adelantamiento se lanzará cuándo el vehículo alcance una buena posición para poder iniciar una maniobra de adelantamiento.
También se tendrá una transición persecución->Inicial si por algún motivo hay que desistir de buscar una posición para adelantar. Esto puede darse por ejemplo si se aproximan curvas cerradas.
La transición adelantamiento->Inicial se activará cuándo se rebase al rival en el adelantamiento.
La transición adelantamiento->persecución se acerca una curva mientras se está rebasando al rival.

Una posible mejora ( que de momento no se aplicará) sería tener distintos modos de conducción (modo conducción agresiva o conducción relajada) que nos permitiese o no hacer maniobras de adelantamiento en curvas.

Ajuste de reglas
--------------------------------------
Esta parte será la que más tiempo de desarrollo requerirá. Consistirá en diseñar el conjunto de reglas para cada uno de los estados.

Ejemplos:
ESTADO INICIAL
0 rival_frente(cerca)->cambio_estado(persecucion)
1 rival_frente(medio)->cambio_estado(persecucion)

ESTADO PERSECUCIÓN
0 huecoMayor(derecha)&posicion_pista(derecha)->cambio_estado(adelantar)
1 huecoMayor(derecha)&posicion_pista(izquierda)->direccion(-0.6)
2 huecoMayor(derecha)&posicion_pista(centro)->direccion(-0.4)
3 huecoMayor(izquierda)&posicion_pista(izquierda)->cambio_estado(adelantar)
4 huecoMayor(izquierda)&posicion_pista(derecha)->direccion(0.6)
5 huecoMayor(izquierda)&posicion_pista(centro)->direccion(0.4)

ESTADO ADELANTAMIENTO
0 entorno(recta)&tiempo_adel(si)->acelerar(1)
1 rival_atras(cerca)->cambio_estado(inicial)
2 rival_atras(medio)->cambio_estado(inicial)
3 entorno(curva)->cambio_estado(persecucion)
4 rival_derecha(si)-> acelerar(1)
5 rival_izquierda(si)-> acelerar(1)


Hay que señalar que estos conjuntos de reglas están diseñados pensando en un solo rival a batir.
En el caso de tener varios rivales, la complejididad del problema de adelantamiento se incrementa sustancialmente.

Finalización de representaciones gráficas
-------------------------------------------
Consistirá en terminar de representar las gráficas que faltan referentes a acciones (aceleración, freno, y marcha).

Corrección de bugs
-----------------------------------------
La aplicación actualmente tiene diversos fallos puntuales, principalmente son sobre refrescos de gráficos. Se hará todo lo posible por corregirlos.

Diseño de un controlador difuso para la tracción del vehículo
----------------------------------------
Si se tiene el suficiente tiempo antes de la finalización del PFC, se diseñará un controlador difuso para la tracción. En principio se iba a diseñar con controlador fuzzy para las marchas, pero no era adecuado este tipo de controlador para esta variable, ya que se trata de una variable discreta, y los sitemas fuzzy son adecuados para variables continuas. Por ello, se decidió que se podría realizar un controlador fuzzy para la tracción, tomando como entradas la velocidad del vehículo y la velocidad objetivo y como salida el nivel de aceleración a aplicar para evitar que patine el coche.

Experimentos

Últimamente he estado realizando algunos experimentos para calcular la velocidad óptima de cambio de marcha, y también otros experimentos para comprobar que el circuito se reconocía adecuadamente.

El primer experimento consistió en partir de meta en el circuito Villarello Death (circuito tipo óvalo con rectas muy largas) en 1ª, 2ª, 3ª, 4ª , 5ª, 6ª y 7ª marcha y tomar los datos de como íba variando la aceleración. Se observa que inicialmente para cada marcha se tiene una aceleración creciente, luego estable y luego decreciente. La idea era observar el punto en el que se cruzan la aceleración decreciente de una marcha con la aceleración de la siguiente marcha, siendo ese punto la velocidad de cambio de marcha óptima.

Otro de los experimentos cosistió en representar gráficamente los radios de curvatura (calculados mediante geometría y álgebra -detallado hace varias entradas-) que se fuesen reconociendo durante la carrera. Exte experimento se realizó sobre el circuito F-speedway1. Se obtuvieron los siguientes resultados:



Se observa que se reconocieron hasta 3 tipos de curvatura para cada curva del circuito, siendo esto correcto, ya que comprobamos que en el fichero xml de definición del circuito, cada curva se componía de 3 subcurvas cada una en ese circuito. Además, el radio calculado era exactamente el reflejado el el fichero de XML, luego el sistema de detección estaba correctamente diseñado.

Cálculo de huecos para adelantamientos

Una de las últimas mejoras en las que he podido progresar ha sido la detección de la zona por la que hay hueco suficiente para poder adelantar.
Para diseñar esta mejora he necesitado aplicar bastante trigonometría:

En esta imagen he representado cómo se calcularía la distancia del oponente al borde izquierdo (para el cálculo al borde derecho sería similar). Supongamos que la zona negra de la imagen es una carretra recta, el rectángulo rojo nuestro vehículo, y el círculo rojo un oponente. Nuestro objetivo es calcular la distancia D_op_b (distancia desde el oponente al borde). Para calcular, básicamente lo que hay que hacer es hallar la diferencia entre D_total (distancia desde nuestro coche al borde) y D_op_x (distancia desde nuestro vehículo al oponente). El problema surge en el cálculo de cada distancia, ya que no es tan simple como pueda parecer, porque entra en juego la variable alpha (ángulo respecto al eje de la pista).
En primer lugar calculamos la D_total; para ello tomamos la distancia proporcionada por S0 (S18 en el caso del cálculo de la distancia del oponente al borde derecho) y la multiplicamos por el coseno de alpha: D_total=S0*cos(Cº). Notar que C=alpha. A continuación necesitamos calcular D_op_x, y para ello necesitamos el ángulo bº. Este ángulo se obtiene mediante la fórmula :

b=( (S_oponente*10) - s.getAngleToTrackAxis())-90

(suponiendo las unidades en grados y siendo S_oponente el índice del sensor que nos ha detectado un oponente).

Una vez que hemos calculado b, podemos cacular D_op_x.

D_op_x=abs( dist_op*cos(b) )

Finalmente, tenemos que calcular si el oponente está a nuestra derecha o izquierda, para sumar o restar el valor D_op_x a D_total. Para realizar este cálculo, previamente tenemos que saber cuál es nuestro "sensor de referencia", esto es, qué sensor está paralelo al eje de la carretera. Esto se calcula fácilmente con la fórmula

referencia=18-(int)(Math.toDegrees(s.getAngleToTrackAxis())/10);

Una vez que sabemos cual es este sensor de referencia, simplemente tenemos que comprobar si el sensor dónde está el oponente tiene un índice menor o mayor. Si el índice es menor, entonces el oponente está a nuestra izquierda, y si es mayor, está a nuestra derecha.

En el caso de que esté a la izquierda, D_op_b =D_total-d_op_x
En el caso de que esté a la derecha, D_op_b =D_total+d_op_x

Con esto, ya tenemos calculado el "hueco", dato que nos servirá para comprobar si nuestro coche es mayor que dicho hueco, y en caso de que sea el mayor hueco que se haya detectado, podríamos plantearnos adelantar si se dan las condiciones (por ejemplo, que nos de tiempo de adelantar antes de llegar a una curva).

En siguientes entradas continuaré ampliando los progresos y trataré con más detalle aspectos que se comentaron en entradas anteriores.

Detección precisa de rectas y curvas

Actualmente me encuentro en la etapa de diseño de reglas, y para ello es imprescindible detectar correctamente cuándo se está en una curva o una recta.
Hasta ahora esto lo detectaba a través del sensor que me proporcionase la mayor distancia, pero daba algunos problemas al encontrarse en curvas y en paralelo al eje de la pista (daba como resultado que estaba en una recta en ese caso). La forma correcta de hacer esta comprobación es la siguiente:

- Hay que calcular la pendiente entre el sensor 0-1 y el 1-2 para la zona izquierda del coche y comprobar si son aproximadamente iguales, esto es, que estén alineados.
Se comprobará que sean aproximadamente iguales porque una recta perfecta no existe en TORCS.

- Para la zona derecha el método es el mismo pero para los pares 16-17 y 17-18.

Si tanto en la derecha como en la izquierda se detectan que los puntos están alineados, entonces se podrá afirmar con seguridad que se está en una recta, y en caso contrario, en una curva. Para saber el sentido de la curva si se podrá utiliza el sensor que nos proporcione la máxima distancia, aunque previamente habrá que calcular cuál es el eje de referencia, que dependerá del ángulo del coche respecto al eje de la pista.

He de decir que tras realizar multitud de pruebas, no me salían alineados los puntos cuándo el coche estaba en una recta y no estaba parelelo al eje, y descubrí a qué era debido... vi que en el fichero SimpleDriver, los autores modificaban los ángulos de separación de los sensores de distancia al inciarse el conductor (en la función initAngles), y por defecto no están a 10º como pensábamos, sino que tienen distintas precisiones. Por ello, cuando estaba en la fase del diseño de la GUI de telemetría no me salían correctamente las distancias... es decir que no era necesario calcular el radio pequeño que se comentó hace varias entradas.
Aquí dejo una captura en la que se puede ver que ahora se perciben las rectas con gran precisión.



Y aquí dejo otra captura mostrando el método que he nombrado anteriormente. Lo he modificado de forma que los sensores queden separados cada 10º.


Una vez que tenga resuelto el problema de detección de curvas/rectas pasaré a diseñar una máquina de estados, que me servirá para poder elegir distintos conjuntos de reglas, según la situación en la que se esté.
En principio se tendrán los siguientes estados: Inicial, Recta, Curva, Adelantamiento.
Se cambiará de estado cuándo se dispare alguna regla que contenga como consecuente un cambio de estado.

Ejemplo de reglas del estado "adelantar":
0 hay_hueco(izquierda)&da_tiempo(adelantar)->adelantar(izquierda)
1 hay_hueco(derecha)&da_tiempo(adelantar)->adelantar(derecha)
2 hay_hueco(centro)&da_tiempo(adelantar)->adelantar(centro)

Se puede observar que cada vez los antecedentes y los consecuentes están siendo más complejos e inteligentes.

También hay algunas ideas más por desarrollar como:

- La comprobación de la velocidad del oponente para ver si es alcanzable antes de que se llegue a una curva (esto es imprescindible para poder tener antecedentes del tipo "me da tiempo de adelantar").
- El diseño de un controlador difuso para el control de las marchas.
- Diseñar un controlador PID (http://es.wikipedia.org/wiki/Proporcional_integral_derivativo) para realimentar la entrada con la dirección.
- Aplicar teoría del campo eléctrico para realizar adelantamientos (basándose en el comportamientos de cargas del mismo signo, que se repelen)



Y para finalizar esta entrada, dejo 2 vídeos más sobre los adelantamientos que se están logrando