Ao de la Diversificacin Productiva y del Fortalecimiento de la

Educacin

UNIVERSIDAD NACIONAL DE PIURA

FACULTAD DE CIENCIAS
INGENIERIA ELECTRONICA Y TELECOMUNICACIONES

ESCUELA

:
ING. ELECTRNICA Y TELECOMUNICACIONES

CURSO

PROYECTO

PROCESAMIENTO DIGITAL DE SEALES II

ROBOT SIGUELINEAS VELOCISTA

PROFESOR

:
ING. JUAN MANUEL JACINTO SANDOVAL

ALUMNOS

:
MEJA SILVA SERGIO
PALACIOS VILCHEZ DANISH ALEXANDRO
PUEL CRUZ DILMER

INTRODUCCIN
Tanto a nivel nacional como a nivel internacional existe una gran cantidad de
competiciones en las que el objetivo principal es que uno o varios robots autnomos
realicen una determinada tarea tratando de conseguir un mejor resultado en trminos de
tiempo u objetivos alcanzados que el resto de participantes, o enfrentndose literalmente
a ellos.
La mayora de estas competiciones estn destinadas a estudiantes (principalmente de
ingeniera, pero cada vez ms tambin a alumnos ms jvenes en institutos) y tienen
asociada una finalidad educativa importante ya que implican una aplicacin prctica de
los conocimientos adquiridos en materias como electrnica, robtica, regulacin
automtica y programacin. Adems, permiten desarrollar capacidades de trabajo en
equipo y plantean un reto importante al enfrentar a los participantes a problemas reales
que han de resolver de manera ingenieril.

ROBOT VELOCISTA
La competicin de velocistas guarda bastante relacin con la de los seguidores de lnea
puesto que tambin se trata de seguir un circuito marcado con lneas negras sobre un
fondo blanco, pero mientras a los robots rastreadores se les exige que sean capaces de
seguir un camino complicado, lleno de curvas y bifurcaciones, lo que se espera de los
robots velocistas es que, como su propio nombre indica, sean capaces de desarrollar altas
velocidades sobre el circuito. Siguiendo esta filosofa la forma de los circuitos es mucho
ms sencilla, reducindose en algunos casos a un simple ovalo.
Generalmente las eliminatorias de robots velocistas se corren uno contra uno. Lo habitual
es que primero se realice una clasificatoria por tiempos para, a continuacin, ir eliminando
participantes por eliminatorias en las que un robot se medir a otro. Estas carreras se
realizan haciendo salir a cada robot desde puntos opuestos del circuito, terminando la
misma cuando uno de ellos alcance al otro o tras un nmero determinado de vueltas,
ganando el robot que haya sido capaz de acercarse ms a su contrincante.
MATERIALES USADOS
a) QTR 8RC

Bsicamente estos sensores utilizan pines digitales, tambin se pueden utilizar en pines
analgicos, pero previamente configurados como digitales. Es por ello que estos sensores
son muy verstiles y tienen mayor distancia de sensado a comparacin de los analgicos.
La forma de funcionamiento de estos sensores es a base de la carga y descarga de los
condensadores que est en serie con los fototransistores, cuando este en una superficie
blanca el capacitor tendera a no retener carga por lo tanto la salida ser de 0 volts, pero,
por el contrario, si se encuentra en una superficie oscura, el foto-transistor no se saturar,
de esta forma el capacitor retendr carga, produciendo un voltaje positivo. Previamente
se tiene que configurar los pines como salida, mandando un pulso de unos cuantos
microsegundos, luego configurando como entrada los pines haciendo una lectura; esto
continuamente en un bucle.
Es as como se puede saber si se est en blanco o negro. Pero estos sensores ya cuentan
con una librera en arduino que hace todo este procedimiento de forma automtica, solo
tendremos que declarar los pines que utilizaremos y haremos los llamados a las
respectivas funciones de calibrados, funciones de lectura de sensores y lecturas de
posicin, que es justamente la que utilizaremos para el robot velocista.

b) Arduino Nano

En teora se puede utilizar cualquier arduino, pero lo recomendable para un robot

velocista (que por lo general son muy livianos) es utilizar un arduino nano o mini pro.
Nosotros utilizamos el arduino nano ya que nos permita cargar el programa directamente
desde el USB.
Utilizamos los pines analgicos del arduino para las lecturas de los sensores, ya que estos
no cuentan con mdulos extras como el que traen los pines digitales que son, PWM, de
interrupcin, de comunicacin serial, etc.
c) Micro metal Gearmotor

Este es elemento principal y crtico que determinar las caractersticas del robot velocista,
ya que bsicamente depender de qu tipo de reduccin, consumo y torque que poseer.
Por lo general se utilizan los " high power" o "HP" con reducciones de 10:1 y 30:1. La
reduccin es el tipo de engranaje que poseer el motor para reducir la velocidad del motor,
y convertirla en torque, o lo vulgarmente decimos "fuerza" es decir, un motor de
reduccin 10:1 utilizara engranajes que reducirn 10 vueltas del motor en un 1
produciendo un torque relativamente mayor, por ejemplo: un motor de reduccin 10:1

