Si has visto algn concurso de robtica y quieres participar, o ests interesado en construir

un robot seguidor de lnea quizs este proyecto pueda ayudarte. Construccin detallada de
un robot velocista bsico, fcil de hacer y de bajo coste, para iniciarse en esta prueba.
Aunque ya est todo dicho en el proyecto Robot Zero, vuelvo a hacer un pequeo resumen
aqu con la versin final.

Uno de los proyectos que tenemos en comn varias personas en el C.I.r.E. es el desarrollo
de robots velocistas, por lo que llevamos ya meses hablando sobre el tema y discutiendo
ideas. Intentando sintetizar parte de las ideas subo aqu mi versin final con la que cierro el
proyecto de robot velocista de iniciacin, a no ser que me haya equivocado en algn pin del
pcb o similar dejo aqu el mundo de los velocistas.
No soy experto en el tema y slo he ido a un par de concursos, a falta de informacin
disponible espero que a alguien que quiera ir a un concurso y sepa an menos que yo del
tema le pueda ayudar. Eso s no garantizo el funcionamiento de nada, slo pongo lo que a
mi me ha funcionado, por lo que si alguien lo monta que lo haga segn su criterio.
Una opcin es comprar el velocista entero directamente, en internet se pueden encontrar
algunos robots velocistas para comprar. No lo recomiendo ya que pierde toda la gracia el
asunto, nos dan todo hecho y la mayor parte del programa, por lo que lo nico que hay que
hacer es darle al botn. Y supongo que en los concursos no admitirn su participacin, ya
que el mrito del que lo lleva es mnimo y por tanto poco digno de ser premiado.
Lo primero a la hora de montar un robot es elegir los componentes y es donde toda persona
que quiere hacer su primer robot encuentra la primera dificultad, qu motor elegir, qu
sensores, etc.. Lo mejor que he encontrado son los componentes de Pololu, por un precio
muy razonable encontramos todos los componentes necesarios para construir un robot que
no lo haga mal en los concursos, no vamos a ganar pero lo mismo podemos pasar la
primera clasificatoria, lo que sera un resultado satisfactorio para muchos principiantes.
Mi eleccin de componentes es la siguiente:

Placa de control ms programador $31.95.

Placa de sensores $14.95.

Ruedas $6.98.

Rueda loca $2.99.

Soporte motores $4.99.

DC-DC $11.95.

Batera $11.95.

Cargador $16.95.

Motor HP $31.90 (opcin A).

Motor $31.90 (opcin B).

Podemos elegir dos motores para el proyecto, si tu objetivo es hacer un primer robot y te
conformas con que funciones recomiendo la opcin B, si tu objetivo es intentar ir lo ms
rpido posible recomiendo la opcin A. El problema de la opcin A es que son motores que
consumen mucha intensidad y existe la posibilidad de quemar el DC-DC, es muy poco
probable quemarlo, pero la posibilidad est ah, para mi gusto son los mejores motores que
podemos comprar por ese precio. Con la rueda seleccionada y la opcin B se pueden
alcanzar velocidades sobre 2 m/s, mientras que con la opcin A podremos alacanzar los 4
m/s.
En total por unos $122.66 tenemos todos los componentes necesarios para el velocista, a lo
que habra que sumarle unos $10-15 aproximadamente en componentes para unirlo todo.
Pongamos el proyecto completo sobre unos 100-110 al cambio en material. Los
componentes se encuentran en dos tiendas y los gastos de envio de cada una estn entre $10
y $15 por correo normal y suelen tardar 7-12 das, he realizado pedidos muchas veces y
siempre llegan y no suelen caer en aduanas.
An as si queremos comprarlo todo en un slo pedido en http://www.robotshop.com/eu
econtramos todos los componentes, aunque sale ms caro ya que como toda tienda te hacen
el cambio $1 = 1, por lo que la mayora de las veces sale mejor comprar directamente en $
$.
Para unir todos los componentes tenemos dos opciones: usar un pcb que a la vez sirva de
base del robot para conectarlo todo, o usar un pcb/placa de topos que poner en una base que
fabriquemos. Pongo foto de las dos opciones:

La mejor opcin de ambas para nuestros objetivos es la de construir un base sobre la que
poner el pcb, ya que nos va a permitir tener un robot verstil al que le podemos poner
distintas bases con diferente longitud y anchura, lo que nos permitir probar y experimentar
con diferentes configuraciones y adaptarnos a los circuitos que nos den en los concursos.
Por ejemplo en un circuito con curvas con un radio grande y rectas largas nos puede
interesar llevar una base ms larga y ancha, mientras que si nos dan un circuito con muchas
curvas pequeas y poca recta puede ser mejor opcin una base pequea. Adems las
dimensiones del robot dependen de las inercias y la fuerza de rozamiento del robot que nos
adhiere al suelo, por lo que muchas veces la nica forma de encontrar las dimensiones
ptimas es probando distitnas bases.
Si montamos todo el robot en un pcb pues no podremos cambiar sus dimensiones, los
robots que venden hechos vienen montados en un pcb ya que es ms fcil integrar todo y
supongo que ms barato de fabricar, el ahorro de peso es mnimo ya que la base en plstico
pesa ms o menos igual que el pcb. Por lo que para un primer robot con el que aprender y
experimentar la mejor es tener bases intercambiables.
La idea final es tener algo como sto, un robot que montar sobre distintas bases.

