Beruflich Dokumente
Kultur Dokumente
Seguidor de Lnea
Gua de usuario
Introduccin
A3 es un robot autnomo de morfologa mvil, diseado para competiciones de
seguimiento de lnea. Se trata de un robot de tipo diferencial, su traccin basa en dos
motores de corriente directa, alimentado por una batera de 9 Voltios.
A3 utiliza un microcontrolador de la marca Atmel modelo Atmega328, con firmware
de Arduino, lo cual facilita su programacin.
Primeros pasos de A3
Qu necesitas?
Batera de 9V. Utiliza de preferencia bateras alcalinas o recargables. Si trabajar durante
tiempos prolongados con el robot, te recomendamos usar bateras recargables de
Niquel-Metal Hidruro, NiMH. No olvides comprar el cargador correspondiente.
Cable A B, USB a Micro USB. A3 no requiere un programador externo, todo el
hardware electrnico ya se incluye en el robot, pero para la comunicacin entre la
computadora y el robot se requiere dicho cable.
Computadora. Necesitas una computadora para programar el robot. Para ello se utiliza la
interfaz de programacin de Arduino, plataforma libre, que funciona en cualquiera de los
siguientes sistemas operativos:
Windows
Mac
Linux
Material para pruebas. Es necesario que tengas a mano papel, cartulinas, cartoncillo y
cinta aislante negra o blanca, para improvisar pistas y probar el robot.
LEDs. Diodos emisores de luz por sus siglas en ingls, son dispositivos que emiten una luz al
circular una corriente por sus terminales. En A3 se usan como indicadores y son programables
por el usuario por medio del Arduino.
Driver para motor. Basado en un transistor de potencia NPN, son los que proveen de potencia
al motor, siendo la interfaz entre el microcontrolador y el motor.
Botones. Son interruptores de encendido al contacto. El robot cuenta con 2, el primero para
reiniciar el microcontrolador (arduino), y el segundo como botn de usuario para propsito
general.
Motorreductores. Son motores de corriente directa (CD, como el de las bateras), con una caja
de engranes adaptada. Los usados en A3 tienen una reduccin de 48:1, esto es, por cada 48
vueltas que gire el motor, el eje del reductor girar 1 vuelta. De este modo se incrementa el
torque, fuerza, y se reduce la velocidad.
Batera. Es la que provee de energa elctrica a todo el robot, arduino, sensores, LEDs,
motores, pulsadores. Es tipo rectangular de 9V.
Arduino Nano
Es una pequea y completa placa basada en el mirocontrolador Atmega328 que generalmente se usa
para hacer prototipos. Tiene ms o menos la misma funcionalidad que el Arduino UNO, pero con una
presentacin ms compacta. No posee conector para alimentacin externa, y funciona con un cable
USB Mini-B en ez del cable estndar.
Especificaciones
Microcontrolador: Atmega328.
Tensin de operacin (nivel lgico): 5 Voltios.
Tensin de entrada (recomendada): 7-12 Voltios.
Tensin de entrada (lmites): 6-20 Voltios.
Pines E/S digitales: 14 (de los cuales 6 proveen de salida PWM).
Entradas Analgicas: 8
Corriente mxima por cada PIN de Entrada/Salida: 40mA
Memoria Flash: 32KB.
SRAM: 2KB
EEPROM: 1KB.
Dimensiones: 18.5 mm x 23.2 mm.
Alimentacin
El Arduino Nano puede ser alimentado usando el cable USB Mini-B , con una fuente externa no
regulada de 6-20V (pin 30), o con una fuente externa regulada de 5V (pin 27). La fuente de
alimentacin es seleccionada automticamente a aquella con mayor tensin.
El chip FTDI FT232RL que posee el Nano solo es alimentado si la placa esta siendo alimentada usando
el cable USB. como resultado, cuando se utiliza una fuente externa (no USB), la salida de 3.3V (la cual
es proporcionada por el chip FTDI) no est disponible y los pines 1 y 0 parpadearn si los
pines digitales 0 o 1 estn a nivel alto.
Memoria
El ATmega168 posee 16KB de memoria flash para almacenar el codigo (de los cuales 2KB son
usados por el bootloader); el ATmega 328 posee 32KB, (tambin con 2 KB usados por el
bootloader). El Atmega168 posee 1KB de SRAM y 512 bytes de EEPROM (la cual puede ser leida
y escrita con la librera EEPROM); el ATmega328 posee 2 KB de SRAM y 1KB de EEPROM.
Entrada y Salida
Cada uno de los 14 pines digitales del Nano puede ser usado como entrada o salida, usando
las funciones pinMode(), digitalWrite(), y digitalRead(). Operan a 5 voltios. Cada pin puede
proveer o recibir un mximo de 40mA y poseen una resistencia de pull-up (desconectada por
defecto) de 20 a 50 kOhms. Adems algunos pines poseen funciones especializadas:
Serial: 0 (RX) y 1 (TX). (RX) usado para recibir y (TX)usado para transmitir datos TTL va serie.
Estos pines estn conectados a los pines correspondientes del chip USB-a-TTL de FTDI.
Interrupciones Externas: pines 2 y 3. Estos pines pueden ser configurados para activar una
interrupcin por paso a nivel bajo, por flanco de bajada o flanco de subida, o por un cambio de
valor. Mira la funcin attachInterrupt() para ms detalles.
PWM: pines 3, 5, 6, 9, 10, y 11. Proveen de una salida PWM de 8-bits cuando se usa la funcin
analogWrite().
SPI: pines 10 (SS), 11 (MOSI), 12 (MISO), 13 (SCK). Estos pines soportan la comunicacin SPI, la
cual, a pesar de poseer el hardware, no est actualmente soportada en el lenguaje Arduino.
LED: Pin 13. Existe un LED conectado al pin digital 13. Cuando el pin se encuentra en nivel alto,
el LED est encendido, cuando el pin est a nivel bajo, el LED estar apagado.
El Nano posee 8 entradas analgicas, cada unas de ellas provee de 10 bits de resolucin (1024 valores
diferentes). Por defecto miden entre 5 voltios y masa, sin embargo es posible cambiar el rango
superior usando la funcin analogReference(). Tambin, algunos de estos pines poseen funciones
especiales:
I2C: Pines 4 (SDA) y 5 (SCL). Soporta comunicacin I2C (TWI) usando la librera Wire
(documentacin en la web Wiring).
Hay algunos otros pines en la placa:
AREF. Tensin de referencia por las entradas analgicas. Se configura con la funcin
analogReference().
Reset. Pon esta linea a nivel bajo para resetear el microcontrolador. Normalmente se usa para
aadir un botn de reset que mantiene a nivel alto el pin reset mientras no es pulsado.
Diagrama Pictrico
Programando en Arduino
Para programa el robot seguidor de lnea es necesario contar con el entorno de programacin de
Arduino. Si an no lo tiene lo puede descargar en: www.arduino.cc en la seccin de descargas. Es
recomendable que la versin de arduino que descarque sea igual o posterior a las 1.0.
Variables:
boolean, booleando,
char, carcter,
byte, 8 bits
int, entero,
unsigned int, entero sin signo,
long, entero de 32 bits,
unsigned long, entero 32 bits sin signo,
float, punto flotante.
Funciones
pinMode(), configura si el pin digital ser salida o entrada,
digitalWrite(), si el pin ha sido configurado como salida digital, su voltaje de salida ser 0 o 5V.
digitalRead(), lectura del valor digital del pin especificado,
analogRead(), lectura del valor analgico del pin especificado,
analogWrite(), configura la modulacin por anchura de pulso de un pin (PWM),
delay(), pausa en milisegundos.
Serial, librera incluida para el uso y configuracin del mdulo serial.
Revisa la referencia del lenguaje de arduino para aprender ms acerca de las estructuras, variables y
funciones de Arduino.
Lo que har esta funcin ser traducir todo lo codificado a un idioma que entienda el microcontrolador. Observe los avisos y errores de salida mostrados. Si el programa se compila
correctamente, el mensaje de salida deber ser como se muestra en la figura:
Ejemplos y proyectos
Ahora que sabe como compilar y cargar un prorama a la tarjeta de Arduino es tiempo de aprender a
disear y codificar programas ms complicados. Comenzar con los ms sencillos.
Ejemplo 1: Luces estilo el auto increible
Movimiento 1
Movimiento 2
Movimiento 3
Movimiento 4
Movimiento 5
Movimiento 7
Movimiento 6
Movimiento 8
Figura 17. Luces del auto increble.
El cdigo de este programa se encuentra disponible en la pgina Web:
http://www.grupoeducare.com/dct/index.php/rec/robotopia
int runled = 13; //Alias para pin 13
int led0 = 11;
int led1 = 6;
int led2 = 7;
int led3 = 8;
int led4 = 9;
void setup()
{
//Configuracin de entradas y salidas
pinMode(runled, OUTPUT); //Salida digital en runled = pin 13
pinMode(led0, OUTPUT); //Salida digital en led0 = pin 11
pinMode(led1, OUTPUT); //Salida digital en led1 = pin 6
void loop()
{
//Cdigo que se repetir infititamente
//Corrimiento de LEDs del B0 al B4
digitalWrite(led0, HIGH); //Puesta en alto de led0, prende
digitalWrite(led1, LOW); //Puesta en bajo de led1, apaga
delay(250);
digitalWrite(led1, HIGH); //Puesta en alto de led1, prende
digitalWrite(led0, LOW); //Puesta en bajo de led0, apaga
delay(250);
digitalWrite(led2, HIGH); //Puesta en alto de led2, prende
digitalWrite(led1, LOW); //Puesta en bajo de led1, apaga
delay(250);
digitalWrite(led3, HIGH); //Puesta en alto de led3, prende
digitalWrite(led2, LOW); //Puesta en bajo de led2, apaga
delay(250);
digitalWrite(led4, HIGH); //Puesta en alto de led4, prende
digitalWrite(led3, LOW); //Puesta en bajo de led3, apaga
delay(250);
Es un ejemplo sencillo pero ayuda a comprender el manejo de los pines digitales como salidas.
Ejercicio 1:
Si el sensor 4, A4, detecta, est sobre una Si el sensor 3, A3, detecta, est sobre una
superficie reflejante, entonces prende el LED superficie reflejante, entonces prende el LED
marcado como B0.
marcado como B1.
Si el sensor 2, A2, detecta, est sobre una Si el sensor 1, A1, detecta, est sobre una
superficie reflejante, entonces prende el LED superficie reflejante, entonces prende el LED
marcado como B2.
marcado como B3.
Si el sensor 0, A0, detecta, est sobre una Cada uno de los sensores debe accionar de
superficie reflejante, entonces prende el LED manera independiente, pudiendo estar varios en
marcado como B4.
superficie reflejante y tener funcionamiento.
Para probar los motores tenemos que conectarlos en los terminales (verdes con tornillos), marcados
como Motor A y Motor B. En la siguiente figura se muestra a manera de ejemplo la conexin.
digitalWrite(MotorA, LOW);
digitalWrite(MotorB, HIGH);
digitalWrite(led1, LOW);
digitalWrite(led2, LOW);
digitalWrite(led3, HIGH);
delay(1000);
}
/*--------------------------------Fin del cdigo--------------------------------*/
Funcionamiento
El robot deber ir hacia adelante, despus a la derecha y por ltimo a la izquierda. Se repetir
infinitamente. Verifique que la secuencia descrita corresponda con el movimiento del robot. Si alguno
de los motores gira en sentido contrario invierta los cables en los terminales de tornillo (verdes).
Una de las grandes ventajas de las tarjetas de Arduino es su simplicidad para establecer conexin con
una computadora. Esto se realiza gracias al convertivor USB a serial incluido en la tarjeta. A dems el
entorno de programacin cuenta con una aplicacin, monitor serial, que sirve para visualizar, recibir y
enviar informacin.
El siguiente programa obtiene el valor de los sensores reflectivos analgico, los cuantifica y los
despliega. La cuantificacin es el proceso por el cual se le asigna un valor en bits a una seal. Los
convertidores CAD, Analgico a Decimal, cuantifican las seales, es decir entregan un valor en nmero
dependiendo de la resolucin que posean. En el caso del microcontrolador que se usa, Atmega328, la
resolucin es de 10 bits, es decir 1024 divisiones en la escala del 0 al 5V. Una buen analoga es la
siguiente: Suponga que tiene una escalera de 5 metros con 1024 escalones, cada escaln le har subir
0.0048 metros. Si otra persona le indica que tiene que pintar una linea a 2.5 metros del piso, Cuntos
escalones tendr que subir?, esto puede resolverse por una simple regla de tres:
2.5metros1024escalones
Dato=
=512escalones
5metros
A grosso modo eso es lo que hace un convertidor Analgico a Digital, convierte un voltaje en un dato
que pueda manipular.
Para realizar la calibracin los sensores o para obtener informacin de ellos se puede realizar un
programa que muestre los datos en el monitor serial. A continuacin se propone el cdigo para
realizar esta tarea.
/*--------------------------------Inicio del cdigo--------------------------------*/
//Declaracin de variables globales
int sensor0, sensor1, sensor2, sensor3, sensor4;
void setup()
{
//Configuracin de entradas y salidas
//Configuracin de mdulos
Serial.begin(9600);
void loop()
{
//Cdigo que se repetir infititamente
sensor0 = analogRead(A0); //Lectura del sensor Derecho
sensor1 = analogRead(A1); //Lectura del sensor Centro Derecho
sensor2 = analogRead(A2); //Lectura del sensor Centro
sensor3 = analogRead(A3); //Lectura del sensor Centro Izquierdo
sensor4 = analogRead(A4); //Lectura del sensor Izquierdo
}
/*--------------------------------Fin del cdigo--------------------------------*/
Funcionamiento
Una vez compilado y descargado el cdigo se deber abrir el monitor serial dentro del IDE de Arduino
para ver los datos.
Se propone el siguiente cdigo, copie y pegue en el rea de cdigo del IDE de Arduino.
/*--------------------------------Inicio del cdigo--------------------------------*/
//Declaracin de variables globales
int sensor0, sensor1, sensor2, sensor3, sensor4;
int runled = 13; //Alias para pin 13
int led0 = 11;
int led1 = 6;
int led2 = 7;
int led3 = 8;
int led4 = 9;
int umbral = 750;
int velocidad = 100;
void setup()
{
//Configuracin de entradas y salidas
pinMode(runled, OUTPUT); //Salida digital en runled = pin 13
pinMode(led0, OUTPUT); //Salida digital en led0 = pin 11
pinMode(led1, OUTPUT); //Salida digital en led1 = pin 6
pinMode(led2, OUTPUT); //Salida digital en led2 = pin 7
pinMode(led3, OUTPUT); //Salida digital en led3 = pin 8
pinMode(led4, OUTPUT); //Salida digital en led4 = pin 9
//Configuracin de mdulos
}
void loop()
{
//Cdigo que se repetir infititamente
sensor0 = analogRead(A0);
sensor1 = analogRead(A1); //Lectura del sensor Centro Derecho
sensor2 = analogRead(A2); //Lectura del sensor Centro
sensor3 = analogRead(A3); //Lectura del sensor Centro Izquierdo
sensor4 = analogRead(A4);
if (sensor0 > umbral && sensor1 > umbral && sensor2 < umbral && sensor3 > umbral && sensor4 >
umbral) //Si la superficie es blanca entonces prende LED
{
analogWrite(5, velocidad);
analogWrite(3, velocidad);
digitalWrite(led1, LOW);
digitalWrite(led2, HIGH);
digitalWrite(led3, LOW);
}
//Centro y derecho
if (sensor0 > umbral && sensor1 < umbral && sensor2 > umbral && sensor3 > umbral && sensor4 >
umbral) //Si la superficie es blanca entonces prende LED
{
analogWrite(5, 50);
analogWrite(3, velocidad);
digitalWrite(led1, HIGH);
digitalWrite(led2, HIGH);
digitalWrite(led3, LOW);
}
//derecho
if (sensor0 < umbral && sensor1 > umbral && sensor2 > umbral && sensor3 > umbral && sensor4 >
umbral) //Si la superficie es blanca entonces prende LED
{
analogWrite(5, 20);
analogWrite(3, velocidad);
digitalWrite(led1, HIGH);
digitalWrite(led2, LOW);
digitalWrite(led3, LOW);
}
//Centro Izquierdo
if (sensor0 > umbral && sensor1 > umbral && sensor2 > umbral && sensor3 < umbral && sensor4 >
umbral) //Si la superficie es blanca entonces prende LED
{
analogWrite(5, velocidad);
analogWrite(3, 50);
digitalWrite(led1, LOW);
digitalWrite(led2, HIGH);
digitalWrite(led3, HIGH);
}
//Izquierdo
if (sensor0 > umbral && sensor1 > umbral && sensor2 > umbral && sensor3 > umbral && sensor4 <
umbral) //Si la superficie es blanca entonces prende LED
{
analogWrite(5, velocidad);
analogWrite(3, 20);
digitalWrite(led1, LOW);
digitalWrite(led2, LOW);
digitalWrite(led3, HIGH);
}
}
/*--------------------------------Fin del cdigo--------------------------------*/
Funcionamiento
Son cinco las entradas que se toman en cuenta para hacer la correccin en los motores y de esta
forma seguir la lnea. Si ya prob el cdigo se dar cuenta que el robot sigue la lnea de la siguiente
manera.
Sensor 1
Sensor 2
Sensor 3
Sensor 4
Motor A (3)
Motor B (5)
8.00%
40.00%
20.00%
40.00%
40.00%
40.00%
40.00%
20.00%
40.00%
8.00%
Como ver este sistema de control no es muy eficiente, el seguidor de lnea no se desliza exactamente
sobre ella y se requiere trabajar a baja velocida.
Ejercicio 3.
Desarrolle un cdigo para la respuesta ante lo cinco sensores y las siguientes condiciones:
Sensor 0
Sensor 1
Sensor 2
Sensor 3
Sensor 4
Motor A
Motor B
Ajuste y determine las acciones a tomar con respecto a la velocidad de cada uno de los motores.
Para seguir la lnea con precisin es necesario aplicar mtodos de control. La tcnica usada en este
ejemplo es el control PID.
Proporcional, es un valor propocional a la posicin del robot sobre la lnea. Si el robot est
centrado sobre la lnea el error ser 0, pero si se encuentra a la derecho o izquierda el valor del
error ser positivo o negativo.
Integral, es una memoria de todos los eventos anteriores. Una integral en sistemas discretos,
generalmente usados por micro-controladores y microprocesadores, se pude expresar como la
sumatoria de todos los puntos anteriores, lo que en sistemas continuos es el rea debajo de la
curva.
Derivativo, es la razn de cambio, la tendencia, el diferencia de los valores actuales y
anteriores.
El cdigo propuesto
/*--------------------------------Inicio cdigo-------------------------------------*/
#include <QTRSensors.h> //Biblioteca para la lectura y calibracin de los sensores de contraste
//Declaracin de constantes
#define NUM_SENSORS
5 // Nmero de sensores
#define NUM_SAMPLES_PER_SENSOR 4 // Nmero de muestras por sensor
#define EMITTER_PIN
2 // Controlador de emisores LED's infrarrojos
//Los sensores reflectivos para detectar contraste de encuentran conectados en las entradas
//Analgicas A0 a A4
QTRSensorsAnalog
qtra((unsigned
char[])
{0,
1,
2, 3, 4, 5}, NUM_SENSORS,
NUM_SAMPLES_PER_SENSOR, EMITTER_PIN);
unsigned int sensorValues[NUM_SENSORS]; //Vector para almacenar seal de sensores
unsigned int sensors[5]; // Matriz para armazenar valores dos sensores
int MotorA = 5; //Alias para Motor B
int MotorB = 3; //Alias para Motor A
//Declaracin de variables
int total = 0;
float average = 0;
int index = 0;
int last_proportional;
int integral;
void setup(){