UNIVERSIDAD

NACIONAL DEL
CALLAO
FIEE

ESCUELA DE INGENIERIA
ELECTRONICA
ROBOT VELOCISTA – CHALON
INTEGRANTES:
- ALVARADO VALDIVIESO HAROL 1423225092
- ESPINOZA DIAZ RENZO 1423215135
- MAYTA CASO MISAEL 1423225173
- GARCIA SALVADOR ALEX 1423225415
PROFESOR: ING. ABILIO CUZCANO

2017 B
INTRODUCCION:

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 autónomos
realicen una determinada tarea tratando de conseguir un mejor resultado en términos
de tiempo u objetivos alcanzados que el resto de participantes, o enfrentándose
literalmente a ellos.
La mayoría de estas competiciones están destinadas a estudiantes (principalmente de
ingeniería, pero cada vez más también a alumnos más jóvenes en institutos) y tienen
asociada una finalidad educativa importante ya que implican una aplicación práctica
de los conocimientos adquiridos en materias como electrónica, robótica, regulación
automática y programación. Además, 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 competición de velocistas guarda bastante relación con la de los seguidores de

línea puesto que también se trata de seguir un circuito marcado con líneas 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 filosofía la forma de los
circuitos es mucho más sencilla, reduciéndose 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 continuación,
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 número
determinado de vueltas, ganando el robot que haya sido capaz de acercarse más a su
contrincante.

QTR 8RC
Básicamente estos sensores utilizan pines digitales, también se pueden utilizar en
pines analógicos, pero previamente configurados como digitales. Es por ello que estos
sensores son muy versátiles y tienen mayor distancia de sensado a comparación de
los analógicos. 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 librería en arduino que hace todo este procedimiento de forma
automática, 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 posición, que es justamente la que utilizaremos para el robot velocista
ARDUINO NANO:

En teoría 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 permitía cargar el programa
directamente desde el USB.
Utilizamos los pines analógicos del arduino para las lecturas de los sensores, ya que
estos no cuentan con módulos extras como el que traen los pines digitales que son,
PWM, de interrupción, de comunicación serial, etc.

MICRO METAL GEARMOTOR:

Este es elemento principal y crítico que determinará las características del robot
velocista, ya que básicamente dependerá de qué tipo de reducción, consumo y torque
que poseerá. Por lo general se utilizan los " high power" o "HP" con reducciones de
10:1 y 30:1. La reducción 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 reducción 10:1 utilizara engranajes que reducirán 10 vueltas del
motor en un 1 produciendo un torque relativamente mayor, por ejemplo: un motor de
reducción 10:1
PROCEDIMIENTO:

PASO I.- Se investigó, observo diseños de otros velocistas ya realizados para poder
tener ideas de como hacer nuestro velocista. Se optó por un diseño y comenzamos a
realizar el nuestro.

PASO II.- Nos guiamos en un cierto diseño y de ahí nos basamos en todo las compras
que realizamos; La lista de materiales que se compro fue:

 ARDUINO NANO
 DRIVER TB6612FNG
 QTR POLOLU 8A ALIMENTACION ANLOGICA
 UN PAR DE MOTORES POLULO 1:10
 RUEDA LOCA BALL CASTER
 UN PAR DE LLANTAS DE GOMAS PARA VELOCISTA
 ESPADINES PARA CONEXIÓN
 GANCHOS PARA SUJETAR EL MOTOR
 BATERIA DE LIPO 7.4v 950 mAh
 CABLES HEMBRA-HEMBRA
 PLACA DE BAQUELITA PARA CONEXIÓN

PASO III.- Comenzamos a soldar dependiendo de nuestro diseño fabricado

PASO IV.- Pasando la programación al velocista para hacer las pruebas
PASO V.- Calibrando el QTR-8ª y haciendo pruebas en la pista de competencia
PUNTOS A CONSIDERAR PARA LA PROGRAMACIÓN DE NUESTRO
ARDUINO:

#include <QTRSensors.h> // es siempre necesario la inclusión de la librería 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);
Funciones Importantes:
qtrrc.calibrate();

Calibración de sensores es necesario antes de utilizar los sensores, esta función no

devuelve valor alguno
qtrrc.readLine(sensorValues, QTR_EMITTERS_ON, 0);

Realiza la lectura de los sensores, y devuelve el valor de posición estimada de los

sensores, la estimación se hace con un promedio ponderado de cada sensor. El tercer
parámetro es para indicar si se requiere leer una superficie blanca con una línea
negra, este valor será de "0". Si se quiere leer una superficie negra con una línea
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];

PROGAMACIÓN DE NUESTRO ARDUINO

El PID (control proporcional, integral y derivativo) es un mecanismo de control por
realimentación que calcula la desviación o error entre un valor medido y el valor que se
quiere obtener (set point, target position o punto de consigna), para aplicar una acción
correctora que ajuste el proceso.
En el caso del robot velocista, el controlador PID, (que es una rutina basada
matemáticamente), procesara los datos del sensor, y lo utiliza para controlar la dirección
(velocidad de cada motor), para de esta forma mantenerlo en curso.
Error: Llamamos a la diferencia entre la posición objetivo y la posición 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 línea.

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 línea, los motores, tendrán
en respuesta una velocidad de igual valor, si nos alejamos del centro, uno de los
motores reducirá su velocidad y el otro aumentara.

Proporcional=(posición) - punto_consigna
Integral: La integral es la sumatoria de los errores acumulados, tiene como
propósito 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 acción
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 función es mantener el error al mínimo,

