Robot móvil controlado por bluetooth Deja un comentario

En este tutorial, construiremos un robot móvil, el cual será controlado por bluetooth desde nuestro celular a través de un aplicativo Android.

Materiales

Empecemos describiendo los principales materiales:

Arduino

Podemos usar cualquiera de las placas Arduino, nosotros usaremos el Arduino Uno R3 por ser uno de los más usados.

Modulo Bluetooth HC-06 o HC-05

Este módulo nos sirve para que nuestro Arduino y el celular puedan comunicarse a través de bluetooth. Para esta aplicación podemos usar cualquiera de los dos modulo pues los trabajaremos en modo esclavo.

Si usan un HC-06 estaría listo para usar, si usan un HC-05 deben verificar que esté configurado como esclavo. La velocidad con la que vamos a trabajar es a 9600baudios, que es la velocidad que viene por defecto tanto en el HC-06 como en el HC-05.

Nosotros usaremos el HC-06 con su configuración por defecto, si desean realizar configuraciones adicionales puede consultar nuestros tutoriales:
Configuración del módulo bluetooth HC-06 usando comandos AT

Configuración del módulo bluetooth HC-05 usando comandos AT

Driver Puente H

El puente H es el que nos permite invertir el giro de un motor, necesitamos un puente H que tenga dos canales para poder controlar dos motores.

Entre los puente H más comunes tenemos el L298N, L293D, TB6612FNG y el L9110S , Algunos módulos aparte de los pines para controlar la dirección tienen un pin (Enable ) por donde podemos enviar PWM y controlar la velocidad, pero para este tutorial podemos usar cualquiera pues solo controlaremos dirección.

Motores con Llanta:

Básicamente  2 motores DC con caja reductora y su respectiva llanta, una velocidad promedio puede ser 100RPM, pero dependerá de la velocidad que uno desee.

El voltaje dependerá de la batería, por ejemplo si tienen una batería de 6V o de 3.7V se puede trabajar con el motor amarillo, si tienen una batería de 12V  o 9V pueden trabajar con los micro motores, Si alimentamos un motor con un voltaje inferior al nominal, su velocidad disminuye, en cambio sí alimentamos con un voltaje superior podemos malograr el motor, por eso debemos de tener en cuenta las especificaciones técnicas del motor.

Batería

Esto tal vez sea lo más difícil de establecer, lo primero que hay que tener en cuenta es el voltaje. Arduino trabaja con un  voltaje entre 6 y 12V, aparte de esto hay que tener en cuenta el voltaje del motor. También hay que considerar la corriente y la capacidad, por ejemplo si usamos una pila económica de 9V nos durará menos de un minuto, se recomienda que la capacidad sea superior a 500mAH

A continuación mostramos las opciones que pueden usar dependiendo del motor que tengan:

Motor de  6V:

Opción 1: 4 pilas AA para los motores y una de 9V para el Arduino

Opción 2: 1 celda de litio (batería de celular) para los motores y una pila de 9V para el Arduino

Opción 2: Cualquier batería superior a 6V (de suficiente corriente) y un step down para bajar el voltaje.

Motor de 12V:

Opción 1: Pila duracell 9V

Opción 2: batería lipo o litio de 2 o 3 celdas.

Opción 3: cualquier Batería de 12V  (de suficiente corriente)

Opción 4: 1 celda de litio (batería de celular) o batería de 3.7V y un step Up para aumentar el voltaje.

Independiente del valor del voltaje de la batería podemos usar conversores DC-DC para aumentar (step up) o reducir (step down) el voltaje.

Chasis y rueda loca

Esto dependerá del diseño de cada uno, pueden hacerlo, o comprar uno hecho. El chasis básicamente es en donde se va a poner los dos motores con llanta y los demás componentes, adicionalmente se necesita una rueda giratoria o una ballcaster, que será el tercer punto de apoyo junto a las otras dos llantas.

Otros accesorios:

Adicionalmente podemos necesitamos un protoboard, cables DuPont Macho-Macho y Hembra-Macho y cablecillo para soldar los motores.

1. Ensamblando la parte mecánica de nuestro Robot Móvil

Existen varios diseños en internet que nos pueden ayudar, así como existen plataformas comerciales. Esto dependerá de cada uno,

Para nuestro tutorial usaremos la locomoción diferencial, que utiliza dos ruedas principales que dan la tracción y por diferencia de velocidad en estas podremos realizar giros. Usaremos esta configuración por ser fácil de implantar, a diferencia de la configuración Ackerman (la que usan los vehículo motorizados) que es más complicado de implementar la parte mecánica.

La principal diferencia entre estas dos configuraciones es en el giro del robot, en la configuración diferencial tenemos que invertir el giro en uno de los motores o simplemente disminuir la velocidad, en cambio en la configuración Ackerman necesitamos de un servomotor para girar las llantas delanteras.

