Práctica 4 - Controlador PID

Antes de utilizar los tres controladores juntos,  hemos probado el controlador P e I juntos para ver cómo se iba a comportar nuestro robot.

Hemos empezado con las dos constantes con valores parecidos:
kp=10 ki=10

Como se puede ver la reacción es bastante "brusca" y oscila demasiado. Tras ver que el valor de la constante de I es muy "grande" hemos decidido ponerle en 1:
kp=10 ki=1

Y por último hemos utilizado los tres controladores juntos. En resumen habíamos visto que el proporcional tenía que tener un valor medio-alto (respecto a los valores que habíamos probado) y que si le añadíamos el controlador D, este iba a suavizar las oscilaciones del P por tanto tenían que estar relacionados sus valores. El controlador I es el que menos habíamos probado por tanto no sabíamos cómo se iba a comportar junto al controlador D.

Al igual que cuando probamos el controlador PI, hemos dejado la constante kI con un valor de 10 para ver cómo se iba a comportar.

kp=20, d=20, i=10

Nos hemos encontrado en el mismo caso que anteriormente con el controlador I, así que le hemos dejado con el menor valor que podíamos darle y con el que mejor se comportaba en conjunto, 1.

Tras ajustar el valor de la constante kI, hemos aumentando ligeramente la constante kD para que no fuese demasiado brusco ya que no nos gustaba cómo había quedado. Finalmente el controlador PID si que es capaz de mantener el robot en equilibrio sin desplazarse demasiado por culpa del peso siendo capaz de recuperarse solo. El resultado final es el siguiente:

FINAL

Práctica 4 - Controlador PD

En este caso el controlador D ayuda a que el controlador P haga que el robot oscile demasiado, es decir, suaviza el movimiento del robot. Aun así, no nos ha sido suficiente cuando hay mucho peso hacia un lado, de tal forma que no se puede recuperar al igual que nos pasaba con el controlador P.

Resultados del controlador PD:

kP = 10 kD = 10
Suave

kP = 10 kD = 20
Mucho más suave

kP = 20 kD = 10
Se acerca más al comportamiento del controlador P en solitario, pero menos brusco.

Práctica 4 - Controlador P

Hemos decidido ir probando poco a poco y por separado los controladores e ir añadiendo uno a uno para ir ajustándolos y ver los cambios en el comportamiento del robot.

Para empezar hemos utilizado solo el controlador proporcional, con una kp = 1. Como era de esperar el resultado no ha sido demasiado bueno.

kp=1;

kp=10;

kp=20;

En resumen, cuando utilizamos solo el controlador P, para valores de la constante altas oscila mucho, sin embargo cuanto más baja es esta constante menos oscila. El problema de utilizar solo este controlador es que cuando el peso se va mucho hacia un lado (o la luz se separa mucho del suelo) no es capaz de recuperarse.

Práctica 4 - Inicio con el SegWay

Hemos empezado buscando un diseño adecuado para nuestra práctica. Tras mirar algunos videos en youtube, hemos encontrado uno que hos ha gustado:

Desde el vídeo nos redirigen a un pequeño manual de cómo construirlo (link).

Tras tener el montaje hecho, hemos empezado a pensar cómo hacer nuestro SegWay. Finalmente, hemos hecho un bucle de la siguiente forma:

Calibrar();

loop

      Leer valor del sensor de luz ();

      Calcular PID ();

      Mover el robot ();

end loop;

Calibrar():
       Para calibrar lo que haremos es situar el robot en la posición 0 (a la que volverá
       siempre) y tras unos segundos leyendo valores, pulsamos "ENTER" para que
       haga la media de esos valores leídos, teniendo el valor medio del sensor de luz
       en esa posición.

Leer valor del sensor de luz ():
       Leerá el valor actual del sensor de luz

Calcular PID ():
       Llamará a tres funciones, calcularProporcional(), calcularDerivada() y calcularIntegral().
       La función calcular PID () nos devolverá el valor del pid, que será el siguiente:

              pid = Kp * proporcional + Kd * derivada + Ki * integral

       De tal forma que cuando queramos probar el segway con uno o varios controladores,
       el valor de las constante del controlador que no queramos utilizar tendrá el valor 0.

Mover el robot():
       Ajustaremos la velocidad del motor con el valor del PID, de tal forma que cuanto más
       alto sea el PID, más velocidad tendrán los motores. Para ello utilizamos el valor
       absoluto del PID y lo metemos en "setSpeed".
       Por último, para si el pid es positivo o negativo los motores irán hacia delante o atrás.

En las siguientes entradas comentaremos las pruebas que hemos ido haciendo con las distintas combinaciones de los controladores y sus constantes.

