Mucha gente me pregunta sobre cómo hacer un pequeño robot. La verdad es que es una pregunta un póco dificil de responder ya que hay muchas maneras de hacerlo y por supuesto muchos tipos de robots diferentes. En la gran mayoría de los casos, se suelen montar robots tipo coche con servomotores o motores de corriente contínua. Esto es lo que os voy a mostrar hoy, un robot con tracción a las cuatro ruedas con motores de corriente contínua. La idea aqui no es hacer un gran robot inteligente que sea capaz de traernos el desayuno a cama (aunque sería la leche!), sino la base para crear un pequeño robot con tracción a las cuatro ruedas basado en Arduino que os pueda servir de base para un robot más completo e inteligente, incluyendo distintos tipo de sensores como los de distancia, GPS o incluso telemetría.
Es un tutorial muy básico que todo el mundo puede realizar de forma sencilla y en muy poco tiempo. Luego de tener la base, podemos ir añadiendo más complejidad. Por supuesto no dudeis en dejar vuestro comentario, dudas y sugerencias!
Robot 4x4 con Arduino
Como he dicho antes, éste pequeño tutorial pretende ofrecer una base de locomoción para un robot, con su chasis, motores, driver de motores y placa Arduino. Digamos que es la parte fundamental para que un robot pueda desplazarse. Una vez que tenemos un sistema el cual somos capaces de controlar (adelante, atrás y giros), podremos ir incluyendo algunos sensores adicionales en función del tipo de robot que deseemos. En éste punto, ya depende en gran medida de la imaginación de cada uno, que puede ir desde un sencillo robot que circule con unos patrones predeterminados y fijos, hasta un completo robot capaz de esquivar obstáculos mediante sensores de distancia o incluso guiado por GPS.
Sin más preambulos, comenzamos!
Las partes fundamentales para un robot de éstas características son las siguientes:
- Chasis
- Sistema programable de control (Arduino)
- Controlador de motores
- Alimentación
- Conexiones
- Código fuente
- Video!
El chasis
Por supuesto, podemos realizar un chasis a medida ya sea de madera, PVC o otros materiales ligeros, pero necesitaremos más tiempo y planificación. Además, no siempre se sabe con exactitud qué componentes se van a utilizar con sus respectivas dimensiones y los posibles inconvenientes que van surgiendo. Luego si optamos por contruir el chasis desde cero, necesitaremos herramientas y útiles que muchas veces no tenemos a mano. En mi caso, he optado por utilizar un chasis ya hecho que además es compatible con la placa Arduino Duemilanove o la nueva Arduino UNO. Éste chasis es muy robusto y está fabricado en aluminio, incluye cuatro motores de corriente contínua de 6V con reductora incorporada, ruedas, tornillos, plataforma para añadir sensores, interruptor de alimentación, caja de pilas 5xAA y algunos cables. Con él tenemos la parte mecánica practicamente resuelta y nos podemos dedicar a la siguiente fase del proyecto.
Sistema programable de control (Arduino)
Obviamente, necesitamos algo que nos permita programar a nuestro antojo el robot. Dado que el chasis ya dispone de agujeros para atornillar un Arduino USB, he utilizado dicho modelo. En mi caso es un Arduino Duemilanove, pero podeis utilizar igualmente un Arduino UNO o Arduino Pro 328 de Sparkfun, ya que las características son iguales y el código es completamente compatible.
Controlador de motores
Una placa Arduino no puede gestionar directamente motores de corriente contínua, dado que la máxima intensidad que es capaz de proporcionar en sus pines de salida es de unos escasos 20mA. Por lo tanto, necesitamos un controlador de motores que sea capaz de soportar la carga de los motores. Dicho controlador será gestionado a su vez por el Arduino. Debemos seleccionar siempre un controlador con potencia suficiente para los motores que vallamos a utilizar. Los cuatro motores incluidos con el chasis funcionan a 6 V y consumen unos 300 mA a plena carga. Dado que tenemos cuatro motores, obtenemos un consumo aproximado total de 4 x 300 = 1,2 Amperios aproximadamente.
Controlador de motores doble puente H - L298
Un buen candidato tanto por sus dimensiones como sus prestaciones, es el controlador en doble puente H basado en el conocido driver L298. Con sus dos salidas, tiene potencia suficiente (25W) para alimentar los cuatros motores. Un momento... cómo que dos salidas? pero si tenemos cuatro motores, entonces cómo hacemos?
Pues no pasa nada, ya que a pesar de que éste controlador tan sólo dispone de dos salidas, utilizaremos cada una de ellas para alimentar los motores en parejas. Agruparemos los motores de tal forma que los dos correspondientes a la parte izquierda del chasis serán cableados en pararelo y lo mismo para los dos motores correspondientes a la parte derecha del chasis. Con esto, podremos conectar los dos motores izquierdos a la salida A y los dos motores derechos a la salida B, tal y como se muestra en la imagen:
Debemos prestar atención a cómo cableamos los motores ya que como se puede ver, cada pareja está en sentido opuesto, por lo que debemos cruzar los cables para que giren en el mismo sentido cuando los alimentemos. Antes de continuar, es recomendable aplicar tensión una vez cableados para comprobar el sentido de giro.
Alimentación
La alimentación es bien sencilla ya que disponemos de un zócalo para 5 pilas de tipo AA que nos dan un total de 7,5 Voltios. Esto nos será suficiente para alimentar los motores y nuestra placa Arduino. La dejaremos atronillada a la base de chasis por la parte baja.
Mientras tanto, montamos el Arduino y el controlador de motores en su sitio. Utilizaremos unos soportes de metal con sus respectivos tornillos, ya que nos dará un montaje seguro y fiable.
Conexiones
A continuación, cableamos todo bien colocado con el largo de los cables justo para que no molesten. Fijaros que al cablear los motores en grupos de dos, sólo tendremos cuatro cables, que son los que irán al controlador.
No olvidemos de soldar los cables al interruptor de encendido. El chasis incluye uno de tres contactos, pero yo he preferido montar uno de seis.
Una vez conectados los motores al controlador, es el turno de conectarlo al Arduino. En la imagen de arriba no se muestra, pero no olvideis de contactar también los cables de alimentación que vienen del interruptor! Irán conectados a VMS y GND.
Las conexiones a la placa Arduino serán así:
- Arduino PIN 8 -> I1
- Arduino PIN 9 -> I2
- Arduino PIN 11 -> EA
- Arduino PIN 6 -> I3
- Arduino PIN 7 -> I4
- Arduino PIN 10 -> EB
Éstas son las señales de control ya que además estamos utilizando los pines PWM para luego poder variar la velocidad de los motores. También necesitareis conectar la salida del controlador marcada como +5V al pin de arduino señalado como VIN. Esto hace que el controlador de motores le proporcione corriente a la placa Arduino. No olvideis también de unir las masas con los pines GND.
He utilizado cables de prototipo Macho/Hembra para que sea más fácil:
Set de cables Premium para protoboard (100 Unid.)
Código fuente
No hay mucho que decir acerca del código fuente. He realizado un pequeño conjunto de funciones que permiten hacer avanzar o retroceder a la velocidad y el sentido que queramos. Al inicio del programa, en la función Setup() defino los pines como salidas y luego en el bucle principal, en la función Loop(), he puesto una secuencia de avance durante dos segundos, retroceso durante otros dos segundos, giro izquierda y giroderecha de dos segundos también. Luego el programa vuelve a comenzar. Es una buena forma de hacer las primeras pruebas y ver cómo se comporta el robot. Fijaros que para girar, se necesita hacer girar la parte izquierda al contrario de la parte derecha. Es el mismo sistema que los tanques. Con distintas velocidades podremos girar más o menos según sea necesario.
/*********************************************************************************************
Tutorial: Robot 4x4 con Arduino
Autor: Oscar Gonzalez - 16 Octubre 2010
https://blog.bricogeek.com/noticias/tutoriales/tutorial-robot-4x4-con-arduino/
********************************************************************************************/
#define MOTOR1_CTL1 8 // I1
#define MOTOR1_CTL2 9 // I2
#define MOTOR1_PWM 11 // EA
#define MOTOR2_CTL1 6 // I3
#define MOTOR2_CTL2 7 // I4
#define MOTOR2_PWM 10 // EB
#define MOTOR_DIR_FORWARD 0
#define MOTOR_DIR_BACKWARD 1
void setup()
{
// Setup pins for motor 1
pinMode(MOTOR1_CTL1,OUTPUT);
pinMode(MOTOR1_CTL2,OUTPUT);
pinMode(MOTOR1_PWM,OUTPUT);
// Setup pins for motor 2
pinMode(MOTOR2_CTL1,OUTPUT);
pinMode(MOTOR2_CTL2,OUTPUT);
pinMode(MOTOR2_PWM,OUTPUT);
}
void setSpeed(char motor_num, char motor_speed)
{
if (motor_num == 1)
{
analogWrite(MOTOR1_PWM, motor_speed);
}
else
{
analogWrite(MOTOR2_PWM, motor_speed);
}
}
void motorStart(char motor_num, byte direction)
{
char pin_ctl1;
char pin_ctl2;
if (motor_num == 1)
{
pin_ctl1 = MOTOR1_CTL1;
pin_ctl2 = MOTOR1_CTL2;
}
else
{
pin_ctl1 = MOTOR2_CTL1;
pin_ctl2 = MOTOR2_CTL2;
}
switch (direction)
{
case MOTOR_DIR_FORWARD:
{
digitalWrite(pin_ctl1,LOW);
digitalWrite(pin_ctl2,HIGH);
}
break;
case MOTOR_DIR_BACKWARD:
{
digitalWrite(pin_ctl1,HIGH);
digitalWrite(pin_ctl2,LOW);
}
break;
}
}
void motorStop(char motor_num)
{
setSpeed(motor_num, 0);
if (motor_num == 1)
{
digitalWrite(MOTOR1_CTL1,HIGH);
digitalWrite(MOTOR1_CTL2,HIGH);
}
else
{
digitalWrite(MOTOR2_CTL1,HIGH);
digitalWrite(MOTOR2_CTL2,HIGH);
}
}
void loop()
{
// Start motors!
motorStart(1, MOTOR_DIR_FORWARD);
setSpeed(1, 200);
motorStart(2, MOTOR_DIR_FORWARD);
setSpeed(2, 200);
delay(2000);
motorStart(1, MOTOR_DIR_BACKWARD);
setSpeed(1, 200);
motorStart(2, MOTOR_DIR_BACKWARD);
setSpeed(2, 200);
delay(2000);
motorStart(1, MOTOR_DIR_FORWARD);
setSpeed(1, 140);
motorStart(2, MOTOR_DIR_BACKWARD);
setSpeed(2, 140);
delay(2000);
motorStart(1, MOTOR_DIR_BACKWARD);
setSpeed(1, 140);
motorStart(2, MOTOR_DIR_FORWARD);
setSpeed(2, 140);
delay(2000);
}
Más adelante, cuando incorporemos sensores, podremos utilizar las funciones motorStart(), motorStop() y setSpeed() según nos sea necesario en función de los datos leidos por los sensores y lo que queremos que haga el robot.
Video
Ha llegado el momento triunfal en el cual estamos listos para el primer arranque de nuestro robot casero! Sólo nos queda asegurarse de tener las pilas puestas (y cargadas ya que las mias estaban en las últimas...) y conectar la alimentación mediante el interruptor trasero. Aqui os dejo un video del resultado final, aunque durante la gravación del video las pilas estaban más muertas que vivas y apenas tenía fuerza. Pero os puedo asegurar que con pilas nuevas o unas baterías bien cargadas, los motores ofrecen una fuerza no despreciable!
Bueno, pues espero que os halla gustado éste pequeño tutorial y por supuesto, si haceis vuestro própio robot o evolucionais éste, queremos verlo! asi que no dudeis en enviar vuestras fotos y dejar vuestro comentario!
En la tienda
Robot SCARA transformado en impresora 3D
Juego Piedra, Papel, Tijeras, Lagarto y Spock con Arduino
Cómo controlar el robot Escornabot por Bluetooth con M5Stack Core
Un brazo robot para meter pizzas en el horno
Cómo utilizar Watchdog con Arduino
Conexión entre Arduino y PLC OMRON