Como indicamos nosotros vamos a trabajar en la configuración diferencial y adicionalmente a las dos llantas principales necesitamos una o dos ruedas giratorias que nos servirán de apoyo, esta rueda lo podemos poner adelante y/o atrás.

2. Conexiones eléctricas:

A continuación mostramos dos posibles conexiones dependiendo del tipo de motor que tengan.

2.1 Para motores DC de 3-6VDC

Para este caso si necesitamos usar una sola batería, es mejor usar un step down y no alimentar los motores con los 5V del Arduino, pues sobrecalentaríamos el regulador interno que tiene.
La betería tiene que ser superior a 6V para que pueda trabajar nuestro Arduino pero se recomienda que tampoco sea superior a los 12V, adicionalmente la batería debe tener suficiente corriente para que pueda alimentar los dos motores, de lo contrario nuestro Arduino se va a estar reseteando cuando empiecen a funcionar los motores.

Antes de instalar el step down hay que regular al voltaje que deseamos, puede ser 6v, 5V, 3v, etc, variando este voltaje también estamos modificando la velocidad de los motores.

2.2 Para motores DC de 12V DC

 

De esta forma el voltaje que ingresa a los motores es el mismo que el de la batería.
Dependiendo del tipo de motor puedes usar la batería que más se adecue a tu necesidad, teniendo en cuenta que tenga la suficiente corriente y duración.

Las conexión son similares para otros tipos de Drivers Puente H, pueden revisar nuestro tutorial de uso del L298N en caso estén usando ese módulo.

3. Programación de  nuestro Robot Móvil

Para que tengan una mayor comprensión trabajaremos el programa en dos etapas:

3.1 Test de movimientos

En este primer ejemplo probaremos los diferentes movimientos del robot, lo realizaremos aun sin conexión bluetooth para poder entender mejor el programa.

Para poder programar necesitamos desconectar el módulo bluetooth, podemos desconectar todo el módulo o simplemente dejar libre el RX (pin 0) del Arduino

El código es el siguiente:

//Pines de conexión del driver
int Pin_Motor_Der_A = 8;
int Pin_Motor_Der_B = 9;
int Pin_Motor_Izq_A = 10;
int Pin_Motor_Izq_B = 11;

void setup() {
  // inicializar la comunicación serial a 9600 bits por segundo:
  Serial.begin(9600);
  // configuramos los pines como salida
  pinMode(Pin_Motor_Der_A, OUTPUT);
  pinMode(Pin_Motor_Der_B, OUTPUT);
  pinMode(Pin_Motor_Izq_A, OUTPUT);
  pinMode(Pin_Motor_Izq_B, OUTPUT);
}

void loop() {
  //movemos el robot hacia delante por 2 segundos
  Mover_Adelante();
  delay(2000);
  //movemos el motor a la derecha por 2 segundos
  Mover_Derecha();
  delay(2000);
  
}

void Mover_Adelante()
{
  digitalWrite (Pin_Motor_Der_A, HIGH);
  digitalWrite (Pin_Motor_Der_B, LOW);
  digitalWrite (Pin_Motor_Izq_A, HIGH);
  digitalWrite (Pin_Motor_Izq_B, LOW);
}
void Mover_Retroceso()
{
  digitalWrite (Pin_Motor_Der_A,LOW );
  digitalWrite (Pin_Motor_Der_B,HIGH );
  digitalWrite (Pin_Motor_Izq_A,LOW );
  digitalWrite (Pin_Motor_Izq_B,HIGH );
}
void Mover_Derecha()
{
  digitalWrite (Pin_Motor_Der_A,LOW );
  digitalWrite (Pin_Motor_Der_B,HIGH );
  digitalWrite (Pin_Motor_Izq_A,HIGH);
  digitalWrite (Pin_Motor_Izq_B,LOW);
}
void Mover_Izquierda()
{
  digitalWrite (Pin_Motor_Der_A,HIGH);
  digitalWrite (Pin_Motor_Der_B,LOW);
  digitalWrite (Pin_Motor_Izq_A,LOW );
  digitalWrite (Pin_Motor_Izq_B,HIGH );
}
void Mover_Stop()
{
  digitalWrite (Pin_Motor_Der_A, LOW);
  digitalWrite (Pin_Motor_Der_B, LOW);
  digitalWrite (Pin_Motor_Izq_A, LOW);
  digitalWrite (Pin_Motor_Izq_B, LOW);
}

Como se observa la programación es fácil, se ha programado cada movimiento del robot en funciones separadas, las cuales llamamos desde el void loop(),

Para probar los movimientos hay que ir probando cada función y ver si nuestro robot se mueva de la misma manera como se lo ha programado, por ejemplo así como está el código, después de encender o resetear el Arduino debe moverse hacia delante por 2 segundos, seguidamente debe girar a la derecha por dos segundos más y lego repetir la secuencia, si el robot gira en dirección equivocada, entonces debemos de cambiar la polaridad de motor que gira en sentido erróneo.
Podemos ir probando los movimientos de forma individual reprogramando cada vez para cambiar el movimiento o programar todos a la vez con pausas entre movimientos, eso dependerá de cada uno, después de estar seguros que nuestro robot funciona correctamente pasamos a implementar la comunicación bluetooth.

