i

DEPARTAMENTO DE CIENCIAS DE LA ENERGÍA Y

MECÁNICA

CARRERA DE INGENIERÍA MECATRÓNICA

INSTRUMENTACIÓN MECATRÓNICA

PROYECTO Nº2

TEMA: COMO CONSTRUIR UN ROBOT SEGUIDOR DE LÍNEA

NRC: 2384

DOCENTE: ING. PAÚL MEJÍA

GRUPO Nº4

INTEGRANTES:

ROBINSON CHILUISA

CHARLY CHIRIBOGA

MARX YÉPEZ
 ii

ÍNDICE DE CONTENIDOS

RESUMEN ...................................................................................................................... iv

ABSTRACT .....................................................................................................................v

OBJETIVOS ................................................................................................................... 1

MATERIALES Y EQUIPOS ........................................................................................ 1

PROCEDIMIENTO ....................................................................................................... 2

1. Construcción de la base del robot ...................................................................... 2

2. Programación en Arduino para el control del robot ........................................ 5

3. Diseño e implementación de una VI en LabVIEW ......................................... 12

RESULTADOS ............................................................................................................. 13

CONCLUSIONES ........................................................................................................ 14

RECOMENDACIONES .............................................................................................. 14

ANEXOS........................................................................................................................ 16
 iii

LISTA DE FIGURAS

Figura 1 Vista superior de la base del robot Fuente: Propia .........................................................2

Figura 2 Vista en perspectiva de la base del robot .......................................................................3

Figura 3 Direcciones a seguir por el robot de acuerdo a la línea Fuente: Wikipedia ....................4

Figura 4 Fotografía del Robot Fuente: Propia...............................................................................5

Figura 5 Conexión de los motores y su drive con la placa Arduino Fuente: Propia realizada en

TinkerCAD ....................................................................................................................................5

Figura 6 Conexión de la regleta de sensores QTR Fuente: Propia realizada en TinkerCAD. .........6

Figura 7 Diagrama de bloques de la etapa de calibración Fuente: Propia ..................................12

Figura 8 Diagrama de bloques de la selección de parámetros Fuente: Propia ...........................12

Figura 9 Robot seguidor de línea terminado Fuente: Propia ......................................................13

 iv

RESUMEN

En el presente documento, se presenta la metodología seguida para el diseño y

construcción de un robot móvil seguidor de una línea negra con fondo blanco, utilizando

una placa de ARDUINO UNO. Se utilizaron dos motores de corriente directa el motor

para la dirección se acopla a la rueda delantera.

El funcionamiento general del robot es adecuado, sin embargo, se puede optimizar su

funcionamiento cambiando algunos aspectos de su programación o utilizando materiales

más ligeros en su estructura para reducir efectos inerciales.

Básicamente en un móvil capaz de desplazarse a lo largo de una línea de un color

diferente al fondo, todos basan su funcionamiento en sensores, sin embargo, dependiendo

de la complejidad del recorrido, el robot debe utilizar más o menos sensores.

Un robot móvil es una máquina automática que es capaz de trasladarse en cualquier

ambiente dado. Los robots móviles son un punto importante de la investigación actual y

casi cada universidad importante que tiene uno o más laboratorios que se centran en la

investigación de robots móviles. Los robots móviles se encuentran también en la industria

y los servicios.

Hoy en día la Robótica Móvil se ha convertido en un tema de gran interés, con grandes

adelantos debido a una gran cantidad de proyectos que se han desarrollado en todo el

mundo y como estudiantes del nivel bachillerato consideramos que es necesario presentar

alternativas que puedan satisfacer las necesidades antes planteadas, nuestro proyecto

presenta un “robot seguidor de línea”.

 v

ABSTRACT

In this document, the methodology followed for the design and construction of a

mobile robot following a black line with a white background is presented, using an

ARDUINO ONE plate. Two direct current motors were used, the motor for the steering

is coupled to the front wheel.

The general functioning of the robot is adequate; however, its operation can be

optimized by changing some aspects of its programming or using lighter materials in its

structure to reduce inertial effects.

Basically, in a mobile capable of moving along a line of a different color to the

background, all base their functioning on sensors, however, depending on the complexity

of the route, the robot must use more or less sensors.

A mobile robot is an automatic machine that is capable of moving in any given

environment. Mobile robots are an important point of current research and almost every

major university that has one or more laboratories that focus on the research of mobile

robots. Mobile robots are also found in industry and services.

Nowadays Mobile Robotics has become a topic of great interest, with great advances

due to a large number of projects that have been developed around the world and as

students of the baccalaureate level we consider it necessary to present alternatives that

can satisfy the needs previously raised, our project presents a "robot line follower".
 1

