Construccion seguidor de línea por joaquín berrocal verano 2017

Joaquín Berrocal Piris 1
PROYECTO:
“seguidor_línea”
nOmbRE dEl PROgRama En aRduinO:
“SEGUIDOR_LINEA_Joaquin_Berrocal_PirisVerano-17.ino”
(Realizado en Arduino 1.6.4)
Vídeo Construcción + Programa + Información variada
Autor: Joaquín Berrocal Piris
Fecha: Verano 2017

CONSTRUCCIÓN (Verano 2017)

UTILIZO UNA PLACA ARDUINO UNO R3 Y UN DRIVER MOTOR CON L298N
CONEXIONADO
Pines de la placa driver con arduino
#define AIN1 3
#define AIN2 4
#define PWMA 5
#define PWMB 6
#define BIN1 8
#define BIN2 7
La placa de sensores que utilizo, no es la pololu QTR8A, es otra china parecida que vale unos 4€
respecto a los 17€ de la pololu. Sí utilizo la misma librería.
Tan sólo utilizo 6 de los 8 sensores que dispone la placa.
Conexiones:
placa sensores --- arduino
GND --- a GND
IR ----- al pin 11(pwm) ¿en pololu serÍa seguramente el pin LEDON?
D1 ----- NC No conexionado
D2 ----- A0
D3 ----- A1
D4 ----- A2
D5 ----- A3
D6 ----- A4
D7 ----- A5
D8 ----- NC No conexionado
+ ----- a +5v
#define NUM_SENSORS 6
#define NUM_SAMPLES_PER_SENSOR 4
#define EMITTER_PIN 11 //en la placa pololu – QTR-8A: se conecta al pin LEDON .
//“Yo lo conectao con el pin IR de mi módulo sensor”
#define LED 13 //para activar led de la placa arduino durante la calibración de los sensores
NOTA : Con la librería “qtr-sensors-arduino-3.0.0 ”de pololu para los sensores infrarrojos
Hay unos ejemplos explicativos para su uso. Y también hay un ejemplo llamado
“QTRAExample_calibrar_QTRSensor.ino” que nos sirve para comprobar la placa de los
sensores y ver si actúan ok viendo sus valores por el puerto serie.
Al comienzo de cada carrera, hay que girar durante unos segundos (hasta que se apague el led
de la placa arduino) de un extremo a otro sobre la cinta, para poder adaptar la sensibilidad de
los sensores de infrarrojo a la luz de la cinta y sus alrededores.

---------------------------------------------------- PINES DE PLACAS ARDUINO -------------------------------------------
Muestro la estructura de algunas placas Arduino, que se pueden utilizar para el control del semáforo de ruido,
siendo más que suficiente con la NANO (3€) o la Uno (10€)
La Arduino UNO R3
La Arduino NANO V3.1

La Arduino MEGA 2560
PROGRAMA EN ARDUINO 1.6.4
SEGUIDOR DE LINEA por Joaquín Berrocal Piris
//--------------------PROGRAMA-----------------
#include <QTRSensors.h>
//Mapeo de pines
//#define STBY 9 //NO LO USO POR NO ESTAR EN MI PLACA DRIVER DE ACTIVACIÓN MOTOR
permite un paro fijo
#define AIN1 3
#define AIN2 4
#define PWMA 5
#define PWMB 6
#define BIN1 8
#define BIN2 7
#define EMITTER_PIN 11 //en la placa pololu – QTR-8A: se conecta al pin LEDON .
//“quizás deba conectarlo con el pin IR de mi módulo sensor”
#define LED 13 //para activar led de la placa arduino durante la calibración de los sensores
// Constantes para PID
float KP = 0.5;//1.0; // ORIGINALES KP 0.01 KD 1.0 Ki 0.006 Va bien para Vmax >=100
float KD = 1.0;
float Ki = 0.15;//0.006;
// Regulación de la velocidad Máxima
int Velmax = 255; //ORIGINAL ERA 80

// Data para integral
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
QTRSensorsAnalog qtra((unsigned char[])
{A0, A1, A2, A3, A4, A5}
, NUM_SENSORS, NUM_SAMPLES_PER_SENSOR, EMITTER_PIN);
unsigned int sensorValues[NUM_SENSORS]; //Estoy usando sólo 6 de los 8
// Función accionamiento motor izquierdo
void Motoriz(int value)
{
if ( value >= 0 )
{
digitalWrite(BIN1,LOW); //original era HIGH Y LOW
digitalWrite(BIN2,HIGH);
}
else
{
digitalWrite(BIN1,HIGH); //ORIGINAL ERA LOW Y HIGH
digitalWrite(BIN2,LOW);
value *= -1;
}
analogWrite(PWMA,value); // ORIGINAL ERA PWMB
}
// Función accionamiento motor derecho
void Motorde(int value)
{
if ( value >= 0 )
{
digitalWrite(AIN1,LOW); // ORIGINAL ERA HIGH Y LOW
digitalWrite(AIN2,HIGH);
}
else
{
digitalWrite(AIN1,HIGH); // ORIGINAL ERA LOW Y HIGH
digitalWrite(AIN2,LOW);
value *= -1;
}
analogWrite(PWMB,value); // ORIGINAL ERA PWMA
}
//Accionamiento de motores
void Motor(int left, int righ)
{
//// digitalWrite(STBY,HIGH); no lo uso por no tenerlo mi placa driver de activación motores
Motoriz(left);
Motorde(righ);
}
//función de freno
void freno(boolean left, boolean righ, int value)
{
//// digitalWrite(STBY,HIGH); no lo uso por no tenerlo mi placa driver de activación motores

if ( left )
{
analogWrite (PWMB, value);
}
if ( righ )
{
analogWrite (PWMA, value);
}
}
void setup()
{
// Declaramos como salida los pines utilizados
pinMode(LED ,OUTPUT);
pinMode(BIN2 ,OUTPUT);
/////// pinMode(STBY ,OUTPUT); //NO LO USO POR NO ESTAR EN MI PLACA DRIVER DE
ACTIVACIÓN MOTOR permite un paro fijo
pinMode(PWMB ,OUTPUT);
pinMode(AIN1 ,OUTPUT);
pinMode(PWMA ,OUTPUT);
// 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);
qtra.calibrate();
digitalWrite(LED, LOW); delay(20);
}
delay(3000);
}
unsigned int position = 0;
//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()
{
position = qtra.readLine(sensorValues, true, true);
proporcional = ((int)position) - 2500;
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);
}
//-----FIN DEL PROGRAMA -------------
PROGRAMA EN ARDUINO 1.6.4
SEGUIDOR DE LINEA por Joaquín Berrocal Piris
Ahora el mismo programa en color, con recortes fotográficos desde el mismo programa

DOCUMENTACIÓN VARIADA
Componentes, drivers posibles
En el video de youtube dice que utiliza micromotores de pololu 5:1 que son los más
rápidos.
Yo, para un peso de 385 a 507 grs, el que uso es el de 30/1 1000 rpm, con ruedas finas
de 34 mm y va con fuerza
Dirección global del youtube: https://www.youtube.com/watch?v=0Qww0lm0MQk
Lamborghini competencia final dic 2016 https://www.youtube.com/watch?v=0G4La3PPuWA
Lamborghino abril 2017 explicación sensores https://www.youtube.com/watch?v=e-
WIZBDN1os
Lamborghino: El Seguidor de Linea más Rápido de América
Publicado el 6 abr. 2017
¿De que está hecho el robot seguidor de línea más rápido de America?
Lamborghino el único representante latino en la All Japan Micromouse Contest
◌ Código y Diagramas: http://lamborghino.cl/diy/
http://www.lamborghino.cl/
◌ Tienda Zambeca: http://www.zambeca.cl
◌ Lista de Componentes:
- Motores: https://goo.gl/J7W5sc
- Sensor: https://goo.gl/NAUfkD
https://www.pololu.com/docs/0J19/all
- Ruedas: https://goo.gl/B2eZRO
- Driver Puente H: https://goo.gl/RFr9Cb
- Arduino: https://goo.gl/uphmMM
◌ Agradecimientos especiales a:
Leonfindel por facilitarnos el material de la competencia en Japón. https://goo.gl/41DWuH
Código http://lamborghino.cl/codigo/
Antes de mostrar el código, es necesario entender el funcionamiento de Lamborghino.
El modo de operar de lamborghino es la siguiente:
• Primero utilizamos las lecturas del sensor de luz infrarroja, para saber “qué tan alejado está el
robot, respecto de la línea”. A esa “distancia de alejamiento”, le llamaremos “El Error”.
• Luego tomaremos “la cuantificación de ese error”, y a través de un algoritmo matemático que ya
describiremos, haremos funcionar a los motores con distintas velocidades, para que siempre se
acomode para ir alineado con el camino.
Entonces lo primero que debemos hacer es obtener la posición del robot, a partir de a lectura de los
sensores de luz infrarroja:
Como ya habíamos visto antes en la parte electrónica, podemos observar que el modo de
funcionamiento de los sensores QTR-8A. Si las conexiones están bien hechas, y hacemos la lectura
analógica de cada uno de los sensores del QTR-8A, podemos observar que obtenemos una lectura de
1023 cuando la superficie es absolutamente blanca, y obtenemos 0, cuando la superficie es
absolutamente negra.

Ahora imaginemos que estamos utilizando los 8 sensores de luz infrarroja disponibles en la
matriz, y que cada una de las salidas de los sensores, las tenemos conectadas desde el pin
analógico 0 hasta el pin analógico 7, y nos arrojará lecturas como las que vemos a
continuación:
Como podemos observar, las mediciones sobre el blanco nos dan 1023, y las que están “en el
umbral entre el blanco y el negro”, nos dan un valor entre 0 y 1023, dependiendo del nivel de
reflectancia. Luego, si graficamos estos valores, podremos observar lo siguiente:

Con esto, podemos intuir que la línea negra está entre el sensor 4 y el sensor 5, pero
debemos obtener el valor exacto de la posición de la línea, y para eso, haremos una
transformación a los datos, para obtener lo que buscamos.
A los valores obtenidos, les cambiaremos el rango, de 0 a 1023, a 0 a 1000; Y además, le
cambiaremos los daremos vuelta. Es decir, lo que antes era 1000, ahora será 0, y lo que
antes era 0, ahora será 1000, y obtendremos el siguiente gráfico.
Ahora, podemos observar gráficamente en qué sensores se concentra mayormente la línea
negra.

Pero nosotros necesitamos el dato exacto, y para poder obtener ese dato, podemos utilizar 2
métodos:
• Estimación de la posición a través de interpolación cuadrática
• Estimación de la posición a través del promedio ponderado
Luego de probar con ambas, nos dimos cuenta que el resultado es idéntico. No hay diferencia
ni velocidad ni en la precisión.
Así que enseñaremos el más sencillo:
El promedio ponderado:
El promedio ponderado se calcula así:
Probando esta fórmula con el ejemplo anterior, no da lo siguiente:
Esta fórmula nos devuelve un valor entre 0 y 7000, donde 0 significa que el sensor está
en el extremo izquierdo, y 7000 significa que está en el extremo derecho. Pero en este
ejemplo nos dice que está en la posición 3587.