Por lo que lo primero podra ser empezar a construir la base, para ello nos hacemos una
plantilla a mano o con el pc que pegamos sobre un trozo de PVC expandido o forex de
3mm, con un punzn marcamos los agujeros de los motores ( han de ir en la plantilla ya
que deben quedar bien alineados) y con una cuchilla cortamos y marcamos en el PVC la
plantilla, pasando luego a recortarla y hacer el resto de taladros, el PVC expandido de 3 mm
se puede cortar y trabajar a mano.
Adjunto un par de plantillas de bases de ejemplo (las dimensiones de los robots en los
concursos mximas son de 30 cm de largo y 20 cm de ancho) y una foto del proceso para
realizar la base.
Base 1.
Base 2.
Las dimensiones de la base para mi gusto no son las ideales, pero son las que he probado.

La otra parte que necesitamos para unir los componentes es realizar un pcb o utilizar una
placa de topos como explic Guillermo en la entrada anterior. Adems esta placa nos
servir para pegar con cinta de doble cara la batera elegida, de tal forma que quede por
debajo del robot, lo que proporciona un centro de gravedad lo ms bajo posible.
La placa de la electrnica se puede ver aqu (click para mayor detalle):

Las caractersticas con los componentes montados seran las siguientes:

8 entradas digitales de senores 6 analgicas en los sensores centrales (no he

querido desoldar el potenciometro del ADC para poner los 8).

Pin para encender y apagar los sensores y as ajustar el nivel de luz que emiten.

Dos diodos leds.

Un pulsador para dar la salida, calibrar unos sensores RC, etc..

Dos interruptores para seleccionar distintas estrategias en el concurso, fundamental

para cambiar la velocidad contra un oponente, o arriesgar ms si hemos perdido la
primera ronda.

Un dc-dc que nos proporciona una tensin de referencia fija para la velocidad de los
motores, por lo que facilita el algoritmo de control.

Un conector con salida de 5V y pines TX y RX de la USART del microcontrolador,

para conectar un mdulo de comunicaciones si queremos mandar datos del robot al
PC.

Duracin de la batera: 28 minutos (ciclo de trabajo 160/255, Vmed = 215 cm/s en

circuito de prueba).

Si usamos los motores de alta intensidad el DC-DC lo podemos quemar si no ponemos el

condensador electroltico que est a la altura del regulador, o si lo ponemos de un valor
pequeo. Aunque es el condensador del montaje tpico de cualquier regulador disipativo
est proporcionando el pico de intensidad necesaria a los motores cuando su f.c.e.m. es
baja.
Lo llevo con un valor de 22 uF y es suficiente para que los motores vayan a velocidad altas.
Hice la prueba de quitar el condensador para ver si el dc-dc cortaba ante una intensidad
mayor de la que puede dar (no s que integrado lleva) y se acaba quemando, ya que los
motores HP pueden tener picos de hasta 1.6 A por motor y el DC-DC slo admite 2 A de
entrada. Poniendo este condensador (una vez visto se podra poner ms cerca del dc-dc o
duplicar) no deberiamos tener problemas de quemar el dc-dc para una buena velocidad del
robot. Con los motores de baja intensidad no hay problema ya que slo consumen 0.36A
como mximo a 6V.
Para conectar la placa de control y el dc-dc ponemos una tira de pines hembra, donde los
insertaremos, de esta forma podemos sacar la placa para utilizarla en otros proyectos y el
dc-dc para ajustar la tensin de salida a distintos valores segn los motores a utilizar. Si
usamos los motores de alta intensidad lo pondremos sobre 5.5-6.5 V y si usamos los de baja
podemos ponerlo a 9V para sacar ms par y velocidad de ellos.
Los conectores de la batera, tira de pines que se ven en la imagen, botones y dems
tambin lo podemos comprar en Pololu (cuanto mayor el pedido mayor la posibilidad de
aduana), aunque en cualquier tienda fsica de electrnica se pueden encontrar los
componentes a un precio razonable.
El esquema para unir toda la parte de la electrnica (click en la imagen para ms detalle), si
todos los pines estn bien asignados (no me haya confundido en alguno ya que no lo he
repasado) as se quedara.

C1 y C2 son los condensadores electrolticos de 22 microFaradios, R1 R2 y R4 470

Ohmios, R10 R7 y R8 330 Ohmios, R3 R5 y R6 15K, un regulador disipativo de 5V
mirando su cada, si sacamos del dc-dc 9V podramos poner un 7805, pero sacando slo 6V
pues mejor poner uno con un cada de tensin menor como un LF50ABP, L4941BV, es
decir cualquier ldo. Los componentes SMD 1206.
Los componentes montados en el pcb y el fotolito.

