Construyendo Nuestro Propio Robot Desde Cero – Parte 3

En la segunda parte vimos la instalación de la placa Arduino UNO R3 junto al Shield de Control de Motores Ardumoto (fabricado por Sparkfun Electronics), la conexión de los motores al shield y la conexión a la fuente de alimentación de lo mencionado anteriormente. Además, escribimos un código de prueba para verificar el correcto funcionamiento de Ardumoto y de los motores conectados al mismo (incluyendo la inversión de giro).

Ahora, en la tercera parte, veremos una de las diversas maneras que tenemos de controlar a nuestro robot y que el mismo ejecute diferentes órdenes según nuestro criterio. Para el sistema de control utilizaremos una tecnología más que común en estos días y la tenemos en nuestros hogares en más de un dispositivo: la radiación infrarroja, comúnmente conocida como IR.

El Receptor Infrarrojo
Para llevar a cabo nuestro propósito utilizaremos un receptor infrarrojo cuya frecuencia de operación será de 38kHz y su longitud de onda será de 940nm. Es de fácil adquisición en cualquier comercio de electrónica y no es requisito fundamental el fabricante, puede ser cualquier receptor cuya frecuencia de operación sea de 38kHz y su longitud de onda de 940nm. En mi caso particular, como veremos más adelante, he utilizado un receptor genérico. También puede obtenerse de equipos electrónicos en desuso.
Como transmisor infrarrojo podemos utilizar cualquier control remoto que tengamos en casa. En mi caso particular, he utilizado el control remoto del TV LCD.

 
Nuestro Robot
Luego de haber completado exitosamente las dos etapas anteriores, nuestro robot se encuentra listo para recorrer el mundo y recibir nuestras órdenes. A continuación llevaremos a cabo la instalación de toda la electrónica necesaria para que esto ocurra.

La instalación del receptor infrarrojo es muy sencilla y no requiere componentes externos, simplemente debemos conectar los pines de alimentación y el pin de datos.
La tensión de alimentación del receptor es de 5V, por lo tanto, se puede obtener la alimentación directamente del pin 5V de la placa Arduino. Ahora sólo resta soldar un pequeño trozo de cable para conectar el pin “Data” del receptor infrarrojo a un pin de la placa Arduino, como se observa en la siguiente imagen:

 
Ahora procedemos a instalarlo en Ardumoto (que a su vez se encuentra conectado a la placa Arduino UNO R3) conectando los pines de alimentación a los pines 5V y GND respectivamente. Luego conectaremos el pin “Data” del receptor infrarrojo al pin 4 de la placa Arduino, como se muestra a continuación:

 
Llegado este punto, ya tenemos instalada toda la electrónica necesaria para controlar nuestro robot mediante IR. Ahora, conectaremos nuestra placa Arduino a la PC a través del puerto USB y ejecutaremos el IDE de Arduino.
Necesitamos conocer los códigos correspondientes a las teclas del control remoto con las cuales controlaremos nuestro robot. En principio, serían cuatro teclas para controlar, lógicamente, las cuatro direcciones por la que se desplaza nuestro robot: adelante, atrás, izquierda y derecha. Podemos definir las teclas que consideremos más apropiadas. Luego, en la barra de menú del IDE, seleccionamos “Archivo” –> “Ejemplos” –> “IRremote”–> “IRrecvDump”, este sketch de ejemplo nos permitirá conocer los códigos correspondientes a las teclas del control remoto. Antes de cargarlo a nuestra placa Arduino, debemos modificar la línea número doce: “int RECV_PIN = 11;” por “int RECV_PIN = 4;” y finalmente lo cargaremos a nuestra placa Arduino. Luego seleccionamos “Herramientas” –> “Monitor Serial” (o simplemente presionamos CTRL+SHIFT+M). Ahora, apuntamos nuestro control remoto en dirección al receptor infrarrojo y pulsamos las teclas de las cuales deseamos conocer su código, como se observa en la siguiente imagen:

 
Luego, conociendo los códigos hexadecimales correspondientes a cada tecla, procederemos a escribir el código para controlar nuestro robot.

