Práctica 4 - Control PID: el robot equilibrista

Para la realización de ésta práctica comenzamos rediseñando el robot, para eso tras unos primeros diseños erróneos, ya que el robot quedaba demasiado desequilibrado, buscando un poco por internet y comparando algunos modelos segway utilizamos el mostrado en la imagen, que conseguía cierta estabilidad.

A continuación nos informamos un poco más sobre la estabilización mediante PID, para ello utilizamos el siguiente enlace de la wikipedia: http://es.wikipedia.org/wiki/Proporcional_integral_derivativo. Un vez comprendido el controlador PID pasamos a ponerlo en práctica en el código. Para ello utilizamos las siguientes formulas que definen cada componente PID:

   P=Medida_Actual-Posicion_Inicial;

I = I+P;

D = P-Error_Anterior;

PID = P*Kp+I*Ki+D*Kd;

El valor obtenido del PID, será el que definirá la velocidad de los motores, de forma que si el PID es positivo (el robot cae hacia adelante) el robot avanzará y si el PID es negativo (el robot cae hacia atrás) el    robot retrocederá. 

Según este comportamiento, realizamos pruebas para ajustar cada constante proporcional. Observando el comportamiento del robot al modificar estas constantes llegamos a la conclusión de que la constante proporcional debería tener una valor suficientemente relevante como para recoger el error actual, la proporcional integral debía tener valores muy pequeños ya que al ser el sumatorio de los errores aumentaba mucho la velocidad del motor, respecto a la constante proporcional derivativa decidimos ajustarla a valores muy altos, ya que al ser la diferencia entre el error actual y el error anterior si esta diferencia es mucha quiere decir que el robot estará muy desequilibrado por lo que necesitará una mayor velocidad y al contrario si la diferencia es pequeña significará que el robot esta relativamente equilibrado con lo que la velocidad no deberá aumentar en exceso. Así decidimos que la mejor configuración y la que mejor resultados nos dio es la siguiente: Kp=30, Ki=2,Kd=160.

A continuación mostramos el robot realizando el equilibrio:

y el siguiente muestra como vuelve a buscar el equilibrio tras desequilibrarle:

Práctica 3 - Navegación local evitando obstáculos

Una nueva práctica, en la que en primer lugar tuvimos que modificar el diseño del robot ya que necesitábamos hacer uso de dos sensores de luz y acoplar un motor para que el sensor de ultrasonido pueda girar.

Para ésta práctica utilizamos los métodos para programar comportamientos que proporciona Lejos, gracias a estos métodos se simplifican bastante la realización de los enunciados, además de ser más legibles.


Comportamiento de evitación de obstáculos usando sensores de contacto:

     Para éste ejercicio no tuvimos ningún problema, nos llevo algo de tiempo ajustar los giros que debíamos ejecutar para que el robot quedara en la misma posición con la que llegaba al objeto. Para ello primero realizamos un giro prácticamente sobre si mismo, hacemos que avance durante unos centímetros, realizamos otro giro,avanzamos hasta dejar atrás el obstáculo y realizamos los mismos giros anteriores pero a la inversa. De esta forma recuperamos la posición inicial.

Comportamiento de evitación de obstáculos usando el sensor de ultrasonidos:


Este ejercicio es el que más esfuerzo nos ha llevado, ya que previamente tuvimos que realizar algunos cálculo para definir las fórmulas por las que se regirá el movimiento del robot al encontrarse algún obstáculo. Una vez definidas estas fórmulas el código simplemente realiza estos cálculos y ejecuta el giro oportuno para evitar el obstáculo.
La fuerza atractiva la fijamos en la distancia que obtenemos del sensor de ultrasonido para la componente x. Esta fuerza la multiplicamos por una constante = 3 para que la fuerza atractiva sea lo suficientemente grande como para que la fuerza resultante posterior siga el sentido fijado, en este caso hacia delante del robot. La componente y la fijamos a cero para que la fuerza atractiva siga siempre la dirección del robot.
Para calcular la fuerza repulsiva multiplicamos tanto la componente x como la componente y por la inversa de la distancia, para que de esta forma para distancias cortas crezca rápidamente y para distancias largas esta sea muy pequeña. Luego las multiplicamos por una constante BETA = 2000, para que las componentes sean lo suficientemente grandes, y el movimiento del robot se vea afectado.

