Seguimos jugando con los motores de corriente continua y la controladora Motor Shield V1 de Adafruit.

Veremos la teoría básica de giro sin volante de dirección.

Programaremos los movimientos básicos de robot.

 

 

Robot Rover 4×4

 

 

En las sesiones previas hemos visto los conceptos básicos de los motores CC y cómo usar una controladora tipo MotorShield, para gobernar varios motores simultáneamente. Pero de lo que no hemos hablado es de una cuestión básica que a algunas personas les suele parecer difícil de entender: El giro.

Como los automóviles forman parte de nuestra vida diaria, comprendemos con facilidad el principio de giro que usan medinate el volante, y tenemos una idea intuitiva de como este desvía la dirección de trazado de las ruedas con respecto a la dirección del movimiento del coche. De ese modo, las ruedas delanteras trazan siempre la tangente a la curva del movimiento.

Pero quizás no resulte tan evidente que las dos ruedas delanteras de los modernos coches, no pueden girar a la misma velocidad en curva, si queremos mantener la estabilidad y gobernabilidad del vehículo. 

 

Pues es bastante fácil, y si lo piensas es el mismo principio que usan los tractores en el campo, que pueden hacer giros impensables para un automóvil, o los tanques de guerra y excavadoras que se desplazan mediante orugas metálicas (sin dirección móvil).

Como en los automóviles disponemos de un único motor de explosión, tenemos que montar un complicado sistema mecánico, que reparta la tracción entre las ruedas motoras, pero en los coches eléctricos en general y en nuestro Rover 4×4 en particular, disponemos de un motor por rueda, por lo que podemos controlar la velocidad de cada una independientemente.

Esto es así, incluso en los vehículos híbridos comerciales, que usan un motor de combustión para recargar las baterías centrales, pero disponen de un motor eléctrico por rueda, lo que nos permite además de tracción 4×4, hacer algunas cosas poco habituales en un coche tradicional, 

 

Controlando la velocidad de cada rueda podemos soslayar la necesidad de una dirección mecánica y podemos hacer movimientos que sorprenderían bastante a un conductor de automóvil, incluyendo girar sin tocar el volante.

El truco esta precisamente en hacer girar cada rueda a  diferente velocidad, de modo que fuercen al vehículo a girar en la dirección y radio deseados.

Si las ruedas del lateral derecha giran al doble de velocidad que las del lateral izquierdo, nuestro Rover girara forzosamente a la izquierda y viceversa, haciendo un giro continuo y tanto más suave cuanto menor sea la diferencia de velocidad entre el giro de los dos laterales.

El radio de giro será más o menos cerrado, dependiendo de la relación entre las velocidades de los laterales. No solo podemos hacer girar el Rover, sino que además podemos controlar lo cerrado del giro. Si paramos completamente uno de los laterales y mantenemos el otro, el giro será muy acusado.

Con tracción independiente a las cuatro ruedas podemos incluso hacer girar las ruedas de un lateral en sentido contrario al giro del otro lado, y en este caso el Rover girará sobre su centro de gravedad sin desplazarse.

Para gobernar nuestro Rover con tracción a las 4 ruedas nos bastara controlar de forma diferencial la velocidad de giro de las ruedas, y esto ya sabemos hacerlo de las sesiones previas. Así que vamos a pasar al programa.

 

 

Vamos a empezar con algunas definiciones, como siempre:

Prog_94_1

#include <AFMotor.h>

AF_DCMotor Motor1(1);
AF_DCMotor Motor2(2);
AF_DCMotor Motor3(3);
AF_DCMotor Motor4(4);

int Vel = 255 ;       // Define la velocidad base del Rover
float P = 0.25 ;      // Proporcion de giro

Incluimos la librería e instanciamos las cuatro ocurrencias de los 4 motores. Después creamos una variable que usaremos para contener la velocidad a la que deseamos mover el Rover. De ese modo variando el contenido de Vel, variaremos la velocidad general del vehículo, y definimos P como una variable que indicará la proporción de velocidad entre un lado y el otro cuando queramos girar.

Como vamos a girar modificando la relación de velocidades de los motores, nos conviene empezar definiendo una función como esta, que usaremos para programar la velocidad de cada rueda independientemente:

void SetVel(int v1, int v2, int v3, int v4)
   {       Motor1.setSpeed(v1);
           Motor2.setSpeed(v2);
           Motor3.setSpeed(v3);
           Motor4.setSpeed(v4);
   }

Recuerda que estas órdenes fijan la velocidad de cada motor pero aún no se ponen en marcha. Para eso vamos a definir algunos movimientos básicos, como Avance, Retroceso y Paro:

void Avance()
    {  SetVel(Vel,Vel,Vel,Vel);        // Misma velocidad a las 4 ruedas
       Motor1.run(FORWARD) ;
       Motor2.run(FORWARD);
       Motor3.run(FORWARD);
       Motor4.run(FORWARD);
   }

