Seguidor de línea

AddThis Social Bookmark Button

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.

373

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 esta vídeo entrevista realizada por Ibraim:

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:

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.

373 032 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.

 

373 02

 

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!!!

 

373 04

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.

 

373 05Placa 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..

373 06

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.

 

373 07Baterí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.

373 08

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)

373 09

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:

373 10

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 todos los pasos todo debería verse algo así:

373 11

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.

373 12

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
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
#include <QTRSensors.h>
#include <OrangutanMotors.h>
//------------------------------------------------------------------------------------//
//Sensores de Linea PD
#define NUM_SENSORS             6  // Numero de sensores que usa
#define NUM_SAMPLES_PER_SENSOR  5  // Muestras por sensor
#define EMITTER_PIN             2  // emitter is controlled by digital pin 2
// sensors 0 through 5 are connected to analog inputs 0 through 5, respectively
QTRSensorsAnalog qtra((unsigned char[]) {0, 1, 2, 3, 4, 5}, 
  NUM_SENSORS, NUM_SAMPLES_PER_SENSOR, EMITTER_PIN);
unsigned int sensorValues[NUM_SENSORS];
OrangutanMotors motors;
//--------------------------------------------------------------------------------------//
//Velocidad Maxima Robot//--------------------------//----------------------------------//
const int maximum = 80
//--------------------------------------------------------------------------------------//
//VALORES PD//----------//VALORES PD//--------------------------------------------------//
int VPropocional = 1.45;
int VDerivarivo = 16;
//--------------------------------------------------------------------------------------//
//Velocidad de Calibracion
int velcalibrate = 20; 
//--------------------------------------------------------------------------------------//
void setup()
{
  int inPin = 10;
  int val = 0;
  pinMode(9, OUTPUT);
  pinMode(8, OUTPUT);
  pinMode(inPin,INPUT);
  
  val = digitalRead(inPin);
  while (val == HIGH)
  {
   digitalWrite(9, HIGH);
   digitalWrite(8, HIGH);
   val = digitalRead(inPin);
  };
  if (val == LOW)
 {
  digitalWrite(9, LOW);
  digitalWrite(8, LOW);  
};
  motors.setSpeeds(0,0);// Motores detenidos  
  
   
//-------------Instrucciones para Empezar a hacer la Calibracion de Sensores--------------------------------------//
  
  delay(1500); 
  digitalWrite(9, HIGH);
  digitalWrite(8, HIGH);// Enciende el leds para indicar que se esta calibrando.
    for (int counter=0; counter<21; counter++)
  { 
    if (counter < 6 || counter >= 15)
      OrangutanMotors::setSpeeds(-velcalibrate, velcalibrate);
    else
      OrangutanMotors::setSpeeds(velcalibrate, -velcalibrate);
      qtra.calibrate(); 
   delay(20);
  }
 
  digitalWrite(9, LOW);     // Apaga el led para indicar que se termino la calibracion.
  digitalWrite(8, LOW); 
 
  OrangutanMotors::setSpeeds(0, 0);
  
  delay(200);
  digitalWrite(9, HIGH);     
  digitalWrite(8, HIGH);
  delay(200);
  digitalWrite(9, LOW);     // Parpadeo para indicar que el robot esta listo.
  digitalWrite(8, LOW);
  delay(200);               // Parpadeo para indicar que el robot esta listo.
  digitalWrite(9, HIGH);     
  digitalWrite(8, HIGH);   // Parpadeo para indicar que el robot esta listo.
  delay(200);
  digitalWrite(9, LOW);     // Parpadeo para indicar que el robot esta listo.
  digitalWrite(8, LOW);
  delay(200);
  //---------------------------Fin Calibracion de Sensores----------------------------------------------------//
pinMode(inPin,INPUT);
  
  val = digitalRead(inPin);
  while (val == HIGH)
  {
   digitalWrite(9, HIGH);
  digitalWrite(8, HIGH);
  val = digitalRead(inPin);
  };
  if (val == LOW)
 {
  digitalWrite(9, LOW);
  digitalWrite(8, LOW);
  delay(1000); // Retardo X segundos antes de Empezar a andar  
};
}
unsigned int last_proportional = 0;
long integral = 0;
void loop()
{
  
  unsigned int position = qtra.readLine(sensorValues); // leemos posicion de la linea en la variable position
 
  // Referencia donde seguira la linea, mitad sensores.
  int proportional = (int)position - 2500;
  // Calculos PD
  int derivative = proportional - last_proportional;
  integral += proportional;
  last_proportional = proportional;
  
  int power_difference = proportional/VProporcional + integral*0 + derivative*VDerivativo;
  
  if (power_difference > maximum)
    power_difference = maximum;
  if (power_difference < -maximum)
    power_difference = -maximum;
  
    if (power_difference < 0)
    OrangutanMotors::setSpeeds(maximum, maximum + power_difference);
  else
    OrangutanMotors::setSpeeds(maximum - power_difference,maximum);
};

Antes de programarlo deberás seleccionar la placa Baby Orangutan y el Programador AVR ISP v2 de la siguiente forma:

Selección Baby Orangutan:

373 13

Selección Programador:

373 14

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
3
4
5
//--------------------------------------------------------------------------------------//
//VALORES PD//----------//VALORES PD//--------------------------------------------------//
int VPropocional = 1.45;
int VDerivarivo = 16;

Otro valor importante es la velocidad del robot, que varía de 0 a 255 y se encuentra en este lugar:

1
2
3
4
//--------------------------------------------------------------------------------------//
//Velocidad Maxima Robot//--------------------------//----------------------------------//
const int maximum = 80

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 llamado VDerivativo, 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 valor VDerivativo 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 tu VProporcional 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.

DESCARGA acá los planos del PCB, los diseños de la trompa, las librerías y el programa en Arduino.