Montamos el pcb y lo ponemos en la base del robot, para conectar los motores
se pueden poner un par de conectores o soldar los cables directamente. Lo
siguiente es pegar la batera con cinta de doble cara al pcb y hacer un agujero
para pasar el cable.

Colocamos la rueda loca, podemos usar unos tornillos para fijarla o pegarla directamente
aunque sto signifique tener que usar una por base. Por ltimo colocamos la placa de
sensores haciendo los correspondientes agujeros para pasar los tornillos, y hacemos el
cables para unir los sensores con la placa de electrnica.
Respecto a la placa de sensores que compramos hay que cambiar o quitar unas resistencias,
ya que los llevamos muy pegados al suelo y vienen pensados para una mayor distancia.

En la imagen superior se puede ver como se ha soldado una resistencia de 100 Ohmios
(101) y desoldado dos resistencias, esas dos resistencias en paralelo vienen para limitar la
corriente de los diodos, podemos quitar una o quitar las dos y soldar una donde aparece en
la iamgen de mayor valor. Aunque no he probado muchos valores una resistencia de unos
82 ohmios podra funcionar bien, depende, ya que algunas placas de Pololu nos la dan con
resistencias de 43 Ohmios y otras con resistencias de 66 Ohmios en los diodos. Otra cosa
que hemos podido comprobar es que estos sensores son terribles para hacer lecturas en
analgico, ya que su orientacin (inclinacin) afecta enormemente a la lectura, por lo que si
el robot vibra u oscila, o la pista no es totalmente lisa podemos encontrar problemas, pero
bueno esto se ve bien cuando desarrollemos la parte de la telemtra en el C.I.r.E., que
supongo que ser lo siguiente.
Por lo que todo montado queda una cosa as:

Esta sera la parte de la base y ahora falta la parte de la programacin, adjunto un programa
sencillo para estos robots que sigue la lnea sin oscilar a una velocidad constante. Al
programa no se le ha dedicado tiempo, es el primero que hic y ha ido pasando de robot a
robot porque pareca que funcionaba, por lo que puede tener fallos por algn lado. La idea
es muy sencilla, medir la distancia de la lnea al centro de los sensores, medir la velocidad
con la que se aleja o se acerca la lnea al centro de los sensores, multiplicar estas medias
por unas constantes que utilizamos para ajustar la respuesta del robot, sumarlas y convertir
la cantidad obtenida en una diferencia de velocidad entre los motores, lo que provoca el
giro.
Programa.
Pongo un par de videos en los que se puede ver el funcionamiento del programa, el segundo
de ellos a cmara lenta (a partir del segundo 30). El robot va montado en la base ms larga
y la tensin de salida del dc-dc es 6.4 V.
>ALGORITMO EN ARDUINO
#include <QTRSensors.h>
/////////////////////////////////////////////////////////////////////////////////////

//************* Programa realizado por MARKO A. CABALLERO

MORENO*************** //
// Solo para fines educativos //
// robot velocista mini FK BOT V 2.0
//
// micro motores pololu MP 10:1, sensores qtr 8rc, driver drv8833, arduino nano
//
05/12/2014
// ACTUALIZADO 29/3/2015
//
/////////////////////////////////////////////////////////////////////////////////////
#define NUM_SENSORS 8 //numero de sensores usados
#define TIMEOUT
2000 // tiempo de espera para dar resultado en uS
#define EMITTER_PIN 6 //pin led on
///////////////pines arduino a utilizar/////////////////////
#define led1
13
#define led2
4
#define mot_i
7
#define mot_d
8
#define sensores
6
#define boton_1
2 //pin para boton
#define pin_pwm_i 9
#define pin_pwm_d 10
QTRSensorsRC qtrrc((unsigned char[]) {19, 18, 17, 16,15,14,11,12}
,NUM_SENSORS, TIMEOUT, EMITTER_PIN);
//variables para almacenar valores de sensores y posicion
unsigned int sensorValues[NUM_SENSORS];
unsigned int position=0;
/// variables para el pid
int derivativo=0, proporcional=0, integral=0; //parametros
int salida_pwm=0, proporcional_pasado=0;
//AQUI CAMBIEREMOS LOS PARAMETROS DE NUESTRO ROBOT
int velocidad=120; //variable para la velocidad, el maximo es 255
float Kp=0.18, Kd=4, Ki=0.001; //constantes
//variable para escoger el tipo de linea
int linea=0; // 0 para lineas negra, 1 para lineas blancas
void setup()
{
delay(800);
pinMode(mot_i, OUTPUT);//pin de direccion motor izquierdo
pinMode(mot_d, OUTPUT);//pin de direccion motor derecho
pinMode(led1, OUTPUT); //led1
pinMode(led2, OUTPUT); //led2
pinMode(boton_1, INPUT); //boton 1 como pull up

//

for (int i = 0; i < 40; i++) //calibracion durante 2.5 segundos,

{
//para calibrar es necesario colocar los sensores sobre la superficie
negra y luego
digitalWrite(led1, HIGH); //la blanca
delay(20);
qtrrc.calibrate(); //funcion para calibrar sensores
digitalWrite(led1, LOW);
delay(20);
}
digitalWrite(led1, LOW); //apagar sensores para indicar fin
//de calibracion
delay(400);
digitalWrite(led2,HIGH); //encender led 2 para indicar la
// espera de pulsacion de boton
while(true)
{
int x=digitalRead(boton_1); //leemos y guardamos el valor
// del boton en variable x
delay(100);
if(x==0) //si se presiona boton
{
digitalWrite(led2,LOW); //indicamos que se presiono boton
digitalWrite(led1,HIGH); //encendiendo led 1
delay(100);
break; //saltamos hacia el bucle principal
}
}
}
void loop()
{
//pid(0, 120, 0.18, 4, 0.001);
pid(linea,velocidad,Kp,Ki,Kd); //funcion para algoritmo pid
//(tipo,flanco de comparacion)
//frenos_contorno(0,700);
frenos_contorno(linea,700); //funcion para frenado en curvas tipo
//0 para lineas negras, tipo 1 para lineas blancas
//flanco de comparacin va desde 0 hasta 1000 , esto para ver
//si esta en negro o blanco
}