FrX=cos(degree)*(1/d)*BETA

FrY=sin(degree)*(1/d)*BETA

Una vez calculados estos datos, realizamos la suma vectorial, con la que obtenemos los grados a los que deberá girar el robot para evitar el obstáculo.

Comportamiento ir hacia la luz:


El problema de este ejercicio consistía en ajustar un rango entre ambas mediciones de los sensores de luz para que el robot pueda ir hacia delante cuando este dentro de este rango y en caso contrario girar hacia el sensor que tenga más intensidad de luz. En primer lugar calibramos los sensores para que tome la intensidad de luz ambiente como el 0%.

Comportamiento ir hacia la luz evitando obstáculos:


En este ejercicio decidimos usar el método de evitación de obstáculos utilizando sensores. El ejercicio no es más que la combinación de las clases del ejercicio 1 y el 3. En este caso, el comportamiento más prioritario es el de evitar obstáculo, de forma que en el momento que lo detecte lo evite y posteriormente continúe siguiendo a la luz.

Practica 2 - Obteniendo información sensorial

Aquí estamos de nuevo con un nueva práctica. Para esta práctica hemos incorporado al robot todos lo sensores, aunque el de sensor de luz simplemente lo utilizamos para obtener información en el ejercicio 1.

Obteniendo información:


En este ejercicio nos resulto sencillo obtener la información de los sensores,ya que disponíamos de todos los métodos, sin embargo para obtener el nombre y la memoria tuvimos que buscar bastante en la API de Lejos. Para el nombre: NXTCommDevice.getName(), para la batería nos costo un poco entender el método ya que primero había que llamar al método estatico getRuntime() que es una instancia de sí mismo.

Control del robot por sonido:

Para este ejercicio el mayor problema fue la calibración previa del sensor de sonido. En un principio lo hicimos realizando 100 medidas y quedándonos con el valor más alto, para estimar el valor de referencia del sonido. Pero este valor nos salía siempre demasiado alto incluso en habitaciones sin apenas sonido. Así decidimos realizar una media con estos valores y sumarle un valor fijo. Por lo demás el ejercicio no nos dio muchos problemas, salvo porque tuvimos ponerle un tiempo de espera tras coger la medida del sonido, para que no lo cogiera dos veces.

Bump & Go! usando sensores de contacto:

El único problema que tuvimos fue entender el método Math.random(), en el que teníamos que fijar el valor máximo, y el valor desde el que queríamos que empezaran los números, pusimos un margen de [45º,315º], es decir, Math.random()*316+45.

Bump & Go! usando sensores de ultrasonido:

En este caso, superando el obstáculo anterior del método Math.random(), tuvimos problemas con la primera medida que nos daba el sensor de ultrasonido, que siempre era 255. Pensamos que esto era debido a que el sensor al principio tardaba en reaccionar, miramos la API y con el método getMode()  y comprobamos que al principio nos daba -1. Lo solucionamos poniendo un while que actúa como barrera hasta que el modo del sensor es distinto de -1.

Comportamiento sigue-pared para salir de un laberinto:


En primer lugar, tuvimos que añadirle al robot base giratoria para poder mover la cabeza del robot. Esto era necesario para poder poner el sensor de ultrasonido a unos 45º para que pudiera localizar las esquinas con antelación y así poder girar antes de chocarse. Planteamos el ejercicio, poniendo un rango de error al robot y que cuando superara este error girara a la izquierda o a la derecha según la medición obtenida. Para ello pensamos en el método forward() para que el robot avanzara y el método steer(float turnRate, float angle)  poniendo el valor de turnRate a 100 para que la rueda interior se pare y la exterior gire completamente, este valor lo pusimos en negativo para que girase a la izquierda y positivo para la derecha. El valor de angle lo fijamos en 2 para que realizase pequeños giros. Pero con este método y aun no tenemos explicación tras realizar un giro el código se bloqueaba y o no ejecutaba el método forward o se bloqueaba antes. Esto lo solucionamos cambiando este método por el mismo pero tan sólo con el parámetro turnRate, de esta forma el código no se bloqueaba pero el robot giraba muy bruscamente, así que antes de realizar un giro redujimos la velocidad del motor.

