Investigación tecnológica

Bryans córdoba

Line Follower (seguidor de linea)


Estructura:

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.

 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 Ajustable 2.5- 9v:













 Es absolutamente indispensable para no dañar los sensores, ya que funcionan con 5v. El regulador lo puedes ajustar desde una entrada de 2.5V hasta 9V para que te entrege el voltaje de salida a 5V y puedas alimentar tus circuitos o puedes utilizar un regulador 5V (Lm7805).

 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.
 Ruedas para seguidor de linea:





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 300mAH:





Las baterías de LiPo son la mejor opción, 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.
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.
Programador AVR pololu: 
Para programar el Baby Orangután 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.
2 Cables de 5 Pines: 
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 1 mts:
 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 micro-controlador de la placa Baby Orangután.
Super Bonder:
 Más conocido como pegante instantáneo, se usara demasiado para algunos ajustes.
PROGRAMACIÓN:
Para programar la placa hay que conectar el programador de AVR Al Baby Orangután.
Con la batería puesta debes prender el robot y verificar que en la placa Baby Orangután 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 Orangután.

Abre el entorno Arduino y pega el siguiente Código, también lo encuentras en la documentación adjunta.
#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 VProporcional = 1.45;
int VDerivativo = 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 Orangután y el Programador AVR ISP v2 de la siguiente forma:
Selección Baby Orangután:

Selección Programador: