Tutorial para construir un robot 4x4 casero

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

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 ardunino duermilanove 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.

Chasis robot 4x4 con motores

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 unArduino 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.

A

Arduino UNO

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 podervariar 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.

view plaincopy to clipboardprint?

1. /********************************************************************************************* 
2.  
3.   Tutorial: Robot 4x4 con Arduino 
4.   Autor: Oscar Gonzalez - 16 Octubre 2010 
5.   http://blog.bricogeek.com/noticias/tutoriales/tutorial-robot-4x4-con-arduino/ 
6.  
7.  ********************************************************************************************/  
8. #define MOTOR1_CTL1  8  // I1  
9. #define MOTOR1_CTL2  9  // I2  
10. #define MOTOR1_PWM   11 // EA  
11.   
12. #define MOTOR2_CTL1  6  // I3  
13. #define MOTOR2_CTL2  7  // I4  
14. #define MOTOR2_PWM   10 // EB  
15.   
16. #define MOTOR_DIR_FORWARD  0  
17. #define MOTOR_DIR_BACKWARD   1  
18.   
19. void setup()  
20. {  
21.   // Setup pins for motor 1  
22.    pinMode(MOTOR1_CTL1,OUTPUT);  
23.    pinMode(MOTOR1_CTL2,OUTPUT);  
24.    pinMode(MOTOR1_PWM,OUTPUT);  
25.      
26.   // Setup pins for motor 2  
27.    pinMode(MOTOR2_CTL1,OUTPUT);  
28.    pinMode(MOTOR2_CTL2,OUTPUT);  
29.    pinMode(MOTOR2_PWM,OUTPUT);     
30. }  
31.   
32. void setSpeed(char motor_num, char motor_speed)  
33. {  
34.    if (motor_num == 1)  
35.    {  
36.       analogWrite(MOTOR1_PWM, motor_speed);  
37.    }     
38.    else  
39.    {  
40.       analogWrite(MOTOR2_PWM, motor_speed);  
41.    }  
42. }  
43.   
44. void motorStart(char motor_num, byte direction)  
45. {  
46.     
47.    char pin_ctl1;  
48.    char pin_ctl2;  
49.      
50.    if (motor_num == 1)  
51.    {  
52.       pin_ctl1 = MOTOR1_CTL1;  
53.       pin_ctl2 = MOTOR1_CTL2;  
54.    }     
55.    else  
56.    {  
57.       pin_ctl1 = MOTOR2_CTL1;  
58.       pin_ctl2 = MOTOR2_CTL2;       
59.    }  
60.     
61.    switch (direction)  
62.    {  
63.      case MOTOR_DIR_FORWARD:  
64.      {  
65.        digitalWrite(pin_ctl1,LOW);  
66.        digitalWrite(pin_ctl2,HIGH);            
67.      }  
68.      break;   
69.             
70.      case MOTOR_DIR_BACKWARD:  
71.      {  
72.         digitalWrite(pin_ctl1,HIGH);  
73.         digitalWrite(pin_ctl2,LOW);            
74.      }  
75.      break;           
76.    }  
77. }  
78.   
79. void motorStop(char motor_num)  
80. {  
81.    setSpeed(motor_num, 0);  
82.    if (motor_num == 1)  
83.    {  
84.      digitalWrite(MOTOR1_CTL1,HIGH);  
85.      digitalWrite(MOTOR1_CTL2,HIGH);       
86.    }  
87.    else  
88.    {  
89.      digitalWrite(MOTOR2_CTL1,HIGH);  
90.      digitalWrite(MOTOR2_CTL2,HIGH);       
91.    }  
92. }  
93.   
94. void loop()  
95. {  
96.   // Start motors!  
97.   motorStart(1, MOTOR_DIR_FORWARD);    
98.   setSpeed(1, 200);  
99.   motorStart(2, MOTOR_DIR_FORWARD);        
100.   setSpeed(2, 200);  
101.     
102.   delay(2000);  
103.     
104.   motorStart(1, MOTOR_DIR_BACKWARD);    
105.   setSpeed(1, 200);  
106.   motorStart(2, MOTOR_DIR_BACKWARD);        
107.   setSpeed(2, 200);  
108.     
109.   delay(2000);  
110.     
111.   motorStart(1, MOTOR_DIR_FORWARD);    
112.   setSpeed(1, 140);  
113.   motorStart(2, MOTOR_DIR_BACKWARD);        
114.   setSpeed(2, 140);    
115.     
116.   delay(2000);  
117.     
118.   motorStart(1, MOTOR_DIR_BACKWARD);    
119.   setSpeed(1, 140);  
120.   motorStart(2, MOTOR_DIR_FORWARD);        
121.   setSpeed(2, 140);    
122.     
123.   delay(2000);    
124.     
125. }  

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 les halla gustado éste pequeño tutorial