////////funciones para el control del robot////

void pid(int linea, int velocidad, float Kp, float Ki, float Kd)
{
position = qtrrc.readLine(sensorValues, QTR_EMITTERS_ON, linea); //0 para linea
//negra, 1 para linea blanca
proporcional = (position) - 3500; // set point es 3500, asi obtenemos el error
integral=integral + proporcional_pasado; //obteniendo integral
derivativo = (proporcional - proporcional_pasado); //obteniedo el derivativo
if (integral>1000) integral=1000; //limitamos la integral para no causar problemas
if (integral<-1000) integral=-1000;
salida_pwm =( proporcional * Kp ) + ( derivativo * Kd )+(integral*Ki);
if ( salida_pwm > velocidad ) salida_pwm = velocidad; //limitamos la salida de pwm
if ( salida_pwm < -velocidad ) salida_pwm = -velocidad;
if (salida_pwm < 0)
{
motores(velocidad+salida_pwm, velocidad);
}
if (salida_pwm >0)
{
motores(velocidad, velocidad-salida_pwm);
}
proporcional_pasado = proporcional;
}
void motores(int motor_izq, int motor_der)
{
if ( motor_izq >= 0 ) //motor izquierdo
{
digitalWrite(mot_i,HIGH); // con high avanza
analogWrite(pin_pwm_i,255-motor_izq); //se controla de manera
//inversa para mayor control
}
else
{
digitalWrite(mot_i,LOW); //con low retrocede
motor_izq = motor_izq*(-1); //cambio de signo
analogWrite(pin_pwm_i,motor_izq);
}
if ( motor_der >= 0 ) //motor derecho
{

digitalWrite(mot_d,HIGH);
analogWrite(pin_pwm_d,255-motor_der);
}
else
{
digitalWrite(mot_d,LOW);
motor_der= motor_der*(-1);
analogWrite(pin_pwm_d,motor_der);
}
}
void frenos_contorno(int tipo,int flanco_comparacion)
{
if(tipo==0)
{
if (position<=500) //si se salio por la parte derecha de la linea
{
motores(-80,90); //debido a la inercia, el motor
//tendera a seguri girando
//por eso le damos para atras , para que frene
// lo mas rapido posible
while(true)
{
qtrrc.read(sensorValues); //lectura en bruto de sensor
if ( sensorValues[0]>flanco_comparacion || sensorValues[1]>flanco_comparacion )
//asegurar que esta en linea
{
break;
}
}
}
if (position>=6500) //si se salio por la parte izquierda de la linea
{
motores(90,-80);
while(true)
{
qtrrc.read(sensorValues);
if (sensorValues[7]>flanco_comparacion || sensorValues[6]>flanco_comparacion )
{
break;
}
}
}

}
//*******
if(tipo==1) //para linea blanca con fondo negro
{
if (position<=500) //si se salio por la parte derecha de la linea
{
motores(-80,90); //debido a la inercia, el motor
//tendera a seguri girando
//por eso le damos para atras ,
//para que frene lo mas rapido posible
while(true)
{
qtrrc.read(sensorValues); //lectura en bruto de sensor
if ( sensorValues[0]<flanco_comparacion || sensorValues[1]<flanco_comparacion )
//asegurar que esta en linea
{
break;
}
}
}
if (position>=6500) //si se salio por la parte izquierda de la linea
{
motores(90,-80);
while(true)
{
qtrrc.read(sensorValues);
if (sensorValues[7]<flanco_comparacion || sensorValues[6]<flanco_comparacion)
{
break;
}
}
}
}
}

Robot Lenin, seguidor de linea para competencias

Lenin bsicamente es un robot seguidor de lineas muy sencillo construido con mdulos
bsicos. Se dise basndose en el robot Zero.