OBJETIVOS

• Desarrollar robots móviles con fines de investigación y adquisición de

conocimiento, mediante la aplicación de todos los conocimientos previamente

adquiridos en la carrera, para promover entre nuestros compañeros el desarrollo

de eventos competitivos.

• Diseñar y producir un robot seguidor de línea.

• Desempeñar una participación en el concurso IEEE-ESPE de velocidad y

destreza.

MATERIALES Y EQUIPOS

• PC Portátil

• IDE Arduino Windows.

• Base impresa en 3D de acuerdo al diseño y parámetros establecidos.

• Una tarjeta ARDUINO NANO (cualquier versión sirve)

• Regleta de 8 sensores QTR.

• 2 Motores 10 a 1 de 6V

• 2 Llantas para robot seguidor.

• 2 Drivers para los motores.

• 1 Rueda loca.

• Alambre para conexiones.

• Cautín.

• Estaño
 2

PROCEDIMIENTO
1. Construcción de la base del robot

Esta parte del proyecto es muy importante ya que de ella depende la movilidad

del robot, así como de su rigidez para soportar los elementos electrónicos que

posteriormente se integrarán a él.

Figura 1 Vista superior de la base del robot

Fuente: Propia

Se diseño el soporte del robot en base a las medidas estipuladas en el

reglamento del concurso las cuales fueron 20.5 cm de largo y 16.5 cm de ancho y

un espesor de 3mm como espesor mínimo para ser impreso en 3D que pueda

soportar el peso de los demás componentes.

La rueda es una rueda igual a la que usan los carritos de supermercado y las

sillas de oficina, esta tiene un movimiento libre de 360º que facilita los giros del

robot.
 3

Y por último, pero no menos importante la parte de tracción del robot;

constituida por los dos moto-reductores y sus respectivas ruedas, cada uno de

estos puede ser controlado independientemente y son los que le dan dirección al

robot, cabe destacar que si uno gira en sentido opuesto al otro respectivamente se

puede obtener un giro de 360º sobre el eje del robot, lo que permite un amplio

rango de movimiento.

Figura 2 Vista en perspectiva de la base del robot

Motores

El robot se mueve utilizando motores uno en cada lado y estos son los

encargados de dar todo el movimiento al robot, es decir, traslacional y

rotacional de tal forma que la configuración del robot es en gran parte el

control de los motores.

 4

Sensores QTR

Los sensores QTR ubicados como pivotes del robot son los encargados de

ir identificando la línea a seguir enviando los datos necesarios para el control

de los motores.

El funcionamiento de los sensores es realmente sencillo, mientras se

detecte negro si es el caso del color de la línea, el robot seguirá avanzando,

mientras que si detecta un desvío permite el giro hacia la derecha o la izquierda

según corresponda.

Figura 3 Direcciones a seguir por el robot de acuerdo a la línea

Fuente: Wikipedia

Ruedas

Las ruedas del robot son movidas por los motores. Normalmente se usan

ruedas de materiales antideslizantes para asegurar buena tracción. Su tamaño

es otro factor a tener en cuenta a la hora de armar el robot.

 5

Fuente de energía

El robot obtiene la energía que necesita para su funcionamiento de baterías.

El peso, capacidad de descarga y duración son factores a tener en cuenta a la

hora de escoger un modelo o tamaño, utilizamos una pila de 9V.

Figura 4 Fotografía del Robot

Fuente: Propia

2. Programación en Arduino para el control del robot

Conexiones en la placa Arduino

Figura 5 Conexión de los motores y su drive con la placa Arduino

Fuente: Propia realizada en TinkerCAD
 6

Figura 6 Conexión de la regleta de sensores QTR

Fuente: Propia realizada en TinkerCAD.

Codificación

#include <QTRSensors.h>

//entradas
//#define btn1 0
//#define btn2 1
//salidas
#define stb 10
#define led1 4
#define led_on 4 //~
#define mi1 9
#define mi2 8
#define pwmi 3 //~
#define md1 11
#define md2 12
#define pwmd 5 //~

#define NUM_SENSORS 8 // number of sensors used

#define NUM_SAMPLES_PER_SENSOR 1 // average 4 analog samples per
sensor reading
#define EMITTER_PIN 13 // emitter is controlled by digital pin 2

QTRSensorsAnalog qtra((unsigned char[]) {

0, 1, 2, 3, 4, 5, 6, 7
}, NUM_SENSORS, NUM_SAMPLES_PER_SENSOR, EMITTER_PIN);
unsigned int sensorValues[NUM_SENSORS];
int proporcional = 0;
int derivativo = 0;
 7

int integral = 0;
int salida_pwm = 0;
int proporcional_pasado = 0;
int position = 0;