Práctica 3 - Comportamiento ir hacia la luz

En este ejercicio vamos a utilizar dos sensores de luz, situados cada uno en un lateral a unos 45 grados aproximadamente.

En resumen nuestro robot, cuando no encuentra diferencia de luz entre los dos sensores, irá hacia delante. Para que la clase "BuscaLuz" tome el control, hemos hecho una resta de los valores que toman los dos sensores y tomando el valor absoluto de la resta, si es mayor de un rango, devolverá un valor verdadero, en caso contrario continuará andando hacia delante.

Nada más arrancar el programa calibramos los sensores mirando hacia la luz con calibrateHigh( ), esperando a que pulsemos un botón. Tras ser pulsado el botón, se quedará esperando a que pulsemos de nuevo para hacer el calibrateLow( ) esta vez con la luz ambiente. Una vez terminada la calibración hará lo explicado anteriormente.

Hemos tenido algún que otro problema al calibrarlos ya que muchas veces no conseguíamos que tuviese los valores deseados, pero sobre todo hemos tenido problemas con la diferencia de medición de los dos sensores, que no nos han facilitado para nada el trabajo.

Y hasta aquí ha llegado nuestra práctica tres, ya que debido a los problemas que hemos tenido en el ejercicio de campo de fuerzas virtuales no nos ha dado tiempo ni a hacer un sigue luz evitando obstáculos con el sensor de contacto.

Hoy hemos empezado con la práctica cuatro, segway, peleándonos con el diseño del robot. Esperemos (no tenemos fé) que esta no nos de tanto trabajo!

Práctica 3 - Evitando obstáculos utilizando el sensor de sonido

Para este ejercicio hemos tomado como referencia el horizonte, es decir, nuestra coordenada "X" actual, será también la de la meta. La coordenada "Y" de la meta está a una distancia lejana. Por tanto cada vez que nuestro robot se encuentre un obstáculo cercano lo evitará, orientándose de nuevo en la posición que empezó para seguir a su objetivo.

Este ejercicio sin duda es el que más "guerra" nos ha dado, llevándose las dos semanas de la práctica casi en su totalidad. Entre los problemas de calcular los puntos "x" e "y" actuales, calcular los puntos y ángulos de los vectores de repulsión y corregir las divisiones entre 0.

En resumen, el programa hace lo siguiente:

Bucle

Toma 5 medidas (a -60, -30, 0, 30 y 60 grados respecto a la situación inicial del ultrasonido)
Si hay algún obstáculo, calcula la fuerza resultante (suma de la fuerza de atracción y la fuerza de repulsión) y gira hacia el vector resultante.
Recorre unos centímetros.

Fin del Bucle

Al final con los problemas que hemos tenido el día de hoy, no hemos podido grabar ningún vídeo. Esperamos que la siguiente práctica no nos la juegue como nos lo ha hecho este ejercicio.

Prácitica 3 - Rodeando obstáculos usando sensores de contacto

Este ejercicio consiste en utilizar el sensor de contacto, para que este nos indique cuando hemos dado con un obstáculo. Hemos utilizado dos sensores de contacto, uno lo situamos en el frontal izquierdo y otro en el derecho, así si se activa el sensor frontal izquierdo, evitaremos el obstáculo por el lado derecho y al contrario para el sensor derecho.

Hemos uilizado la definición de comportamientos que nos han facilitado en la práctica. A continuación vamos a describir las tres clases que hemos utilizado y los métodos que estas contienen:

> DriveForward: La finalidad de esta clase es que el robot ande hacia delante mientras no se encuentre un obstáculo

 -takecontrol: Devolverá siempre verdadero, es decir siempre que no haya un obstáculo, tomará el control.

 -action: Cuando este método sea llamado, indicará a los dos motores que avancen.

 -supress: Parará los motores cuando llegue la clase "pierda" el control.

> HitObstacle: Esta clase evitará el obstáculo rodeándolo

 -takecontrol: Comprueba si se ha activado alguno de los dos sensores, para tomar el control.

 -action: Cuando tome el control, retrocederá una distancia, y rodeará el obstáculo por la izquierda o por la derecha dependiendo de cuál de los dos sensores se haya activado.

 -supress: Las variables booleanas que nos ayudan a saber si se ha detectado un obstáculo pasarán a tener el valor falso.

> BumperCar: En esta clase tendremos el programa principal. Consta de la siguiente declaración

Behavior b1 = new DriveForward();
Behavior b2 = new HitObstacle();
Behavior [] bArray = {b1, b2};
Arbitrator arby = new Arbitrator(bArray);
arby.start(); 