Los componentes usados son:

Arduino Pro Mini 16 MHz 5v

Sensores QTR-8A de pololu

Ruedas de pololu, solarbotic o banebots

Ball caster de plastico

Bateria walkera de 3,7 V y 240 mAh

Soporte de motores

Boost de 4-25 V

Boost de 5 V

Motor HP pololu 10:1

Driver TB6612FNG

Tornillos de plastico (opcionales)

Forex (para el chasis) en Venezuela lo consigues como "pvc inflado" o "espuma de pvc"

Esta configuracin se obtuvo luego de muchas pruebas. Result ser la mas idnea para las
pruebas en competencias venezolanas donde hay muchas curvas y poco espacio para
acelerar, por lo que se necesita un robot pequeo y lo ms ligero posible, para salir de las
curvas rpido y tener poca inercia.
El tema del peso fue extremadamente importante, nos dimos cuenta que mientras ms
ligero mejor. Llegando al punto que el robot solo pesa 54 gramos (47 sin batera). Para
lograrlo usamos hilos de cobre esmaltado para las conexiones entre mdulos y sensores y
substituimos los pesados tornillos de metal por unos de acrlico.

Explicacin detallada de componentes probados:

Dimensiones y peso:
~15x10 cm
57 gramos
Controlador (arduino pro mini):

Elegimos el arduino pro mini por varias razones:

- Es liviano
- Consume muy poco
- Facilidad de programacin
- Viene sin pines soldados (usamos los que necesitemos)
- Se consigue en Venezuela
- Es el ms econmico
- En nuestro caso compramos la versin ms moderna que tiene 8 entradas analgicas que
es justamente la cantidad de sensores analgicos que vamos a usar.
Aunque tiene la desventaja de no poseer puerto usb, hay que cargarle los sketch a travs de
un adaptador usb-serial, para ello usamos un arduino duamilanove sin micro.

Sensores de linea QTR-8A:

- Por ser analgico nos permite lecturas ms precisas de la linea y una mayor resolucin,
permitiendo que podamos distinguir si el sensor est sobre la linea inclusive esta a medias
sobre esta.
- Tiene 8 sensores que es una cantidad suficiente para llevar un buen control PID del robot.
Estos sensores son costosos, pero pueden ser sustituidos por CNY70 o por QRD1114.

Ruedas:
Es sin duda uno de los aspectos ms importantes. Por lo general, la mayor limitacin es el
agarre. Mientras ms agarre a mayor velocidad puede girar en las curvas.
Hemos comprado 3 ruedas para determinar cual es la mejor.

Ruedas de solarbotics:
Tienen buen agarre, aunque son pesadas. Cuando se usan el robot es sacado de las curvas
por la centrifuga.

Ruedas banebots.
Vienen en tres tipos de material: verde blando, naranja semiduro y azul duro. Eleg las
verdes porque son las que tienen mejor traccin. Aunque estas son las que se desgastan ms
no importa, puesto que las pistas de velocistas son lisas y el desgaste es mnimo.
Estas ruedas tienen el mejor agarre, el detalle es que son demasiado pesada (incluso mucho
mas que las solarbotics). Hace que el robot acelere lento, y la respuesta sea mucho menos
delicada, por lo cual quedan descartadas. Se puede usar si se substituye la pieza central por
una de acrlico, pero no lo he intentado.

Ruedas pololu: Son finitas y pesan solo 3 gramos.

El caucho tiene surcos lo cual no es beneficioso en absoluto puesto que limita
la superficie de contacto. La solucin a esto es quitar esos surcos lijando la
rueda. Por ser tan liviana esta rueda no nos saca en las curvas. Es ideal para
pistas pequeas y con muchas curvas como en las competencias venezolanas.
Nos decantamos por estas rueditas.
Un dato: en cada prueba del robot debe limpiar las ruedas. El polvo limita
mucho el agarre.

Actualizado (2015)
Para las ultimas competencias se utilizaron ruedas impresas en 3D
Estas ofrecen ms superficie de contacto y su radio es muy inferior a las de
pololu.
El aumento de estabilidad y agarre fue considerable. Nos basamos en el
modelo en 3D de las ruedas del robot zero. Se le modific el ancho de la chapa

puesto que esta se quebraba con mucha facilidad.

Para las gomas se usaron las que traen las ruedas de pololu, las de banebots,
inclusive se hizo la prueba con silicn fri. Al final nos quedamos con unas
gomas kyosho que compramos por ebay

Ball caster
La ball caster no debe estar muy alejada del eje de loas ruedas, puesto que
mientras mayor sea la separacin mayor es la distancia que recorre para un
giro determinado, lo que aumenta la friccin y disminuye el control.

Puede ver que mientras mas se aleja del eje de las ruedas "ms se mueve"
Estas son las opciones que he probado:

Led:
S, as como lees. Un led como ball caster es una buena opcin, Es liviano y
podemos graduar la altura inclinandolo. La desventaja es que con la friccin el
led se va desgastando y hay que cambiarlo continuamente.

