Estudiamos hoy el problema de la deriva en NXT y LeJOS. Se trata de uno de los problemas que tienen cualquier sistema que tenga que desplazarse, y en particular un robot NXT móvil: la deriva en la navegación. La deriva es el desvío de la trayectoria real respecto de la trayectoria prevista, y se debe a diversos factores. Cuanto menos deriva tenga un robot más preciso será su desplazamiento y menos se desviará de su destino objetivo al finalizar el movimiento. Este problema es muy común con los LEGO Mindstorms NXT debido a que no son robots con una forma única, sino que hay muchos montajes diferentes de robots móviles. La forma en que estén implementados los programas también influye en esta deriva.

Cosas que influyen en la deriva:

En el aspecto físico del robot hay muchas cosas que influyen en la deriva. Influye por ejemplo la diferencia de tamaño entre las ruedas, aunque está sea mínima porque una está mas hinchada que otra. Influye el peso del robot en gran medida, y por supuesto el cómo está distribuido este peso. Es importante que el mayor peso posible se encuentre sobre las ruedas tractoras, lo que impedirá que el robot se desvíe de su camino porque le pese demasiado la parte de delante o de atrás:

Influye la solidez del vehículo, que no modifique su forma mientras se va desplazando, su simetría. Otro aspecto importante es que no tenga rozamiento con nada, ya que el mínimo rozamiento podría crear una modificación de la trayectoria. La velocidad es bastante importante también, un vehículo que se desplace rápido es mucho más difícil de controlar que uno que lo haga lentamente.

La parte de implementación es también muy importante, por ejemplo si está usando dos motores para desplazarse, ambos deben ir con la misma potencia y velocidad. También es importante que a la hora de arrancar lo hagan simultáneamente, o el robot comenzará a moverse ya desviado de la trayectoria. Así mismo es importante que se detengan simultáneamente cuando el robot tenga que parar.

A pesar de todas estas precauciones es difícil mantener determinada trayectoria de forma continuada. Por ejemplo es imposible mantener a un robot realizando desplazamientos en forma de cuadrado de manera indefinida, y que siempre vuelva al mismo punto de partida, lo que pasará es que en cada vuelta el robot se desviará más y más hasta que ya nunca pase por su posición inicial.

Clase Pilot, la mayor precisión:

Una de las maneras de alcanzar una precisión muy alta a la hora de desplazar el robot es mediante la clase Pilot de LeJOS. Esta clase, que ya introduje en el artículo Manejo de motores avanzado: clase Pilot, introduce una nueva forma de manejar el robot. Lo primero que se hace es configurar un objeto de esa clase indicando que motores vamos a utilizar (dos motores, ya que esta clase esta solo diseñada para tribots), que distancia hay entre los puntos medios de las ruedas, y el diámetro de la rueda:

Pilot navegador = new TachoPilot(diametro_ruedas, distancia_ruedas, Motor.A, Motor.C);

Aunque las ruedas de los NXT tiene un diámetro de 5.6 cm es importante que pongáis un poco menos, sobre todo si vuestro robot pesa mucho, ya que el peso hace que las ruedas se aplanen un poco. La distancia entre las ruedas debe ser bastante precisa, ya que es de vital importancia sobre todo a la hora de las rotaciones.

A los métodos ya comentados en el artículo sobre la clase Pilot es importante añadir:

void setMoveSpeed(float distancia): Establece la velocidad del robot a la distancia que pongamos por segundo. Por ejemplo si ponemos 5, se moverá a 5 cm por segundo (que seán cm, pulgadas o una medida distinta solo depende de que tipo de medida hayamos usado para configurar el Pilot).

void setTurnSpeed(float grados): Establece la velocidad del robot, pero en este caso es en grados por segundo. Si ponemos 360 las ruedas realizarán una rotación completa por segundo.

Es importante controlar la velocidad, ya que si vemos que nuestro robot no es capaz de moverse con precisión a cierta velocidad deberíamos reducirsela. Otro método útil es:

void steer(float velocidad_giro, float angulo, boolean devolverControl): El robot se mueve en una trayectoria curva a la velocidad de giro indicada hasta que complete el número de ángulos deseado. Si devolver control es True el robot seguirá ejecutando las siguientes líneas de código mientras gira. No hace falta indicarle un angulo, si omitimos este campo el robot girará indefinidamente, o hasta que lo detengamos con otra instrucción.

Programa de prueba:

Para probar la precisión de la clase Pilot he creado un programa que describe un gran rectángulo de 240 cm. Cuanto más cerca quede el robot de la posición inicial más preciso será el programa. Además contamos con un montaje simétrico, relativamente ligero, y con la mayoría del peso sobre las ruedas tractoras. La rueda trasera no es la mejor posible, pero hace bien su función. El programa es el siguiente:

public class figuras {

/**
* @param args
*/
public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
Pilot navigator = new TachoPilot(5.4f, 10.4f, Motor.A, Motor.C);
LCD.clear();

navigator.reset();

//Rectángulo
navigator.travel(90);
navigator.rotate(90);
navigator.travel(30);
navigator.rotate(90);
navigator.travel(90);
navigator.rotate(90);
navigator.travel(30);
navigator.rotate(90);

LCD.drawInt((int)navigator.getTravelDistance(), 6,4);
Button.waitForPress();
}

}

Aquí tenéis el vídeo demostrativo del programa, en el podéis ver que la deriva es mínima (apenas un centímetro), habiendo recorrido 240 cm. y realizado tres rotaciones de 90º:

Ante cualquier duda podéis preguntar en el foro.