IMPORTANTE: al momento de cargar el siguiente código se deben reemplazar los códigos hexadecimales en el grupo de directivas “#define” (titulado “Remote Control Codes”) por los códigos hexadecimales particulares de cada control remoto. Además, debemos modificar dos líneas en el archivo “IRremoteInt.h” ubicado en “DirPrincipalIDEArduino\libraries\IRremote”. Las líneas en cuestión son las número 71 y 72:

// Arduino Duemilanove, Diecimila, LilyPad, Mini, Fio, etc
#else
     #define IR_USE_TIMER1   // tx = pin 9
     //#define IR_USE_TIMER2     // tx = pin 3
#endif

Deben modificarse de la siguiente manera:

// Arduino Duemilanove, Diecimila, LilyPad, Mini, Fio, etc
#else
     //#define IR_USE_TIMER1   // tx = pin 9
     #define IR_USE_TIMER2     // tx = pin 3
#endif

 

#include <IRremote.h>

#define    PWM_A        3
#define    PWM_B        11
#define    DIR_A        12
#define    DIR_B        13
#define    RECV_PIN     4

// Remote Control Codes
#define    DIR_UP       0x1CE3728D
#define    DIR_DOWN     0x1CE3F20D
#define    DIR_LEFT     0x1CE3F807
#define    DIR_RIGHT    0x1CE37887
#define    START_STOP   0x1CE32AD5

IRrecv irrecv(RECV_PIN);

decode_results results;

bool stopped;

void fadein()
{ 
	for(int fadeValue = 125 ; fadeValue <= 255; fadeValue +=5)
	{
		analogWrite(PWM_A, fadeValue);
		analogWrite(PWM_B, fadeValue);
	}
}

void fadeout()
{ 
	for(int fadeValue = 255 ; fadeValue >= 125 ; fadeValue -=5)
	{
		analogWrite(PWM_A, fadeValue);
		analogWrite(PWM_B, fadeValue);
	}
}

void forward()
{
    fadeout();
	digitalWrite(DIR_A, HIGH);
	digitalWrite(DIR_B, HIGH);
	fadein();
}

void backward()
{
	fadeout();
	digitalWrite(DIR_A, LOW);
	digitalWrite(DIR_B, LOW);
	fadein();
}

void rotateleft()
{
	fadeout();
	digitalWrite(DIR_A, LOW);
	digitalWrite(DIR_B, HIGH);
}

void rotateright()
{
	fadeout();
	digitalWrite(DIR_A, HIGH);
	digitalWrite(DIR_B, LOW);
}

void stop()
{
	analogWrite(PWM_A, 0);
	analogWrite(PWM_B, 0);
}

void setup()
{
	pinMode(PWM_A, OUTPUT);
	pinMode(PWM_B, OUTPUT);
	pinMode(DIR_A, OUTPUT);
	pinMode(DIR_B, OUTPUT);
	
	irrecv.enableIRIn();
	
	stopped = true;
}

void loop()
{
	if (irrecv.decode(&results))
	{
		switch (results.value)
		{
			case START_STOP:
				if(stopped)
				{
					forward();
					
					stopped = false;
				}
				else
				{
					stop();
					stopped = true;
				}
				break;
			
			case DIR_UP:
				if(!stopped)
					forward();
				break;
			
			case DIR_DOWN:
				if(!stopped)
					backward();
				break;
			
			case DIR_LEFT:
				if(!stopped)
					rotateleft();
				break;
			
			case DIR_RIGHT:
				if(!stopped)
					rotateright();
				break;
			
			default:
				break;
		}
		
		irrecv.resume();
	}
}

 

Construyendo Nuestro Propio Robot Desde Cero – Parte 2

En la primera parte ensamblamos la Plataforma Móvil de Doble Tracción para Arduino Turtle 2WD, además de realizar el primer mod para mejorar la fuente de alimentación que nos proporcionará más energía, menor peso y menor espacio ocupado por las baterías.

Ahora, en la segunda parte, veremos la instalación de la placa Arduino UNO R3 junto al Shield de Control de Motores Ardumoto (fabricado por Sparkfun Electronics), la conexión de los motores al shield y la conexión a la fuente de alimentación de lo mencionado anteriormente. Lógicamente, también escribiremos un código de prueba para verificar el correcto funcionamiento de Ardumoto y de los motores conectados al mismo (incluyendo la inversión de giro).