Ball caster de metal: tiene muy poca friccin y se desliza muy bien. La
recomiendo para pistas largas. La desventaja es que pesa mucho (3.96
gramos) y si lo colocas en la parte delantera del robot el control se va a
complicar por el efecto palanca.

Ball caster de plstico. Ideal, es liviana y rueda bien. Los inconvenientes es

que luego de mucho uso va desgastando el holder trayendo consigo serios
problemas de control puesto que aumenta la friccin. Aunque tenga ms
friccin esta es la que gana la batalla por pesar 4 veces menos que la de
metal. La diferencia de control entre ambas es notorio.

Batera (Lipo walkera 3.7 V y 240 mAh)

La batera a usar depende del consumo del robot y la duracin de prueba en la

competencia. La batera ideal es aquella que se agota justo despus de haber
pisado la meta. Si dura mucho ms es porque hay peso adicional intil y si dura
menos es que no es suficiente para nuestro robot. La tasa de descarga nos
indica "cuanta corriente puede proveer la bateria". Debemos conseguir una
batera en la cual la tasa de descarga sea ligeramente superior al consumo de
nuestro robot.
Para calcular la tasa de descarga puedes usar esta formula:
Tasa_de_descarga = Capacidad_de_la_bateria * Razn_de_descarga
Donde:
La Capacidad_de_la_bateria es la indicada en mAh. La batera de la foto tiene una
capacidad de 240 mAh.
La Razn_de_descarga es un nmero seguido de la letra "C", por ejemplo la batera de
la foto indica 30C por lo que su razn de descarga es 30.
Entonces, la tasa de descarga de la batera de la foto es = 240 * 30 = 7200 mA
= 7,2 A
Como s que mi robot consume 4,2 A (en pico) entonces puedo determinar que
esta batera le funciona perfectamente sin cortes de energa.
Para cargar las bateras se utiliz un arduino fio

Soporte de motores:

Es de suma importancia la alineacin de los motores, para ello puedes usar

estos soportes. Recuerda que los elementos pegados con pegamentos tienden
a ceder por la vibracin. Estos soportes vienen con tornillos de metal con sus
respectivas arandelas. Substituimos esto por tornillos de acrlico y nos
ahorramos unos cuantos gramos.

Elevador de voltaje (Boost o DC-DC)

Es lo que nos permite convertir los 3.7 V de la batera a los 12 V que necesitan
los motores para funcionar.
Es una gran ventaja porque nos ahorra el tener que usar dos pesadas baterias
de 7.4V. Adems mantiene estable el voltaje de alimentacin lo que garantiza
que el PWM aplicado a los motores no debe ser ajustado dependiendo del
estado de la batera.
Este circuito se puede fabricar a mano o se puede comprar el mdulo (ahorra
mucho trabajo).
Nosotros usamos el boost 4-25V de Pololu pero se pueden usar otros como el
XL6009.
Boost de 4-25 V De Pololu

Son EXTREMADAMENTE delicados y deben ser tratados con mucha precaucin.

Durante el proceso de construccin del robot quemamos 3 de estos. Son
bastante caros pero hacen bien su trabajo. El voltaje de entrada nunca puede
ser superior al voltaje de salida. Recomiendo colocar un diodo a la salida para
evitar contras. Cuando se recalienta, el carbon que tiene en la bobina se
despega. SI esto ocurre revisa que ests haciendo mal, es el primer aviso antes
de quemarse.Este es un punto dbil del robot que siempre nos tiene alertas
porque puede daarse en cualquier momento puesto que le exigimos ms de lo
que indica de fabrica.

Boost XL6009

Es unas 5 veces ms barato que el de Pololu. Soporta el doble de amperaje, se

recalienta menos y es mucho ms robusto y durable, adems de tener
proteccin contra-corriente. El nico inconveniente es su peso y tamao. Es

una buena opcin si quieres quitarte la preocupacin de que se te queme el

boost en cualquier momento.

Este es un velocista llamado Xubots. Particip en la ulabots 2014 y usaba

el XL6009

Boost de 5 V:

Se usa para alimentar los componentes lgicos (Arreglo de sensores, arduino y

motor driver). Tambin son delicados y de igual forma se recomienda ponerle
un diodo a la salida.

Motor HP 10:1 de Pololu:

Inconvenientes:
- El shaft en media luna hace que vibre
- Su consumo no es eficiente.
- Los engranajes estn expuestos y se daan con facilidad ante la obstruccin
de algn granito de arena. Hay que protegerlos mucho.
- No son precisos y el freno fem es dbil.
Ventajas:
- Es pequeo y liviano
- Es lo mejor que vamos a conseguir en ese precio.
- Tiene un torque aceptable.
Consejo: suelden bien los cables de alimentacin puesto que la
vibracin por el shaft en D hace que se despeguen con facilidad.
Cuando se piensa en motores pololu generalmente se elige entre 10:1 y 5:1. La
eleccin depende del peso de tu robot y del tipo de pista.
Si eliges motores 10:1 tendras ms torque, lo que permite tener buen control,
preciso, aceleracin y un mejor frenado. Es ideal si tu robot pesa ms de 60
Gramos y/o si el tipo de pista es pequea con muchas curvas. En las
competencias venezolanas el mayor tiempo del recorrido se tarda en
desacelerar para entrar en una curva y acelerar para salir de esta, no hay

