Proyecto: Robot seguidor de línea

https://www.youtube.com/watch?v=HzJjHM1MnUM
https://www.youtube.com/watch?v=bgbfPz2KBrw

1. Sistemas de Telecomunicación e Informática
Curso 2011-2012



Clavero Carrascull, Carlos
Rodríguez Grota, David


ROBOT
SEGUIDOR
DE LINEA
Sistemas de Telecomunicación e Informática
Clavero Carrascull, Carlos
Rodríguez Grota, David
Curso 2011-2012

2. Sistemas de Telecomunicación e Informática
Curso 2011-2012



Clavero Carrascull, Carlos
Rodríguez Grota, David

Índice
1.- Introducción ....................................................................................... 1
1.1.- Presentación ......................................................................... 1
1.2.- Motivaciones ......................................................................... 1
1.3.- Objetivos ............................................................................... 1
2.- Desarrollo de un robot seguidor de línea ........................................ 2-24
2.1.- Conceptos básicos ............................................................. 2-7
2.1.1.- Introducción a Arduino .......................................... 2-4
2.1.2.- Introducción a la programación Arduino ................. 5-7
2.2.- Práctica ............................................................................ 8-24
2.2.1.- Componentes del chasis ........................................ 8-9
2.2.2.- Componentes electrónicos .................................. 10-12
2.2.3.- Primeros programas ........................................... 13-18
2.2.4.- Seguimiento del proyecto ....................................... 19
2.2.5.- Problemas y soluciones ...................................... 20-24
3.- Resultados y estadísticas.............................................................. 25-28
3.1.- Robot finalizado .............................................................. 25-26
3.2.- Presupuesto ........................................................................ 27
3.3.- Mejoras futuras ................................................................... 28
4.- Anexo ........................................................................................... 29-31
4.1.- Programa y conexiones finales ......................................... 29-30
4.2.- Web grafía ........................................................................... 31

3. Sistemas de Telecomunicación e Informática
Curso 2011-2012




Clavero Carrascull, Carlos Página 1 de 33
Rodríguez Grota, David
1. Introducción
1.1. Presentación
El proyecto ha sido realizado por Carlos Clavero Carrascull y David Rodríguez Grota,
del Centro de Estudios STUCOM, de l segundo curso de CFGS de Sistemas de
Telecomunicaciones e Informática. Este consta de una parte práctica, la cual es la
realización de un robot seguidor de línea, de un informe donde se explican todos los
pasos seguidos en el proceso de construcción del robot, de un CD que almacena videos,
fotografías y datos de pruebas y procesos realizados y una presentación en PowerPoint
con una breve explicación del desarrollo de este proyecto.
1.2. Motivaciones
En primer lugar hemos decidido realizar este proyecto porque uno de los motivos por los
que empezamos este curso de CFGS de Sistemas de Telecomunicaciones e Informática
es la realización de un robot al final de curso.
En segundo lugar este proyecto nos permitía poner en práctica algunos de los
conocimientos adquiridos durante este curso.
Otra de las motivaciones que nos impulsaron a crear un robot, es ponernos a prueba a
nosotros mismos demostrando que somos capaces de entender y llevar a la práctica la
aplicación de diferentes elementos electrónicos.
Finalmente una presente motivación fue ver si conseguíamos desarrollar el código de
programación necesario, ya que, este era un aspecto bastante complejo por nuestra
parte debido a nuestros conocimientos.
1.3. Objetivos
Mínimos:
- Robot rastreador de una línea (Placa Arduino, 2 LDR, 2 leds y 2 servomotores)
con el mínimo presupuesto posible.
El robot dispondrá de sensores que deberán captar la intensidad de luz, principalmente
el procesador interpretara los estímulos de esta manera. Cuando del robot este
encendido deberá seguir o bien, una línea blanca o negra en el suelo. El procesador de
alguna manera deberá captar e interpretar por separado cada estimulo de luz.
Máximos:
A parte de la característica anterior, si hay tiempo y presupuesto suficiente el robot
deberá hacer también:
- Robot que interprete un sonido.
- Robot rastreador luz (LDR).
- Conectar una pantalla que muestre cuando esta encendido o apagado.

4. Sistemas de Telecomunicación e Informática
Curso 2011-2012




Clavero Carrascull, Carlos Página 2 de 33
Rodríguez Grota, David
2. Desarrollo de un robot seguidor de línea
2.1. Conceptos básicos
2.1.1. Introducción a Arduino:
¿Qué es Arduino?

Arduino es una placa creada para el aprendizaje y la introducción a la programación e
implementación en le mundo físico. Es una plataforma de desarrollo de computación
física de código abierto, basada en una placa con un sencillo micro controlador y un
entorno de desarrollo para crear software para la placa.
Puedes usar Arduino para crear objetos interactivos, leyendo datos de una gran
variedad de interruptores y sensores y controlar multitud de tipos de luces, motores y
otros actuadores físicos. Los proyectos de Arduino pueden ser autónomos o
comunicarse con un programa (software) que se ejecute en tu ordenador. El lenguaje de
programación de Arduino es una implementa ción de Wiring, una plataforma de
computación física parecida, que a su vez se basa en Processing, un entorno de
programación multimedia, este lenguaje de programación es parecido al lenguaje C o
C++.
¿Por qué usar Arduino?
Arduino, además de simplificar el proceso de trabajar con microcontroladores, ofrece
algunas ventajas respecto a otros sistemas a profesores, estudiantes y amateurs:
 Asequible: Arduino UNO es asequible en cuanto a precio. La placa con el cable