Calibración del sensor de ultrasonidos:

Calibración del sensor de ultrasonidos

Practica 1 - Primeros pasos con el API e instalacion eclipse (cont)

Seguimos con la continuación de la práctica 1. Esta vez implementamos con la clase TachoPilot los primeros movimiento del robot. Para ello comenzamos con el primer ejemplo, en el que tuvimos que modificar el ancho de vía que debíamos pasar como parámetro al constructor de la clase TachoPilot, para que se ajustara a nuestro diseño.
A continuación mostramos un vídeo, donde podemos observar la navegación en línea recta:

Después realizamos un nuevo código para que el robot dibujase un cuadrado. Con el código no tuvimos ningún problema, pero al realizar las pruebas en el papel comprobamos que el rotulador no estaba colocado en el eje de rotación del robot. De forma que tuvimos que modificar totalmente el diseño del robot y así  modificar el ancho de vía del constructor de la clase.
Mostramos el vídeo en cuestión de la prueba con el diseño modificado:

El rango de error cometido al dibujar el cuadrado ha sido:
ErrorCuadrado


Para el cálculo de la matriz de covarianza utilizamos el ejercicio de la línea recta, los resultados obtenidos fueron los siguientes:

MatrizCovarianza



Por último abordamos el ejercicio de la visualización de la trayectoria en la pantalla. Aquí tuvimos bastantes problemas para comprender debidamente las fórmulas, ya que una vez realizado el movimiento y hacer la rotación no partíamos desde esta última posición. Por lo tanto el resultado en pantalla no era una línea continua. Para solventarlo fuimos sumando la ultima posición (x e y) a la fórmula para que partiera desde el último punto. Otro pequeño problema que tuvimos, fue al transformar el espacio real al espacio de la pantalla, en un principio hicimos la transformación con las medidas que nos da LCD.SCREEN_WIDTH y LCD.SCREEN_HEIGHT. Así en la pantalla se dibujaba un rectángulo en vez de un cuadrado, ya que las medidas de la pantalla forman un rectángulo. Cuando nos dimos cuenta de esto hicimos la transformación del eje x e y con la misma medida, de esta forma queda bien definido el cuadrado en pantalla como mostramos a continuación:

Practica 1 - Primeros pasos con el API e instalacion eclipse

Aquí estamos de nuevo, con algunas novedades.
Comenzamos esta primera práctica obligatoria con la configuración de eclipse, seguimos los pasos y lo configuramos sin ningún problema. Tras esto comenzamos a familiarizarnos un poco con el API de leJOS, realizamos los primeros programas de control básico del motor, utilizando los métodos de la clase Motor. Tan sólo tuvimos algunas dudas de lo que pedía algún programa, en un primer momento pensábamos que los dos últimos programas tan sólo tenían que moverse 45 grados y detenerse, hasta que entendimos bien el método rotateTo y nos dimos cuenta de que se tenía que mover el motor continuamente y hacer las cuentas oportunas (sumarle 45 grados continuamente al argumento que se le pasa a rotateTo) para que hiciera lo mismo que el programa BasicMotor2.
Después realizamos el siguiente punto, la visualización de la odometría del motor, sin ningún problema, aunque nos ayudo utilizar el método Button.ESCAPE.isPressed como condición de salida de nuestros programas, y no tener que estar reiniciando el ladrillo todo el rato.
Y hasta aquí nuestros primeros pasos con leJOS, la siguiente semana seguiremos instruyendo a nuestro Pepon.

Un Saludo.

Bienvenidos

Hola somos Daniel, Roberto y Ricardo, abrimos este blog para ir recogiendo información sobre las prácticas de la asignatura de Robótica. En él iremos publicando los avances que hagamos con nuestro robot.

Un saludo.