/*
////////////////////Parametros PID/////////////////////////////////
int velocidad = 92;
//float KP=0.15, KD=2.2, KI=0.006; //reaccion rapida
float KP = 0.16, KD = 2.1 , KI = 0.005; //reaccion rapida
///////////////////////////////////////////////////////
*/
////////////////////Parametros PID/////////////////////////////////
int velocidad = 100;
//float KP=0.15, KD=2.2, KI=0.006; //reaccion rapida
float KP = 0.17, KD = 2.1 , KI = 0.005; //reaccion rapida
///////////////////////////////////////////////////////

///////////////////Labview////////////////
char datocalibracion = 'I';
String velo = String(velocidad * 100);
String kp = String(KP * 1000);
String kd = String(KD * 1000);
String ki = String(KI * 1000);
String selector;
/////////////////parametros de sensado/////////////////////////////
int linea = 0; //0 linea negra, 1 para linea blanca
int flanco_color = 0 ;
int en_linea = 500 ;
int ruido = 30;
/////////////////////////////////////////////////////////
//int boton1=7;
//int boton2=7;

void setup()
{
pinMode(stb, OUTPUT);
pinMode(led_on, OUTPUT);
pinMode(mi1, OUTPUT);
pinMode(mi2, OUTPUT);
pinMode(pwmi, OUTPUT);
pinMode(md1, OUTPUT);
pinMode(md2, OUTPUT);
pinMode(pwmd, OUTPUT);

digitalWrite(stb, HIGH);
Serial.begin(9600);
//Serial.begin(115200);
//Serial.println();
 8

/*while(true)
{
botones();
if(boton2==0)
{
delay(20);
digitalWrite(led1,HIGH);
delay(100);
digitalWrite(led1,LOW);
delay(100);
break;
}
}
*/

//bt.println("Hello, world?");
}
void loop()
{
if (datocalibracion == 'I') {
if (Serial.available())
{
datocalibracion = Serial.read();
if (datocalibracion == 'O')
{
datocalibracion = 'R';
calibra();
} else
{
datocalibracion = 'I';
}
}
}

if (datocalibracion == 'R')
{
if (Serial.available())
{
selector = Serial.read();
switch (selector.toInt()){
case 1:
velo=Serial.read();
velocidad=velo.toInt()/100;
break;
case 2:
kp=Serial.read();
KP=kp.toInt()/1000;
break;
case 3:
kd=Serial.read();
 9

KD=kd.toInt()/1000;
break;
case 4:
ki=Serial.read();
KI=ki.toInt()/1000;
break;

}
}
pid(0, velocidad, KP, KI, KD);
frenos_contorno(600);
delay(2);
}
}
void calibra()
{
digitalWrite(led1, HIGH); // turn on Arduino's LED to indicate we are in
calibration mode
for (int i = 0; i < 200; i++) // make the calibration take about 10 seconds
{
qtra.calibrate(); // reads all sensors 10 times at 2.5 ms per six sensors (i.e.
~25 ms per call)
}
digitalWrite(led1, LOW);
}
void pid(int linea, int velocidad, float Kp, float Ki, float Kd)
{

position = qtra.readLine(sensorValues, QTR_EMITTERS_ON, linea,

flanco_color, en_linea, ruido);
//0 linea negra, 1 para linea blanca

// Serial.println(position);
proporcional = (position) - 3500; // set point es 3500, asi obtenemos el error
integral = integral + proporcional_pasado; //obteniendo integral
derivativo = (proporcional - proporcional_pasado); //obteniedo el derivativo
int ITerm = integral * KI;
if (ITerm >= 255) ITerm = 255;
if (ITerm <= -255) ITerm = -255;

salida_pwm = ( proporcional * KP ) + ( derivativo * KD ) + (ITerm);

if ( salida_pwm > velocidad ) salida_pwm = velocidad; //limitamos la salida

de pwm
if ( salida_pwm < -velocidad ) salida_pwm = -velocidad;

if (salida_pwm < 0)
{
int der = velocidad - salida_pwm; //(+)
int izq = velocidad + salida_pwm; //(-)
 10

if (der >= 255)der = 255;

if (izq <= 0)izq = 0;
motores(izq, der);
}
if (salida_pwm > 0)
{
int der = velocidad - salida_pwm; //(-)
int izq = velocidad + salida_pwm; //(+)

if (izq >= 255) izq = 255;

if (der <= 0) der = 0;
motores(izq , der );
}

proporcional_pasado = proporcional;
}

void frenos_contorno(int flanco_comparacion)