void Retroceso()
   {  SetVel(Vel,Vel,Vel,Vel);          // Misma velocidad a las 4 ruedas
      Motor1.run(BACKWARD) ;
      Motor2.run(BACKWARD);
      Motor3.run(BACKWARD);
      Motor4.run(BACKWARD);
   }

void Paro()
   {  Motor1.run(RELEASE);
      Motor2.run(RELEASE);
      Motor3.run(RELEASE);
      Motor4.run(RELEASE);
   }

Para girar ya hemos comentado que bastará con mover a diferente velocidad los laterales del Rover. Podemos montar un sistema de giro abierto haciendo que uno de los laterales se mueva a digamos 1/3 de la velocidad del otro lado, usando la variable P que definimos al principio.

En un Rover real, podemos alterar el radio de giro, leyendo un potenciómetro, como una palanca, de modo que a medida que movemos la palanca hacia la derecha, por ejemplo, va reduciendo proporcionalmente la velocidad de las ruedas de la derecha.

Os lo dejo como ejercicio, porque no creo que tengáis dificultad y ya hablaremos de ello cuando veamos cómo usar un mando a distancia para gobernar el Rover.

 

void giroIzquierda()
   { 
     int v = Vel * P ;
     SetVel( v, Vel, v, Vel) ;

     Motor1.run(FORWARD) ;
     Motor2.run(FORWARD);
     Motor3.run(FORWARD);
     Motor4.run(FORWARD);
   }

void giroDerecha()
   {  
      int v = Vel * P ;
      SetVel( Vel, v, Vel, v) ;

      Motor1.run(FORWARD) ;
      Motor2.run(FORWARD);
      Motor3.run(FORWARD);
      Motor4.run(FORWARD);
   }

Y ya solo nos falta hacer una prueba en movimiento real. Vamos a programar el movimiento, (Porque aún no tenemos control remoto sobre la dirección).

void loop()
   {      
       Avance();
       delay(2000);
       Retroceso();
       delay(2000);
       giroIzquierda();
       delay(3000);
       giroDerecha();
       delay(3000);
   }

¿Fácil, No? Avanza, retrocede y gira a un sentido y al otro.  Vamos a probar como se mueve, de este modo tan sencillo.

 

 

Para mover el Rover la primera intención suele ser usar el cable de USB y dejar el Rover con el conectado para moverlo, pero aunque parece una buena idea, me temo que no va a funcionar.

El cable USB puede mover los motores sin ninguna carga, pero escasamente podrá mover el Rover por una alfombra, ya que los motores tienen la mala costumbre de consumir mucha intensidad y el USB típico no pasa de medio Amperio máximo.

Tendréis que usar pilas y os recomiendo que sean 6 pilas, no 4, porque con el alimentador externo, necesitamos por lo menos 7V para darnos 5V con garantías.(y 4 pilas x 1,5V = 6V, lo que resulta insuficiente)

Además y por si fuera poco, los motores baratos suelen ser muy poco eficientes energéticamente y estos, creedme, son muy baratos.

 

Para probar el movimiento vamos a necesitar un paquete de pilas externo y unas baterías. Algo así como esto:

El conector que veis, en la imagen de arriba, encaja perfectamente en vuestro Arduino (En ese conector que nadie usa, ya ves) y nos ahorrará el llevar un cable colgando, que siempre acaba liándose con el movimiento.

Montando todo esto junto, tenemos el program

Prog_94_2,

¡Accede al contenido!

y este es un mini video con el resultado

 

No puedo resistir la tentación de mostraros lo que ocurre si hacemos girar las ruedas de los laterales en sentidos contrarios, veamos el programa Prog_94_3:

void giroIzquierda()
   { 
       SetVel( Vel, Vel, Vel, Vel) ;

       Motor1.run(BACKWARD) ;
       Motor2.run(FORWARD);
       Motor3.run(BACKWARD);
       Motor4.run(FORWARD);   
   }

void giroDerecha()
   { 
       SetVel( Vel, Vel, Vel, Vel) ;

       Motor1.run(FORWARD) ;
       Motor2.run(BACKWARD);
       Motor3.run(FORWARD);
       Motor4.run(BACKWARD);   
   }

Este tipo de giro nos resulta un tanto contra intuitivo, porque los coches no pueden hacerlo, pero funciona muy bien y hace que el Rover gire sobre su propio centro geométrico.

Aquí va el mini video correpsondiente:

Y ya solo nos queda definir una manera de gobernar el Rover 4×4 mediante algún sistema de control remoto. En la próxima sesión veremos que opciones tenemos y cual elegir.

 

 

 

 

Seguimos usando la controladora de Adafruit MotorShield, y poco queda ya por hacer con ella para controlar motores de CC.

Hemos visto la teoría básica de como girar mediante velocidad diferencial con tracción  a las 4 ruedas.

Vimos los programas básicos que gobierna el giro del Robot incluyendo el giro sobre su centro[/three-fourth]