USB esta entre los 30 a 40 €. El software necesario para la programación es
gratuito y se puede descargar desde la pagina oficial
http://arduino.cc/es/Main/Software
 Multiplataforma: El software utilizado para Arduino es multiplataforma, funciona
en los sistemas operativos Windows, Macintosh OSX y Linux.
 Entorno de programación simple y directa: El entorno de programación de
Arduino es fácil de usar para principiantes y lo suficientemente flexible para los
usuarios avanzados.
 Software ampliable y de código abierto: El software Arduino esta publicado bajo
una licencia libre y preparado para ser ampliado por programadores
experimentados.

5. Sistemas de Telecomunicación e Informática
Curso 2011-2012




Clavero Carrascull, Carlos Página 3 de 33
Rodríguez Grota, David
 Hardware ampliable y de Código abierto: Los planos de los módulos están
publicados bajo licencia Creative Commons, por lo que diseñadores de circuitos
con experiencia pueden hacer su propia versión del módulo, ampliándolo u
optimizándolo.
Componentes de la placa Arduino UNO:

- AREF (Verde claro): Terminal de referencia analógica. Referencia de voltaje
para las entradas analógicas.
- GND (Naranja): Toma de tierra
- Pines 2-13 (Azul claro): Terminales digitales
- Pines 0-1 (Amarillo): Terminales digitales E/S serie - Tx/Rx. Estos pines no se
pueden utilizar como e/s digitales si se esta utilizando comunicación en serie.
- Reset (Blanco): Botón de reinicio
- ICSP (Azul oscuro): "In-circuit Serial Programmer"/Programador serie en
circuito
- ATMEGA328P-PU (Rojo): Microcontrolador ATMEGA328P-PU
- Pines 0-5 (Gris oscuro): Terminales de entrada analógica
- Pines 3.3V, 5V, Vin (Marrón): Terminales de alimentación.
Vin (a veces marcada como "9V"), es el voltaje de entrada a la placa Arduino
cuando se está utilizando una fuente de alimentación externa (En comparación
con los 5 voltios de la conexión USB o de otra fuente de alimentación regulada).
Puedes proporcionar voltaje a través de este pin.

6. Sistemas de Telecomunicación e Informática
Curso 2011-2012




Clavero Carrascull, Carlos Página 4 de 33
Rodríguez Grota, David
- Pin Reset (Gris claro): Se pone a LOW para resetear el microcontrolador.
Utilizada típicamente para añadir un botón de reset a shields que bloquean el de
la placa principal.
- Entrada de alimentación (Rosa): Entrada de alimentación externa
- USB (Verde oscuro): Entrada USB utilizada para subir programas a la placa y
comunicaciones serie entre la placa y el ordenador; puede utilizarse como
alimentación.

7. Sistemas de Telecomunicación e Informática
Curso 2011-2012




Clavero Carrascull, Carlos Página 5 de 33
Rodríguez Grota, David
void setup() {
estamentos;
}
void loop(){
estamentos;
}

vo id s e tu p( ){
pi nM od e (p in , O UT PU T) ;
// c on f ig ur a e l 'p in '
co mo s a li da
}

vo id l o op () {
di gi ta l Wr it e( p in , HI GH ); / / p on e e n un o (o n,
5v ) el ´p in ´
de la y( 1 00 0) ; / / es pe ra u n s eg un do (1 00 0 ms )
di gi ta l Wr it e( p in , LO W) ; // po ne e n c er o (o ff ,
0v .) e l ´ pi n´
de la y( 1 00 0) ;
}
2.1.2. Introducción a la programación de Arduino
Este apartado pretende explicar la programación más básica que se necesitaría saber
crear programas sencillos en Arduino UNO.
Para empezar analizaremos la estructura de un sketch (código de programación). La
estructura básica del lenguaje de programación de Arduino es bastante simple y se
compone de al menos dos sectores. Estos dos son necesarios ya que encierran bloques
que contienen declaraciones, estamentos o instrucciones.
En donde “setup()” es la parte encargada de recoger la
configuración y “loop()” es la que contienen el programa que
se ejecutará cíclicamente.Ambas funciones son necesarias
para que el programa trabaje.
La función de configuración
(“setup”) debe contener la
declaración de las variables. Es la primera función a
ejecutar en el programa, se ejecuta sólo una vez. Se
utiliza para inicializar los modos de trabajo de los
pines o del puerto serie.
La función bucle (“loop”) siguiente contiene el código que se ejecutara continuamente
(lectura de entradas,
activación de salidas,
etc.) Esta función es el
núcleo de todos los
programas de Arduino y
la que realiza la mayor
parte del trabajo.
Una vez comprendida la
estructura de la programación procedemos a estudiar las funciones básicas.
Una función es un bloque de código que tiene un nombre y un conjunto de estamentos
que son ejecutados cuando se llama a la función. Son funciones “setup()” y “loop()” de
las que ya se ha hablado. Las funciones de usuario pueden ser escritas para realizar
tareas repetitivas y para reducir el tamaño de un programa. Las funciones se declaran
asociadas a un tipo de valor. Este valor será el que devolverá la función, por ejemplo
“int”, que se utilizará cuando la función devuelva un dato numérico de tipo entero. Si la
función no devuelve ningún valor entonces se colocará delante la palabra “void”, que
significa función vacía. Después de declarar el tipo de dato que devuelve la función se
debe escribir el nombre de la función y entre paréntesis se escribirán, si es necesario,
los parámetros que se deben pasar a la función para que se ejecute.
Ahora pasaremos a explicar las normas básicas de la programación en Arduino, que
siempre se tendrán en cuenta para no ocasionar errores de código.
Las llaves ({}) sirven para definir el principio y el final de un bloque de instrucciones.
Se utilizan para los bloques de programación “setup()”, “loop()”, “if”, etc.