tendr mucha ms velocidad que un motor 30:1, pero este poseer menor torque que el
motor 30:1.
Dado que nuestro robot que sali un poco pesado, utilizamos los motores 30:1.
d) Driver del Motor

Para el driver de nuestros motores, usamos un circuito L293D. El L293D es un

controlador de motor tpico o conductor del motor de IC que se utiliza para conducir DC
en cualquier direccin. Posee 16 pines que puede controlar un conjunto de dos motores
de corriente continua de forma simultnea en cualquier direccin.
Este circuito se basa en el concepto de puente en H. El puente H es un circuito que permite
que la alta tensin se recorra en cualquier direccin.
En un solo integrado L293D hay dos circuitos puente H dentro de la misma que puede
girar dos motores de corriente continua de forma independiente.
Los motores se hacen girar sobre la base de las entradas las cuales pueden ser de entrada
como 1 o 0 lgico.
e) Solarbotics RW2

Estas llantitas se acoplan bien a los micro motores utilizado para este proyecto

f) Bateras

g) Ball Caster

La ball caster son tambin parte fundamental del robot. Nosotros utilizamos una sola Ball
Caster
h) Capacitores
Uno de estos factores que puede afectar a nuestro robot es el ruido elctrico. Este es el
principal factor que afecta a la mayora de artefactos electrnicos en especial a los
microcontroladores, y arduino no se salva de esto. El ruido elctrico es generalmente
inducido por los motores, haciendo que haya un mal funcionamiento del microcontrolador
(reinicios, hace cosas extraas, apagado intempestivo, y en el peor de los casos quemado
del chip).
Para evitar el ruido elctrico, utilizamos dos condensadores cermicos 104 (0.01 uf).
PUNTOS A CONSIDERAR PARA LA PROGRAMACIN DE NUESTRO
ARDUINO
#include <QTRSensors.h> // es siempre necesario la inclusin de la librera de los qtr8rc
Lo primero que hay que reconocer son los define:
#define NUM_SENSORS 8 // aqu definimos cuantos sensores estamos utilizando, en
este caso 8
#define TIMEOUT 2500 //este ser el tiempo que esperaremos para que se de los
resultados de lectura de los sensores.
El tiempo optimo esta entre los 1500 us a 2500 us.
#define EMITTER_PIN 2 // este es el pin del "led ON" es necesario especificar en qu
pin se utilizar
Se utilizar en este caso, el 2
*Objeto para sensor QTR 8RC:
Aqu van los pines a utilizar para las lecturas
QTRSensorsRC qtrrc((unsigned char[]) {3, 4, 5, 6, 7, 8, 9, 10},
NUM_SENSORS, TIMEOUT, EMITTER_PIN);
Lo que hay que especificar aqu son los pines de lectura que utilizaremos del arduino para
cada sensor, se pueden utilizar pines del 0 hasta el 19(del 14 al 19 son los analgicos q

los podemos tambin utilizar como digitales). Para el caso de utilizar los pines analgicos
comenzara desde el 14 hasta el 19.
unsigned int sensorValues[NUM_SENSORS]; // es necesario la creacin de un array,
esto para la almacenaran de los valores de reluctancia de los sensores
Funciones Importantes:
qtrrc.calibrate();
Calibracin de sensores es necesario antes de utilizar los sensores, esta funcin no
devuelve valor alguno
qtrrc.readLine(sensorValues, QTR_EMITTERS_ON, 0);
Realiza la lectura de los sensores, y devuelve el valor de posicin estimada de los
sensores, la estimacin se hace con un promedio ponderado de cada sensor. El tercer
parmetro es para indicar si se requiere leer una superficie blanca con una lnea negra,
este valor ser de "0". Si se quiere leer una superficie negra con una lnea blanca, se tiene
que cambiar el valor a "1".
qtrrc.read(sensorValues);
Realiza lecturas en bruto de cada sensor, para obtener estos valores es necesario leer el
ndice de array donde se guarda los valores de cada sensor. Por ejemplo, si queremos
saber el valor de reflactancia que tiene el sensor numero 1 tenemos que crear una variable
y asignar el valor del array que contiene el valor del sensor:
int sensor_1=sensorValues[0];
PROGAMACIN DE NUESTRO ARDUINO
El PID (control proporcional, integral y derivativo) es un mecanismo de control por
realimentacin que calcula la desviacin o error entre un valor medido y el valor que se
quiere obtener (set point, target position o punto de consigna), para aplicar una accin
correctora que ajuste el proceso.