Shield de Control de Motores
Para poder controlar la velocidad y la dirección de los motores de corriente continua, se utiliza un circuito denominado “Puente H”. Este curioso nombre proviene de la forma en la que antiguamente se posicionaban los transistores al realizar el puente. La electrónica ha avanzado y en la actualidad utilizamos circuitos integrados que nos proporcionan esa funcionalidad, en un espacio menor y a bajo costo. En nuestro caso, la interfaz de potencia se basa en el circuito integrado L298 fabricado por STMicroelectronics, el cual contiene dos Puentes H completos, por lo tanto, podremos controlar dos motores de corriente continua (con inversión de giro) de hasta 2A de pico. El circuito integrado no cuenta con diodos de protección internos, por esta razón se encuentran ubicados exteriormente en la placa.

 
Nuestro Robot
Luego de ensamblar exitosamente la Plataforma Móvil de Doble Tracción Turtle 2WD, es el momento de que nuestro robot comience a recorrer el mundo. De la etapa anterior, los motores quedaron listos con sus cables de conexión correspondientes para ser alimentados/controlados de alguna manera. A continuación llevaremos a cabo la instalación de toda la electrónica necesaria para que esto ocurra.

Los motores de nuestro robot soportan una tensión de alimentación comprendida entre 3V – 6V y la fuente de alimentación proporciona una tensión de 7.4V, la cual resulta excesiva para nuestros motores y llevará a reducir la vida útil de los mismos. Entonces, nuestra primera tarea será solucionar este “inconveniente”, para ello, utilizaremos un regulador de voltaje “switching” con el objetivo de incrementar aún más la eficiencia energética y, por ende, la vida útil de las baterías. Este módulo regulador de voltaje está basado en el circuito integrado LM2596S-ADJ, fabricado por Texas Instruments y es capaz de proporcionar hasta 2A de corriente sin el uso de disipador (y hasta 3A de corriente con el uso de disipador). Al ser ajustable, debemos regular la tensión de salida en 6V a través de un preset que se encuentra en el módulo. Luego, procederemos a instalarlo en la placa superior del fuselaje, como se observa en la siguiente imagen:

 

 
Con el módulo regulador de voltaje instalado y la salida del mismo fijada en 6V, procederemos a armar el cable de alimentación con los conectores correspondientes. En este caso constará de un plug hueco de 3.5mm en cada extremo y además, en un extremo, constará de una conexión en paralelo adicional que se conectará en la bornera de entrada del módulo regulador de voltaje. Acto seguido, fijaremos la placa Arduino UNO R3 en los soportes centrales destinados para tal fin, como se muestra a continuación:

 
Finalmente es el momento de instalar el Shield de Control de Motores, pero antes, realizaremos una pequeña modificación en el mismo para adaptarlo a nuestro diseño.
Como sabemos, los shields son placas “apilables” que se insertan sucesivamente, y Ardumoto no es la excepción. Este shield obtiene la alimentación para el circuito integrado L298 a partir del pin “5V” de la placa Arduino, y además, obtiene la alimentación para los motores a partir del pin “Vin” de la placa Arduino. En este punto estamos ante otro “inconveniente”. La tensión presente en el pin “Vin” es igual a la diferencia entre la tensión de entrada en el jack y 0.6V dada la presencia de un diodo de protección contra inversión de polaridad, entonces, la tensión en el pin “Vin” es de 7.4V – 0.6V = 6.8V. Este voltaje excede al de nuestros motores.
La solución adoptada es sencilla. Ardumoto nos permite alimentar los motores de dos maneras diferentes, una es la analizada anteriormente, a través del pin “Vin” y la otra, es a través de una bornera destinada para tal fin. Entonces, cortaremos o doblaremos el pin “Vin” de Ardumoto y así evitaremos que obtenga alimentación a través de este pin y utilizaremos la bornera. Es importante destacar que con esta solución, se establece una separación física entre la alimentación de la lógica y la alimentación de los motores.

 
Como último paso, instalaremos el shield sobre la placa Arduino y conectaremos la salida del módulo regulador de voltaje a la bornera “Vin” de Ardumoto así como también conectaremos los motores a las borneras correspondientes.

 
Habiendo realizado exitosamente todas las conexiones, procederemos a escribir el código de prueba para verificar el correcto funcionamiento de Ardumoto y de los motores conectados al mismo (incluyendo la inversión de giro). En particular, he utilizado el código de prueba que provee Sparkfun Electronics para Ardumoto pero con modificaciones propias, Además de la marcha hacia adelante y hacia atrás, he agregado los giros a izquierda y a derecha. Como documentación del código he agregado una tabla de verdad que no se encontraba originalmente y puede resultar útil.

/*

5/22/2012
Timothy Holmberg
SparkFun Electronics

This code includes the ddition of fade in and out PWM. Also a stop feature. And the addition of individual functions for motor control.

This was a revision of the example sketch that originated from Pete Dokter's code for Arduino that shows very basically how to control an Ardumoto motor driver shield with a 5V Arduino controller board.
http://www.sparkfun.com/datasheets/DevTools/Arduino/Ardumoto_test_3.pde

This also includes parts of the Fading Example,  Created 1 Nov 2008 By David A. Mellis, modified 30 Aug 2011 By Tom Igoe
http://arduino.cc/en/Tutorial/Fading

*/

/*
+-----------+-----------+----------+----------+----------+----------+----------------+
|   DIR_A   |   DIR_B   |   OUT1   |   OUT2   |   OUT3   |   OUT4   |   ACTION       |
+-----------+-----------+----------+----------+----------+----------+----------------+
|   HIGH    |   HIGH    |   HIGH   |   LOW    |   LOW    |   HIGH   |   FORWARD      |
|   HIGH    |   LOW     |   HIGH   |   LOW    |   HIGH   |   LOW    |   ROTATE RIGHT |
|   LOW     |   HIGH    |   LOW    |   HIGH   |   LOW    |   HIGH   |   ROTATE LEFT  |
|   LOW     |   LOW     |   LOW    |   HIGH   |   HIGH   |   LOW    |   BACKWARD     |
+-----------+-----------+----------+----------+----------+----------+----------------+
*/

#define	PWM_A	3
#define	PWM_B	11
#define	DIR_A	12
#define	DIR_B	13

void setup()
{
	pinMode(PWM_A, OUTPUT);  //Set control pins to be outputs
	pinMode(PWM_B, OUTPUT);
	pinMode(DIR_A, OUTPUT);
	pinMode(DIR_B, OUTPUT);

	analogWrite(PWM_A, 100); //set both motors to run at (100/255 = 39)% duty cycle (slow)
	analogWrite(PWM_B, 100);
}

void loop()
{
	forw();         //Set Motors to go forward. Note: no pwm is defined with the for function, so that fade in and out works.
	fadein();       //fade in from 0-255
	delay(1000);    
	forward();      //full speed forward
	delay(1000);    
	fadeout();      //Fade out from 255-0
	delay(1000);    //Wait one second

	stopped();      // stop for 2 seconds
	delay(2000);

	back();         //Set motors to reverse. Note: no pwm is defined with the back function, so that fade in and out works.
	fadein();       //fade in from 0-255
	delay(1000);
	backward();     //full speed backward
	delay(1000);
	fadeout();      //Fade out from 255-0
	delay(1000);
	
	stopped();      // stop for 2 seconds
	delay(2000);
	
	turnleft();     //Set motors to turn left. Note: no pwm is defined with the back function, so that fade in and out works.
	fadein();       //fade in from 0-255
	delay(1000);
	rotateleft();   //full speed rotate left
	delay(1000);
	fadeout();      //Fade out from 255-0
	delay(1000);
	
	stopped();      // stop for 2 seconds
	delay(2000);
	
	turnright();    //Set motors to turn right. Note: no pwm is defined with the back function, so that fade in and out works.
	fadein();       //fade in from 0-255
	delay(1000);
	rotateright();  //full speed rotate right
	delay(1000);
	fadeout();      //Fade out from 255-0
	delay(1000);
}

/* Let's take a moment to talk about these functions. The forw and back functions are simply designating the direction the motors will turn once they are fed a PWM signal.
If you only call the forw, or back functions, you will not see the motors turn. On a similar note the fade in and out functions will only change PWM, so you need to consider
the direction you were last set to. In the code above, you might have noticed that I called forw and fade in the same grouping. You will want to call a new direction, and then
declare your pwm fade. There is also a stop function. 
*/

