Universidad de Concepción

Facultad de Ingeniería

Informe
LABORATORIO 4
Motores servo y comunicación infrarroja

Docente: Mario Medina

Alumnos: Christopher Ruiz Gutiérrez

Mauricio Novoa Díaz

Concepción, octubre 2019

 Objetivo del Laboratorio

El objetivo de este laboratorio es desarrollar un vehículo robot autónomo que sea

capaz de seguir una línea.
 1. Vehículo autónomo
Se procedió a ensamblar el auto seguidor de línea de acuerdo como se ve en la imagen, y
luego a generar el código respectivo para su automatización.

Imagen 1 Vehículo ensamblado (izquierda, imagen posterior, derecha imagen inferior. Ruedas, portapilas, driver,
arduino, y debajo los sensores IR)

Materiales:
• Kit Auto seguidor de linea
• Arduino UNO
• Arreglo de 8 sensores en linea
• Driver L298n
• Cables de conexión
• Fuente 6 pilas en serie con L7805
1.1 Arreglo de 8 sensores en línea
En este diseño de incluyó arreglo de sensores infrarrojos similar al QTR-8RC, y su
funcionalidad es semejante.
Cada sensor (8 en total) tiene dos leds infrarrojos, uno emisor y otro receptor, estos mismo
detectan la variación de luz que hay en el entorno próximo.
AL utilizar la librería QTRSensors, se puede obtener como valor de salida de cada sensor un
rango de entre 0 y 1000, siendo 0 mucha luz y 1000 nada de luz. Con esto se puede obtener
una variable distinta, llamada posición, que es el valor medio de los 8 sensores sensores que
emiten una señal, es decir, el sensor 1 se le asigna el valor 1000, al sensor el valor 2000 y así
sucesivamente, entonces, cuando solo el sensor 3 y el sensor 4 reciben señal, el valor medio
será 3500, significando que la línea está en el centro.
1.2 L298N
Este circuito es el driver de los motores, permite administrar la corriente necesaria para que
los motores funcionen correctamente.
La funcionalidad del driver es bastante simple, aunque para hacer más simple el código se
utilizó una librería, sin embargo, el driver funciona de la siguiente manera:
Posee cuatro conectores, dos a ambos lados del driver donde se conectan los motores.
Además, cuatro pines de control de giro del motor, IN1,IN2,IN3,IN4, los primeros dos
controlan un motor y los demás el otro. Por ejemplo, Cuando IN1 está Alto, IN2 está bajo,
eso define un sentido del giro y cuando IN1 está bajo, IN2 está alto, eso cambia la dirección
del giro, lo mismo sucede con los demás IN.
Además de esto, existe los pines ENA y ENB que permiten controlar la velocidad del motor
mediante PWM, si no se desea utilizar esto, se pone el jumper que mantiene activado los
motores a su máxima velocidad.
Por último, los pines de alimentación existen dos modos de alimentación, un modulo
conjunto, en donde se alimenta los motores y el circuito lógico mediante una sola fuente,
permitiendo que una salida constante de 5v mediante un regulador interno, por otro lado, está
el otro modo, con dos fuentes, una para los motores y otra para el sistema lógico, todo esto
controlado por la colocación de un jumper.
Finalmente, en el código se utilizó la librería L298n, que permite controlar todo lo anterior
mediante un código más amable para el usuario.

1.2 Controlador PID

Dentro del código de Arduino, se utilizó un control tipo PID que, dejando la mayor parte de
teoría de control de lado, en pocas palabras permite un lazo realimentado de control mediante
los sensores, dependiendo de la posición que tenga la linea dentro de el arreglo de 8 sensores,
ajusta la velocidad de ambos motores por la siguiente formula:
𝑎𝑗𝑢𝑠𝑡𝑒 = 𝐾𝑝 ⋅ 𝑒𝑟𝑟𝑜𝑟 + 𝐾𝐷 (𝑒𝑟𝑟𝑜𝑟 − 𝑙𝑎𝑠𝑡𝑒𝑟𝑟𝑜𝑟 )

En donde error equivale a la diferencia entre la posición deseada de la linea menos la actual,
es aquí donde actúan los sensores, 𝑙𝑎𝑠𝑡𝑒𝑟𝑟𝑜𝑟 corresponde al error anterior, y ajuste es la
velocidad que se debe añadir o restar a la velocidad actual del motor.
Para que esto funcione como es correcto se debe restar a un motor y sumar a otro motor la
misma cantidad de ajuste, esto es para que si el auto se desvía hacia un lado, vuelva hacia el
lado contrario al que se estaba moviendo.
Luego, se utilizó el siguiente código:
/* Auto seguidor de line */
#include <QTRSensors.h>
#include <L298N.h>
// Pines arduino
const int IN1 = A0;
const int IN2 = A1;
const int IN3 = A2;
const int IN4 = A3;
const int ENA = 10;
const int ENB = 11;
// inicialización L298n library
L298N motorderecho(ENA, IN1, IN2);
L298N motorizquierdo(ENB, IN3, IN4);
// Inicializacion QTR library
QTRSensors qtr;
const uint8_t SensorCount = 8;
uint16_t sensors[SensorCount];
// PropiedadesPID
const double KP = 0.0308;
const double KD = 0.0;
double lastError = 0;
const int GOAL = 3500;
const unsigned char MAX_SPEED = 108; // Velocidad máxima (255 full
speed)
const unsigned char ROT_SPEED = 50; // Velocidad de rotación