2.2 Robot Móvil controlado por Bluetooth

Para controlar el Robot usaremos una aplicación en nuestro celular, para esto debemos de instalar en nuestro celular la siguiente aplicacion.

Naylamp Car: Instalar desde Google Play

La aplicación consta de 4 botones una para cada dirección, al presionar el botón para mover adelante, la aplicación envía por bluetooth el carácter ‘a’ y lo sigue enviando constantemente mientras se tenga presionado. De igual manera para los otros botones, la aplicación envía ‘r’ para retroceso, ‘i’ para izquierda y ‘d’  para mover a la derecha.

Nuestro  Arduino debe de leer estos 4 caracteres y realizar el movimiento, además al no tener un botón stop, nuestro Arduino deberá detener de forma automática los movimientos cuando no se tenga presionado ningún botón.

Antes de cargar el programa a nuestro Arduino debemos de desconectar los cables de nuestro bluetooth y después de terminado la carga podemos volverlo a conectarlo.

El  código que debemos de cargar a nuestro Arduino es el siguiente:

//Pines de conexión del driver
int Pin_Motor_Der_A = 8;
int Pin_Motor_Der_B = 9;
int Pin_Motor_Izq_A = 10;
int Pin_Motor_Izq_B = 11;

int tiempo=0;
void setup() {
  // inicializar la comunicación serial a 9600 bits por segundo:
  Serial.begin(9600);
  // configuramos los pines como salida
  pinMode(Pin_Motor_Der_A, OUTPUT);
  pinMode(Pin_Motor_Der_B, OUTPUT);
  pinMode(Pin_Motor_Izq_A, OUTPUT);
  pinMode(Pin_Motor_Izq_B, OUTPUT);

}

void loop() {

  if (Serial.available()) {
     char dato= Serial.read();
     if(dato=='a')
     {
        Mover_Adelante();
        tiempo=0;
     }
     else if(dato=='r')
     { 
        Mover_Retroceso();
        tiempo=0;
     }
     else if(dato=='d')
     { 
        Mover_Derecha();
        tiempo=0;
     }
     else if(dato=='i')
     { 
        Mover_Izquierda();
        tiempo=0;
     }   
   
  }

  if(tiempo<200) // 100 cilcos de 1ms 
  {    
    tiempo=tiempo+1;
  }
  else   //ya transcurrió 100ms (100ciclos)
  {
    Mover_Stop();
  }
  
  
  delay(1); //pasusa de 1ms por ciclo
  
}

void Mover_Adelante()
{
  digitalWrite (Pin_Motor_Der_A, HIGH);
  digitalWrite (Pin_Motor_Der_B, LOW);
  digitalWrite (Pin_Motor_Izq_A, HIGH);
  digitalWrite (Pin_Motor_Izq_B, LOW);
}
void Mover_Retroceso()
{
  digitalWrite (Pin_Motor_Der_A,LOW );
  digitalWrite (Pin_Motor_Der_B,HIGH );
  digitalWrite (Pin_Motor_Izq_A,LOW );
  digitalWrite (Pin_Motor_Izq_B,HIGH );
}
void Mover_Derecha()
{
  digitalWrite (Pin_Motor_Der_A,LOW );
  digitalWrite (Pin_Motor_Der_B,HIGH );
  digitalWrite (Pin_Motor_Izq_A,HIGH);
  digitalWrite (Pin_Motor_Izq_B,LOW);
}
void Mover_Izquierda()
{
  digitalWrite (Pin_Motor_Der_A,HIGH);
  digitalWrite (Pin_Motor_Der_B,LOW);
  digitalWrite (Pin_Motor_Izq_A,LOW );
  digitalWrite (Pin_Motor_Izq_B,HIGH );
}
void Mover_Stop()
{
  digitalWrite (Pin_Motor_Der_A, LOW);
  digitalWrite (Pin_Motor_Der_B, LOW);
  digitalWrite (Pin_Motor_Izq_A, LOW);
  digitalWrite (Pin_Motor_Izq_B, LOW);
}

Como se observa al código del primer ejemplo solo le hemos agregado la parte de la comunicación serial, en donde leemos el dato y comparamos para ver si es el carácter correspondiente para realizar su respectivo movimiento, adicionalmente si durante 100 milisegundos no llega ningún dato detenemos el robot, y tan pronto le llega uno de los datos reiniciamos la cuenta de los 100ms.

Una vez que tengan todo listo, tan solo hay que abrir la App, conectarnos a nuestro modulo bluetooth y empezar a mover nuestro robot con los botones.