8. Sistemas de Telecomunicación e Informática
Curso 2011-2012




Clavero Carrascull, Carlos Página 6 de 33
Rodríguez Grota, David
in t
va ri ab l eE nt ra d a =
0; / / d ec la ra un a
va ri ab l e y le
as ig na el v al o r 0
va ri ab l eE nt ra d a =
an al og R ea d( 2) ;
Una llave de apertura ({) siempre debe ir seguida de una llave de cierre (}), si no es así
el programa dará errores. El entorno de programación de Arduino incluye una
herramienta de gran utilidad para comprobar el total de llaves. Sólo tienes que
seleccionar en el punto de inserción de una llave abierta e inmediatamente se marca el
correspondiente cierre de ese bloque (llave cerrada).
El punto y coma (;) se utiliza para separar instrucciones en el lenguaje de programación
de Arduino. También se utiliza para separar elementos en una instrucción de tipo bucle.
Olvidarse de poner fin a una línea con un punto y coma se traducirá en un error de
compilación. El texto de error puede ser obvio, y se referirá a la falta de una coma, o
puede que no. Si se produce un error raro y de difícil detección lo primero que debemos
hacer es comprobar que los puntos y comas están colocados al f inal de las
instrucciones.
Los bloques de comentarios, o multi-línea de comentarios, son áreas de texto ignorados
por el programa que se utilizan para las descripciones del código o comentarios que
ayudan a comprender el programa. Comienzan con “/*” y terminan con “*/” y pueden
abarcar varias líneas.
Una línea de comentario empieza con “//” y terminan con la siguiente línea de código. Al
igual que los comentarios de bloque, los de línea son ignoradas por el programa y no
ocupan espacio en la memoria.
Una vez entendido todo lo anterior procedemos a hacer una explicación básica de las
variables y su declaración.
Una variable es una manera de nombrar y almacenar un
valor numérico para su uso posterior por el programa. Como
su nombre indica, las variables son números que se pueden
variar continuamente en contra de lo que ocurre con las
constantes cuyo valor nunca cambia. Una variable debe ser
declarada y, opcionalmente, asignarle un valor.
Las variables deben tomar nombres descriptivos, para hacer
el código más legible, para ayudar al programador y a cualquier otra persona a leer el
código y entender lo que representa la variable.
Todas las variables tienen que declararse antes de que puedan ser utilizadas. Para
declarar una variable se comienza por definir su tipo como “int” (entero), “long” (largo),
“float” (coma flotante), etc. asignándoles siempre un nombre, y, opcionalmente, un valor
inicial. Esto sólo debe hacerse una vez en un programa, pero el valor se puede cambiar
en cualquier momento usando aritmética y reasignaciones diversas.
Una variable puede ser declarada en una serie de lugares del programa y en función del
lugar en donde se lleve a cabo la definición esto determinará en que partes del
programa se podrá hacer uso de ella.
Una variable puede ser declarada al inicio del programa antes de la parte de
configuración “setup()”, a nivel local dentro de las funciones, y, a veces, dentro de un

9. Sistemas de Telecomunicación e Informática
Curso 2011-2012




Clavero Carrascull, Carlos Página 7 de 33
Rodríguez Grota, David
in t va l ue ; // 'v al ue ' es v i si bl e p ar a
cu al qu i er f un c ió n
vo id s e tu p( )
{
// n o e s ne ce s ar io c on fi gu r ar
}
vo id l o op ()
{
fo r (i n t i= 0; i< 20 ;) / / 'i ' s ol o e s
vi si bl e
{ // d e nt ro d e l bu cl e fo r
i+ +;
}
fl oa t f ; // ' f ' es v is ib le so lo
} // d e nt ro d e l bu cl e
bloque, como para los bucles del tipo “if”, “for”, etc. En función del lugar de declaración
de la variable así se determinara el ámbito de aplicación, o la capacidad de ciertas
partes de un programa para hacer uso de ella.
Una variable global es aquella que puede ser vista y utilizada por cualquier función y
estamento de un programa. Esta variable se declara al comienzo del programa, antes de
“setup()”.
Una variable local es aquella que se define dentro de una función o como parte de un
bucle. Sólo es visible y sólo puede utilizarse dentro de la función en la que se declaró.
Por lo tanto, es posible tener dos o
más variables del mismo nombre
en diferentes partes del mismo
programa que pueden contener
valores diferentes. La garantía de
que sólo una función tiene acceso
a sus variables dentro del
programa simplifica y reduce el
potencial de errores de
programación.

10. Sistemas de Telecomunicación e Informática
Curso 2011-2012




Clavero Carrascull, Carlos Página 8 de 33
Rodríguez Grota, David
2.2.- Práctica
2.2.1.- Componentes del chasis
Placa de metacrilato
La placa de metacrilato se utilizará como base para el
chasis del robot y se trata únicamente de una placa
transparente de plástico pero de gran dureza y grosor. Por
tanto, será perfecta para sujetar todos los elementos del
robot a ella aunque trabajarla será algo mas complicado
debido a sus características.

CD
Los CD los utilizaremos como las ruedas delanteras del
robot y serán unos simples CD que podríamos utilizar para
grabar información o películas. Aunque también servirían
unos discos transparentes iguales a los CD tal y como
hemos utilizado nosotros en nuestro proyecto que
quedarán mejor con la placa transparente.

Rueda con base giratoria
La rueda trasera será una rueda con base giratoria que
permitirá al robot desplazarse sin dificultad en curvas del
recorrido, ya que, la única función de ésta será obedecer a
las delanteras que llevarán la dirección.