void setup() {
// Calibrar sensores
// Configuracion de los sensores, incluye pines.
qtr.setTypeRC();
qtr.setSensorPins((const uint8_t[]) {
3, 4, 5, 6, 7, 8, 9, 12
}, SensorCount);
qtr.setEmitterPin(2);
delay(500);
pinMode(LED_BUILTIN, OUTPUT);
digitalWrite(LED_BUILTIN, HIGH);
for (uint16_t i = 0; i < 400; i++)
{
qtr.calibrate();
}
// Calibracion ok
digitalWrite(LED_BUILTIN, LOW);
delay(1000);
//I/O
pinMode(IN1, OUTPUT);
pinMode(IN2, OUTPUT);
pinMode(IN3, OUTPUT);
pinMode(IN4, OUTPUT);
pinMode(ENA, OUTPUT);
pinMode(ENB, OUTPUT);
// Default
motorderecho.setSpeed(MAX_SPEED);
motorizquierdo.setSpeed(MAX_SPEED);
motorderecho.forward();
 motorizquierdo.forward();
}

void loop() {

//############# Ciclo de encedido o trabajo ############

// Obtener posición de la linia
uint16_t position = qtr.readLineBlack(sensors);

// Error de la posicion actual y la deseada

int error = GOAL - position;

// Ajuste del PDI

int adjustment = KP * error + KD * (error - lastError);

// Guarda el error para la proxima iteracion

lastError = error;

// Velocidad de motores ajustada

motorderecho.setSpeed(constrain(MAX_SPEED - adjustment, 0, 255));
motorizquierdo.setSpeed(constrain(MAX_SPEED + adjustment, 0, 255));
motorderecho.forward();
motorizquierdo.forward();

// En caso de perder la linea se recupera

if (sensors[0] < 250 && sensors[1] < 250 && sensors[2] < 250 &&
sensors[3] < 250 && sensors[4] < 250)
{
findtheline();
}
}

//Funcion de calibración
void calibracion() {
// Configuracion de los sensores, incluye pines.
qtr.setTypeRC();
qtr.setSensorPins((const uint8_t[]) {
3, 4, 5, 6, 7, 8, 9, 12
}, SensorCount);
qtr.setEmitterPin(2);
delay(500);
pinMode(LED_BUILTIN, OUTPUT);
digitalWrite(LED_BUILTIN, HIGH);
for (uint16_t i = 0; i < 400; i++)
{
qtr.calibrate();
}
// Calibracion ok
digitalWrite(LED_BUILTIN, LOW);
delay(1000);
}
//FUNCION QUE ENCUENTRA LA LINEA
void findtheline() {
int aux = 1;
motorderecho.setSpeed(0);
motorizquierdo.setSpeed(0);
while (aux) {
 uint16_t position = qtr.readLineBlack(sensors);

motorderecho.setSpeed(ROT_SPEED);
motorizquierdo.setSpeed(ROT_SPEED);
motorderecho.forward();
motorizquierdo.backward();

if (sensors[0] > 750 || sensors[4] > 750) {

aux = 0;
}
}
}

Observaciones:
La funcionalidad del código es la siguiente:
En la sección de setup comienza un periodo de declaración de pines y también de calibración
de los sensores, todo este proceso demora como 10 segundos en total, luego en la sección
loop, comienza todo el proceso de PID describido anteriormente, guarda los valores de
posición de los sensores en la variable position y luego comienza el algorimo de PID,
mediante setSpeed, se establece la velocidad del motor ya ajustada y mediante Forward se
inicia la rotación de las ruedas hacia delante.
Finalmente se implementa una funciona de perdida de línea, si todos los sensores tienen un
valor menor a 250 significa que se perdió la linea negra, por lo que, un motor gira hacia
delante y otro hacia atrás, provocando que el auto gire para encontrar la linea, luego que la
encuentra continua el proceso de PID, esto permite que, en el caso de la pista con forma de
corazón, al llegar al punto centro, pueda girar y volver a la pista.
Por último, se vieron las siguientes dificultades:
Primero, una de las ruedas del auto está fallando, está más presionada que la otra, por lo que,
gira más lento que la otra al mismo nivel pwm y la velocidad mínima es mucho más alta,
provocando que se frene en distintas maniobras, esto afecta directamente al seguimiento de
la línea.
Segundo, debido a que las ruedas no funcionan bien, no se pudo sintonizar de forma correcta
el PID, aumentando o disminuyendo el Kp para mejor seguimiento y luego el KD para un
seguimiento más suave, se intentó, pero debido a estas dificultades físicas no fue posible
llegar a un movimiento continuo como se esperaba.