Bien, ahora que ya encontramos nuestra posición actual (que es x = 3587) debemos aplicar el
algoritmo matemático que nos ayudará a controlar los motores, a partir del error respecto a la
posición ideal.
Si la posición del sensor respecto a la línea debe estar entre 0 y 7000, obviamente, la
posición ideal será de 3500, a esa posición ideal, le llamaremos Setpoint. (Setpoint =
3500), y como habíamos dicho antes, le llamaremos “Error”, a la distancia entre la lectura
actual, y la posición ideal del robot. (Posición Actual = 3587).
Error = Posición Actual – Setpoint
Error = 3587 – 3500
Error = 87
Ahora que sabemos qué tan alejado estamos de la posición ideal, aplicaremos un algoritmo
matemático para energizar a los motores para éstos siempre se acomoden a la posición ideal.
Este algoritmo se llama “Proporcional, Integral, Derivativo” (más conocido como PID). ( No
se asusten con el nombre, la verdad es que es muy sencillo. No es necesario ser un experto
matemático para aplicarlo.)
Copiamos el código, para que lo apliques, lo mejores y lo comentes!
//Mapeo de pines
#define STBY 9
#define AIN1 3
#define AIN2 4
#define PWMB 5
#define PWMA 6

#define BIN1 8
#define BIN2 7
#define EMITTER_PIN 11
#define LED 13
// Constantes para PID
float KP = 0.01;
float KD = 1.0;
float Ki = 0.006;
// Regulación de la velocidad Máxima
int Velmax = 80;
// Data para integral
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
QTRSensorsAnalog qtra((unsigned char[])
{A0, A1, A2, A3, A4, A5}
, NUM_SENSORS, NUM_SAMPLES_PER_SENSOR, EMITTER_PIN);
unsigned int sensorValues[NUM_SENSORS];
// Función accionamiento motor izquierdo

void Motoriz(int value)
{
if ( value >= 0 )
{
}
else
{
value *= -1; // Lo positiviza para evitar error en el próximo: analogWrite
(PWMB,value);
}
analogWrite(PWMB,value);
}
// Función accionamiento motor derecho
void Motorde(int value)
{
if ( value >= 0 )
{
}
else
{

value *= -1; // Lo positiviza para evitar error en el próximo: analogWrite
(PWMB,value);
}
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 )
{
analogWrite (PWMB, value);
}
if ( righ )
{
analogWrite (PWMA, value);
}
}

void setup()
{
// Declaramos como salida los pines utilizados
pinMode(LED ,OUTPUT);
pinMode(STBY ,OUTPUT);
pinMode(PWMB ,OUTPUT);
pinMode(PWMA ,OUTPUT);
// 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);
qtra.calibrate();
digitalWrite(LED, LOW); delay(20);
}
delay(3000);
}
unsigned int position = 0;
//declaraos variables para utilizar PID
int proporcional = 0; // Proporcional
int integral = 0; //Integral
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()
{
position = qtra.readLine(sensorValues, true, true);
proporcional = ((int)position) - 2500;
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);
}
Mecánica http://lamborghino.cl/mecanica/
El secreto de lamborghino, es que está diseñado por ingenieros mecánicos. Si bien es cierto que la
electrónica es fundamental el desarrollo de los seguidores de línea, una vez “solucionado” el tema
electrónico, la velocidad y la precisión de nuestro seguidor de líneas dependerá casi exclusivamente de
la mecánica.
Cuando diseñamos el robot, nos planteamos 2 principios de diseño:
1. El robot debe pesar lo menos posible.
2. Debemos disminuir la inercia.
Cuando comenzamos a seleccionar las piezas que utilizaríamos para armar nuestro seguidor de líneas,
optamos por las ruedas vendidas por Pololu, Solarbotics RW2 Wheel. Nuestra primera impresión fue
que eran perfectas para nuestro seguidor de línea. El ancho de las ruedas, el agarre aparente y todo se
veía perfecto. Además estas ruedas las vendían de a una… eso nos hablaba de la calidad de las ruedas.
además la descripción de las ruedas era así:
The Solarbotics RW2 rubber wheel has a black, anodized aluminum hub with a generously thick rubber
tire for maximum traction (great for minisumo robots or fast line-following robots that need traction
when rounding corners).
Así que decidimos comprarlas.
Aprovechando la compra en el extranjero, compramos una ruedas mucho menos sofisticadas, con
nombre Wheel 32×7mm Pair. La verdad es que estas ruedas las compramos como una alternativa poco
probable, ya que según nuestra apuesta, las solarbotics deberían ser infinitamente mejores.
Pero como somos ingenieros, hicimos las pruebas para saber cuáles eran las mejores ruedas para nuestro
seguidor de línea. Así que construimos una pista de aproximadamente 16 metros lineales. (con curvas y
todo). Primero probamos con las ruedas solarbotics, y el robot se demoró aproximadamente 20
segundos en promedio, en dar una vuelta completa.
Luego probamos con las ruedas estándar de 32×7 mm, y el robot se demoró 12 segundos. Así que
Tamaño de la pista [m] 15,9
Diámetro Peso [gr] tiempo/vuelta [s] V prom [m/s]
Solarbotics 31,2 12,2 20,1 0,79
Ruedas 32×7 32 3,2 11,58 1,37

haciendo una pequeña tabla podemos observar lo siguiente:
La conclusión inmediata que se nos viene a la mente, es que con las rudas de 32×7 mm casi duplicamos
la velocidad promedio que con las ruedas “súper sofisticadas solarbotics”. ¿Pero por qué?, la respuesta
es “EL PESO”.
Como ya habíamos dicho en un principio, el peso de nuestros robots es una de las variables que más
influyen en la velocidad de este; y haciendo una observación de cómo afecta esta variable, podemos ver
que tan solo la disminución de 9 gramos en cada rueda, hizo que el robot casi duplicara su
velocidad promedio.
En conclusión, el peso es la variable más importante.
A las velocidades y los pesos a los que frecuenta nuestro robor, la variable del “agarre”, no es tan
influyente como la variable del peso. Cuando nuestro robot supera los 3 metros por segundo, y está
sometido a aceleraciones “muy bruscas”, ahí recién, la variable del agarre de las ruedas, pasa a a ser una
variable de igual importancia que el peso.
Luego de comprender la importancia del peso en nuestro seguidor de líneas, rediseñamos todo,
pensando en disminuir el peso a su mínima expresión. Así que nos hicimos un chasis de cartón Foam,
con una figura “velocista”. En realidad la forma del robot puede ser cualquiera, pero tienen que
cumplirse la siguiente característica.
• La separación entre las ruedas debe ser de aproximadamente 14 centímetros
• La separación entre el eje de las ruedas y los sensores, debe ser de aproximadamente 12
centímetros
Es decir, debe quedar como en este diagrama:
Otra variable importante al momento de construir nuestro seguidor de líneas, es la Inercia.
Mientras más alejado del centro de giro se encuentre el peso, mayor dificultad tendrá nuestro robot para
girar, por lo tanto, debemos procurar que la mayor parte del peso, se encuentre en el centro de giro,
es decir, entremedio de los dos motores. Por lo tanto, la batería y los componentes electrónicos más
pesados, deberán ir lo más centrados respecto al eje de giro.
El pivote:
Ya que nuestro robot posee solo dos ruedas, deberemos agregarle un tercer punto de apoyo para que los
sensores no toquen el piso, y se mantengan siempre a la misma altura. Para eso tenemos 2 soluciones,
igual de prácticas y con resultados muy similares.
La primera, es comprar una bola rodante, que vende Pololu.

Es muy cómodo, pero con el tiempo se ensucia y pierde movilidad. además, tendremos que perforar
nuestro robot para poder utilizarlo.
La otra opción, la vimos en internet, que es utilizar luces led de 3mm… Sí… tal como de escucha…
Utilizar un led de 3mm como pivote.
Si nos preguntan cuál es el mejor lugar para ubicar el pivote, les decimos que deben probarlo ustedes. no
obstante, deben considerar que mientras más alejado del centro de giro, provocará una mayor inercia.
Por otro lado, mientras más cerca esté el pivote del centro de giro, la estabilidad de los sensores va a
empeorar.
Electrónica http://lamborghino.cl/electronica/
Lamborghino es básicamente un vehículo eléctrico autónomo, y como todo vehículo,
éste debe generar su movimiento a través de actuadores electromecánicos, en este
caso, serán motores eléctricos. Así que primero que todo, deberemos definir el
microcontrolador que utilizaremos.
Como Lamborghino es un proyecto “Mecatrónico”, al momento de fabricarlo,
procuramos no abusar de los límites entre las áreas de la electrónica y la mecánica,
de tal manera que decidimos trabajar con un procesador que fuese capaz de
programarlo cualquier integrante del grupo, y no solo el ingeniero electrónico.
Por esta razón, decidimos trabajar con la plataforma de Arduino. En este caso,
utilizamos un Arduino Nano (ATmega 328, 16Mhz.)
Con Arduino Nano Posee:
• 8 Entradas Analógicas
• 14 Entradas y salidas digitales (6 con PWM)
Suficiente para hacer nuestro seguidor de líneas.

Además nuestro robot deberá ser capas de seguir el camino trazado, (que será una
línea blanca sobre una superficie negra, o una linea negra sobre una superficie
blanca)por lo que necesitaremos utilizar entonces, un “sensor de línea”.
Tenemos una buena y una mala noticia respecto a esto. La mala es que los sensores
de línea no existen…, la buena es que podemos hacernos uno utilizando sensores y
emisores de luz infrarroja. ¿Por qué?, lo veremos con el siguiente diagrama.
Como podemos ver en la imagen, si emitimos luz infrarroja sobre una superficie
blanca, entonces la luz revotará y la recibirá el sensor. Ahora bien, si emitimos luz
infrarroja sobre una superficie negra, la luz no rebotará.
De esta forma podremos saber si nuestros sensores están sobre el camino, o si no.
Dentro de una amplia gama de sensores de luz infrarroja, los más utilizados son los
siguientes:
Emisor y receptor de Luz infrarroja, formato led 3mm.

Pack de emisor y receptor de montaje de orificio pasante. (Por ejemplo CNY70)
Pack de emisor y receptor de montaje superficial. (Por ejemplo QRE1113GR)
En nuestra experiencia, la forma más fácil y eficiente para hacer un seguidor de líneas
velocista es utilizando las matrices de sensores, prefabricadas, como el módulo QTR-
8A de pololu.