corrigiéndolo proporcionalmente con la misma velocidad que se produce, de esta
manera evita que el error se incremente, en otra palabra, anticipara la acción 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 pequeño, 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 amortiguación. provocando
inestabilidad.
Salida_pwm = (proporcional * Kp) + (derivativo * Kd) + (integral*Ki);

SINTONIZACION PID

Aquí viene el reto, la sintonización PID, es aquí donde se tendrá que buscar las
constantes que correspondan a las características físicas del robot, la forma más fácil
de hacerlo es por ensayo y error, hasta obtener el valor deseado.
Los pasos a seguir para lograr una buena sintonización, 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
línea, incluso si es muy inestable.
Si el robot llega más allá y pierde la línea, 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 línea, 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 línea 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
rápidamente. 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 línea con una buena precisión, se puede
aumentar la velocidad y ver si todavía es capaz de seguir la línea. La velocidad afecta
el controlador PID y requerirá re-sintonizar como los cambios de velocidad.

PROGRAMACION:
#include <QTRSensors.h>

//Mapeo de pines
#define STBY 6
#define AIN1 8
#define AIN2 7
#define PWMB 3
#define PWMA 9
#define BIN1 5
#define BIN2 4
#define NUM_SENSORS 8
#define TIMEOUT 2500
#define NUM_SAMPLES_PER_SENSOR 4
#define EMITTER_PIN 13
#define LED 12
const int btn1=2;

// Constantes para PID3

float KP = 0.01;
float KD = 1.0;
float Ki = 0.013;

// Regulación de la velocidad Máxima

int Velmax = 120;

// Data para intrgal

int error1=0;
int error2=0;
int error3=0;
int error4=0;
int error5=0;
int error6=0;

// Configuración de la librería QTR-8A

QTRSensorsRC qtrrc((unsigned char[]) {11, 10, 14, 15, 16, 17, 18, 19},
NUM_SENSORS, TIMEOUT, EMITTER_PIN);
unsigned int sensorValues[NUM_SENSORS];
// Función accionamiento motor izquierdo
void Motorde(int value)
{
if ( value >= 0 )
{
digitalWrite(BIN1,HIGH);
digitalWrite(BIN2,LOW);
}
else
{
digitalWrite(BIN1,LOW);
digitalWrite(BIN2,HIGH);
value *= -1;
}
analogWrite(PWMB,value);
}

// Función accionamiento motor derecho

void Motoriz(int value)
{
if ( value >= 0 )
{
digitalWrite(AIN1,HIGH);
digitalWrite(AIN2,LOW);
}
else
{
digitalWrite(AIN1,LOW);
digitalWrite(AIN2,HIGH);
 value *= -1;
}
analogWrite(PWMA,value);
}

//Accionamiento de motores
void Motor(int left, int righ)
{
digitalWrite(STBY,HIGH);
Motoriz(left);
Motorde(righ);
}

//función de freno
void freno(boolean left, boolean righ, int value)
{
digitalWrite(STBY,HIGH);
if ( left )
{
digitalWrite(BIN1,HIGH);
digitalWrite(BIN2,HIGH);
analogWrite (PWMB, value);
}
if ( righ )
{
digitalWrite(AIN1,HIGH);
digitalWrite(AIN2,HIGH);
analogWrite (PWMA, value);
}
}

void setup()
{
// Declaramos como salida los pines utilizados
pinMode(LED ,OUTPUT);
pinMode(BIN2 ,OUTPUT);
pinMode(STBY ,OUTPUT);
pinMode(BIN1 ,OUTPUT);
pinMode(PWMB ,OUTPUT);
pinMode(AIN1 ,OUTPUT);
pinMode(AIN2 ,OUTPUT);
pinMode(PWMA ,OUTPUT);
pinMode(btn1 ,INPUT);
// Calibramos con la función qtra.calibrate();, y dejamos parpadeando el led, mientras
se produce la calibración.

for ( int i=0; i<70; i++)

{
digitalWrite(LED, HIGH); delay(20);
qtrrc.calibrate();
digitalWrite(LED, LOW); delay(20);
}
delay(3000);
}

unsigned int position = 0;

//declaraos variables para utilizar PID

int proporcional = 0; // Proporcional
int integral = 0; //Intrgral
int derivativo = 0; // Derivativo

int diferencial = 0; // Diferencia aplicada a los motores

int last_prop; // Última valor del proporcional (utilizado para calcular la derivada
del error)
int Target = 2500; // Setpoint (Como utilizamos 6 sensores, la línea debe estar entre 0
y 5000, por lo que el ideal es que esté en 2500)

void loop()
{
if (digitalRead(btn1)==1){

for(;;){
qtrrc.read(sensorValues);
position = qtrrc.readLine(sensorValues, QTR_EMITTERS_ON, 0);
proporcional = ((int)position) - 3500;

if ( proporcional <= -Target )

{
Motorde(0);
freno(true,false,255);
}
else if ( proporcional >= Target )
{
Motoriz(0);
freno(false,true,255);
}
derivativo = proporcional - last_prop;
integral = error1+error2+error3+error4+error5+error6;
last_prop = proporcional;

error6=error5;
error5=error4;
error4=error3;
error3=error2;
error2=error1;
error1=proporcional;

int diferencial = ( proporcional * KP ) + ( derivativo * KD )+ (integral*Ki) ;

if ( diferencial > Velmax ) diferencial = Velmax;

else if ( diferencial < -Velmax ) diferencial = -Velmax;

( diferencial < 0 ) ?
Motor(Velmax+diferencial, Velmax) : Motor(Velmax, Velmax-diferencial);
}}}

OBSERVACIONES
Tuvimos que cambiar el driver DRV8835, por el L293D debido a una mala conexión. 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.