1

Carro Seguidor de Línea con PID

Luis Antonio Curtidor Ramírez 201222534, José Pablo López Enríquez 201313774, José Iván Mejía
200512139.
Grupo #397
Universidad de San Carlos de Guatemala, Guatemala
Facultad de Ingeniería, Escuela Mecánica Eléctrica

curtidor.luuis@gmail.com
jospalk3@gmail.com
jimpetz@gmail.com


Abstract— Este informe contiene la teoría y el procedimiento
para realizar un seguidor de línea mediante un control PID.
Como aplicación, se realizó un carro seguidor de línea. Se explica
los conceptos matemáticos necesarios para obtener los
parámetros de forma directa y eficiente, ya que estos parámetros
y el modelado del sistema mediante los mismo es crucial para la
obtención del control PID
Términos Clave— Carro Seguidor de línea, control
proporcional, integral y derivativo (PID), error positivo, error
negativo, sin error.
I. INTRODUCCIÓN
II. MARCO TEÓRICO
II-A. PID
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 seguidor de línea, 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.

Los robots seguidores de línea son robots muy sencillos, que

cumplen una única misión: seguir una línea marcada en el
suelo normalmente de color negro sobre un tablero blanco
(normalmente una línea negra sobre un fondo blanco).

Todos los rastreadores basan su funcionamiento en los

sensores. Sin embargo, dependiendo de la complejidad del
recorrido, el robot debe ser más o menos complejo (y, por
ende, utilizar más o menos sensores).

Los rastreadores más simples utilizan 2 sensores, ubicados en

la parte inferior de la estructura, uno junto al otro. Cuando uno Fig. 1. Representacion de los errores del PID
de los dos sensores detecta el color blanco, significa que el
robot está saliendo de la línea negra por ese lado. En ese
II-B. ERROR
momento, el robot gira hacia el lado contrario hasta que
vuelve a estar sobre la línea. Esto en el caso de los seguidores Llamamos a la diferencia entre la posición objetivo y la
de línea negra, ya que también hay seguidores de línea blanca. posición medida del error. (que tan lejos del punto de consigna
se encuentra el sensor, en nuestro caso el objetivo es tener los
Las dos maneras más comunes de armar los rastreadores son: sensores centrados)
OPAMPS (Amplificadores Operacionales), o con simples
transistores trabajados en su zona de saturación. Esto
dependiendo de la complejidad con la que se quiera armar el
circuito. Podemos utilizar un microcontrolador para realizar
las funciones de control o guardar en él la forma del recorrido
por una pista. También sirve como escaneador eléctrico.

Fig. 2. Tipos de error PID

 2

-Set point o Target Position - Cuando el error es 0 (cero).

En el caso del seguidor de línea, la idea es siempre mantenerlo Salida_pwm = ( proporcional * Kp ) + ( derivativo * Kd ) +
en la línea, o lo que es el caso de los sensores, mantenerlo (integral*Ki);
centrado y así no se llegue a salir de la línea.

III. MARCO METODOLÓGICO

A. Diseño Experimental

Fig. 4. Grafica comporatamiento del motor siguiendo la linea.

II-C. Parámetros
-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 mismo velocidad que se produce, de esta manera evita
que el error se incremente, en otra palabra, anticipara la acción
evitando asi las oscilaciones excesivas.
Derivativo=proporcional-proporcional_pasado
II-C. 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.
 3

B. Programacion de Seguidor de Linea