Su implementación es muy sencilla, gracias a la facilidad de conexión. (en nuestra
opinión, utilizar este módulo es un ahorro de tiempo y de dinero).
Nota:
Existen dos tipos de QTR8, Están los Análogos (QTR-8A) y los digitales (QTR-(8RC),
Pueden ver la diferencia en la página del fabricante, pero en nuestro caso, por
comodidad, preferimos utilizar los QTR-8A.
Como podemos observar, esta matriz posee 8 sensores, pero luego de varias
pruebas, hemos llegado a la conclusión de que con una buena programación del
algoritmo, podemos trabajar perfectamente con 6 sensores. Disminuyendo así, a solo
9 las conexiones necesarias.
1. Salida sensor 1
2. Salida sensor 2
3. Salida sensor 3
4. Salida sensor 4
5. Salida sensor 5
6. Salida sensor 6
7. LEDON
8. VCC
9. GND
El pin LEDON sirve como un STANDBY de los emisores de luz infrarroja, por lo tanto,
si el LEDON recibe un “HIGH”, entonces prende los emisores de luz infrarroja, y si
recibe un “LOW”, los apaga. Esto sirve para ajustar la luminosidad que queremos
utilizar (usando PWM), o para ahorrar energía, utilizando los emisores, sólo cuando
sea necesario.
Las salidas de los sensores, las conectaremos a las entradas analógicas del
microcontrolador, el pin LEDON lo conectaremos a una salida digital, y la
alimentación VCC y GND la suministraremos de la que nos puede dar Arduino.
OJO: Muchos nos dirán que esto último no se debe hacer, y tienen razón, ya que
arduino solo puede suministrar hasta un máximo de 40mA, y el QTR-8A necesita
aproximadamente 100 mA… Pero bueno, nuestro robot funciona así, y nunca ha
fallado, ni quemado, ni nada. Si no confían, pueden utilizar un regulador de voltaje
(LM7805, pero a nosotros nos da pereza hacer esa conexión jajajaja).
Otro de los dispositivos fundamentales para nuestro seguidor de líneas, será el Driver,
para energizar y controlar nuestros motores.
Para los que no sean “Electrónicos”, explicaré por qué el driver cumple una función
primordial para poder controlar los motores. Como sabemos, Los motores de
corriente continua poseen 2 cables, y estos exigen un cierto voltaje y una cierta

corriente. La mayoría de las veces, tanto el voltaje como la corriente que necesitan,
sobrepasa la que puede suministrarle el Arduino. Entonces, con el driver podremos
energizar externamente nuestros motores y controlarlos con Arduino…. Para eso sirve
el driver.
Luego de probar un sin fin de Drivers, hemos llegado a la conclusión de que la mejor
opción es utilizar el Toshiba TB6612FNG, Como dato anecdótico, podemos contar que
este Driver viene incorporado en los discos duros SATA de marca TOSHIBA, por lo
tanto su fidelidad es tremenda.
Luego de probar un sin fin de Drivers, hemos llegado a la conclusión de que la
mejor opción es utilizar el Toshiba TB6612FNG, Como dato anecdótico, podemos contar que este
Driver viene incorporado en los discos duros SATA de marca TOSHIBA, por lo tanto su fidelidad es
tremenda
Además, este driver puede aguantarnos corrientes permanentes de 1.2 A por canal y
un peak de 3.2 amperes por canal, además con este driver lo podemos utilizar para
generar un freno en los motores por inducción electromagnética.
en julio 2017 en aliexpress 10uds = 9€
Los pines de este driver son los siguientes:
1. PWMA –> Entrada de señal PWM para motor A
2. AIN2 –> Control de dirección para motor A (Horario o Anti-horario)
3. AIN1 –> Control de dirección para motor A (Horario o Anti-horario)
4. STBY –> Standby motores, ( si recibe un LOW, los motores se desconectan)
5. BIN1 –> Control de dirección para motor B (Horario o Anti-horario)
6. BIN2 –> Control de dirección para motor B (Horario o Anti-horario)
7. PWMB –>Entrada de señal PWM para motor B
8. GND –> Tierra
9. GND –> Tierra
10. B01 –> Salida para motor B
11. B02 –> Salida para motor B
12. A02 –> Salida para motor A
13. A01 –> Salida para motor A
14. GND –> Tierra
15. Vcc –> Alimentación del driver (2,7 – 5,5V)
16. Vin –> Alimentación de los motores (15V máx.)

Por ejemplo, si tiramos un LOW al AIN1 y un LOW al AIN2, y un HIGH al PWMA y al
STANDBY, provocaremos una frenada brusca en los motores.
Bueno, finalmente, pero no menos importante, hablaremos sobre la alimentación del
robot.
Queremos ser tajantes desde un principio, LAS PILAS AA o AAAo todas esas que se
utilizan en las radios NO SIRVEN!!.
En primer lugar, no sirven porque son una aberración mecánica. Cada una de estas
pilas, pesa lo mismo que nuestro robot, y lo que no queremos hacer, es aumentarle el
peso. Además, tenemos que pensar que necesitamos suministrar más de 4 amperes
en el peak al robot. Esto ocurre porque cada motor consume en el peak, 1.6 amperes,
más un factor de seguridad, necesitaríamos por lo menos una fuente de energía que
pueda aguantarnos 4 amperes.
Para eso utilizaremos baterías de litio… PERO NO CUALQUIER BATERÍA DE
LITIO!!. dentro de las baterías de litio más comunes, podemos encontrar las baterías
de Litio – Ion (que son las que utilizan los smartphones o tablets) y las baterías
de Litio – Polímero (Li-po). que son las que utilizan en aeromodelismo o cosas así.
También queremos ser categóricos en esto…
LAS BATERÍAS DE LITIO – ION NO SIRVEN!!
SÓLO SIRVEN LAS BATERÍAS DE LITIO – POLÍMERO!
Ahora que ya sabemos qué batería son las que nos sirven, aprenderemos a cómo
elegirlas:
Las baterías de litio – polímero tienen siglas para entender sus especificaciones.
Ejemplo:

Esta batería dice que es 2S, significa que posee 2 celdas en serie. Si dijera 6s,
significaría que posee 6 celdas en serie. Cada celda genera 3,7 V, por lo tanto, si
tiene 2 celdas en serie, generaría 7,4 volts.
Para saber cuánto es lo máximo que puede suministrarnos una batería de litio
polímero, debemos fijarnos en la letra “C”. La letra C, nos indica la tasa de descarga
de nuestra batería. Es decir, si la batería es de 200 mAh y 30C, Entonces nos podrá
suministrar hasta 30*200mAh, es decir hasta 6 amperes!. En fin, las baterías son
todo un mundo, y si quieren saber más acerca de las baterías, pueden ver este link.
Ahora que ya sabemos todas las partes electrónicas que necesitamos, procederemos
a describir las conexiones entre los elementos.
Mostraremos las conexiones por separado, para que sea más fácil el entendimiento:
La conexión entre la batería, el driver y arduino es la siguiente:
• D0 (Reservado para puerto serial)
• D1 (Reservado para puerto serial)
• D2 – Libre disposición
• D3 – Driver: AIN1
• D4 – Driver: AIN2
• D5 – Driver: PWM A
• D6 – Driver: PWM B
• D7 – Driver: BIN2
• D8 – Driver: BIN1
• D9 – Driver: STANDBY
• D11 – QTR-8A: LEDON “quizás deba conectarlo con el pin IR de mi módulo
sensor”
• D13 – Reservado para utilizar led incorporado en arduino
• A0 – QTR-8A: 1
• A1 – QTR-8A: 2
• A2 – QTR-8A: 3
• A3 – QTR-8A: 4
• A4 – QTR-8A: 5
• A5 – QTR-8A: 6
• GND – Driver: GND, QTR-8A GND, Batería: GND
• VIN – Batería: 7,4V
• 5V – Driver: Vcc, QTR-8A: VCC

OJO: El pin VM del Driver debe ir conectado a la batería: 7,4 Volt.
La conexión entre arduino y el módulo QRT-8A será la siguiente:
---------------------------------------------------- 0 ----------------------------------
+ Más sobre el sensor QTRSensor y hay mas datos con otros archivos informativos:

Materiales resumen: Micro Metal Gearmotor (motores con reductora de la casa Pololu)
He aquí el dilema , Que tipo de motor utilizar?. Pues si tienes un robot que te va a
salir un poco pesado, es decir que este por 200 a 400 gramos, que es mucho para
un robot velocista de competencia, pues puedes utilizar los motores 30:1. Pero
en cambio si tienes un robot liviano de unos 100 gramos, pues puedes utilizar
uno de reducción 10:1.
NOTA: el mío (Joaquín) pesa 385grs com 6 pilas de 1.5V y cierto es que va bien
con 30:1 con rueda de 32mmx7mm
Lo anterior fue una parte de lo que debemos tener en cuenta para el motor del robot,
Ahora está el consumo de los motores. Pololu, empresa de venta de articulos para
robotica, posee 3 tipos de motores, están los de consumo: High Power o HP,
Medium Power MP y los Low Power LP.
Los HP tienen consumos de corriente de 120mA libre a 1600 mA en paro obteniendo
mayores revoluciones por minuto 10:1 -> 3000 rpm, 30:1 -> 1000 rpm.
Los MP tienen consumos de 40mA libre a 700mA en paro obteniendo revoluciones
relativamente altas 10:1 -> 2200 rpm, 30:1 -> 730 rpm
Los LP tienen consumos de 40mA libre a 360mA en paro obteniendo revoluciones
bajas pero a menor consumo 10:1 -> 1300 rpm, 30:1 -> 440 rpm
En el caso de mi robot , utilizo motores 10:1 MP 2200 rpm , elegí estos tienen
revoluciones altas y el consumo del motor no es tan alto por lo que no tengo
problemas con el agotamiento de baterías.
-> Driver de motor
Hasta la fecha no existe un microcontrolador que sea capas de entregar mas de
100mA, por lo que el driver de motor seguirá siendo una opción obligatoria. Los driver
que se pueden utilizar son los siguientes:

TB6612FNG. Este driver posee 2 canales (para dos motores) es capaz de entregar 1
amperio continuo de corriente y 3 A pico por canal. soporta hasta los 13 Voltios y va
bien con los motores HP. En embajadores Madrid dice : 1.2A y picos de 3.2A
DRV8833. Este driver es de 2 canales y entrega una corriente de 1.2 A continuos y 2
A pico por cada canal soporta hasta 10.8 Voltios y es el que yo utilizo:3, este driver es
simple de utilizar, cuenta con los pines necesarios para el control de cada motor, a un
pin lo puedes usar para dar para el sentido de giro al motor y al otro para el pwm,
cumple su proposito muy bien, lo utilizo para motores MP.
La recomendación que puedo dar aquí es que para tener un mejor control de los
motores, es mejor utilizar una configuración inversa de pwm para el control del motor
....... investiguen :D
->Baterias

Las baterias de lipo son siempre la mejor opción, lo recomendable es que sean de
7.4 voltios, ya que nuestros micromotores funcionan a ese voltaje. Un aspecto
importante también es la capacidad A/h (amperios hora que es capas de entregar la
bateria antes de agotarse), Yo me tome la molestia de medir la corriente que consume
en funcionamiento el circuito de control del robot (arduino, sensores, leds, etc) y
estos consumen alrededor de 100 mA- 150 mA y los motores con carga
consumes 200 mA- 400 mA ( es decir si promediamos el consumo del robot en
funcionamiento normal, este estaría cosumiendo algo mas de 400 mA, por lo que lo
ideal sería contar con una batería que suministre al menos una hora de
funcionamiento. Este seria el caso de una bateria de 500mAh. Como nuestro robot
consume alrededor de 400 mAh, esta batería nos brindara un poco mas de una hora
de funcionamiento antes de que este completamente descargada.
Pero por supuesto siempre está la opción de comprar una batería que tenga mayor
capacidad como los de 1000mA y los de 1500mAh, pero sabemos que a mayor
capacidad, mayor tamaño y peso, produciendo un mayor consumo de los motores, por
lo tanto siempre hay q buscar un equilibrio
+ Condensadores en los motores:
Una las soluciones mas baratas que hay es simplemente poner un capacitores de
"tantalio" de codigo 104 (0,1uF) y 103 (0.01 uF) en paralelo con la alimentación,
http://aprendiendofacilelectronica.blogspot.com.es/2014/12/robot-velocista-de-
competencia.html
http://aprendiendofacilelectronica.blogspot.com.es/2016/11/robot-velocista-qtr8a-parte-ii.html
Continuación http://aprendiendofacilelectronica.blogspot.com.es/2016/11/robot-velocista-qtr8a-
parte-iii.html
-------------------------------- 0 ----------------------

Zinc–
carbono
Alcalina Li-FeS2 NiCd NiMH
Designación IEC R6 LR6 FR6 KR6 HR6
Designación
ANSI/NEDA
15D 15A 15LF 1.2K2 1.2H2
Capacidad típica 1100 mAh
2700–
2900 mAh
3000 mAh
500–
1100 mAh
1500–
2900 mAh
Tensión nominal 1,5 V 1,5 V 1,55 V 1,25 V 1,25 V
+ Las pilas de 1.5V alcalinas pesan 25.6grs (Pila cilíndrica alcalina LR6 / AA - 1,5V)
+ 6 pilas x 25.6grs= 153,6grs . la capacitad total > 16200mah
+ Las batería LIPO de 7.4V (2S o 2 celdas)
+ La que he comprado yo : 7.4V 30C 4200mah pesa 260grs
+ Batería Lipo de 7.4V Capacidad: 2000 mAh Celdas: 2S 25C Peso neto: 100 gr
+ Una de 11,1V (3S -15C -5200maH) pesa 365grs
+ Mi power Bank (PowerAdd) es de Li-ion de 5V / 5000mAh 18.5W output 5V/2.1A y pesa
122grs
++++ BATERIAS LIPO CARACTERISTICAS INTERESANTES+++
http://blogturbohobby.blogspot.com.es/2013/05/bateriaslipo.html
las baterías de Lipo están formadas por elementos de 3.7v. Para saber el voltaje de una batería
solo tenemos que multiplicar el número de elementos por el voltaje de este, ya que se conectan en
serie (2S por ejemplo). Es decir que una batería de 2 elementos tendría el voltaje de 7.4v (3.7v x 2
elementos = 7.4v)
las letras KW. Si multiplicas el número por el voltaje de tu batería el resultado son las vueltas por
minuto de tu motor. Por ejemplo, si tu coche rc lleva un motor brushless que saca 3500KV y le has
montado una batería de 7.4v las revoluciones totales por minuto serán, 25.900RPM. Ahora
bien, si en este mismo coche resulta que tu variador admite un voltaje de hasta 14v. por ejemplo y
le montas una batería de 11.1v tendrías la friolera de 38.850RPM (una pasada!!!) y sin aumentar
apenas el peso de la batería...
Por otro lado las Lipos a parte de la especificación de los miliamperios de la batería, también se detalla una
referencia de descarga máxima que viene expresada con un número seguido de una ‘C’ (25C), donde C es el
amperaje de la batería. Para saber que amperaje descarga nuestra batería tenemos que multiplicar los
miliamperios de esta por el número delante de la C. Por ejemplo, si tenemos una batería de 4.000Mha y
30C, la descarga máxima a la que podemos someter esta batería sería 120.000Mha (120A). Es decir que
la podemos montar en un modelo RC que consuma como máximo 100 o 110A ya que siempre es necesario
dejar un margen por si se produce algo que no tengamos controlado.
En algunas batería de Lipo, aparecen una referencia de descarga indicada por dos valores 20C-30C,
esto nos indica que el fabricante está diciendo que la batería se puede descargar a 20C de manera
continuada y que la batería podría darnos hasta 30C por un tiempo limitado, unos segundos
Mantenimiento de la Batería
1 Compruebe la tensión (voltaje) por celda tras la primera carga, conforme a la siguiente
tabla: nota cada celda da 3.7V si tiene 2 celdas dará 7.4V como valor nomial.

1 celda 4.2V (4.15 a 4.22)
2 celdas 8.4V (8.32 a 8.44) --Nota la q yo he comprado al llegar tenía 7,8V y al cargarla 8.37V
3 celdas 12.6V (12.48 a 12.66)
4 celdas 16.8V (16.64 a 16.88)
5 celdas 18.5V (18.30 a 18.60)
2. No descargue la batería por debajo de 3V por celda. Una descarga profunda, por
de bajo de 3V puede deteriorar el rendimiento de la batería.
----------------tabla de características de baterías de LI-POLY -----------------
Compro el 3-7-2017 la de 7,4V 4200Mah 30C peso 215grs

Tabla de referencia Motorcillos con engranajes metálicos N20
Parámetro del ENGRANAJE-JA12 n20
tensión
velocidad sin
carga
velocidad de
carga
par nominal
corriente
nominal
par máximo stall actual Ratio reductor
DCV rpm/min rpm/min kg. cm ma kg. cm ma 1:00
3 750 500 0.02 80 0.3 100 10
3 250 200 0.07 80 0.56 100 30
3 150 120 0.1 80 0.8 100 50
3 75 60 0.15 80 1.2 100 100
3 50 40 0.2 60 1.6 100 150
3 37 30 0.25 60 2 100 200
3 25 20 0.5 60 4 100 298
3 19 13 0.5 60 4 100 380
6 1500 1000 0.05 160 0.3 100 10
6 500 400 0.15 160 1.2 100 30
6 300 240 0.2 160 1.6 100 50
6 150 120 0.3 160 2.4 200 100
6 100 80 0.4 160 3.2 200 150
6 74 70 0.6 120 3.2 200 200
6 50 40 1.5 120 10 200 298
6 39 40 1.5 120 10 300 380
12 3000 2000 0.08 200 0.8 300 10
12 1000 800 0.3 200 2.4 300 30
12 600 480 0.4 200 3.2 300 50
12 300 240 0.6 200 4 300 100
12 200 160 1 200 7 300 150
12 148 118 1.5 150 9 300 200
12 100 80 2 150 16 300 298
12 78 80 2 150 16 300 380
---------------- CONVERTIDORES DE TENSIÓN Step Up / Step Down----------------------
Lo puedo utilizar para utilizar 4 baterías de 1.5V = 6V para alimentar a la placa arduino y los
motores por ejemplo a < 6 A 12Voltios. Con lo que podré activar los motores sin problemas.
Regulador de voltaje DC-DC Step Up 4V a 35V
Módulo Step Up basado en el integrado XL6009E1, permite elevar el voltaje de entrada hacia
una salida regulable entre 1.25 y 35 Vdc con una corriente máxima de 4A (se sugiere utilizar
disipador).

El módulo incluye el circuito integrado XL6009E1 que corresponde a una tecnología de conmutación de alta
frecuencia, eficiencia de un 96% y bajo rizado. La salida es ajustable mediante el potenciómetro.
Características:
• Voltaje de entrada: 3V a 32V (se recomienda un mínimo de 5V)
• Voltaje de salida: 4-35V regulable
• Intensidad máxima de entrada: 4A
• Intensidad máxima de salida: 4A
• Eficiencia aproximada: 96%
• Frecuencia de trabajo: 400KHz
• Temperatura trabajo: -40º a +85ºC
• Dimensiones: 43 x 21 x 14 (mm)
Ejemplo de rendimiento para una salida deseada de 12V:
• Si entrada es 3V, 1,6A (5W) se obtiene una salida de 12V, 0.4A (4.8W)
• Si entrada es 5V, 2A (10W) se obtiene una salida de 12V, 0.8A (9.6W)
• Si entrada es 7.4V, 2,53A (18,75W) se obtiene una salida de 12V, 1.5A (18W)
-------- Este otro la entrada dice que debe ser superior 1.5V a la salida-------
A estos se les llama Step Down necesitan 1.5V por encima de la salida
Regulador de Voltaje DC-DC 1.3V a 37V LM2596 con Voltímetro
Módulo que permite la regulación del voltaje de salida (según la entrada) entre 1.3 y 37 Vdc, y
corriente máxima de 2 A.
Mediante su display es posible visualizar el voltaje de entrada o voltaje de salida.
Se debe asegurar que el voltaje de entrada sea al menos de 4 V y mínimo 1.5 V por encima
de la salida deseada.
Características:
Resolución ± 1 V
Rango tensión de entrada: 4 - 40 Vdc
Tensión de salida ajustable: 1.3 - 37 Vdc
Corriente de salida: 2 A
Voltímetro digital con displays de 7 segmentos, rango: 0 - 40 Vdc
Pulsadores para elegir visualizar voltaje de entrada o de salida
Circuito integrado: LM2596

http://www.fpalzira.es/web/index.php/es-es/2015-05-21-16-45-34/61-
departamentos/electricidad-y-electronica/proyectos/robotica/tutorial-como-se-construye-un-
robot
----------------------------------- OTROS MATERIALES -----------
RUEDA ESPUMA - BANEBOTS
http://www.todohobby.net/es/2798-ruedas-espuma
https://www.fingertechrobotics.com/proddetail.php?prod=ft-minisumo-wheels-1125
Aquí habla de característica de las scaleauto de espuma
http://bantuslot.com/blog/ruedas-con-neumatico-de-espuma-para-rallyslot-124/
Escala rueda 1:24 con diámetro inte de 3mm las hay de 17/19 y 21 mm
DIRECCIÓN INTERESANTE CON PROGRAMACIÓN VELOCISTA
http://aprender.tdrobotica.co/seguidor-de-lineaprofesional/
COMENTARIOS DE LOS CONSTRUCTORES DE VELOCISTAS
https://www.youtube.com/watch?v=TAvCD_xx39c
dirección con instrucciones y pista velocista
http://www.pascualbravo.edu.co/virtual/index.php/90-expotecnologica/132-x-muestra-de-
robotica
CATEGORÍA: SEGUIDOR DE LÍNEA VELOCISTA
• DEFINICIÓN:
La categoría Seguidor de Línea velocista, busca que los constructores diseñen robots
que se adapten a las especificaciones de la prueba y que desarrollen estrategias de
programación, adecuadas a la tarea
El robot velocista tiene un punto específico de partida que a la vez es el de llegada. Su
recorrido lo hace con el objetivo de realizar 3 vueltas.
Características:
Una vez iniciada la competencia el cronómetro no es detenido bajo ninguna
circunstancia.
• Pista:
Esta se encuentra demarcada sobre una lámina plástica (PVC y poliéster) de color
blanco mate de dimensiones 1.80 x 2.40 metros. El robot debe seguir la línea

negra de 18 mm de ancho. Todas las medidas especificadas están sujetas a
variaciones hasta ±2% debido a los cortes sobre el material.
La pista estará iluminada de forma artificial o natural y las condiciones de luz
pueden ser cambiantes, por lo cual no se garantiza la ausencia de sombras.
Durante la competencia, existirán equipos de filmación y cámaras fotográficas
que podrán generar rayos infrarrojos por sus sistemas de auto foco. Por lo tanto,
los robots deben estar preparados para que las condiciones de luz cambiante no los
afecten.
------------------- MÁS INFORMACIÓN alguna ya está comentada anteriormente----------------
https://www.pololu.com/product/1000
https://www.youtube.com/watch?v=ee-GuCBWyH4
descripción piezas micromotor reductor y ruedas pololu
Rueda direccional: 0,19 + gastos envio total 2,13€
CY-15A 5/8A inteligente casters coche pequeño maverick ojo redondo bola de acero
omni rueda universal rueda caster wheel 1 unids

Ruedas traseras de 34 mm diámetro: 34 MM
apertura: D-3mm 10 pzs 8,56€
10 unids 3PI miniQ N20 Micro Motor Mount Set 12mm DC
Gear Motor Soporte De Montaje Accesorios Del Coche de
Juguete F05101
10 pzs 4,71€
altura: 11mm
ancho: 25mm
Material: plástico de alta calidad
cantidad: 10 set/lote
Nota especial: sólo para HM N20 motor de serie
---------------------------------------------------------------------------------------------
2 Motores 6,48€
el paquete Incluye:
1 x Motor De Engranajes(12 V 100 RPM)
Tamaño Del Eje de salida: 3*10mm (Tipo D)
Módulo de Módulo de Sensor de Detección de Infrarrojos DIY
Para Arduino Módulo Sensor Hunt Módulo Detector de
Infrarrojos de $ Number Canales de $ number bits 3,96€

http://www.zambeca.cl/tiendaOficial/index.php?route=product%2Fproduct&product_id=
398&search=qtr-8a
Especificaciones:
• Dimensiones: 74,93 mm x 12,70 mm x 3,18 mm (2,95 "x 0,5" x 0,125") (sin
conectores instalados)
• Voltaje de funcionamiento: 3,3 a 5,0 V
• Corriente de alimentación: 100 mA, aunque el del video dice que se puede
conectar sin problemas a arduino
• Formato de salida: 8 voltajes análogos
• Rango de voltaje de salida: desde 0 V al voltaje suministrado
• Distancia óptima de detección: 3 mm (0,125")
• Distancia máxima de detección recomendada: 6 mm (0,25")
• Peso sin conectores: 3,09 g (0,11 oz)
Incluye:
• 1 tira de terminales macho 1 x 25 pines, de 2,54 mm (0,1”)
• 1 resistencia 100 Ohm.
Documentos
• Guía del usuario para el sensor QTR-8A.
• Notas de aplicaciones de los sensores Pololu QTR
• Guía del usuario: Librería Pololu AVR C/C++
• Librería Arduino para los sensores de reflectancia Pololu QTR

• Librería de comandos de referencia Pololu AVR
• Construcción de seguidores de líneas y laberintos de líneas
• Robot Zero: un rápido seguidor de líneas para principiantes
Etiquetas: Pololu, sensor reflectancia, seguidores de línea, QTR-8A
GND
IR
D1
D2
D3
D4
D5
D6
D7
D8
+
GND
IR
D1
D2
D3
D4
D5
D6
D7
D8
+
Gnd-IR-D1------------D8-VCC
Gnd-IR-D1----------D8-VCC
Información sobre el sensor SQR 8 A DE POLOLU
Biblioteca de Arduino para la reflectancia Sensores de Pololu
QTR
También puede ver este documento como un PDF imprimible .
1. Introducción
2. Instalación Biblioteca
3. Métodos y QTRSensors Notas de uso
1. Introducción
QTR comparación de tamaño del sensor. Las agujas del reloj desde arriba
a la izquierda: QTR-3RC, QTR-1RC, QTR-L-1RC, QTR-8RC.

Los sensores de reflectancia Pololu QTR llevan pares de LED y el fototransistor de infrarrojo
que pueden proporcionar mediciones analógicas de reflectancia IR, lo que los hace ideal para
la detección de bordes de proximidad y aplicaciones de línea siguiente. Los módulos vienen
como compacto, las unidades de un solo sensor ( QTR-1A y QTR-1RC ; QTR-L-1A y QTR-L-
1RC ), matrices de 3-sensor ( QTR-3A y QTR-3RC ), o como 8- matrices de sensores ( QTR-
8A y QTR-8RC ) que pueden estar opcionalmente dividida en una matriz de 2-sensor y una
matriz de 6-sensor.
Los módulos están disponibles en dos formatos de salida diferentes: la QTR-xA da salida a
una tensión analógica entre 0 y Vcc que puede ser medido por un convertidor de analógico a
digital (ADC), y las salidas de QTR-XRC requiere una E / S digital línea capaz de conducir la
línea de salida de alta y luego midiendo el tiempo para la tensión de salida a la
descomposición (que proporciona una medición analógica de la reflectancia).
sensor de
reflectancia QTR-L-
1A diagrama
esquemático.
sensor de
reflectancia QTR-1A
diagrama
esquemático.
QTR-1RC y QTR-L-1RC
sensor de reflectancia
diagrama esquemático.
Por favor, vea las páginas de productos para obtener más información sobre cómo funcionan
estos sensores.
Este documento explica cómo instalar las bibliotecas de Arduino para los sensores de
reflectancia Pololu QTR, y proporcionará bocetos de muestra, así como enlaces a
documentación de la biblioteca. Las bibliotecas le dará todo lo necesario para interactuar con
un conjunto de sensores de reflectancia QTR-8x o múltiples sensores de reflectancia QTR-1x,
incluyendo funciones avanzadas como la calibración automática y, en el caso de detección de
la línea, el cálculo de la posición de la línea.
2. Instalación Biblioteca
Si está utilizando la versión 1.6.2 o posterior del software de Arduino , puede utilizar el gestor
de bibliotecas para instalar esta biblioteca:
En el IDE de Arduino, abra el menú “Boceto”, seleccione “Incluir biblioteca”, luego “Administrar
bibliotecas ...”.
1. La búsqueda por “QTRSensors”.
2. Haga clic en la entrada QTRSensors en la lista.
3. Haga clic en “Instalar”.
Si esto no funciona, puede instalar manualmente la biblioteca:
1. Descargar el archivo de notas último de GitHub y descomprimirlo.
2. Cambiar el nombre de la carpeta “qtr-sensores en Arduino-xxxx” a “QTRSensors”.
3. Arrastre la carpeta “QTRSensors” en el directorio “bibliotecas” dentro de su directorio de
bocetos Arduino. Puede ver su ubicación bloc de dibujo, abra el menú “Archivo” y seleccionar

“Preferencias” en el IDE de Arduino. Si no hay ya una carpeta “bibliotecas” en ese lugar, usted
debe hacer la carpeta sí mismo.
4. Después de instalar la biblioteca, reiniciar el IDE Arduino.
Ahora debería ser capaz de utilizar estas bibliotecas en sus bocetos al seleccionar Boceto>
Importar Biblioteca> QTRSensors desde el IDE de Arduino (o simplemente escriba #
include <QTRSensors.h> en la parte superior de su dibujo). Tenga en cuenta que puede que
tenga que reiniciar el IDE Arduino antes de ver las nuevas bibliotecas.
Una vez hecho esto, se puede crear un QTRSensorsAnalog objeto para sus sensores QTR-
Xa y un QTRSensorsRC objeto para sus sensores QTR-XRC:
?
1
2
3
4
5
6
// create an object for three QTR-xA sensors on analog inputs 0, 2, and 6
QTRSensorsAnalog qtra((unsigned char[]) {0, 2, 6}, 3);
// create an object for four QTR-xRC sensors on digital pins 0 and 9, and on analog
// inputs 1 and 3 (which are being used as digital inputs 15 and 17 in this case)
QTRSensorsRC qtrrc((unsigned char[]) {0, 9, 15, 17}, 4);
Esta biblioteca se encarga de las diferencias entre los sensores QTR-Xa y QTR-XRC
internamente, que le proporciona una interfaz común para ambos sensores. La única
diferencia externa está en los constructores, como se puede ver en el ejemplo de código
anterior. El primer argumento del constructor QTRSensorsAnalog es una matriz de pines de
entrada analógicas (0 - 7) mientras que el primer argumento del constructor QTRSensorsRC
es una matriz de pines digitales (0 - 19). Tenga en cuenta que las entradas analógicas a 0 - 5
se pueden utilizar como pines digitales 14 - 19. Para más detalles, véase la sección 3 .
La única otra diferencia es que puede experimentar en el tiempo que se tarda en leer los
valores de los sensores. Los sensores QTR-XRC pueden ser leídas en paralelo, pero cada
uno requiere la sincronización de un impulso que podría llegar a tardar hasta 3 m (se puede
especificar el tiempo que la biblioteca debe vez este pulso antes de tiempo de espera y
declarando el resultado completo negro) . Los sensores QTR-Xa utilizar el convertidor de
analógico a digital (ADC) y por lo tanto deben ser leídos secuencialmente. Además, los
resultados analógicas son producidos internamente promediando un número de muestras
para cada sensor (se puede especificar el número de muestras a la media) para reducir el
efecto del ruido en los resultados.
Varios bocetos de ejemplo están disponibles para ayudarle a empezar. Para ver los bocetos
ejemplo, abra el IDE Arduino y vaya a:
Archivo> Ejemplos> QTRSensors
Como primer paso, se recomienda utilizar QTRARawValuesExample (para sensores QTR-
Xa) o QTRRCRawValuesExample (para los sensores QTR-XRC). Estos ejemplos
simplemente imprimir las lecturas en bruto de los sensores para el monitor de serie, utilizando
9600 baudios. Una vez que se está trabajando, es posible que desee probar uno de los
ejemplos más avanzados, QTRAExample o QTRRCExample , que incorporan la calibración y
también estimar la posición de una línea.
3. QTRSensors Métodos y Notas de uso
QTRSensor Referencia de comandos
Las versiones anteriores de esta biblioteca fueron nombrados PololuQTRSensors , pero
hemos cambiado a QTRSensors para diferenciarla de la biblioteca sensor de QTR en
nuestro Arduino Bibliotecas para el orangután y el robot 3pi . Aparte de la biblioteca y

nombre de clase cambios, la nueva biblioteca QTRSensors es funcionalmente idéntico a
las versiones anteriores.
Para los sensores QTR-Xa, tendrá que crear una instancia de un QTRSensorsAnalog objeto,
y para los sensores QTR-XRC tendrá que crear una instancia de
un QTRSensorsRC objeto. Aparte de los constructores, estos dos objetos proporcionan los
mismos métodos para la lectura de los valores del sensor (ambas clases se derivan de la
misma clase base abstracta). La biblioteca proporciona acceso a los valores de los sensores
primas, así como para funciones de alto nivel, incluyendo la calibración y alineación de
seguimiento.
Esta sección de la biblioteca define un objeto para cada uno de los dos tipos de sensores
QTR, con el QTRSensorsAnalog clase destinado para su uso con sensores QTR-Xa y
la QTRSensorsRCclase destinado para su uso con sensores QTR-XRC. Esta biblioteca se
encarga de las diferencias entre los sensores QTR-Xa y QTR-XRC internamente, que le
proporciona una interfaz común para ambos sensores. La única diferencia externa está en los
constructores. Esto se consigue por tener tanto de estas clases se derivan de la clase base
abstracta QTRSensors . Esta clase base no se pueden crear instancias.
Las clases QTRSensorsAnalog y QTRSensorsRC deben crearse instancias antes de ser
utilizados. Esto permite que múltiples matrices de sensores QTR para ser controlados de
forma independiente como objetos QTRSensors separadas.
Para la calibración, se asigna memoria mediante el malloc () de comandos. Esto conserva la
memoria RAM: si los ocho sensores se calibran con los emisores de ambos en un off, un total
de 64 bytes estaría destinada a almacenar los valores de calibración. Sin embargo, para una
aplicación donde sólo se utilizan tres sensores, y los emisores están siempre en durante lee,
sólo se requieren 6 bytes.
Internamente, esta biblioteca utiliza todas las funciones estándar de Arduino como micros ()
para sincronización y analogRead () o digitalRead () para obtener los valores de los sensores,
por lo que debería funcionar en todos Arduino sin entrar en conflicto con otras bibliotecas.
vacío de lectura (unsigned int * sensorValues , sin firmar carbón readMode =
QTR_EMITTERS_ON)
Lee los valores de sensor en bruto en una matriz. Hay DEBE haber espacio para tantos
valores como había sensores especificados en el constructor. Los valores devueltos son una
medida de la reflectancia en las unidades que dependen del tipo de sensor que se utiliza, con
valores más altos de reflectancia que corresponde a inferior (una superficie de color negro o
un vacío). Sensores QTR-Xa devolverá un valor en bruto entre 0 y 1023. sensores QTR-XRC
devolverá un valor en bruto entre 0 y el tiempo de espera de argumento (en unidades de
microsegundos) proporcionado en el constructor (que por defecto es 2000).
Las funciones que se leen los valores de los sensores de todos toman un
argumento readMode, que especifica el tipo de lectura que se va a realizar. Se definen varias
opciones: QTR_EMITTERS_OFF especifica que la lectura debe hacerse sin necesidad de
encender el infrarrojo (IR) emisores, en cuyo caso la lectura representa niveles de luz
ambiente cerca del sensor; QTR_EMITTERS_ON especifica que los emisores deben estar
encendidos para la lectura, lo que resulta en una medida de
reflectancia; y QTR_EMITTERS_ON_AND_OFF especifica que una lectura debe hacerse

tanto en los estados activado y desactivado. Los valores devueltos cuando
el QTR_EMITTERS_ON_AND_OFF opción se usa están dadas por el + max - off ,
donde en es la lectura con los emisores en, off es la lectura con los emisores de descanso,
y max es la lectura máxima del sensor. Esta opción se puede reducir la cantidad de
interferencia de iluminación de ambiente desigual. Tenga en cuenta que el control del emisor
sólo funcionará si especifica un alfiler emisor válido en el constructor.
Ejemplo de uso:
?
1
2
unsigned int sensor_values[8];
sensors.read(sensor_values);
anulará emittersOn ()
A su vez los LEDs IR sucesivamente. Esto es principalmente para su uso por el método de
lectura, y llamar a estas funciones antes o después de la lectura de los sensores no tendrá
ningún efecto sobre las lecturas, pero puede que desee utilizar éstos para fines de
prueba. Este método sólo se va a hacer algo si el pin emisor especificada en el constructor no
es QTR_NO_EMITTER_PIN .
anulará emittersOff ()
A su vez los LEDs IR off. Esto es principalmente para su uso por el método de lectura, y
llamar a estas funciones antes o después de la lectura de los sensores no tendrá ningún
efecto sobre las lecturas, pero puede que desee utilizar éstos para fines de prueba.
void Calibrar (unsigned char readMode = QTR_EMITTERS_ON)
Lee los sensores para la calibración. Los valores de los sensores no se devuelven; En
cambio, los valores máximos y mínimos que se encuentran con el tiempo se almacenan
internamente y se utilizan para la readCalibrated () método. Puede acceder a la calibración
(es decir, max prima y lecturas del sensor min) a través de los punteros miembro
públicas calibratedMinimumOn , calibratedMaximumOn , calibratedMinimumOff ,
y calibratedMaximumOff . Tenga en cuenta que estos indicadores señalarán a matrices de
longitud numSensors , tal como se especifica en el constructor, y sólo se asignarán después
de calibrar () se ha llamado. Si sólo se calibra con los emisores en, no se asignarán las
matrices de calibración que mantienen los valores de corte.
anulará readCalibrated (unsigned int * sensorValues , sin firmar carbón readMode =
QTR_EMITTERS_ON)
Lecturas de sensor vuelve calibrados a un valor entre 0 y 1000, donde 0 corresponde a una
lectura que es menor o igual al valor mínimo leído por Calibrar () y 1000 corresponde a una
lectura que es mayor que o igual al valor máximo. Los valores de calibración se almacenan
por separado para cada sensor, de modo que las diferencias en los sensores se tienen en
cuenta automáticamente.
unsigned int ReadLine (unsigned int * sensorValues , unsigned char readMode =
QTR_EMITTERS_ON, unsigned char WhiteLine = 0)
Funciona igual que leer calibrado, pero con una característica diseñada para la línea

siguiente: esta función devuelve una posición estimada de la línea. La estimación se realiza
utilizando una media ponderada de los índices de sensor multiplicado por 1000, de modo que
un valor de retorno de 0 indica que la línea está directamente debajo de sensor 0 (o fue visto
por última vez por el sensor de 0 antes de perderse), un valor de retorno de 1000 indica que la
línea está directamente debajo de sensor 1, 2000 indica que está por debajo de sensor 2, etc.
los valores intermedios indican que la línea se encuentra entre dos sensores. La fórmula es:
0 * valor0 + 1000 * 2000 * + valor1 valor2 + ...
--------------------------------------------
valor0 + valor1 valor2 + + ...
Mientras sus sensores no están demasiado separados en relación con la línea, esta volvió
valor está diseñado para ser monótona, que lo hace ideal para su uso en el control de PID de
bucle cerrado. Además, este método recuerda donde se vio por última vez la línea, por lo que
si alguna vez pierde la línea hacia la izquierda o la derecha, que es la posición de línea
continuará indicando la dirección que necesita ir a readquirir la línea. Por ejemplo, si el sensor
4 es su sensor de más a la derecha y se acaba completamente fuera de la línea a la
izquierda, esta función continuará a volver 4000.
Por defecto, esta función supone una línea oscura (valores altos), rodeada de blancos
(valores bajos). Si su línea es luz sobre negro, ajustar el segundo argumento
opcional WhiteLine true. En este caso, cada valor del sensor será reemplazado por el valor
máximo posible menos su valor real antes de la promediación.
unsigned int * calibratedMinimumOn
Los valores mínimos calibrados medidos para cada sensor, con emisores en. Los punteros no
asignado y se ponen a 0 hasta Calibrar () se llama, y después se asignan a exactamente el
tamaño requerido. Dependiendo de la readMode argumento para calibrar (), solo los valores
Activar o Desactivar pueden ser asignados, según sea necesario. Esta y las siguientes
variables se hacen públicos para que pueda usarlos para sus propios cálculos y hacer cosas
como guardar los valores en la EEPROM, la realización de la cordura de cheques, etc.
unsigned int * calibratedMaximumOn
Los valores máximos calibrados midieron para cada sensor, con emisores en.
unsigned int * calibratedMinimumOff
Los valores mínimos calibrados midieron para cada sensor, con emisores de apagado.
unsigned int * calibratedMaximumOff
Los valores máximos calibrados midieron para cada sensor, con emisores de apagado.
Destructor: ~ QTRSensors ()
El destructor para la clase QTRSensors libera la memoria asignada para las matrices de
calibración.
Constructor: QTRSensorsRC ()
Esta versión del constructor realiza ninguna inicialización. Si se utiliza, el usuario debe llamar
a init () antes de usar los métodos de esta clase.

Constructor: QTRSensorsRC (unsigned char * digitalPins , unsigned char numSensors ,
unsigned int timeout = 2000, unsigned char emitterPin = QTR_NO_EMITTER_PIN);
Este constructor sólo llama a init () , a continuación.
anulará QTRSensorsRC :: init (unsigned char * digitalPins , unsigned
char numSensors , unsigned int timeout = 2000, unsigned char emitterPin =
QTR_NO_EMITTER_PIN)
Inicializa una matriz de sensores QTR-RC (digital).
La matriz digitalPins deben contener los números de pin digital Arduino para cada sensor.
numSensors especifica la longitud de la digitalPins array (el número de sensores QTR-RC que
está utilizando). numSensors deben ser mayores de 16 años.
tiempo de espera especifica la cantidad de tiempo en microsegundos más allá de que
considere la lectura del sensor completamente negro. Es decir, si la longitud del pulso para un
pasador supera el tiempo de espera , el tiempo de impulsos se detendrá y la lectura para que
el pin se considera negro completo. Se recomienda que ajuste el tiempo de espera para ser
entre 1000 y 3000 nosotros, dependiendo de factores como la altura de los sensores y la
iluminación ambiente. Esto le permite acortar la duración de un ciclo de sensor de lectura,
mientras que el mantenimiento de las medidas útiles de reflectancia.
emitterPin es el pin digital Arduino que controla si los LED IR están encendidos o
apagados. Este pin es opcional y sólo existe en el 8A y matrices de sensores 8RC QTR. Si se
especifica un PIN válido, los emisores sólo se activan durante una lectura. Si el
valor QTR_NO_EMITTER_PIN se usa (255), puede dejar el pasador emisor desconecta y los
emisores IR siempre estará encendida.
Constructor: QTRSensorsAnalog ()
Esta versión del constructor realiza ninguna inicialización. Si se utiliza este constructor, el
usuario debe llamar a init () antes de usar los métodos de esta clase.
Constructor: QTRSensorsAnalog (unsigned char * analogPins , unsigned
char numSensors , unsigned char numSamplesPerSensor = 4, unsigned
char emitterPin = QTR_NO_EMITTER_PIN)
Este constructor sólo llama a init () , a continuación.
void init (unsigned char * analogPins , unsigned char numSensors , unsigned
char numSamplesPerSensor = 4, unsigned char emitterPin = QTR_NO_EMITTER_PIN)
Inicializa una matriz de sensores QTR-A (analógico).
La matriz de pasadores deben contener el número pin de entrada analógica Arduino para
cada sensor. Por ejemplo, si pasadores es {0, 1, 7}, sensor 1 está en la entrada analógica 0,
sensor 2 es en la entrada analógica 1, y el sensor 3 está en la entrada analógica 7.
numSensors especifica la longitud de la analogPins array (el número de sensores QTR-A que
está utilizando). numSensors deben ser mayores de 16 años.
numSamplesPerSensor indica el número de muestras analógicas de 10 bits a media por canal
(por sensor) para cada lectura. El número total de conversiones de analógico a digital
realizados será igual a numSensors veces numSamplesPerSensor . El aumento de este

parámetro aumenta la supresión de ruido en el costo de la frecuencia de muestreo. Este
parámetro no debe exceder de 64. El valor recomendado: 4.
emitterPin es el pin digital Arduino que controla si los LED IR están encendidos o
apagados. Este pin es opcional y sólo existe en el 8A y matrices de sensores 8RC QTR. Si se
especifica un PIN válido, los emisores sólo se activan durante una lectura. Si el
valor QTR_NO_EMITTER_PIN se usa (255), puede dejar el pasador emisor desconecta y los
emisores IR siempre estará encendida.
Notas de uso
Calibración
Esta biblioteca le permite usar la Calibrar () método para calibrar fácilmente sensores para las
condiciones particulares que se encontrará. Calibración de los sensores puede dar lugar a
lecturas del sensor mucho más fiables, que a su vez puede ayudar a simplificar su código
desde entonces. Como tal, se recomienda construir una fase de calibración en la rutina de
inicialización de la aplicación. Esto puede ser tan simple como una duración fija sobre la que
se repite la llamada de calibración () método. Durante esta fase de calibración, que tendrá
que exponer a cada uno de los sensores de reflectancia a las lecturas más claras y oscuras
que van a encontrar. Por ejemplo, si usted ha hecho un seguidor de línea, tendrá que
deslizarse a través de la línea durante la fase de calibración por lo que el cada sensor puede
obtener una lectura de lo oscura que la línea es y cómo iluminar el suelo es. Una rutina de
calibración de la muestra sería:
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// create an object for your type of sensor (RC or Analog)
// in this example we have three sensors on analog inputs 0 - 2, a.k.a. digital pins 14 - 16
QTRSensorsRC qtr((char[]) {14, 15, 16}, 3);
// QTRSensorsA qtr((char[]) {0, 1, 2}, 3);
void setup()
{
// optional: wait for some input from the user, such as a button press
// then start calibration phase and move the sensors over both
// reflectance extremes they will encounter in your application:
int i;
for (i = 0; i < 250; i++) // make the calibration take about 5 seconds
{
qtr.calibrate();
delay(20);
}
// optional: signal that the calibration phase is now over and wait for further
// input from the user, such as a button press
}
La lectura de los sensores
Esta biblioteca le da un número de diferentes formas de leer los sensores.
1. Puede solicitar los valores del sensor primas utilizando la lectura () método, que toma un
argumento opcional que le permite realizar la lectura con los emisores IR desactivado (tenga
en cuenta que al girar los emisores fuera sólo es compatible con las redes de sensores de
reflectancia QTR-8x).
2. Puede solicitar valores de los sensores calibrados utilizando el readCalibrated () método, que
también toma un argumento opcional que le permite realizar la lectura con los emisores IR
apagados. Valores de los sensores calibrados siempre variar de 0 a 1000, con 0 siendo tan o
más reflectante (es decir, más blanco) que la superficie más reflectante encontrado durante la

calibración, y 1.000 siendo tan o menos reflectante (es decir, más negro) que la superficie
menos reflectante encontrado durante la calibración .
3. Para las aplicaciones de línea de detección, puede solicitar la ubicación de la línea utilizando
el readLine () método, que toma como parámetros opcionales un booleano que indica si la
línea es de color blanco sobre un fondo negro o negro sobre un fondo blanco, y un booleano
que indica si los emisores IR deben estar encendido o apagado durante la medición. readLine
() proporciona valores de calibrado para cada sensor y devuelve un entero que le indica donde
se cree es la línea. Si está utilizando N sensores, un valor devuelto de 0 significa que piensa
que la línea está en o hacia el exterior del sensor 0, y un valor devuelto de 1000 * ( N -1)
significa que piensa que la línea está en o hacia el exterior de sensor N -1. A medida que
desliza sus sensores a través de la línea, la posición de línea cambiará monotónicamente de 0
a 1000 * ( N -1), o viceversa. Este valor-posición de la línea se puede utilizar para el control de
PID de bucle cerrado.
Una rutina de muestra para obtener los valores de los sensores y realizar línea rudimentaria
siguiente sería:
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
void loop()
{
unsigned int sensors[3];
// get calibrated sensor values returned in the sensors array, along with the line position
// position will range from 0 to 2000, with 1000 corresponding to the line over the middle
// sensor.
int position = qtr.readLine(sensors);
// if all three sensors see very low reflectance, take some appropriate action for this
// situation.
if (sensors[0] > 750 && sensors[1] > 750 && sensors[2] > 750)
{
// do something. Maybe this means we're at the edge of a course or about to fall off
// a table, in which case, we might want to stop moving, back up, and turn around.
return;
}
// compute our "error" from the line position. We will make it so that the error is zero
// when the middle sensor is over the line, because this is our goal. Error will range from
// -1000 to +1000. If we have sensor 0 on the left and sensor 2 on the right, a reading of
// -1000 means that we see the line on the left and a reading of +1000 means we see the
// line on the right.
int error = position - 1000;
int leftMotorSpeed = 100;
int rightMotorSpeed = 100;
if (error < -500) // the line is on the left
leftMotorSpeed = 0; // turn left
if (error > 500) // the line is on the right
rightMotorSpeed = 0; // turn right
// set motor speeds using the two motor speed variables above
}
control PID
El valor entero devuelto por readLine () se puede convertir fácilmente en una medida de su
error de posición para aplicaciones de línea siguiente, como se demostró en el ejemplo de
código anterior. La función que se utiliza para generar este valor de posición / error está
diseñado para ser monótona, lo que significa que el valor casi siempre va a cambiar en la
misma dirección a medida que barre sus sensores en toda la línea. Esto hace que sea una
gran cantidad a utilizar para el control PID.
Al explicar la naturaleza del control PID está más allá del alcance de este documento, pero
Wikipedia tiene un muy buen artículo sobre el tema.
El siguiente código da un ejemplo muy simple de control PD (me parece por lo general el

término integral PID no es necesario cuando se trata de la línea que sigue). La naturaleza
específica de las constantes será determinado por su aplicación particular, pero se debe tener
en cuenta que la constante derivado Kd es por lo general mucho más grande que la constante
proporcional Kp . Esto es debido a que la derivada del error es una cantidad mucho menor
que el error en sí mismo, por lo que a fin de producir una corrección significativa que debe ser
multiplicado por una constante mucho mayor.
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
int lastError = 0;
void loop()
{
unsigned int sensors[3];
// get calibrated sensor values returned in the sensors array, along with the line position
// position will range from 0 to 2000, with 1000 corresponding to the line over the middle
// sensor
int position = qtr.readLine(sensors);
// compute our "error" from the line position. We will make it so that the error is zero when
// the middle sensor is over the line, because this is our goal. Error will range from
// -1000 to +1000. If we have sensor 0 on the left and sensor 2 on the right, a reading of
// -1000 means that we see the line on the left and a reading of +1000 means we see the
// line on the right.
int error = position - 1000;
// set the motor speed based on proportional and derivative PID terms
// KP is the a floating-point proportional constant (maybe start with a value around 0.1)
// KD is the floating-point derivative constant (maybe start with a value around 5)
// note that when doing PID, it's very important you get your signs right, or else the
// control loop will be unstable
int motorSpeed = KP * error + KD * (error - lastError);
lastError = error;
// M1 and M2 are base motor speeds. That is to say, they are the speeds the motors should
// spin at if you are perfectly on the line with no error. If your motors are well matched,
// M1 and M2 will be equal. When you start testing your PID loop, it might help to start with
// small values for M1 and M2. You can then increase the speed as you fine-tune your
// PID constants KP and KD.
int m1Speed = M1 + motorSpeed;
int m2Speed = M2 - motorSpeed;
// it might help to keep the speeds positive (this is optional)
// note that you might want to add a similiar line to keep the speeds from exceeding
// any maximum allowed value
if (m1Speed < 0)
m1Speed = 0;
if (m2Speed < 0)
m2Speed = 0;
// set motor speeds using the two motor speed variables above
}
------------------------------------- 0 ------------------------------------------
DRIVERS POSIBLES LAMBORHINO
https://www.luisllamas.es/arduino-motor-dc-tb6612fng/ muy Buena página de Luis
Llamas
https://www.sparkfun.com/products/9457 lo mismo en sparkfun
Conductor Sparkfun Motor - TB6612FNG
Dual (1A)
ROB-09457 ROHS
15
Descripción: El controlador de motor TB6612FNG puede controlar hasta dos motores de corriente
continua a una corriente constante de 1,2 A (pico 3.2A). Dos señales de entrada (IN1 y IN2) se
pueden utilizar para controlar el motor en uno de cuatro modos de funcionamiento - CW, CCW,
corto de freno, y parada. Las dos salidas de motor (A y B) pueden ser controladas por separado, la
velocidad de cada motor se controla a través de una señal de entrada PWM con una frecuencia de
hasta 100 kHz. El pasador ESPERA debe tirar alta para tomar el motor fuera del modo de espera.
tensión de alimentación de lógica (VCC) puede estar en el intervalo de 2.7-5.5VDC, mientras que
la alimentación del motor (VM) está limitada a una tensión máxima de 15 V CC. La corriente de
salida tiene una clasificación de hasta 1.2A por canal (o hasta 3.2A por un corto pulso único,).

Junta viene con todos los componentes instalados como se muestra. condensadores de
desacoplamiento se incluyen en ambas líneas de suministro. Todos los pines de la TB6612FNG se
rompen a dos 0.1" cabeceras de tono; los pasadores se disponen de modo que los pines de
entrada están en un lado y pines de salida están en el otro.
Nota: Si usted está buscando el controlador del motor Sparkfun con las cabeceras, que se puede
encontrar aquí o en los productos recomendados a continuación.
COMIENZA CON EL CONDUCTOR DEL MOTOR DE GUÍA DE CONEXIÓN
caracteristicas:
• Tensión de alimentación: VM = 15V max, VCC = 2.7-5.5V
• Corriente de salida: Iout = 1.2A (promedio) / 3.2A (pico)
• control de reposo para ahorrar energía
• CW / CCW / freno / parada corta modos de control del motor
• Incorporado en el circuito de apagado térmico y el circuito de detección de bajo voltaje
• Todos los pines de la TB6612FNG rompen a 0.1" pasadores espaciados
• condensadores de filtrado de ambas líneas de suministro
Dimensiones: 0.8x0.8"
Documentos:
• Esquemático
• Los archivos de eagle
• Guía de conexión
• Hoja de datos (TB6612FNG)
• bildr Tutorial
• GitHub

-------------------------------------------------------------------------------
TB6612FNG 1A de sparkfun
CONTROLAR DOS MOTORES DC CON ARDUINO Y DRIVER TB6612FNG
SHARE ON:
— 18 AGOSTO, 2016
¿QUÉ ES UN TB6612FNG ?
El TB6612FNG es un controlador (driver) de motores que nos permite manejar dos
motores de corriente continua desde Arduino, variando tanto la velocidad como el
sentido de giro.
El TB6612FNG puede ser considerado una versión mejorada del L298N. Al igual que
esté, internamente está formado por dos puentes-H, junto con la electrónica necesaria
para simplificar su uso, y eliminar posibles cortocircuito por errores de uso.
Sin embargo, en el caso del TB6612FNG los puentes-H están formados por transistores
MOSFET, en lugar de transistores BJT como en el L298N. Esto permite que el
TB6612FNG tiene mejor eficiencia y menores dimensiones que el L298N.
El TB6612FNG también permite controlar intensidades de corriente superiores, siendo
capaz de suministrar 1.2A por canal de forma continua, y 3.2A de pico. Recordar que el
L298N tiene una intensidad máxima teórica de 2A, pero las pérdidas hace que en la
práctica sólo pueda suministrar 0.8-1A.
Además, el TB6612FNG no tiene la caída de tensión que sí tiene el L298N debido a sus
transistores BJT, que podían llegar a ser superiores a 3V. En su lugar, el TB6612FNG se
comporta como una pequeña resistencia de 0.5 Ohm.
Como puntos negativos, el TB6612FNG puede proporcionar tensiones inferiores, de
hasta 13.5V (frente a los 35V del L298N). Además, es algo más difícil de montar, ya que
las placas con L298N frecuentemente incorporan placas de conexión, que permiten

conectar de forma sencilla el motor.
Finalmente, la protección contra corrientes inducidas son algo más limitadas que las
del L298N, por lo que podemos tener algún reinicio de Arduino cuando alimentamos
cargas medianas o grandes.
El TB6612FNG dispone de dos canales, por lo que es posible controlar dos motores de
corriente continua de forma independiente. También puede controlar un único motor
paso a paso aunque, en general, preferiremos usar controladores específicos.
En cada canal podemos controlar el sentido de giro y la velocidad, para lo cual admite
una señal PWM de frecuencia máxima de 100 kHz (muy por debajo del rango normal de
PWM en Arduino)
El TB6612FNG dispone de protecciones térmicas, de inversión de corriente en la fuente
de suministro de los motores, condensadores de filtrado en ambas líneas de
alimentación, detección de bajo voltaje, y protecciones contra las corrientes inducidas
en los motores.
El TB6612FNG también incorpora un modo de Standby, que desactiva por completo el
controlador, entrando en un modo de ahorro de energía.
El controlador TB6612FNG puede ser empleado en proyectos de electrónica y robótica.
Es ampliamente usado en proyectos electrónico y robótica, por su sencillez de uso,
bajo coste, y buena calidad precio
PRECIO
El controlador TB6612FNG es un dispositivo barato. En un principio el TB6612FNG era
más caro que el L298N, pero los precios descendieron y en la actualidad el TB6612FNG
es más barato que el L298N.
Podemos encontrar un TB6612FNG por 1,10€ en vendedores internacionales de
AliExpress o eBay.
ESQUEMA DE MONTAJE
El esquema de montaje no es demasiado complicado. Por un lado, suministramos la
tensión que alimentará el motor desde una fuente de alimentación externa, mediante el
pin VM. La tensión máxima es de 15V.
Además, tenemos que alimentar la electrónica del módulo mediante el pin VCC. El
rango de tensión para VCC es 2.7 a 5.5V.
Para el control del módulo Los pines AIN1, AIN2 Y PWMA controlan el canal A, mientras
que los pines BIN1, BIN2, y PWMB controlan el canal B.
Finalmente, el pin STBY controla el modo Standby. Debemos ponerlo en HIGH para
activar el motor. Podemos conectarlo a un pin digital de Arduino, si queremos poder
activar el modo Standby, o conectarlo a VCC si queremos dejarlo permanentemente
desconectado.

La conexión, vista desde Arduino quedaría de la siguiente forma.
EJEMPLOS DE CÓDIGO
El código necesario es similar al que vimos al ver el L298N. Igualmente, conviene que
agrupemos el código en funciones que podamos reutilizar, o el código crecerá
rápidamente.
El siguiente código permite desplazar y girar un vehículo, actuando sobre ambos
motores. Empleamos el modo Standby para reducir el consumo cuando esté parado,
alargando la batería.
1
2
3
4
5
6
7
const int pinPWMA = 6;
const int pinAIN2 = 7;
const int pinAIN1 = 8;
const int pinBIN1 = 9;
const int pinBIN2 = 10;
const int pinPWMB = 11;
const int pinSTBY = 12;

8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
const int waitTime = 2000; //espera entre fases
const int speed = 200; //velocidad de giro
const int pinMotorA[3] = { pinPWMA, pinAIN2, pinAIN1 };
const int pinMotorB[3] = { pinPWMB, pinBIN1, pinBIN2 };
enum moveDirection {
forward,
backward
};
enum turnDirection {
clockwise,
counterClockwise
};
void setup()
{
pinMode(pinAIN2, OUTPUT);
pinMode(pinAIN1, OUTPUT);
pinMode(pinPWMA, OUTPUT);
pinMode(pinBIN1, OUTPUT);
pinMode(pinBIN2, OUTPUT);
pinMode(pinPWMB, OUTPUT);
}
void loop()
{
enableMotors();
move(forward, 180);
delay(waitTime);
move(backward, 180);
delay(waitTime);
turn(clockwise, 180);
delay(waitTime);
turn(counterClockwise, 180);
delay(waitTime);
fullStop();
delay(waitTime);
}
//Funciones que controlan el vehiculo
void move(int direction, int speed)
{
if (direction == forward)
{
moveMotorForward(pinMotorA, speed);
moveMotorForward(pinMotorB, speed);
}
else
{
moveMotorBackward(pinMotorA, speed);
moveMotorBackward(pinMotorB, speed);
}
}
void turn(int direction, int speed)

70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
{
if (direction == forward)
{
moveMotorForward(pinMotorA, speed);
moveMotorBackward(pinMotorB, speed);
}
else
{
moveMotorBackward(pinMotorA, speed);
moveMotorForward(pinMotorB, speed);
}
}
void fullStop()
{
disableMotors();
stopMotor(pinMotorA);
stopMotor(pinMotorB);
}
//Funciones que controlan los motores
void moveMotorForward(const int pinMotor[3], int speed)
{
digitalWrite(pinMotor[1], HIGH);
digitalWrite(pinMotor[2], LOW);
analogWrite(pinMotor[0], speed);
}
void moveMotorBackward(const int pinMotor[3], int speed)
{
digitalWrite(pinMotor[2], HIGH);
analogWrite(pinMotor[0], speed);
}
void stopMotor(const int pinMotor[3])
{
analogWrite(pinMotor[0], 0);
}
void enableMotors()
{
digitalWrite(pinSTBY, HIGH);
}
void disableMotors()
{
digitalWrite(pinSTBY, LOW);
}
En un proyecto complejo, estas funciones estarían integradas en los objetos que
integran nuestro modelo.

DRV8833
Este pequeño tablero del desbloqueo para DRV8833 controlador dual motor
de TI puede entregar 1,2 A por canal de forma continua (2 Un pico) a un par
de motores de corriente continua. Con un rango de tensión de
funcionamiento de 2,7 V a 10,8 V y una protección incorporada contra
inversa voltaje, bajo voltaje, sobreintensidad de corriente, y el exceso de
temperatura, este controlador es una gran solución para la alimentación de
motores pequeños, de bajo voltaje
--------------------driver motor DRV885 me ahorro 2 cables ---------------
caracteristicas
• controlador de motor-H-puente Dual: puede conducir dos motores de
corriente continua o un motor paso a paso bipolar
• tensión de alimentación del motor: 0 V a 11 V
• tensión de alimentación lógica: 2 V a 7 V
• Corriente de salida: 1.2 A continua (1,5 A pico) por motor
• salidas del motor pueden conectar en paralelo para suministrar 2,4 A
continua (3 Un pico) a un único motor
• Dos posibles modos de interfaz: IN / IN (salidas principalmente entradas
espejo) o fase / activar (una clavija para la dirección y otro para la velocidad)
• Las entradas son compatibles 3V-y-5V
• de bloqueo de sub-voltaje en el suministro de la lógica y la protección contra
sobre-corriente y de la temperatura

• protección Reverse-tensión en la alimentación del motor
• El tamaño compacto (0,7 "x 0,4") con el factor de forma de un paquete DIP
de 14 pines
hardware incluido
Dos 1 × 7-pin de ruptura 0.1 "conectores macho se incluyen con el portador
de conductor de doble motor DRV8835, que puede ser soldada en utilizar el
controlador con placas universales , perfboards , o 0.1" conectores
hembra . (Las cabeceras pueden enviar como una sola pieza 1 × 14 que
puede ser roto por la mitad). La imagen de la derecha de arriba muestra las
dos posibles orientaciones de mesa cuando se utiliza con estos pasadores
de cabecera (partes visibles o serigrafía visible). También puede soldar sus
cables del motor y otras conexiones directamente a la placa.
Uso del controlador de motor
diagrama de cableado mínimo para la conexión de un microcontrolador para un
portador de conductor del motor dual DRV8835 en modo de fase a habilitar.
Motor y la potencia del motor conexiones se realizan en un lado de las
conexiones de junta y la lógica de potencia y control se realizan por el
otro. El controlador necesita una tensión de motor entre 0 V y 11 V para ser
suministrada a la VIN o pasador VMM y una tensión lógica entre 1,8 V y 7 V
para ser suministrada a la clavija de VCC; la tensión lógica típicamente
puede ser suministrada por o compartida con el dispositivo de control. El
pasador VIN es la entrada de alimentación del motor protegido inversa y es
el punto recomendado para la conexión de potencia del motor. Sin embargo,
el rendimiento del conductor se comienza a sentirse peor cuando el voltaje
de entrada al circuito de protección inversa está por debajo de unos pocos
voltios y 1,5 V es el límite inferior de donde se puede utilizar el pasador de
VIN. Para las aplicaciones de muy baja tensión, la alimentación del motor
debe estar conectado directamente a VMM, que no pasa por el circuito de
protección inversa.
El DRV8835 cuenta con dos posibles modos de control: EN / EN FASE y /
Habilitar. El pasador MODE determina la interfaz de control. Cada entrada
de control está a nivel bajo a través de una débil resistencia de pull-down
(aproximadamente 100 kW), por lo que el conductor estará en la R I /O En el
modo si el PIN del modo permanece desconectado, y las salidas del
controlador será desactivado por defecto. Ajustar el PIN modo de alta, ya
sea con una resistencia pull-up o una línea de conducción de alta I / O,
establece que el conductor de fase / modo, donde el pasador FASE

determina la dirección del motor de ENABLE y el pasador de ENABLE
puede ser suministrado con un PWM señal para controlar la velocidad del
motor. Este modo es generalmente más fácil de usar, ya que sólo
requiere de un PWM por canal, pero sólo permite la operación de
accionamiento / freno. (Funcionamiento / freno Drive por lo general
proporciona una relación más lineal entre el ciclo de trabajo PWM y la
velocidad de motor de funcionamiento de la unidad / costa, y generalmente
recomienda el uso de la operación de accionamiento / freno cuando sea
posible.)
Nota deduzco que por defecto esta el pin MODE en down con

funcionamiento de la unidad de freno / simplificado con MODE = 1
(FASE / ENABLE)
XPhase xENABLE xOUT1 xOUT2 modo operativo
0 PWM PWM L
adelante / freno a la
velocidad PWM%
1 PWM L PWM
revertir / freno a la
velocidad PWM%
x 0 L L
bajo freno (salidas en cortocircuito
a tierra)
Cuando el pasador MODO se desconecta o se baja, la interfaz de control es
IN / IN, que permite opciones de control un poco más avanzados. La
siguiente tabla de verdad muestran cómo lograr la unidad / costa y
funcionamiento de la unidad / freno a través de la EN / EN interfaz de
control:
Conduce / costa o conducir la operación / freno con MODE = 0 (EN / EN)
XIN1 xIN2 xOUT1 xOUT2 modo operativo
0 0 ABIERTO ABIERTO costa (salidas desactivadas)
PWM 0 PWM L
adelante / costa a una
velocidad PWM%
0 PWM L PWM reversa / costa a velocidad PWM%
1 PWM PWM L
adelante / freno a la velocidad de 100%
- PWM%
PWM 1 L PWM
revertir / freno a la velocidad de 100% -
PWM%
1 1 L L
bajo freno (salidas en cortocircuito a
tierra)

Construccion seguidor de línea por joaquín berrocal verano 2017

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Was ist angesagt?

Was ist angesagt? (20)

Ähnlich wie Construccion seguidor de línea por joaquín berrocal verano 2017

Ähnlich wie Construccion seguidor de línea por joaquín berrocal verano 2017 (20)

Mehr von joaquinin1

Mehr von joaquinin1 (20)

Kürzlich hochgeladen

Kürzlich hochgeladen (20)

Construccion seguidor de línea por joaquín berrocal verano 2017