Bridas
Unas bridas de plástico normales servirán para fijar los
elementos electrónicos como servomotores o placas al
chasis sin dificultad. Al utilizar bridas pequeñas y cortar
en trozo restante una vez puesta conseguimos que
queden más discretas en el robot y que no tengamos
que hacer agujeros demasiado grandes para pasarlas.

11. Sistemas de Telecomunicación e Informática
Curso 2011-2012




Clavero Carrascull, Carlos Página 9 de 33
Rodríguez Grota, David
Cinta de goma de doble cara auto-adhesiva
Se trata de una cinta de goma que podemos
utilizar para rodear las ruedas y así conseguir que
no resbalen las ruedas sobre una superficie lisa.
Ésta goma es de doble cara y fácil de poner
debido a su elasticidad y sus prop iedades
adhesivas.
Perfil de silicona
El perfil de silicona hace la misma función que la
cinta de goma que es la de rodear la rueda y evitar
que no se adhiera sobre superficies lisas y es como
la goma de una bicicleta pero de silicona y nosotros
podemos adaptarla a nuestra rueda.
Hemos puesto éste perfil de silicona porque quedaba
mejor en cuanto a estética pero cualquiera de las dos
opciones cumple con el objetivo.

Estaño
El estaño es un metal que se utiliza y durante el
proyecto hemos utilizado para soldar pequeños
elementos electrónicos, pero también nos ha servido
en el chasis para fijar los CD que a los servomotores
simplemente como elemento de unión a través de los
agujeros en lugar de un tornillo.

12. Sistemas de Telecomunicación e Informática
Curso 2011-2012




Clavero Carrascull, Carlos Página 10 de 33
Rodríguez Grota, David
2.2.2.- Componentes electrónicos
Placa Arduino UNO: (mirar apartado 1.1)
Sensor de Luz o LDR (Light Dependent Resistor):
Un LDR es una resistencia variable, que varía su valor
dependiendo de la cantidad de luz que incide sobre su
superficie. Cuanta mas intensidad de luz incide en la
superficie de la LDR
menor será su
resistencia y cuanto
menos luz incide mayor será la resistencia. Suelen
ser utilizados como sensores de luz ambiental o
como una fotocélula que activa un determinado
proceso en ausencia o presencia de luz.
Los valores que puede tomar una LDR en total
oscuridad y a plena luz puede variar un poco de un modelo a otro, en general oscilan
entre unos 50 a 1000 ohmios cuando están iluminadas y valores comprendidos entre
50K y varios megohmios cuando está a oscuras.
Sensor CNY70
El CNY70 es un pequeño dispositivo con forma de cubo y
cuatro pines que tiene en su interior un diodo emisor de
infrarrojos y un fototransistor en paralelo y apuntando ambos
en la misma dirección.
Con solo 2 resistencias y un transistor es fácil conectar un
CNY70 a una placa Arduino, este sensor es muy usado en
robots seguidores de líneas.

Protoboard
El protoboard es una especie de tablero con
orificios, en la cual se pueden insertar
componentes electrónicos y cables para armar
circuitos. Los orificios están interconectados
entre si por columnas como lo vemos en la foto.
En algunas placas también hay filas
interconectando los orificios, estas se encuentran
en los bordes de la placa, como lo muestra la
segunda foto.

13. Sistemas de Telecomunicación e Informática
Curso 2011-2012




Clavero Carrascull, Carlos Página 11 de 33
Rodríguez Grota, David
Motor Servo
Un motor servo es un dispositivo actuador que tiene la capacidad de ubicarse en
cualquier posición dentro de su rango de operación, y de mantenerse estable en dicha
posición.
Consta de un motor de corriente continua, con una caja reductora y un circuito de
control, para su posicionamiento.

Los servos estándar llevan 3 cables: tensión, tierra y control. Se mueven en función de
pulsos que le enviamos a través del cable de control y estos pulsos que le enviamos
son los que establecen la posición del servo. El servo espera pulsos cada 20
milisegundos para tener una idea correcta de la posición que ha de tener. En general
los servos giran unos 180 grados, aunque hay algunos que giran más. Tienen una
amplitud de pulsos de entre 0.5 y 2.5 milisegundos para establecer la posición.
Para nuestro proyecto deberemos utilizar el servomotor para poder mover las ruedas
delanteras y deberá poder realizar giros de 360º continuos.
LED:
Los LED (Light Emiting Diode). Son diodos que se iluminan cuando
pasa la electricidad.
Tienen dos “patas”, una positiva más larga (ánodo) y otra negativa
(cátodo).Se conectan a Arduino por medio de una resistencia para
proteger el LED y el microcontrolador.
Resistencias
La resistencia eléctrica de un objeto es una medida de su
oposición al paso de corriente. Una resistencia ideal es un
elemento pasivo que disipa energía en forma de calor según
la ley de Joule.
También establece una relación de proporcionalidad entre
la intensidad de corriente que la atraviesa y la tensión
E j e de
p o t e n c i a
R e d u c t o r d e v e l o c i d a d

14. Sistemas de Telecomunicación e Informática
Curso 2011-2012




Clavero Carrascull, Carlos Página 12 de 33
Rodríguez Grota, David
medible entre sus extremos, relación conocida como ley de Ohm. De acuerdo con la ley
de Ohm. La resistencia de un material puede definirse como la razón entre la caída de
tensión y la corriente en dicha resistencia, así: R = V / I Donde: R = Resistencia V =
Voltaje I= Corriente.
Porta-pilas
El porta-pilas es un elemento que nos permitirá
alimentar el robot que construyamos de forma
independiente sin estar sujeto a un cable
conectado al ordenador. El porta-pilas puede
ser de diferente tamaño, forma o cantidad de
pilas que puede albergar pero en nuestro
proyecto nos será suficiente con 4 espacios
para 4 pilas de 1,5V.