/* variables to keep track of current speed of motors */
/* Define motor controll inputs */ int motorLSpeed = 0;
//const int motorRPin1 = 2; // signal pin 1 for the right motor, int motorRSpeed = 0;
connect to IN1
//const int motorRPin2 = 3; // signal pin 2 for the right motor, void setup() {
connect to IN2
const int motorREnable = 5; // enable pin for the right motor /* Set up motor controll pins as output */
(needs to be PWM enabled) DERECHA // pinMode(motorLPin1,OUTPUT);
// pinMode(motorLPin2,OUTPUT);
//const int motorLPin1 = 4; // signal pin 1 for the left motor, pinMode(motorLEnable,OUTPUT);
connect to IN3 (was 5 - need to change)
//const int motorLPin2 = 7; // signal pin 2 for the left motor, // pinMode(motorRPin1,OUTPUT);
connect to IN4 // pinMode(motorRPin2,OUTPUT);
const int motorLEnable = 6; // enable pin for the left motor pinMode(motorREnable,OUTPUT);
(needs to be PWM enabled) IZQUIERDA
/* Set-up IR sensor pins as input */
/* Define the pins for the IR receivers */ for (int i = 0; i < 6; i++) {
const int irPins[4] = {A0, A1, A2, A3}; pinMode(irPins[i], INPUT);
}
/* Define values for the IR Sensor readings */
/* Change the PWM frequency of digital pins 5 and 6
// an array to hold values from analogRead on the ir sensor (0- (timer0) to Phase-correct PWM of 31.250 kHz
1023) from the default of ~500Hz. Using code from Adjusting
int irSensorAnalog[4] = {0,0,0,0}; PWM Frequencies
*/
// an array to hold boolean values (1/0) for the ir sensors, TCCR0A = _BV(COM0A1) | _BV(COM0B1) |
based on the analog read and the predefined treashold _BV(WGM01) | _BV(WGM00);
int irSensorDigital[4] = {0,0,0,0}; TCCR0B = _BV(CS00);
}
// the value above which we determine an IR sensor reading
indicates the sensor is over a line void loop() {
int treashold = 700; Scan();
UpdateError();
// binary representation of the sensor reading from left to right UpdateCorrection();
int irSensors = B0000; Drive();
}
// sensors detecting the line
int count = 0; void Scan() {
// Initialize counters, sums etc.
// a score to determine deviation from the line [-180 ; +180].
Negative means the robot is left of the line. count = 0;
int error = 0;
irSensors = B0000;
// store the last value of error
int errorLast = 0; for (int i = 0; i < 6; i++) {
irSensorAnalog[i] = analogRead(irPins[i]);
// a coorection value, based on the error that is used to change
motor speed with PWM if (irSensorAnalog[i] >= treashold) {
int correction = 0; irSensorDigital[i] = 1;
}
// keep track of the laps else {irSensorDigital[i] = 0;}
//int lap = 0; Serial.print(irSensorAnalog[i]);
Serial.print("|");
/* Set up maximum speed and speed for turning (to be used count = count + irSensorDigital[i];
with PWM) */ int b = 5-i;
irSensors = irSensors + (irSensorDigital[i]<<b);
// PWM to control motor speed [0 - 255] }
int maxSpeed = 255; }
 4

void UpdateError() { // case B011100:

error = -150;
errorLast = error; break;

switch (irSensors) { case B0111:

// case B001110:
case B000000: error = 150;
if (errorLast < 0) { error = -180;} break;
else if (errorLast > 0) {error = 180;}
break; /* 4 Sensors on the line */
/* case B111100:
case B1000: // leftmost sensor on the line error = -150;
error = -150; break;
break;
case B111010:
case B0100: error = -150;
error = -75; break;
break;
case B001111:
case B0010: error = 150;
error = 75; break;
break;
case B010111:
case B0001: error = 150;
error = 150; break;
break;
/* 5 Sensors on the line */
/* case B000010: /* case B111110:
error = 90; error = -150;
break; break;

case B000001: // rightmost sensor on the line case B011111:

error = 150; error = +150;
break; break;
*/
/* 2 Sensors on the line */ case B111111:
lap = lap + 1; // increment laps when start/finish line is
case B1100: crossed
error = -120; error = 0;
break; break;
*/
case B0110: default:
error = 0; error = errorLast;
break; }
}
case B0011:
error = 120; void UpdateCorrection() {
break;
/* if (error >= 0 && error < 30) {
case B000110: correction = 0;
error = 60; }
break;
else if (error >=30 && error < 60) {
case B000011: correction = 15;
error = 120; }
break;
* else if (error >=60 && error < 90) {
/* 3 Sensors on the line */ correction = 40;
}
case B1110:
 5

else if (error >=90 && error < 120) { else if (motorLSpeed < -255) {motorLSpeed = -255;}
correction = 55;
} if (motorRSpeed > 0) { // right motor forward (using PWM)
analogWrite(motorREnable, motorRSpeed);
else if (error >=120 && error < 150) { // digitalWrite(motorRPin1, HIGH);
correction = 75; // digitalWrite(motorRPin2, LOW);
} }

else if (error >=150 && error < 180) { else if (motorRSpeed < 0) {// right motor reverse (using
correction = 255; PWM)
} analogWrite(motorREnable, abs(motorRSpeed));
// digitalWrite(motorRPin1, LOW);
else if (error >=180) { // digitalWrite(motorRPin2, HIGH);
correction = 305; }
}
else if (motorRSpeed == 0) { // right motor fast stop
if (error <= 0 && error > -30) { digitalWrite(motorREnable, HIGH);
correction = 0; // digitalWrite(motorRPin1, LOW);
} // digitalWrite(motorRPin2, LOW);
}
else if (error <= -30 && error > -60) {
correction = -15; if (motorLSpeed > 0) { // right motor forward (using PWM)
} analogWrite(motorLEnable, motorLSpeed);
// digitalWrite(motorLPin1, HIGH);
else if (error <= -60 && error > -90) { // digitalWrite(motorLPin2, LOW);
correction = -40; }
}
else if (motorLSpeed < 0) { // right motor reverse (using
else if (error <= -90 && error > -120) { PWM)
correction = -55; analogWrite(motorLEnable, abs(motorLSpeed));
} // digitalWrite(motorLPin1, LOW);
// digitalWrite(motorLPin2, HIGH);
else if (error <= -120 && error > -150) { }
correction = -75;
} else if (motorLSpeed == 0) { // left motor fast stop
digitalWrite(motorLEnable, HIGH);
else if (error <= -150 && error > -180) { // digitalWrite(motorLPin1, LOW);
correction = -255; // digitalWrite(motorLPin2, LOW);
} }
}
else if (error <= -180) {
correction = -305; IV. CONCLUSIONES
}
Por medio de los conocimientos obtenidos por la realización
if (correction >= 0) {
e investigacion de cada módulo se logró llevar a cabo de una
motorRSpeed = maxSpeed - correction;
manera mucho mas fácil, la realización, construcción, control
motorLSpeed = maxSpeed;
y programación del seguidor de línea, se obtuvo un resultado
}
satisfacctorio, con lo cual se pudo contruir el seguidor de línea
else if (correction < 0) { y nosotros como grupo obtuvimos, mas conocientos en el área
motorRSpeed = maxSpeed; de progracion y sistemas de control.
motorLSpeed = maxSpeed + correction;
} REFERENCIAS
}

void Drive() { [1] http://aprendiendofacilelectronica.blogspot.com/2014/12/robot-

velocista-de-competencia-parte.html
if (motorRSpeed > 255) {motorRSpeed = 255;}
else if (motorRSpeed < -255) {motorRSpeed = -255;}

if (motorLSpeed > 255) {motorLSpeed = 255;}