Instanciamos nuestras clases DriveForward y HitObstacle e indicamos que HitObstacle tendrá preferencia sobre DriveForward, dandole el índice más alto en el array bArray.

La forma de evitar el obstáculo ha sido bastante sencilla, hemos retrocedido una distancia, girado 60º y utilizando la función steer, hemos hecho una curva al rededor del objeto. Cuando ha sido ya superado, hemos vuelto a girar 60º para dejarle en la misma orientación antes de encontrarse el obstáculo:

Práctica 2 - Calibración del sensor de ultrasonidos

Matriz de covarianza:

43.78      11.31

11.31      8.806

El valor minimo que mide el robot son 8 cm, aunque la medida que da el robot es de 10 cm. La medida maxima que nos puede dar el robot es de 197cm (1,97m)

Práctica 2 - Sigue Pared

El ejercicio consiste en colocar el sensor ultrasonido más o menos unos 40º de la pared, siguiendo así está a la vez que puedes detectar si viene una esquina o un cambio de ángulo en la pared.

Este sin lugar a dudas ha sido el ejercicio que más nos ha costado "terminar" (ya que por falta de tiempo no hemos podido dejarlo como nosotros quisiésemos). A continuación una demostración del robot en funcionamiento:

El mayor problema que tenemos ocurre cuando tenemos 2 giros hacia la derecha seguidos y a continuación uno a la izquierda. Lo que ocurre es que nuestro ladrillo no coge la linea "buena" con la suficiente rapidez como para rehacerse de tres giros tan seguidos, abriéndose demasiado en el segundo giro a la derecha y comiéndose el siguiente a izquierdas.

Individualmente se puede ver que los giros en esquina cerrados (es decir que si no gira se chocaría contra la pared) son los  que más "daño" causan a nuestro robot recorriendo una linea extraña, ya que al tener el sensor de ultrasonido en la parte trasera, la distancia a la pared es mayor y la parte delantera puede tocar con la pared arruinando así el camino a seguir por el robot.

Como comentario final a este desquiciante, aunque divertido ejercicio (eso sí, cuando hace lo que debe, la alegría es inmensa =P) se nos sumó un error que no hemos conseguido identificar. Este consistía en que empezaba a girar sobre si mismo (rueda derecha hacia delante, rueda izquierda hacia atrás) quedándose tostado (sin mostrar nada en pantalla ni haciendo caso a los valores recibidos por el sensor ultrasonido) y sin posibilidad de recuperarlo. Al final nos hemos quedado con la incertidumbre de conocer la causa del error pero bueno, seguro que más adelante nos volverá a amargar la tarde...tiempo al tiempo.

Práctica 2 - Bump & Go! con sensor de ultrasonido

Este ejercicio es igual que el anterior pero cambiando el sensor de contacto por el de ultrasonido. La diferencia en nuestra clase "Sao", es que no entraremos en el if cuando se active el sensor, sino cuando la distancia leida por el ultrasonido sea menor o igual a 20 cm.

Práctica 2 - Bump & Go! con sensor de contacto

Este ejercicio consiste en que el robot detecte que se ha chocado con algo, para así dar marcha atrás y girar aleatoriamente un número de grados aleatorio (-360, 360) incluyendo el 0.

El código de nuestra clase es muy sencillo:

loop 

     si se activa el sensor {

         ir hacia atrás

         girar grados aleatorios

         ir hacia delante

     }

end loop

Tanto este ejercicio como el siguiente (utilizando el sensor de ultrasonido) han sido bastante rápidos. El único dato destacable que puede haber, es que hemos utilizado la clase Random para conseguir el número de grados aleatorio de al siguiente forma:

public static int GRADOS = 360;
int gradoAleatorio = rand.nextInt(GRADOS-(-GRADOS)) - GRADOS;

Así giraremos un número aleatorio en el rango [-360, 360]. Aunque a lo mejor no deberíamos haberlo hecho, hemos dado como resultado válido el girar 0 grados.

Práctica 2 - Control del robot por sonido

En este ejercicio, nuestro robot debe empezar a andar o pararse si damos una palmada. Nosotros hemos creado un método en nuestra clase ClapControl, que hace una media del valor más alto leído (de la palmada) y el menor, para así detectar mejor la palmada.

Hemos calibrado el sensor de sonido de la siguiente forma. Nuestro programa se queda esperando hasta que presionemos el botón ENTER, mientras lee los valores que recoge el micrófono y guarda tanto mayor valor recogido como el menor para posteriormente cuando hayamos pulsado el botón hacer una media de esos dos valores. En este periodo debemos dar un par de palmadas, para que coja una de ellas sea el valor más alto.

En cuanto salga de ese bucle, entraremos en el ejercicio en si. Cuando demos una palmada (si supera la media obtenida de la forma que hemos contado) el robot empezará a andar, si estaba parado sino se parará.