Conmutador de placa MSP1M1
Es un interruptor para poder cortar la entrada de voltaje a la
placa Arduino. Este tiene tres pines, pero nosotros solo
conectaremos 2 de ellos, uno de los extremos del conductor a
alguno de los pines pequeños y el otro extremo al pin central que
es más grande que los otros dos.
Cable unifilar
El cable unifilar será el conector entre elementos
electrónicos y pines o para realizar las conexiones en la
protoboard de éstos.

15. Sistemas de Telecomunicación e Informática
Curso 2011-2012




Clavero Carrascull, Carlos Página 13 de 33
Rodríguez Grota, David
2.2.3.- Primeros programas
Este apartado mostrara funciones básicas de la placa Arduino UNO, por las que es
recomendable empezar a probar ya que de esta manera se van adquiriendo
conocimientos básicos de su funcionamiento, programación y características físicas.
Algunos de los programas empleados están descritos en la página web oficial de
Arduino (http://www.arduino.cc/).
Para realizar los esquemas visuales de las conexiones hemos utilizado el software
gratuito “Fritzing”.
Programa#1:
Esta función consiste en un led parpadeante. Dicho led estará conectado a un pin (por
ejemplo el 13), y a la toma de tierra de Arduino (pin GND). El código ordenará al led
que se encienda y que se apague cada cierto tiempo.

Como vemos en el código lo primero que hacemos es declarar el pin nº 13 como salida,
después le ordenamos con la función “digitalWrite()” que deje salir tensión y con el
“delay()” el tiempo en milisegundos que ha de estar encendido, acto seguido decimos
que se pare también por tiempo limitado. Todo el código escrito en “void loop()” se
repite continuamente.
A partir de este código se puede ir experimentando
introduciendo más leds, para que se apaguen y se
enciendan dependiendo de las órdenes que se le
dan.



El le d s e c o nec ta
dir ect a me nt e a l a
plac a ( pin 1 3 y
GN D)

16. Sistemas de Telecomunicación e Informática
Curso 2011-2012




Clavero Carrascull, Carlos Página 14 de 33
Rodríguez Grota, David
Programa#2:
El segundo programa consistía entender el funcionamiento de un sensor LDR.
Modificando algunos aspectos del código expuesto en la página web oficial,
conseguimos identificar los valores dados por el LDR y entender las conexiones
necesarias (necesaria resistencia 10kΩ). Ejemplo de las conexiones y el código:
Conectamos al LDR al pin de 5V y en el
otro pin lo conectamos en serie a una
resistencia de 10kΩ que ira al GND y al
pin analógico de Arduino el cual recibirá
los datos del sensor. En el código hay funciones específicas para que los datos
recibidos por el LDR se muestren por pantalla con la función Monitor Serial del software
Arduino 1.0.1.

17. Sistemas de Telecomunicación e Informática
Curso 2011-2012




Clavero Carrascull, Carlos Página 15 de 33
Rodríguez Grota, David
Programa#3:
Partiendo del programa anterior, pasamos a calibrar un LDR junto con un led. El LDR,
en la práctica, lo tapamos de alguna manera para que no distorsione los datos por el
efecto de la luz del led o la iluminación ambiental.
En la práctica comprobamos
los valores numéricos que
interpreta el LDR con una
hoja de papel blanca y una
raya negar para verificar
que diferencia a la
perfección los dos colores.

18. Sistemas de Telecomunicación e Informática
Curso 2011-2012




Clavero Carrascull, Carlos Página 16 de 33
Rodríguez Grota, David
Programa#4:
Este consiste en aprender a hacer funcionar un servomotor con Arduino. Consta de tres
conexiones (rojo-5V, negro-GND y amarillo-digitalPin), con el siguiente código
comprobamos su funcionamiento.
Mediante el código,
conseguimos que el
servomotor funcione
durante 5 segundos y este
parado durante 1 segundo
y así consecutivamente.




Programa#5:
Probamos de controlar dos servomotores a la vez.

19. Sistemas de Telecomunicación e Informática
Curso 2011-2012




Clavero Carrascull, Carlos Página 17 de 33
Rodríguez Grota, David
#include <Servo.h>
Servo servo1;
Servo servo2;
int entrada_sensor;
int entrada_sensor2;
void setup(){
pinMode (12, OUTPUT);
pinMode (13, OUTPUT);
pinMode (0, INPUT);
pinMode (1, INPUT);
Serial.begin(9600);
}
void loop(){
digitalWrite (12, HIGH);
digitalWrite (13, HIGH);
entrada_sensor = analogRead (0);
Serial.print(" \n");
Serial.print("LDR = ");
Serial.println(entrada_sensor);
if (entrada_sensor < 450){
attach_servos();
}
else {
detach_servos2();
}
entrada_sensor2 = analogRead (1);
Serial.print("LDR2 = ");
Serial.println(entrada_sensor2);
delay(500);
if (entrada_sensor2 < 450){
attach_servos2();
}
else {
detach_servos();
}
}
void detach_servos(){
servo1.detach();
}
void detach_servos2(){
servo2.detach();
}
void attach_servos(){
servo1.attach(9);
}
void attach_servos2(){
servo2.attach(10);
}

Programa#6:
Este es el último programa realizado antes del código final. Consiste en controlar los
servomotores dependiendo de los datos captados por los LDR.
En este programa, por un lado vemos
funciones para controlar el encendido y
apagado de los servos, y por otro las
lecturas de los LDR por separado. En
cada lectura de los LDR, hay un
“if()…else()”, llamando a las funciones
de los servomotores (si la lectura es
menos a un valor, que se encienda un
servomotor determinado, y viceversa).

20. Sistemas de Telecomunicación e Informática
Curso 2011-2012




Clavero Carrascull, Carlos Página 18 de 33
Rodríguez Grota, David
Programa#7:
Una vez ya podemos controlar los servomotores dependiendo de los sensores LDR,
probamos los sensores CNY70 ya que presentan un mejor rendimiento y funcionalidad
ya que son unos sensores compactos e infrarrojos. El primer código utilizado es
sencillo, sirve para ver el comportamiento y los datos interpretados por los dos
sensores.
Las conexiones necesarias son
un poco complicadas ya que el
sensor tiene cuatro pines, a uno
de entrada le llegan 5V, al otro
le llegan 5V pasando por una
resistencia de 220Ω, uno de los de salida se conecta con el GND y el otro de salida se
conecta en seria con una resistencia conectada al GND y con el pin analógico concreto.

21. Sistemas de Telecomunicación e Informática
Curso 2011-2012




Clavero Carrascull, Carlos Página 19 de 33
Rodríguez Grota, David
2.2.4.- Seguimiento del proyecto
Para realizar este robot seguidor de línea es necesario un micro controlador, en nuestro
caso hemos utilizado la placa Arduino que como mostramos en el apartado 2.1.1 es
idónea para desarrollar éste tipo de robot. Aquí encontramos nuestro primer obstáculo
al conectar la placa al ordenador (apartado 2.2.5).
Para comprender el funcionamiento y las características físicas de la placa Arduino es
necesario realizar varias pruebas básicas (como muestra el apartado 2.2.3 o los videos
incluidos en el CD adjunto al informe) para familiarizarse con los pines y código que
posteriormente utilizaremos para el robot. Una vez comprendido el funcionamiento de
dichos elementos podremos entender como conectar los elementos electrónicos por
separado para posteriormente poder conectarlos entre si y así construir un robot
seguidor de líneas.
Una vez realizadas las pruebas y solucionados los problemas con los servomotores
(apartado 2.2.5), el paso siguiente es crear un programa capaz de sincronizar los dos
sensores con los dos servomotores (video adjunto en el CD). Para ello deberemos
interpretar las lecturas de los sensores y una vez obtenidos los valores deseados
sincronizar dichos sensores con los servomotores para controlar su funcionamiento.
El siguiente procedimiento a tener en cuenta es el montaje del chasis de nuestro robot.
Para el montaje de nuestro robot intentamos utilizar en la mayor medida posible los
materiales que podemos obtener de forma sencilla por casa para no gastar en nuevos
materiales (apartado 2.2.1). La construcción del chasis consiste en una base en la que
colocar los elementos electrónicos (placa arduino, servomotores, protoboard…) y a la
que poder unir unas ruedas para su desplazamiento. En nuestro caso, utilizamos una
placa de metacrilato para la base, unos CD con recubrimiento de goma para las ruedas
y una rueda “loca” para sostener junto a las ruedas motrices el robot.
A continuación, tendremos el chasis del robot montado junto a los componentes
electrónicos (apartado 2.2.2) y únicamente tendremos que interconectarlos todos a
través de cables unifilares a la placa arduino sirviéndonos de la protoboard.
Finalmente podremos realizar las pruebas pertinentes para el seguimiento de la línea y
solucionar los problemas que vayamos encontrando tanto como por la disposición de los
elementos físicos del robot como por parte de la programación.

22. Sistemas de Telecomunicación e Informática
Curso 2011-2012




Clavero Carrascull, Carlos Página 20 de 33
Rodríguez Grota, David
2.2.5.- Problemas y soluciones
Puerto USB-Serial Arduino
Al conectar la placa Arduino UNO, el PC no la detecta ya que no tiene los controladores
necesarios instalados. Para instalar los drivers hay que hacerlo manualmente desde
“Administrador de dispositivos”, buscamos la conexión correcta, vamos a “Propiedades”
y en la pestaña de “Controladores” seleccionamos “Actualizar controlador…”. Una vez
acabamos esto nos aparece una ventana que en la que seleccionamos “Buscar software
de controlador en el equipo”, cuando le veamos que nos deja seleccionar el directorio,
en la misma carpeta del software Arduino hay un directorio llamado “drivers”,hay que
decirle que los busque en esta carpeta, una vez encontrados se instalan y procedemos
a configurar el software.
Una vez finalizado el proceso de instalación de los controladores, configuramos el
software indicándole el
puerto y el modelo de
placa que vamos a
programar.
En la siguiente imagen
podemos ver la
configuración, en la
pestaña de “Tools”,
seleccionamos “Board”,
e indicamos nuestra placa Arduino (en nuestro caso Ardu ino UNO). Después
seleccionamos “Serial Port” e indicamos el puerto serial correcto (en nuestro caso
COM8).

23. Sistemas de Telecomunicación e Informática
Curso 2011-2012




Clavero Carrascull, Carlos Página 21 de 33
Rodríguez Grota, David
Adaptar servo (de 180º a 360º continuos)
El servomotor adquirido (Servo Hitec HS-311 Standard) para nuestro robot rastreador de
línea, es un servomotor sencillo de mediana ponencia y de giro de 180º, con un precio
de 11,95€.
Especificaciones técnicas del Servo Hitec HS-311 Standard:
> Peso: 43 g
> Rotación: 180º
> Tensión recomendada de operación: 4.8V
> Torque estático: 6.0v >/= 3.7kg.cm 4.8v >/= 3.0kg.cm
> Velocidad 6.0v: 0.15sec/60°
> Velocidad 4.8v: 0.19sec/60°
> Soporte para NXC

Este servomotor tienen el inconveniente de que su giro es de 180º y nosotros
necesitamos que llegue a girar 360º continuos ya que van a ser las ruedas de nuestro
robot.
Para conseguir que el servo girara los 360º hay que trucarlo; este tiene unos
engranajes en la parte superior, los cuales hemos de sacar y modificarlos para nuestro
propósito. A continuación veremos el ejemplo de cómo trucamos el servo (Servo Hitec
HS-311 Standard):
PASO 1:
Desmontamos la pieza giratoria de la parte superior del servo y acto seguido
desmontaremos también la parte de inferior:

24. Sistemas de Telecomunicación e Informática
Curso 2011-2012




Clavero Carrascull, Carlos Página 22 de 33
Rodríguez Grota, David
Una vez desmontada la pieza inferior la superior ya la podemos sacar para ver los
engranajes.
PASO 2:
Una vez con los engranajes delante nos podemos fijar que hay dos topes que evitan que
el motor gire los 360º:

En la primera imagen podemos ver como en el engranaje señalado hay una especie de
rectángulo que es el que evita el giro. En la segunda imagen podemos ver como debajo
del mismo engranaje esta la forma de la pieza de que va debajo, esta pieza no puede
llegar a girar más de 180º.
PASO 3:
Ahora que hemos localizado el engranaje que sirve de tope para el giro completo,
procedemos a modificarlo de la manera más sencilla posible y con cuidado. Con un
taladro o una herramienta parecida hacemos el agujero de la parte inferior del
engranaje mas grande y totalmente circular.

25. Sistemas de Telecomunicación e Informática
Curso 2011-2012




Clavero Carrascull, Carlos Página 23 de 33
Rodríguez Grota, David
Después con unos alicates cortamos el tope superior del engranaje:

PASO 4:
Una vez finalizado este proceso volvemos a poner el engranaje en su sitio y montamos
otra vez el servomotor:

Programación de los servos
En relación a la programación de Arduino para hacer funcionar los servomotores,
tuvimos dos problemas.
El primer problema estaba relacionado con la librería de los servos, el inconveniente lo
teníamos a la hora de parar el servomotor. Podíamos ponerlo en funcionamiento con la
función “attach.servo(9)”, pero a la hora de detenerlo, no fuimos conscientes de que
existía la función contraria “detach.servo()”.
El segundo problema nos lo encontramos al intentar programar los dos servomotores y
los dos LDR. Teníamos que conseguir que dependiendo del valor que se obtenía en los
LDR, funcionara un servomotor y se parara el otro, funcionaran los dos o se detuvieran
los dos. Probamos varias funciones diferentes, como las funciones “swichCase()” o
“if()…else if()…else()”, pero finalmente encontramos una forma muy sencilla de hacerlo
con la función “if()…else()”, consistía en programar cada sensor junto con su respectivo
servomotor de forma independiente ordenándole cuando tenia que parar y cuando tenia
que ponerse en funcionamiento.

26. Sistemas de Telecomunicación e Informática
Curso 2011-2012




Clavero Carrascull, Carlos Página 24 de 33
Rodríguez Grota, David
Sensor infrarrojo CNY70
Cuando nos propusimos cambiar los LDR por los sensores CNY70, tuvimos varios
problemas con lo que son las conexiones y las resistencias necesarias para obtener
buenos resultados, ya que mucha de la información que aparece en internet es errónea.
En este apartado se explicaran las soluciones obtenidas.
Uno de los inconvenientes más importantes a la hora de usar un sensor infrarrojo
CNY70 es tener las resistencias adecuadas para que proporcione datos fiables. La
resistencia necesaria para el emisor infrarrojo es de 220Ω y las resistencias necesarias
para el receptor son de 10kΩ o 47kΩ indistintamente (se obtienen buenos resultados
con cualquiera de las dos).
Otro inconveniente es el de tener claro como conectar cada uno de los pines, la
solución la muestra la siguiente imagen
En la primera imagen se muestra el esquema lógico de las conexiones necesarias para
el buen funcionamiento del sensor CNY70 y en la segunda imagen se muestra el
esquema físico en una protoboard.
Un aspecto que no se tiene en cuenta a la hora de usar dichos sensores, es el que el
emisor infrarrojo cuando esta encendido, no se percibe por el ojo humano, para
comprobar que el infrarrojo esta encendido, es necesario disponer de una cámara digital
como la de un móvil, y cuando enfocas el sensor aparece el infrarrojo encendido.

27. Sistemas de Telecomunicación e Informática
Curso 2011-2012




Clavero Carrascull, Carlos Página 25 de 33
Rodríguez Grota, David
3.- Resultados y estadísticas
3.1.- Robot finalizado
Aquí podemos ver diferentes imágenes, de un prototipo realizado con 3D Studio
Max2010 para tener una idea de cómo pensábamos que habría de ser, un chasis
montado con los componentes eléctricos para entender donde colocar los componentes
y unas imágenes de dos robots finalizados. En el CD adjunto a este informe, se han
guardado varios videos demostrativos.

28. Sistemas de Telecomunicación e Informática
Curso 2011-2012




Clavero Carrascull, Carlos Página 26 de 33
Rodríguez Grota, David

29. Sistemas de Telecomunicación e Informática
Curso 2011-2012




Clavero Carrascull, Carlos Página 27 de 33
Rodríguez Grota, David
3.2.- Presupuesto Productos UnidadesPrecio / UnidadTotal
Placa Arduino UNO 1 35,95 € 35,95 €
Porta-pilas 1 0,85 € 0,85 €
Pack 4 pilas de 1,5V 1 3,65 € 3,65 €
Servomotor 2 13,43 € 26,86 €
Juego de cables unifilares 1 8,70 € 8,70 €
Pack 100 resistencias 10K Ohmios 1 1,25 € 1,25 €
Pack 100 resistencias 220 Ohmios 1 1,25 € 1,25 €
Sensor de luz CNY70 2 0,63 € 1,26 €
Conmutador de placa MSP1M1 1 0,93 € 0,93 €
Placa con cara de fibra de vidrio 1 1,44 € 1,44 €
TOTAL 82,14 €
Productos UnidadesPrecio / UnidadTotal
Pack LED de colores 3 1,25 € 3,75 €
LDR 5 1,68 € 8,40 €
Cinta de goma doble cara autoadhesiva 1 4,40 € 4,40 €
TOTAL 16,55 €
TOTAL FINAL 98,69 €
PRESUPUESTO
PRESUPUESTO PARA PRUEBAS

30. Sistemas de Telecomunicación e Informática
Curso 2011-2012




Clavero Carrascull, Carlos Página 28 de 33
Rodríguez Grota, David
3.3.- Mejoras futuras
Este apartado tiene como objetivo explicar posibles mejoras para el robot seguidor de
línea.
Algunas de las mejoras factibles para nuestro robot seguidor de línea podrían ser entre
otras:
 Introducir una pantalla LCD que muestre los datos obtenidos por los sensores o
la dirección en la que gire el robot.
 La introducción de un micrófono el cual tenga el objetivo de parar o encender el
robot.
 La implementación de un sensor que permita la detección de obstáculos a corta
distancia para evitar una colisión.
 Implementar un LDR para detectar la cantidad de luz del ambiente y así simular
la diferencia entre día y noche para encender de forma automática unos LED
delanteros y traseros a modo de faros para su detección.

31. Sistemas de Telecomunicación e Informática
Curso 2011-2012




Clavero Carrascull, Carlos Página 29 de 33
Rodríguez Grota, David
4.- Anexo
4.1.- Programa y conexiones finales
En el siguiente apartado incluimos el código final utilizado y las conexiones realizadas.
#include <Servo.h>
Servo servo1;
Servo servo2;
int CNY1;
int CNY2;
int LDR;
void setup(){
Serial.begin(9600); //para visualizar los datos
pinMode(10, OUTPUT);
pinMode(9, OUTPUT);
pinMode(8, OUTPUT);
pinMode(7, OUTPUT);
}
void loop(){
CNY1 = analogRead (A0);
Serial.print(" \nCNY_Dr = ");
Serial.println(CNY1);
if (CNY1 < 500){ // si el CNY capta <200 funcione el servo 1
attach_servos();
}
else { //sino que se apague
detach_servos();
}
CNY2 = analogRead (A1);
Serial.print("CNY_Iz = ");
Serial.println(CNY2);
if (CNY2 < 500){ //si el CNY capta <200 funcione el servo 2
attach_servos2();
}
else { //sino que se apague
detach_servos2();
}
LDR = analogRead (A2);
Serial.print("LDR = ");
Serial.println(LDR);
//delay(1000);
if (LDR > 200){
digitalWrite(10, LOW);
digitalWrite(9, LOW);
digitalWrite(8, LOW);
digitalWrite(7, LOW);
}
else {
digitalWrite(10, HIGH);
digitalWrite(9, HIGH);
digitalWrite(8, HIGH);
digitalWrite(7, HIGH);
}
}
void detach_servos(){
servo1.detach();
}
void detach_servos2(){
servo2.detach();
}
void attach_servos(){
servo1.attach(13);
}
void attach_servos2(){
servo2.attach(12);
}

32. Sistemas de Telecomunicación e Informática
Curso 2011-2012




Clavero Carrascull, Carlos Página 30 de 33
Rodríguez Grota, David

Estas son las conexiones necesarias para un robot seguidor de línea en el cual hay dos
sensores CNY70 que se utilizan para detectar la línea, dos servomotores para las
ruedas motrices del robot, un LDR que detectara la luz ambiente para comprobar si se
va la luz y unos leds que se encenderán cuando el LDR no detecte luz. También son
necesarias varias resistencias para este proyecto: 220Ω, 10kΩ y 47kΩ. Se recomienda
utilizar cables de distintos colores para diferenciar las funciones y poder entenderlo de
forma sencilla.

33. Sistemas de Telecomunicación e Informática
Curso 2011-2012




Clavero Carrascull, Carlos Página 31 de 33
Rodríguez Grota, David
4.2.- Web grafía
Información
http://www.arduino.cc/es/
http://www.info-ab.uclm.es/labelec/solar/otros/infrarrojos/sensor_cny70.htm
http://jorgefloresvergaray.blogspot.com.es/2009/07/un-carrito-seguidor-de-linea-
sencillo.html
http://www.slideshare.net/ronguti/robot-seguidor-de-linea
http://www.robotgroup.com.ar/web/
Componentes
http://www.ondaradio.es/ (Componentes varios)
http://www.diotronic.com/ (Sensores CNY70)
http://ro-botica.com/ (Servomotores)

*Las paginas webs de información, anteriores, han sido las mas utilizadas. En internet,
puede haber mucha información y puede llegar a ser útil o no, estar correcta o
incorrecta, pero muchas de las conclusiones a las que hemos llegado para realizar este
proyecto han sido a partir de foros o blogs.