tramos de recta que nos dejen alcanzar altas velocidades.

Los 5:1 nos permiten llegar a mayores velocidades pero con menor aceleracin.
Adems la inercia del motor es mayor y es difcil detenerlo para frenar en las
curvas. Para usarlos deberas tener un robot liviano y bastante agarre. Adems
con la experiencia aprendimos que hay que trabajarlos con ms de (13 V) para
poder frenar en las curvas.
Existen otras alternativas para los motores como los motores maxon o
faulhaber. Aunque son alternativas muy caras valen la pena si queremos hacer
un velocista fuera de lo normal. Por lo general, en micromouse usan los
motores faulhaber 1717, logrando velocidades increbles. Una opcin ms
barata son los motores mabuchi. Aqu puede ver un video de un robot que los
tiene y va bastante rpido.

Driver

L298n: Fue el primer driver que usamos. Es barato pero desperdicia

demasiada energa en forma de calor lo que reduce el tiempo de batera y
recalienta el boost. Adems de ser pesado y no poseer la funcin de freno,
ocupa mucho espacio y eleva el centro de masa. El control se vuelve bastante
difcil y es complicado alcanzar una velocidad alta. No lo recomiendo para
seguidores de linea. Aunque conseguimos un robot relativamente rpido.

TB6612FNG: Buen driver, con el se logr una buena velocidad. Es

liviano, pequeo y tiene la funcin de freno. Cuando lo
instalamos conseguimos que la duracin de la batera pasara de
4 min a 13 min. El boost ya no se recalienta tanto como antes.

Chasis

Para nuestro primer modelo usamos

forex de 3 mm. Luego rebajamos el peso y lo cambiamos a uno de 2 mm, lo
cual disminuy de forma considerable el peso. Ventajas
- Peso ligero
- Alta resistencia
- Facilidad de limpieza
- No se hincha ni se pudre
- Es rgido pero fcilmente se puede cortar con un exacto
- Permite imprimir sobre el (para hacer diseos) El forex tiene muchos
nombres:
"PVC espumado"
"Espuma de PVC"
"PVC inflado"
Mis laminas de 20 x 20 las compre por mercadolibre a una distribuidora de pvc

Conexiones
Diagrama de conexiones de un seguidor de linea bsico:

Las conexiones entre mdulos se hicieron con hilos de cobre esmaltado. Lo que reduce el
peso de forma considerable.

/*
* [ Cdigo Fuente: Robot Velocista Lenin ]
* [ Fecha: Agosto 2013 ]
*
* [ Equipo: Bolchevique ]
*
- Abraham Jos
*
- Lihon Fredy
*
- Oliveros Hector
*/
#include <QTRSensors.h>
#define
#define
#define
#define
#define
#define
#define

STANDBY
MOTORLEFT_DIR_A
MOTORLEFT_DIR_B
MOTORLEFT_PWM
MOTORRIGHT_DIR_A
MOTORRIGHT_DIR_B
MOTORRIGHT_PWM

9
7
8
6

// pin STANDBY del Motor Driver

// pin 1 de direccin del Motor Izquierdo
// pin 2 de direccin del Motor Izquierdo
// pin PWM del Motor Izquierdo
4 // pin 1 de direccin del Motor Derecho
3 // pin 2 de direccin del Motor Derecho
5 // pin PWM del Motor Derecho

#define NUM_SENSORS

// nmero de sensores usados

// cant. lecturas analgicas que sern ledas por sensor

#define NUM_SAMPLES_PER_SENSOR
#define EMITTER_PIN
#define ENCODERPIN 10
#define LEDPIN
13
#define BUTTONPIN 2

4
11

// pin emisor del QTR

// pin del encoder
// nmero del pin de test
// boton externo

// funcin para pulsar el botn y esperar que deje de pulsarlo

#define esperarBoton() while(!digitalRead(BUTTONPIN));
while(digitalRead(BUTTONPIN))

// estructura para los sensores