{
if (position <= 12) //si se salio por la parte derecha de la linea
{
while (true)
{
digitalWrite(led1, HIGH);
motores(-125, 60);
qtra.read(sensorValues); //lectura en bruto de sensor
if ( sensorValues[0] < flanco_comparacion || sensorValues[1] <
flanco_comparacion || sensorValues[2] < flanco_comparacion || sensorValues[3]
< flanco_comparacion || sensorValues[4] < flanco_comparacion ||
sensorValues[5] < flanco_comparacion || sensorValues[6] < flanco_comparacion
|| sensorValues[7] < flanco_comparacion)
{
break;
}

}
}

if (position >= 6988) //si se salio por la parte izquierda de la linea

{
while (true)
{
digitalWrite(led1, HIGH);
motores(60, -125);
qtra.read(sensorValues);
if (sensorValues[7] < flanco_comparacion || sensorValues[6] <
flanco_comparacion || sensorValues[5] < flanco_comparacion || sensorValues[4]
< flanco_comparacion || sensorValues[3] < flanco_comparacion ||
sensorValues[2] < flanco_comparacion || sensorValues[1] < flanco_comparacion
|| sensorValues[0] < flanco_comparacion)
 11

{
break;
}
}
}
digitalWrite(led1, LOW);
}

void motores(int motor_izq, int motor_der)

{
if ( motor_izq >= 0 )
{
digitalWrite(mi1, LOW);
digitalWrite(mi2, HIGH);
analogWrite(pwmi, motor_izq);
}
else
{
digitalWrite(mi1, HIGH);
digitalWrite(mi2, LOW);
motor_izq = motor_izq * (-1);
analogWrite(pwmi, motor_izq);
}

if ( motor_der >= 0 ) //motor derecho

{
digitalWrite(md1, LOW);
digitalWrite(md2, HIGH);
analogWrite(pwmd, motor_der);
}
else
{
digitalWrite(md1, HIGH);
digitalWrite(md2, LOW);
motor_der = motor_der * (-1);
analogWrite(pwmd, motor_der);
}
}
 12

3. Diseño e implementación de una VI en LabVIEW

Diagramas de bloques

Figura 7 Diagrama de bloques de la etapa de calibración

Fuente: Propia

Figura 8 Diagrama de bloques de la selección de parámetros

Fuente: Propia
 13

Descripción de la VI

La VI se encarga de comandar la función de calibración que es el principal

parámetro que debe definir el seguidor de línea para funcionar de forma

correcta, luego se puede seleccionar un parámetro para variar el

funcionamiento del seguidor, sea esta velocidad, kp, kd o ki. Los valores de

velocidad, kp, kd y ki están directamente relacionados y permiten darle una

mayor estabilidad, rapidez y precisión al seguidor durante la trayectoria. Las

ventajas de tener estos parámetros en la vi es que se puede tanto monitorear

como modificar los datos en tiempo real y conseguir una mayor calibración

del funcionamiento.

La conexión entre Labview y la plataforma de arduino se logró por medio

de un módulo bluetooth, que se encarga de enviar o recibir información un

dato a la vez. La conexión entre ambas plataformas se debe programar para

que la información se guarde de forma correcta.

RESULTADOS

Figura 9 Robot seguidor de línea terminado

Fuente: Propia
 14

CONCLUSIONES

Posteriormente a la realización del proyecto logramos concluir que, la implementación

de un robot desde cero, requiere de una gran variedad de consideraciones desde su diseño

ya que cada parámetro influye significativamente en su desempeño final.

Se concluye, que es posible realizar una conexión inalámbrica para la configuración

de los parámetros de funcionamiento del robot utilizando un módulo inalámbrico para la

placa Arduino y programación en un IDE como Arduino y LabVIEW para la

comunicación.

Se concluye, que existen otras maneras de conseguir mejores resultados en un robot

seguidor de línea tanto mecánicamente como en programación, y eso va a depender de la

experiencia y tiempo de pruebas que se tenga para corregir errores.

RECOMENDACIONES

Para un ámbito experimental académico, se recomienda trabajar con elementos que

sean fáciles de conseguir en el mercado y siempre guiándose en proyectos previamente

realizados a fin de no toparse con inconvenientes en el desarrollo del proyecto.

Se recomienda revisar e investigar las herramientas, módulos y bloques de la

plataforma virtual LabVIEW para la interpretación de los datos obtenidos a partir de la

tarjeta y para prevenir problemas de compatibilidad o carencia de funciones para realizar

correctamente la práctica.
 15

BIBLIOGRAFÍA

Aprendiendo Electrónica (2018). Construcción de un seguidor de línea.

Carrión L., et al. (2009). Desarrollo e implementación de una conexión de las placas

Arduino con LabVIEW.

 16

ANEXOS