void forw() //no pwm defined
{ 
	digitalWrite(DIR_A, HIGH);  //Reverse motor direction, 1 high, 2 low
	digitalWrite(DIR_B, HIGH);  //Reverse motor direction, 3 low, 4 high
}

void back() //no pwm defined
{
	digitalWrite(DIR_A, LOW);   //Set motor direction, 1 low, 2 high
	digitalWrite(DIR_B, LOW);   //Set motor direction, 3 high, 4 low
}

void forward() //full speed forward
{ 
	digitalWrite(DIR_A, HIGH);  //Reverse motor direction, 1 high, 2 low
	digitalWrite(DIR_B, HIGH);  //Reverse motor direction, 3 low, 4 high
	analogWrite(PWM_A, 255);    //set both motors to run at 100% duty cycle (fast)
	analogWrite(PWM_B, 255);
}

void backward() //full speed backward
{
	digitalWrite(DIR_A, LOW);   //Set motor direction, 1 low, 2 high
	digitalWrite(DIR_B, LOW);   //Set motor direction, 3 high, 4 low
	analogWrite(PWM_A, 255);    //set both motors to run at 100% duty cycle (fast)
	analogWrite(PWM_B, 255);
}

void turnleft() //no pwm defined
{ 
	digitalWrite(DIR_A, LOW);   //Reverse motor direction, 1 low, 2 high
	digitalWrite(DIR_B, HIGH);  //Reverse motor direction, 3 low, 4 high
}

void turnright() //no pwm defined
{ 
	digitalWrite(DIR_A, HIGH);  //Reverse motor direction, 1 high, 2 low
	digitalWrite(DIR_B, LOW);   //Reverse motor direction, 3 high, 4 low
}

void rotateleft()
{
	digitalWrite(DIR_A, LOW);   //Set motor direction, 1 low, 2 high
	digitalWrite(DIR_B, HIGH);  //Set motor direction, 3 low, 4 high
	analogWrite(PWM_A, 255);    //set both motors to run at 100% duty cycle (fast)
	analogWrite(PWM_B, 255);
}

void rotateright()
{
	digitalWrite(DIR_A, HIGH);  //Set motor direction, 1 high, 2 low
	digitalWrite(DIR_B, LOW);   //Set motor direction, 3 high, 4 low
	analogWrite(PWM_A, 255);    //set both motors to run at 100% duty cycle (fast)
	analogWrite(PWM_B, 255);
}

void stopped()	//stop
{
	digitalWrite(DIR_A, LOW);   //Set motor direction, 1 low, 2 high
	digitalWrite(DIR_B, LOW);   //Set motor direction, 3 high, 4 low
	analogWrite(PWM_A, 0);
	analogWrite(PWM_B, 0);
}

void fadein()
{ 
	// fade in from min to max in increments of 5 points:
	for(int fadeValue = 0 ; fadeValue <= 255; fadeValue +=5)
	{
		// sets the value (range from 0 to 255):
		analogWrite(PWM_A, fadeValue);
		analogWrite(PWM_B, fadeValue);
		// wait for 30 milliseconds to see the dimming effect
		delay(30);
	}
}

void fadeout()
{ 
	// fade out from max to min in increments of 5 points:
	for(int fadeValue = 255 ; fadeValue >= 0; fadeValue -=5)
	{
		// sets the value (range from 0 to 255):
		analogWrite(PWM_A, fadeValue);
		analogWrite(PWM_B, fadeValue);
		// wait for 30 milliseconds to see the dimming effect
		delay(30);
	}
}

void astop()	//stop motor A
{
	analogWrite(PWM_A, 0);    //set both motors to run at 100% duty cycle (fast)
}

void bstop()	//stop motor B
{ 
	analogWrite(PWM_B, 0);    //set both motors to run at 100% duty cycle (fast)
}

 

 
En la tercera parte de esta publicación veremos el armado (desde cero) y la instalación de dos sensores de línea en la parrilla delantera. Con este par de sensores nuestro robot será capaz de seguir una línea blanca sobre una superficie negra o viceversa. Lógicamente, se incluirá el código correspondiente para realizar esta tarea.

Construyendo Nuestro Propio Robot Desde Cero – Parte 1