QTRSensorsAnalog qtra((unsigned char[])
{A0, A1, A2, A3, A4, A5, A6, A7}
, NUM_SENSORS, NUM_SAMPLES_PER_SENSOR, EMITTER_PIN);
// arreglo para almacenamiento de valores por sensor
unsigned int sensorValues[NUM_SENSORS];
// funcin Velocidad Motor Izquierdo
void setMotorLeft(int value)
{
if ( value >= 0 )
{
// si valor positivo vamos hacia adelante
digitalWrite(MOTORRIGHT_DIR_A,HIGH);
digitalWrite(MOTORRIGHT_DIR_B,LOW);
}
else
{
// si valor negativo vamos hacia atras
digitalWrite(MOTORRIGHT_DIR_A,LOW);
digitalWrite(MOTORRIGHT_DIR_B,HIGH);
value *= -1;
}
// Setea Velocidad
analogWrite(MOTORRIGHT_PWM,value);
}
// funcin Velocidad Motor Derecho
void setMotorRight(int value)
{
if ( value >= 0 )
{
// si valor positivo vamos hacia adelante
digitalWrite(MOTORLEFT_DIR_A,HIGH);
digitalWrite(MOTORLEFT_DIR_B,LOW);
}
else
{
// si valor negativo vamos hacia atras
digitalWrite(MOTORLEFT_DIR_A,LOW);
digitalWrite(MOTORLEFT_DIR_B,HIGH);
value *= -1;
}

// Setea Velocidad
analogWrite(MOTORLEFT_PWM,value);
}
// funcin Velocidad Motores
void setMotors(int left, int right)
{
digitalWrite(STANDBY,HIGH);
setMotorLeft(left);
setMotorRigh(right);
}
// funcin Freno en Motores
void setBrake(boolean left, boolean right, int value)
{
// pin STAND BY
digitalWrite(STANDBY,HIGH);
if ( left )
{
// pines LEFT motor
digitalWrite(MOTORRIGHT_DIR_A,HIGH);
digitalWrite(MOTORRIGHT_DIR_B,HIGH);
analogWrite (MOTORRIGHT_PWM, value);
}
if ( right )
{
// pines RIGHT motor
digitalWrite(MOTORLEFT_DIR_A,HIGH);
digitalWrite(MOTORLEFT_DIR_B,HIGH);
analogWrite (MOTORLEFT_PWM, value);
}
}
void setup()
{
// inicializar pines de
pinMode(LEDPIN
pinMode(STANDBY
pinMode(MOTORRIGH_DIR_A
pinMode(MOTORRIGH_DIR_B
pinMode(MOTORRIGH_PWM
pinMode(MOTORLEFT_DIR_A
pinMode(MOTORLEFT_DIR_B
pinMode(MOTORLEFT_PWM

salida
,OUTPUT);
,OUTPUT);
,OUTPUT);
,OUTPUT);
,OUTPUT);
,OUTPUT);
,OUTPUT);
,OUTPUT);

pinMode(BUTTONPIN

,INPUT);

// presiona botn para activar calibracin

while ( !digitalRead(BUTTONPIN) );
// calibrar sensores QTRA, titilando LED como gua
for ( int i=0; i<70; i++)
{
digitalWrite(LEDPIN, HIGH); delay(20);
qtra.calibrate();
digitalWrite(LEDPIN, LOW); delay(20);
}
// apagar LED
digitalWrite(LEDPIN, LOW);
// presionar botn para correr el robot
while ( !digitalRead(BUTTONPIN) );
// esperar 5 segundos
delay(5000);
// mover el robot suave para ganar inercia
setMotors(90, 90);
// durante 0.3 segundos
delay(300);
}
unsigned int position = 0;
int derivative = 0;
int proportional = 0;
int power_difference = 0;

//
//
//
//

posicin actual de los sensores

derivada
proporcional
velocidad diferencial

// Mxima velocidad en el poder diferencial

int max = 123;
// Ultima Proporcional
int last_proportional;
// Constantes Proporcional y Derivativa
float KP = 0.17;
float KD = 2.2;
// Constante para Rango de Freno (Range Brake)

#define RANGEBRAKE 3500

void loop()
{
// Obtiene la posicin de la linea
// Aqu no estamos interesados en los valores
// individuales de cada sensor
position = qtra.readLine(sensorValues);
// El trmino proporcional debe ser 0 cuando estamos en lnea
proportional = ((int)position) - 3500;
// Si entra en el rango de freno, aplicarlo en la
// direccion de la curva
if ( proportional <= -RANGEBRAKE )
{
setMotorRigh(0);
setBrake(true,false,255);
delay(1);
}
else if ( proportional >= RANGEBRAKE )
{
setMotorLeft(0);
setBrake(false,true,255);
delay(1);
}
// Calcula el trmino derivativo (cambio) de la posicin
derivative = proportional - last_proportional;
// Recordando la ltima posicin
last_proportional = proportional;
// Calcula la diferencia entre la potencia de los dos motores [ m1 - m2
].
// Si es un nmero positivo, el robot gira a la [ derecha ]
// Si es un nmero negativo, el robot gira a la [ izquierda ]
// y la magnitud del nmero determina el ngulo de giro.
int power_difference = ( proportional * KP ) + ( derivative * KD );
// Si velocidad diferencial es mayor a la posible tanto positiva como
negativa,
// asignar la mxima permitida
if ( power_difference > max ) power_difference = max;
else if ( power_difference < -max ) power_difference = -max;

// Asignar velocidad calculada en el poder diferencial de los motores

( power_difference < 0 ) ?
setMotors(max+power_difference, max) : setMotors(max, maxpower_difference);
}