En el caso del robot velocista, el controlador PID, (que es una rutina basada
matemticamente), procesara los datos del sensor, y lo utiliza para controlar la direccin
(velocidad de cada motor), para de esta forma mantenerlo en curso.
Error: Llamamos a la diferencia entre la posicin objetivo y la posicin medida del error.
(que tan lejos del punto de consigna se encuentra el sensor, en nuestro caso el objetivo es
tener los sensores centrados)

Target Position: Cuando el error es 0 (cero). En el caso del robot velocista, la idea es
siempre mantenerlo en la lnea, o lo que es el caso de los sensores, mantenerlo centrado
y as no se llegue a salir de la lnea
PARAMETROS:
Proporcional: Es la respuesta al error que se tiene que entregar de manera inmediata,
es decir, si nos encontramos en el centro de la lnea, los motores, tendrn en respuesta
una velocidad de igual valor, si nos alejamos del centro, uno de los motores reducir
su velocidad y el otro aumentara.
Proporcional=(posicin) - punto_consigna
Integral: La integral es la sumatoria de los errores acumulados, tiene como propsito
el disminuir y eliminar el error en estado estacionario provocado por el modo
proporcional, en otras palabras, si el robot velocista se encuentra mucho tiempo
alejado del centro (ocurre muchas veces cuando se encuentra en curvas), la accin
integral se ira acumulando e ira disminuyendo el error hasta llegar al punto de
consigna
Integral=Integral + proporcional_pasado

 Derivativo: Es la derivada del error, su funcin es mantener el error al mnimo,

corrigindolo proporcionalmente con la misma velocidad que se produce, de esta
manera evita que el error se incremente, en otra palabra, anticipara la accin evitando
as las oscilaciones excesivas.
Derivativo=proporcional-proporcional_pasado
CONSTANTES
Factor (Kp): Es un valor constante utilizado para aumentar o reducir el impacto de
Proporcional. Si el valor es excesivo, el robot tendera responder inestablemente,
oscilando excesivamente. Si el valor es muy pequeo, el robot responder muy
lentamente, tendiendo a salirse de las curvas
Factor (Ki): Es un valor constante utilizado para aumentar o reducir el impacto de
la Integral, El valor excesivo de este provocara oscilaciones excesivas, Un valor
demasiado bajo no causara impacto alguno.
Factor (Kd): Es un valor constante utilizado para aumentar o reducir el impacto de
la Derivada. Un valor excesivo provocara una sobre amortiguacin. provocando
inestabilidad.
Salida_pwm = (proporcional * Kp) + (derivativo * Kd) + (integral*Ki);
SINTONIZACION PID
Aqu viene el reto, la sintonizacin PID, es aqu donde se tendr que buscar las constantes
que correspondan a las caractersticas fsicas del robot, la forma ms fcil de hacerlo es
por ensayo y error, hasta obtener el valor deseado.
Los pasos a seguir para lograr una buena sintonizacin, son los siguientes:
1. Comience con Kp, Ki y Kd igualando 0 y trabajar con Kp primero. Pruebe establecer
Kp a un valor de 1 y observar el robot. El objetivo es conseguir que el robot siga la lnea,
incluso si es muy inestable.
Si el robot llega ms all y pierde la lnea, reducir el valor de Kp. Si el robot no puede
navegar por una vez, o parece lenta, aumente el valor Kp.
2. Una vez que el robot es capaz de seguir un poco la lnea, asignar un valor de 1 a Kd.
Intente aumentar este valor hasta que vea menos oscilaciones.
3. Una vez que el robot es bastante estable en la lnea siguiente, asigne un valor de 0,5 a
1,0 a Ki. Si el valor de Ki es demasiado alto, el robot se sacudir izquierda y derecha
rpidamente. Si es demasiado baja, no se ver ninguna diferencia perceptible. El Integral
es acumulativo por lo tanto el valor Ki tiene un impacto significativo. puede terminar
ajustando por 0,01 incrementos.
4. Una vez que el robot est siguiendo la lnea con una buena precisin, se puede aumentar
la velocidad y ver si todava es capaz de seguir la lnea. La velocidad afecta el controlador
PID y requerir re-sintonizar como los cambios de velocidad.

PROGRAMACIN
#include <QTRSensors.h>
#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;
// PARAMETROS DE NUESTRO ROBOT
int velocidad=120; //variable para la velocidad, el maximo es 255
float Kp=0.18, Kd=100, Ki=100; //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 est 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; //limitar la integral ( evitar errores)
if (integral<-1000) integral=-1000;
salida_pwm =( proporcional * Kp ) + ( derivativo * Kd )+(integral*Ki);
if ( salida_pwm > velocidad ) salida_pwm = velocidad; //limitar 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;
}
}

}
}
}

OBSERVACIONES
Tuvimos que cambiar el driver DRV8835, por el L293D debido a una mala
conexin. El segundo tiene un similar funcionamiento al primer driver usado.
En un comienzo, el sensado solo se realizaba del lado derecho, corregimos ese
error, revisando y cambiando las entradas del PWM, las cuales estaban mal
conectadas.