Día a día, nos sorprendemos con las noticias que aparecen en los medios de comunicación vinculadas a la presencia de robots en diversos campos de la vida cotidiana. Robots enfermeros, mascotas, repositores de supermercados, detectores de explosivos, aspiradoras hogareñas, drones, o simples jugadores de fútbol, son algunos de los ejemplos que podemos encontrar en el mercado de la tecnología de última generación.

En síntesis, la robótica ya no es parte de nuestro futuro sino de nuestro presente tangible. Sin embargo, probablemente gracias a la literatura y al cine de ciencia ficción, el concepto de lo que es un robot, sus posibilidades y sus limitaciones reales están desdibujadas en el imaginario colectivo. Por este motivo haremos una introducción a los conceptos fundamentales de la robótica.

¿Que es un robot?
Existen muchas definiciones de la palabra robot. En cada una de ellas, encontraremos destacado algún aspecto en particular, que es el que cada autor quiere resaltar en su obra.

Según la Asociación Japonesa de Robótica Industrial (JIRA), los robots son dispositivos capaces de moverse de modo flexible, análogo al que poseen los organismos vivos, con o sin funciones intelectuales, lo que permite la realización de operaciones en respuesta a órdenes recibidas por los humanos.

El Instituto de Robótica de Norteamérica (RIA) define a un robot industrial como un manipulador multifuncional y reprogramable diseñado para desplazar materiales, componentes, herramientas o dispositivos especializados por medio de movimientos programados variables, con el fin de realizar diversas tareas.

Particularmente, agregaremos una definición más a la larga lista preexistente: un robot es un dispositivo con un determinado grado de movilidad, que puede realizar un conjunto de tareas en forma independiente y que se adapta al mundo en el que opera.

Tipos de Robots
De la misma manera que con las definiciones, podemos encontrar muchas clasificaciones distintas de robots.

