Seguidor de línea
Nota: Este articulo fue escrito con la colaboración de nuestro amigo robotista Sebástian Agudelo,
agradecemos mucho su apoyo e interés en compartir su conocimiento y experiencia con la
comunidad.
Después de un largo tiempo tenemos la oportunidad de actualizar nuestro ya éxitoso tutorial de
robot seguidor de línea (http://tdrobotica.co/noticias/robotica/53), vale la pena decir que no es
cualquier actualización, este tutorial muestra las partes y funcionamiento de uno de los seguidores
de línea más famosos del 2012 y 2013 en las competencias de Bogotá, Colombia.
Para muchas personas un robot seguidor de línea es la puerta de entrada al mundo de la electrónica
y la robótica, para otros se convierte en una obsesión, en un reto, en una excusa para continuar
mejorando sus conocimientos y experiencia en la robótica. Creemos que esta última opción es la
que mejor define a Sebastián y sus creaciones.
Iniciemos conociendo a Sebastián y sus robots en este vídeo entrevista realizada por Ibraim:
http://www.youtube.com/watch?feature=player_embedded&v=69b3wklPo34
Ahora dejemos que Sebastián nos guíe sobre los pasos para construir tu robot seguidor de línea
éxitoso para este nuevo año.
1. Meta del Proyecto
En este pequeño artículo intentaremos lograr que construyas un robot seguidor de línea negra
velocista, realmente muy sencillo con pocos conocimientos, pero muy rápido y eficaz.
Demostración de funcionamiento de Relampago, el robot que vamos a construir:
http://www.youtube.com/watch?feature=player_embedded&v=hrQia8Y_xO0
2. Materiales a Usar
Para empezar crearemos una lista de todos los materiales que necesitas, aparte de esto te hará falta
herramientas básicas como destornilladores, alicates, cautín, estaño, y muchas ganas de empezar.
Fíjate que todos los elementos del robot Relampago los puedes conseguir en tdrobotica, solo haz
clic en el nombre del producto para que puedas ver su precio y proceder a realizar la compra para tu
próximo robot seguidor de línea.
2 Motores Pololu 10:1: Gracias a las características de reducción y el diseño del
robot este motor acopla perfectamente con las necesidades
requeridas. IMPORTANTE: Si se quiere un robot más grande o pesado
recomendamos usar motores Pololu 30:1.
Soporte para micro motores: Este soporte te permite fijar el motor a la base del
robot con mucha seguridad, especializado para micromotores pololu.
Regleta Sensores QTR 8A: Estos sensores ya ensamblados te permiten ahorrar
mucho tiempo y dinero, son 8 sensores ya arreglados para una detección de línea
óptima. Entre mayor número de sensores tienes mayor es la velocidad a la cual el
robot puede ir ya que siempre puede encontrar la línea que debe de seguir.
Hemos visto robot seguidor de línea con hasta 24 sensores!!!
Regulador 5v 100mAH: Es absolutamente indispensable para no dañar los
sensores, ya que funcionan con 5v.
Trompa Robot: Este componente es de acrílico, al final del tutorial encontraras un
archivo zip en donde se encuentran los planos para que lo puedas fabricar.
Placa Baby Orangután: Esta pequeña placa agrupa un puente H para controlar los
motores y un microcontrolador conectados previamente ahorrándote
prácticamente toda la parte electrónica y será nuestro controlador. Definitivamente
es la mejor opción que puedes tener para tu robot basados en las características de
tamaño, precio, potencia y fácilidad de programación.
Programador AVR Pololu: Para programar el Baby Orangutan es necesario usar
este programador de AVR, puedes programarlo ya sea desde el AVR Studio o la
interfaz de programación de Arduino como será nuestro caso..
Ruedas para Sumo 1K: Son indispensables este tipo de ruedas ya que aunque el
robot es un seguidor de línea, al alcanzar velocidades de más de 2 mts segundo
necesita un agarre optimo en cada curva.
Placa, PCB Robot: Esta placa será la estructura del robot, donde se soldaran y
acoplaran todos los componentes. También puedes encontrar los diseños en el
archivo adjunto al final.
Batería 7.4v 500mAH: Las baterías de LiPo son la mejor opción en robótica el día
de hoy, está en particular es excelente opción para el robot ya que su tamaño y
peso en relación a su eficiencia es muy buena. Ten en cuenta que estás baterías no
se puede cargar con cualquier cargador, sino que se necesita un cargador especial
que también encuentras en tdrobotica: cargador de baterías de LiPo.
2 Cables de 5 Pines: Lo usaras para conectar los sensores a la placa del robot.
Regleta 40 Pines: Esto lo usaras en conjunto con los cables de 5 pines, igualmente para conectar la
batería a la placa.
Regleta Hembra: Esta se usara para conectar la baby orangután a la placa principal. Este elemento
al igual que los siguientes los conseguiras con tu proveedor favorito de partes electrónicas.
Cable Delgado 1mts: Sera necesario para conectar el motor a la placa.
2 Leds 3mm: Te indicara el estado del robot, y será una buena decoración.
1 Interruptor: Permite el paso de energía para programar, o usar el robot.
1 Pulsador: Te permitirá activar el robot para que empiece a funcionar.
Resistencias Superficiales 1k: Resistencias para los leds y el pulsador, su función es no dañar los
leds y no crear un corto con el pulsador al microcontrolador de la placa Baby Orangutan.
Super Bonder: Más conocido como pegante instantáneo, se usara demasiado para algunos ajustes.
3. Construcción y Diseño
3.1 Placa, PCB Robot
En este caso el chasis del robot es la misma placa PCB, se ha realizado así para minimizar el peso
del robot y hacer que la potencia de los motores se aproveche de la mejor manera. Adicionalmente
es uno de los principales componentes del robot, ya hemos realizado el diseño y te lo presentamos
para que te guíes, por supuesto te aconsejamos que lo modifiques y le des a tu robot una forma
única. Puedes fabricar esta placa manualmente o mandarla fabricar según sea tu experiencia.
Puedes encontrar en el zip del proyecto una carpeta con todos los diseños para que los modifiques y
un archivo en pdf que te puede servir también para crear tu propio chasis. El diseño se realizó en
el PCB Wizard, puedes descargar una versión de prueba en el sitio web del fabricante aquí.
3.2 Soldar Componentes a tu Placa
Cuando ya tengas la placa lista debes ahora soldar todos los componentes a ella, te explicaremos de
forma grafica y sencilla en donde debe ir cada uno de los componentes y su orden especifico.
3.3 Soldar y Colocar Motores
El siguiente paso es soldar a cada una de las terminales del motor un cable corto de 5 cm, los otros
extremos del cable deberán ser soldados a la placa teniendo en cuenta la imagen anterior.
Siguiente a esto, se debe con los soportes para motores, ajustar los motores uno en cada lado,
siguiendo los agujeros de referencia en la placa.
3.4 Trompa del Robot
Como antes especificamos en la lista de materiales necesitas una trompa para el robot donde
colocaras los sensores para que detecten la línea, hemos diseñado unos archivos para que la mandes
a fabricar y que puedes encontrar en el zip al final del tutorial. Los archivos corresponden a:
-Trompa Robot Archivo Corel (Corte Laser)
-Trompa Robot PDF (Corte Artesanal)
Cuando tengas ya tu trompa debes pegar la parte número uno, a la placa principal del
robot. Seguidamente con 2 pequeños tornillos ajustar a la parte numero uno la número dos que ira
abajo, encajando los agujeros perfectamente, con esto podrías cambiar el largo del robot.
3.5 Sensores y Cables
¡Muy bien!, pronto terminaras tu seguidor velocista!
Ahora el siguiente paso es soldar la regleta que tiene incluida los sensores, de esta manera:
IMPORTANTE: No soldar nada en el “By Pass”
Seguidamente colocar los sensores en la base numero 2 de la trompa del robot, entran
perfectamente, y para ajustarlos debes tener 2 pequeños tornillos.
Cuanto ya tengas todo esto armado el siguiente paso es usar los 2 cables de 5 pines y conectar un
extremo de ambos cables a la regleta de sensores, y el otro extremo a la regleta de 11 pines que
soldamos en nuestro robot.
Si hiciste correctamente todo el paso todo debería verse algo así:
3.6 Ruedas
Tu seguidor cada vez tiene más forma, y es hora de colocarle sus respectivas ruedas, como antes
hemos mencionado aunque estas ruedas sean de sumo, son excelentes para el seguidor de línea
velocista ya que tienen un agarre increíble.
Para colocar las ruedas de tu robot debes insertar el eje del motor en el rin, verificando que la parte
plana del eje este contra el tornillo, seguidamente pasar ajustarlo.
Ya ajustado debes insertar el neumático a presión y ya tienes una de las dos ruedas en el robot…
Sigue los mismos pasos para la otra.
4. Programación
Esta es la etapa final de tu seguidor, no queremos que esta sea una etapa compleja y para esto te
daremos todo para que tu seguidor funcione y lo puedas adaptar a tus necesidades.
4.1 Arduino y Configuración
Ya que la idea del robot es que sea muy sencillo y fácil de comprender, se decidió usar el famoso
software Arduino, ya que es fácil e intuitivo y seguramente lo aprenderás en poco tiempo.
Adicionalmente si no sabes nada de Arduino te recomendamos visitar estos muy buenos tutoriales
aquí.
Antes de programar nuestro robot, debemos tener en cuenta que usamos una placa no nativa con el
entorno Arduino y debemos configurar y cambiar algunas cosas para que la placa sea programada
correctamente.
Pololu la empresa que fabrica esta placa, te explica un poco que debes hacer para que funcione
debidamente en el siguiente link:
http://www.pololu.com/docs/0J17/3
Igualmente tienes que instalar los drivers del programador, en este link Pololu te explica:
http://www.pololu.com/docs/0J6/4
Después de estos pasos, hay que guardar las siguientes librerías en esta dirección en tu PC: C:\
Program Files (x86)\Arduino\libraries En el caso que Arduino esté instalado en otra dirección tienes
que buscarla y guardar las librerías en la carpeta libraries. Adjunto Archivo
4.2 Programa
¡¡¡En buena hora solo falta programar tu robot y lo tendrás en pista de inmediato!!!.
Para programar la placa debes conectarla el programador de AVR Al Baby Orangutan.
Con la batería puesta debes prender el robot y verificar que en la placa Baby Orangutan prenda el
led verde, de otra forma alguno de los pasos anteriores incluso la PCB puede estar mal. Si todo sale
bien conecta el programador a tu PC ya configurado y este a tu Baby Orangutan.
Abre el entorno Arduino y pega el siguiente Código, también lo encuentras en la documentación
adjunta.
1 #include <QTRSensors.h>
2 #include <OrangutanMotors.h>
3 //------------------------------------------------------------------------------------//
4 //Sensores de Linea PD
5 #define NUM_SENSORS 6 // Numero de sensores que usa
6 #define NUM_SAMPLES_PER_SENSOR 5 // Muestras por sensor
7 #define EMITTER_PIN 2 // emitter is controlled by digital pin 2
8 // sensors 0 through 5 are connected to analog inputs 0 through 5, respectively
9 QTRSensorsAnalog qtra((unsigned char[]) {0, 1, 2, 3, 4, 5},
10 NUM_SENSORS, NUM_SAMPLES_PER_SENSOR, EMITTER_PIN);
11 unsigned int sensorValues[NUM_SENSORS];
12 OrangutanMotors motors;
13 //--------------------------------------------------------------------------------------//
14 //Velocidad Maxima Robot//--------------------------//----------------------------------//
15 const int maximum = 80
16 //--------------------------------------------------------------------------------------//
17 //VALORES PD//----------//VALORES PD//--------------------------------------------------//
18 int VPropocional = 1.45;
19 int VDerivarivo = 16;
20 //--------------------------------------------------------------------------------------//
21 //Velocidad de Calibracion
22 int velcalibrate = 20;
23 //--------------------------------------------------------------------------------------//
24 void setup()
25 {
26 int inPin = 10;
27 int val = 0;
28 pinMode(9, OUTPUT);
29 pinMode(8, OUTPUT);
30 pinMode(inPin,INPUT);
31
32 val = digitalRead(inPin);
33 while (val == HIGH)
34 {
35 digitalWrite(9, HIGH);
36 digitalWrite(8, HIGH);
37 val = digitalRead(inPin);
38 };
39 if (val == LOW)
40 {
41 digitalWrite(9, LOW);
42 digitalWrite(8, LOW);
43 };
44 motors.setSpeeds(0,0);// Motores detenidos
45
46
47 //-------------Instrucciones para Empezar a hacer la Calibracion de Sensores--------------------------------------//
48
49 delay(1500);
50 digitalWrite(9, HIGH);
51 digitalWrite(8, HIGH);// Enciende el leds para indicar que se esta calibrando.
52 for (int counter=0; counter<21; counter++)
53 {
54 if (counter < 6 || counter >= 15)
55 OrangutanMotors::setSpeeds(-velcalibrate, velcalibrate);
56 else
57 OrangutanMotors::setSpeeds(velcalibrate, -velcalibrate);
58 qtra.calibrate();
59 delay(20);
60 }
61
62 digitalWrite(9, LOW); // Apaga el led para indicar que se termino la calibracion.
63 digitalWrite(8, LOW);
64
65 OrangutanMotors::setSpeeds(0, 0);
66
67 delay(200);
68 digitalWrite(9, HIGH);
69 digitalWrite(8, HIGH);
70 delay(200);
71 digitalWrite(9, LOW); // Parpadeo para indicar que el robot esta listo.
72 digitalWrite(8, LOW);
73 delay(200); // Parpadeo para indicar que el robot esta listo.
74 digitalWrite(9, HIGH);
75 digitalWrite(8, HIGH); // Parpadeo para indicar que el robot esta listo.
76 delay(200);
77 digitalWrite(9, LOW); // Parpadeo para indicar que el robot esta listo.
78 digitalWrite(8, LOW);
79 delay(200);
80 //---------------------------Fin Calibracion de Sensores----------------------------------------------------//
81 pinMode(inPin,INPUT);
82
83 val = digitalRead(inPin);
84 while (val == HIGH)
85 {
86 digitalWrite(9, HIGH);
87 digitalWrite(8, HIGH);
88 val = digitalRead(inPin);
89 };
90 if (val == LOW)
91
92
93
94
95
96
97
98
99
100
101
102
{
103
digitalWrite(9, LOW);
104
digitalWrite(8, LOW);
105
delay(1000); // Retardo X segundos antes de Empezar a andar
106
};
107
}
108
unsigned int last_proportional = 0;
109
long integral = 0;
110
void loop()
111
{
112
113
unsigned int position = qtra.readLine(sensorValues); // leemos posicion de la linea en la variable position
114
115
// Referencia donde seguira la linea, mitad sensores.
116
int proportional = (int)position - 2500;
117
// Calculos PD
118
int derivative = proportional - last_proportional;
119
integral += proportional;
120
last_proportional = proportional;
121
122
int power_difference = proportional/VProporcional + integral*0 + derivative*VDerivativo;
123
124
if (power_difference > maximum)
125
power_difference = maximum;
126
if (power_difference < -maximum)
127
power_difference = -maximum;
128
129
if (power_difference < 0)
130
OrangutanMotors::setSpeeds(maximum, maximum + power_difference);
131
else
132
OrangutanMotors::setSpeeds(maximum - power_difference,maximum);
133
};
134
135
136
137
138
139
140
141
142
143
144
145
Antes de programarlo deberás seleccionar la placa Baby Orangutan y el Programador AVR ISP v2
de la siguiente forma:
Selección Baby Orangutan:
Selección Programador:
Cuando ya tengas esto seleccionado, lo único que falta es que programes y tu robot debería
funcionar torpemente.
5. Ajuste del Control
En esta etapa si hablaremos un poco más del control para que entiendas el funcionamiento básico y
porque tienes que ajustarlo.
Tu robot tiene programado un control llamado PD (Proporcional – Derivativo), no entrare en detalle
acerca del él, ya que matemáticamente es un poco complejo, este control tiene 2 variables que
cambian la respuesta del robot en cada situación, literalmente son 2 numero que pueden cambiar
todo.
Esto quizá es la parte más compleja del robot ajustar esos dos números mediante muchas pruebas,
aunque algunos tips te pueden facilitar la obtención de los valores adecuados, a continuación veras
cuales y donde se encuentran en el código estos números:
1
//--------------------------------------------------------------------------------------//
2
//VALORES PD//----------//VALORES PD//--------------------------------------------------//
3
int VPropocional = 1.45;
4
int VDerivarivo = 16;
5
Otro valor importante es la velocidad del robot, que varía de 0 a 255 y se encuentra en este lugar:
1
//--------------------------------------------------------------------------------------//
2
//Velocidad Maxima Robot//--------------------------//----------------------------------//
3
const int maximum = 80
4
Retomando los valores del PD para lograr ajustarlos, una vez que estás seguro que el robot
funciona, debes al valor llamado VProporcional: darle un numero bajo, y el Valor
llamado VDerivativo: Darle un valor de 0, una vez hagas esto programas el robot y pruebas que
quede oscilatorio pero siguiendo la línea, sin volverse loco a la velocidad que tu deseas, te
recomiendo empezar con menos de 150.
Hay dos posibilidades, una que el robot oscile de una manera adecuada sin descontrolarse, y otra
que el robot se vuelva “loco”, si sucede esto debes conectar al PC nuevamente y probar otro valor
hasta encontrar la oscilación adecuada.
Si ya has encontrado la oscilación adecuada, es el momento para agregarle un número al valor
llamadoVDerivativo, podrías agregarle un número mayor al valor de VProporcional, prográmalo y
prueba el robot… Podrás notar que el robot tiene un comportamiento totalmente diferente y que ese
valor cambio todo, ahora es cuestión de cambiar esos valores hasta encontrar que el robot funcione
como en los videos que te hemos mostrado.
Esto es un arduo trabajo y lo que más toma tiempo, lo que yo te recomendaría es que varíes el
valorVDerivativo más que el VProporcional ya que este una vez encontrado es efectivo, una forma
de darte cuenta es que en rectas no oscile y acelere al 100% de la velocidad establecida, en este
punto tuVProporcional esta casi perfecto, ahora si se sale en las curvas debes cambiar
el VDerivativo poco a poco hasta encontrar el valor adecuado que haga conjunto con tu
valor VProporcional y poco a poco vallas subiendo la velocidad y cambiando los valores, la
velocidad del robot afecta los valores directamente.
NOTA: Hay que tener en cuenta que cada vez que el robot se apague debe calibrar sensores, esta
función está incluida en el código, y mueve el robot para que los sensores pasen por toda la línea,
cuando la batería esta descargada el robot le cuesta hacer esta operación y debe ser recargada.