Como se puede ver en el vídeo no es la mejor solución, ya que hay veces que hace algún inicio-parón inesperado, pero no hemos encontrado una solución mejor  : (

Practica 2 - Obteniendo Información

En este ejercicio debemos mostrar los siguientes datos:
-Nombre del ladrillo
-Valor del sensor ultrasonido en milímetros
-Valor del sensor de luz configurado en pasivo
-Tensión de la batería en mV
-Memoria libre del ladrillo en Bytes

En este ejercicio tuvimos un problema un poco..."puñetero". Elegimos para el sensor ultrasonido el puerto S4...y en qué momento. Tras mucho trastear (y no probar con otros puertos), buscando por google encontramos un link al foro de lejos donde otro usuario tenia el mismo problema, resuelto de una forma increible...cambiando de puerto !!

Práctica 1 - Continuación

Cómo resumen hasta ahora, los primeros ejercicios básicos tanto de los motores como del LCD no han sido gran problema, al igual que el ejercicio de la odometría.

Cuadrado de calibración de movimiento:

Con anterioridad mostramos una prueba que hicimos con nuestro ladrillo para el ejercicio del cuadrado. Tras unos cambios hemos hecho correctamente el ejercicio con los siguientes resultados.

-Una sola vuelta:

Como podemos ver, hay unos 3 centímetros de diferencia entre el punto de inicio y el de llegada

- Varias vueltas con el mismo punto de salida:

Hay diferencias entre unas vueltas y otras, pero en general a una sola

vuelta no se aprecia tanto el error.

Diferencia entre puntos de salida y llegada, unos 33 milímetros

- Diez vueltas seguidas:

Tras diez vueltas (los números indican donde acaba cada vuelta)

se ve claramente la acumulación de los errores.

En este ejercicio no hemos tenido problemas con la programación ya que hemos diseñado un programa muy sencillo, con un bucle que se ejecutaba,  4 * número de vueltas, veces dependiendo de cuantas vueltas queriamos dar

for i = 0 hasta 4 * num_vueltas {

      avanzar 40 cm;

      rotar 90 grados;

}

Visualizar trayectoria:

Con este ejercicio hemos tenido más problemas, ya que al necesitar actualizar los valores de los ejes x e y por pantalla, el movimiento de los motores debían ser no bloqueantes. Esto entre otros problemas, provocaba que cuando se hiciese la comparación de la condición de nuestro bucle (si la distancia recorrida es igual a la distancia que quiero recorrer) no tuviese el valor deseado provocando un bucle infinito.

Finalmente hemos corregido este y los demás errores y el resultado es el siguiente:

Cálculo de la matriz de covarianza:

Hemos recogido los puntos donde termina cada cuadrado, haciendo 10 iteraciones.

x1: 3                                          y1: 2.2

x2: 2                                          y2: 2

x3: 3                                          y3: 2.5

x4: 2.5                                       y4: 2.5

x5: 2.5                                       y5: 1.5

x6: 3                                          y6: 2.5

x7: 2                                          y7: 1.5

x8: 1.5                                       y8: 1.5

x9: 2.5                                       y9: 2 

x10: 2.5                                     y10: 2.5

X=2.45                                      Y=2.07

La matriz resultante es:

0.2225                  1.385

1.385                    1.741

Práctica 1 - Montaje y video del cuadrado

El montaje del ladrillo fue fácil, siguiendo las instrucciones dadas en el manual.

Más tarde, para dibujar el cuadrado, le añadimos una base para apoyar un bolígrafo como se puede ver en el siguiente vídeo. Aunque llegamos a la solución del programa rápidamente, nos estuvimos peleando durante bastante tiempo con las medidas del "TachoPilot". El resultado es este:

Practica 0 (Ataque, abordaje y retirada)

Diario de a bordo (19:40):

Tras pelearnos con el calamar gigante de la compilacion conseguimos vencerle y así subir el ejecutable al ladrillo y despues de comprobar que funciona hemos hecho el abordaje al codigo en JAVA para ver como estaba escrito, pero nos hemos asustado, y decidimos volver a la isla del tesoro el jueves que viene

Practica 0 (INICIOS)

Diario de a bordo (16:30):
Hemos comenzado el segundo dia de practicas buscando las piezas que no teniamos en nuestra caja y hemos comenzado con la practica 0 y estamos mas LOST que un burro en un garaje

Inicio de las prácticas de robótica

Tras el recuento de piezas, acabamos de crear el blog y con ello a publicar nuestra primera entrada con una foto del grupo. 

De izquierda a derecha:

 Raphael, Angel y Jose