Según el uso del robot
Industriales: se utilizan dentro de un proceso de trabajo industrial.
Espaciales: deben desenvolverse en zonas inexploradas y a larga distancia de su centro de control.
Médicos: son utilizados como apoyo en la intervención médica sobre los humanos y como complemento para las personas con capacidades disminuidas.
Domésticos: un robot que realiza alguna o todas las tareas del hogar.
Sociales: robots utilizados en ámbitos sociales (como películas, eventos y supermercados.
Agrícolas: robots utilizados en el sector agrícola-ganadero como cosechadoras autónomas, sembradoras controladas por mapas satelitales, fumigadores robotizados y otros dispositivos que hicieron su aparición dentro de lo que actualmente se conoce como agricultura de precisión.

Según el medio en el que desarrolla la actividad
Acuáticos: se caracterizan por movimientos tridimensionales en un ambiente hostil desde el punto de vista mecánico y electrónico.
Terrestres: son los más populares y económicos. Se desplazan sobre la superficie a través de diversos sistemas de locomoción: ruedas, orugas, patas, fijos, arrastre, etcétera.
Aéreos: con movimientos tridimensionales, como el acuático, pero con una exigencia mucho mayor en el control en tiempo real del sistema de levitación.
Híbridos: combinación de algunos de los anteriores.

Según la ubicación de la inteligencia del robot
Autónomos: la inteligencia está ubicada en el mismo robot.
Control Automatizado: la mayor parte de la inteligencia del robot está ubicada en un sistema central. Los sensores pueden ser locales, es decir que le envían la información obtenida a ese sistema central, o globales.
Híbridos: son robots autónomos que, en ciertos momentos del proceso, pueden ser controlados por humanos o por un sistema central.

Nuestro Robot
El objetivo de esta serie de publicaciones es poder describir, paso a paso, la electrónica, la mecánica y la programación necesarias para poder construir un robot sencillo y de bajo costo, que permita realizar tareas simples de forma autónoma. Para ello se mostrarán todos los aspectos esenciales que conforman la arquitectura de un robot, de manera tal cada uno pueda ajustarlo a sus necesidades a través del agregado de nuevos sensores, actuadores y procesadores.

Como base para la construcción de nuestro robot utilizaremos la Plataforma Móvil de Doble Tracción para Arduino Turtle 2WD fabricada por DFRobot. Es una plataforma móvil pequeña, de bajo costo, para uso con una placa Arduino estándar. Se entrega como un kit que incluye dos motores, dos ruedas motrices (y una rueda trasera tipo bola), chasis y todos los accesorios de montaje.
Las dos unidades motrices con motoreductor, el radio de giro cercano a cero, materiales del cuerpo de aleación de aluminio de alta resistencia, y las ruedas de goma flexible lo hacen adecuado para casi cualquier superficie de interior.

Especificaciones de la plataforma “Turtle 2WD”
• Plataforma de desarrollo de robot móvil 2WD Arduino.
• Doble tracción diferencial.
• Bola de soporte trasero incluida.
• Chasis completo con accesorios de montaje.
• Dimensiones: 170 mm de diámetro base.
• Peso: 445g

Especificación del motor
• Relación de engranajes: 1:120
• Velocidad en vacío (3V): 100 RPM
• Velocidad en vacío (6V): 200 RPM
• Corriente en vacío (3V): 60mA
• Corriente en vacío (6V): 71mA
• Corriente a motor bloqueado (3V): 260mA
• Corriente a motor bloqueado? (6V): 470mA
• Torque (3V): 1.2Kgcm
• Torque (6V): 1.92Kgcm
• Tamaño: 55 x 48.3 x 23 mm
• Peso: 45g

Ensamblar las partes es una tarea sencilla que no trae mayores inconvenientes y las herramientas necesarias se encuentran presentes en cualquier kit de electrónica básica.
La plataforma viene acompañada con un manual completamente ilustrado en donde se explica paso a paso el ensamblado y ajuste de las partes.

Ver este documento en Scribd

En primer lugar comenzaremos ensamblando la placa inferior del fuselaje. Soldaremos los cables de alimentación de los motores y luego los fijaremos a la placa inferior. También fijaremos a la placa inferior la parrilla delantera.
En este primer paso, sin ir más lejos, comenzaremos con lo que será el primer mod a nuestro robot (sí, ahora mismo). La plataforma cuenta con una fuente de alimentación que consiste en un portapilas con capacidad para 5 baterías AA, lo cual presenta una serie de desventajas, a saber:

• El peso total de este pack de baterías es de 125g.
• Autonomía limitada debido a la baja capacidad (mAh) de este tipo de baterías.
• Voltaje insuficiente* para alimentar la placa Arduino a través del plug (Voltaje mínimo de entrada: 7.5V)
(*) Es insuficiente en caso de utilizar baterías recargables AA 1.2V

En su lugar utilizaremos un portapilas con capacidad para 2 baterías 18650 (3.7V – 4900mAh), con las cuales obtendremos las siguientes ventajas:

• El peso total de este pack de baterías es de 70g.
• Mayor autonomía dado que este tipo de baterías poseen mayor capacidad (mAh).
• Voltaje suficiente para alimentar la placa Arduino a través del plug (3.7Vx2=7.4V).

Como desventaja, necesitaremos un regulador de voltaje para los motores ya que la tensión de trabajo de los mismos es de 6V. Este “inconveniente” será analizado y solucionado más adelante.

Colocando el portapilas en la ubicación deseada, marcaremos los puntos de perforación correspondientes como se observa en la siguiente imagen (puntos blancos):

 
Marcados los puntos, realizaremos las perforaciones correspondientes.

A continuación, instalaremos las ruedas laterales y la rueda trasera (tipo bola) utilizando para ello los tornillos de fijación correspondientes, como se observa en la siguiente imagen:

 
Terminada la instalación de las ruedas, podemos continuar con la fijación del portapilas. Podríamos utilizar el portapilas original que incluye la plataforma pero no lo haremos ya que tenemos una solución energética más eficiente con nuestro mod 🙂

 

 
Ahora es el turno de ensamblar la placa superior del fuselaje, instalaremos el interruptor (inversor simple, on-on) y el jack de alimentación. Luego, soldaremos un cable de corta longitud que conectará un extremo del interruptor con el terminal positivo del jack de alimentación, como se observa en la siguiente imagen:

 
Luego, instalaremos los soportes frontales (para montaje de sensores) y los centrales para instalar la placa Arduino.

 
Sólo resta fijar la placa superior a la plataforma y listo! En las siguientes imágenes se observa la plataforma completamente terminada.

 

 
En la segunda parte de esta publicación veremos el montaje de la placa Arduino junto al Shield de Control de Motores y un pequeño código de prueba para darle movilidad a nuestro robot.