Arduino PDF

Proyecto Fin de Carrera Plataforma docente para la enseanza de las TIC
basada en la maqueta de un puente colgante
ndice
1 CAPTULO 1. MOTIVACIN, OBJETIVOS Y FASES .................................................... 3

1.1 Introduccin .................................................................................................................. 3
1.2 Trabajos relacionados ................................................................................................... 4
Fritzing................................................................................................................................... 4
Otros programas ................................................................................................................... 6
2 CAPTULO 2. LA PLACA ARDUINO Y EL ENTORNO DE DESARROLLO .............. 14
2.1 Introduccin ................................................................................................................ 14
2.2 La placa Arduino UNO ................................................................................................. 16
2.3 Entorno de programacin y funciones especficas ..................................................... 18
2.3.1 Entorno de Programacin ................................................................................... 18
2.3.2 Estructura y funciones especficas ...................................................................... 20
2.4 Descarga e instalacin ................................................................................................. 23
3 CAPTULO 3. ARDUINO DESDE CERO. PRCTICAS ................................................ 26
3.1 Prcticas con Arduino.................................................................................................. 26
4 CAPTULO 4. ARDUINO Y LABVIEW .......................................................................... 52
4.1 Instalacin de Libreras................................................................................................ 52
4.2 Prcticas con LabView ................................................................................................. 55
5 CAPTULO 5. ROBOT POLOLU 3 ................................................................................. 68
5.1 Introduccin ................................................................................................................ 68
5.2 Programar nuestro 3 ................................................................................................. 69
1
6 CAPTULO 6. MAQUETA ................................................................................................ 73

6.1 Introduccin ................................................................................................................ 73
6.2 Componentes principales............................................................................................ 74
6.3 Programas Arduino ..................................................................................................... 80
6.3.1 Semforos programados por tiempo .................................................................. 80
6.3.2 Motor programado por tiempo con cambio de sentido ..................................... 82
6.3.3 Servomotores (barreras) programadas por tiempo ............................................ 84
6.3.4 Programa final ..................................................................................................... 85
6.4 Programa Pololu 3pi como sigue-lnea........................................................................ 86
6.5 Lneas futuras de la maqueta ...................................................................................... 90
7 Bibliografa ......................................................................................................................... 91
2
1 CAPTULO 1. MOTIVACIN, OBJETIVOS Y FASES
1.1 Introduccin
El presente PFC surge de la idea de generar un paquete de prcticas de
programacin, electrnica, automatizacin y robtica bsica orientadas a la asignatura
de Tecnologa impartida en diferentes cursos de educacin secundaria obligatoria.
Aunque en principio estas prcticas se orientan a secundaria, la idea es extenderlas para
su uso en los primeros cursos de Ingeniera Industrial y de Telecomunicacin.
La razn de utilizar Arduino como herramienta educativa viene dada por su fcil
manejo, compatible con una gran capacidad de control electrnico. Arduino reduce
considerablemente el tiempo de diseo electrnico as como la programacin de su
microcontrolador. Estamos ante una plataforma muy intuitiva a la que se le puede sacar
mucho provecho. Vemos como poco a poco Arduino se va abriendo camino en robtica,
sistemas de comunicaciones, domtica, telemtica y un largo etctera. En un futuro no
muy lejano y gracias a sus caractersticas podremos apostar en esta herramienta como
una oportunidad de negocio, implantndola en mbitos de automatizacin y
comunicaciones industriales, creacin de juguetes, as como la programacin y manejo
de impresoras 3D. Es por tanto una herramienta de trabajo apropiada para el uso
docente, pero con una gran proyeccin en otros mbitos.
El modelo de trabajo propuesto es ir generando un conjunto de prcticas de
dificultad creciente, empezando por montajes muy sencillos, con programas muy
simples, adaptados a los primeros de aos de la educacin secundaria e ir aadiendo
complejidad de forma progresiva. La ltima prctica es un pequeo proyecto de
automatizacin, que puede adaptarse a las necesidades de cada centro docente. En esta
prctica, adems de Arduino se utilizan otros recursos, como son AVR Studio, Fritzing
y Pololu 3pi.
De esta manera, partiendo desde la instalacin del IDE Arduino iremos viajando
a travs de sencillas prcticas hasta ser capaces de controlar un circuito con un cruce,
cuatro semforos, cuatro barreras y un puente levadizo. As mismo explicaremos cmo
manejar Arduino con LabVIEW. Segn esto, la presente memoria est organizada de
la siguiente manera:
Introduccin a Arduino y estudio de la placa Arduino UNO
Redaccin de prcticas Arduino y diseo con Fritzing
Arduino y LabVIEW
Estudio y programacin del robot Pololu 3pi
3
Aplicacin prctica en una maqueta
1.2 Trabajos relacionados

Arduino va abrindose paso poco a poco en campos relacionados con la
electrnica, la programacin, robtica Podemos observar como cada vez son ms los
programas que incluyen entre sus libreras las necesarias para trabajar con las distintas
placas de Arduino o bien la introduccin al mercado de nuevo software para el manejo
de Arduino. En nuestro proyecto usaremos las libreras que National Instruments pone a
nuestra disposicin para controlar nuestra placa Arduino y realizaremos los
esquemticos de cada prctica con la ayuda de Fritzing, programa que describimos a
continuacin:
Fritzing
Ilustracin 1 Fritzing
Fritzing es una aplicacin con la que podemos realizar los esquemas de

proyectos electrnicos. Nosotros utilizaremos la versin 0.7.11. Est pensada
principalmente para organizar proyectos con Arduino de forma clara y sencilla. Cada
proyecto creado contiene tres vistas principales (protoboard, esquema y PCB)
organizadas en pestaas como podemos ver a continuacin:
La vista protoboard nos muestra una visin realista de la implementacin del

proyecto. Realizaremos las conexiones arrastrando los componentes que necesitemos y
unindolos entre s hasta completar el circuito, pudiendo aadir notas aclaratorias en
cualquier parte del diseo.
4
Ilustracin 2 Fritzing Vista Protoboard
En la vista PCB (layout) podremos observar la distribucin de los componentes

en la placa de circuito impreso. El programa nos permite modificar tanto el tamao
como la complejidad de las conexiones en funcin de nuestras necesidades. Dispone
tambin de una opcin de autorruteo para realizar las pistas de cobre (por desgracia esta
opcin no es muy fiable y se recomienda hacerlo a mano).
Ilustracin 3 Fritzing Vista Layout
La vista esquema nos ofrece de forma abstracta los componentes y conexiones.

Gracias a ella podemos comprobar la correcta disposicin de las conexiones realizadas
en las vistas anteriores.
5
Ilustracin 4 Vista Esquema
Fritzing nos permite exportar nuestro proyecto, en cualquiera de sus tres vistas,
en diferentes formatos (PDF, PNG, JPG, SVG,). Tiene licencia GPL para el cdigo y
Creative Common para el contenido, es decir, podemos obtenerlo y utilizarlo
gratuitamente; adems, en su pgina web www.fritzing.org podremos compartir y
discutir proyectos y experiencias.
Otros programas
A continuacin vamos a comentar muy de pasada algunos de los programas
relacionados con Arduino que xisten en el mercado y nos podran ayudar en un futuro
no muy lejano en la divulgacin y enseanda de esta nueva herramienta.
Minibloq
Minibloq es un entorno de programacin grfica para dispositivos fsicos
informticos y robots. Uno de sus principales objetivos es el de llevar la computacin
fsica y las plataformas robticas a la escuela primaria (nios y principiantes.
Principales caractersticas:
Fcil e intuitivo
Generador de cdigo en tiempo real
Comprobacin de errores en tiempo real
Drag & Drop bsico con giro automtico
Interfaz avanzada
Terminal incorporado
Todo en uno para comenzar a utilizarlo
Portable
Rpido
Modular y ampiable
6
Ilustracin 5 Minibloq
Ms informacin en http://blog.miniblog.or/
Ardublock
Se trata de una utilidad grfica cuya misin es generar cdigo compatible con el
entorno IDE Arduino y sus principales caractersticas son:
Herramienta gratuita
Fcil creacin de sketchs para Arduino
Genera cdigo directamente
Posee una coleccin de bloques funcionales bsicos que facilitan la comprensin
de la programacin
Indicado para aplicaciones educativas en niveles bsicos dnde el usuario no
necesita tener conocimientos de programacin
Aplicacin muy sencilla de instalar
Se trata de un plugin que el IDE Arduino reconoce e instala como Tool
Ilustracin 6 Ardublock
Ms informacin en http://blog.ardublock.com/
7
Amici
Amici ha sido desarrollado por investigadores de DIMEB de la Universidad de
Bremen, como parte de la EduWear (proyecto europeo). El software ha sido utilizado en
ms de 25 talleres formados por nios y jvenes.
Se suministra junto con una versin completa del IDE Arduino, lo que permite
realizar cualquier programa sin tener que cargar ningn otro firmware adicional. Una
vez realizado el programa, se genera el cdigo correspondiente y se hace el volcado en
la tarjeta Arduino. Es uno de los primeros entornos creados para programar Arduino
generando cdigo.
Ilustracin 7 Amici
Ms informacin en http://www.dimeb.de/
Modkit
Es un entorno de programacin para microcontroladores. Nos permite programar
Arduino y hardware compatible con simples bloques grficos y/o cdigo de texto
tradicional. El entorno de bloques grficos de Modkit est basado en el Scratch, entorno
de programacin desarrollado por el grupo Lifelong Kindergarten del Media Lab del
MIT. Se ejecuta en cualquier navegador web y requiere de un widget de escritorio para
comunicarse con la placa de Arduino. Podemos usarlo de forma gratuita o formar parte
del Club de Alpha, dnde podemos contribuir con nuestros proyectos y disfrutar de
caractersticas adicionales antes de que se lancen al pblico en general.
8
Ilustracin 8 Modkit
Ms informacin en http://www.modk.it/
VirtualBread Boared
Entorno de simulacin y desarrollo de aplicaciones integradas que utilizan los
microcontroladores. Fcil de usar y capaz de sustituir a una protoboard para
experimentar con nuevos diseos.
Nos permite disear el prototipo en la protoboard virtual:
1. Realizar la PCB del diseo
2. Importar sketches de Arduino
3. Trabajar con distintas PICs
4. Descargar sobre Arduino la aplicacin
Ilustracin 9 VirtualBread Boared
Ms informacin en http://www.virtualbreadboard.com/
9
Physical Etoys
Es una herramienta de programacin visual que une el mundo virtual de los
ordenadores con el mundo fsico. Con Physical Etoys podemos programar fcilmente
objetos del mundo real (por ejemplo robots) para realizar cualquier accin o mover
objetos grficos en la pantalla a travs de variables recogidas del mundo fsico.
Interfaces con las que se comunica:
Arduino
Nintendo Wiimote
Puerto paralelo
RoboSapien v2
Roboquad
I-Sobot
Lego Mindstorms Nxt
Ilustracin 10 Physical Etoys
Ms informacin en http://tecnodata.com.ar/gira/projects/physical-etoys/
10
S4A (Scratch) + Arduino

Se trata de un proyecto de Citilab y tiene el aval de estar realizada en el entorno
Scratch, que es uno de los ms conocidos y poderosos en cuanto a programacin grfica
se refiere desarrollado en el MIT y escrito en lenguaje Smalltalk.
Ilustracin 11 S4A (Scratch) + Arduino
Ms informacin en http://seaside.citilab.eu/scratch/arduino
11
Ardulab
Entorno de trabajo que permite interactuar con una placa Arduino para crear un
laboratorio virtual. Podemos realizar una serie de experimentos y actividades orientados
principalmente al aprendizaje de sencillos conceptos relacionados con la tecnologa
(electrnica y robtica). No es un entorno de programacin, es un laboratorio virtual
que nos permite aprender, probar y conocer como paso previo a la programacin de
sistemas, con sensores y actuadores, basados en Arduino. Se puede adquirir
gratuitamente y tenemos acceso desde el principio a toda su funcionalidad.
Ilustracin 12 Ardulab
Ms informacin en:
http://complubot.educa.madrid.org/proyectos/arduino/ardulab/ardulab_index.php
Rhino + Firefly
Podemos conectar Arduino al poderoso entorno grfico Rinho a travs del
conocido plugin Grasshopper, que es un entorno grfico muy verstil y fcil de utilizar
con el que se programa eventos y gobierna imgenes de Rinho. Una de la libreras de
Grasshopper es Firefly y est concebida para interactuar con Arduino en el gobierno de
entradas y salidas tanto digitales como analgicas.
Ilustracin 13 Rhino + Firefly
Ms informacin en http://www.fireflyexperiments.com/download/
12
MyOpenlab
Entorno orientado a la simulacin y modelado de sistemas fsicos, electrnicos,
robticos y de control con un amplio campo de aplicaciones didcticas. Sus principales
caractersticas son:
Facilidad de uso
Amplia biblioteca de funciones analgicas y digitales
Gran biblioteca de objetos grficos de visualizacin y/o actuacin
Tratamiento de los tipos de datos y operaciones con stos.
Realizacin de las aplicaciones mediante el uso de bloques de funcin
Posibilidad de ampliacin de su librera de componentes, editndolos en cdigo
JAVA
Posibilidad de creacin de submodelos de panel y submodelos de circuito
encapsulados
Libreras propias: Elementos Funcionales; Elementos de Decoracin,
Visualizacin y Actuacin
Ilustracin 14 MyOpenlab
Ms informacin en http://es.myopenlab.de/
13
2 CAPTULO 2. LA PLACA ARDUINO Y EL ENTORNO DE

DESARROLLO
En el presente apartado se van a describir las principales caractersticas de

Arduino como plataforma; profundizaremos en la placa con la que hemos realizado
todos nuestros ejercicios (Arduino UNO); estudiaremos el entorno de programacin as
como ciertas funciones especficas y veremos al final como conseguir e instalar el IDE
de Arduino.
2.1 Introduccin
Utilizaremos para el desarrollo del proyecto el hardware y software de Arduino.
Como indican sus creadores, Arduino es una plataforma de prototipos electrnica de
cdigo abierto (open-source) basada en hardware y software flexibles y relativamente
fciles de usar. Arduino se vende como herramienta pensada para artistas,
diseadores, arquitectos y cualquiera que est interesado en crear objetos o entornos
interactivos.
Arduino basa toda su fuerza en los microcontroladores Atmega168, Atmega 328,

Atmega 1280, Atmega8 y otros similares; chips sencillos y de bajo coste capaces de
desarrollar mltiples diseos. Su hardware no deja de ser por tanto una plataforma
controlada por un microcontrolador mediante computacin fsica como otros muchos
disponibles hoy en da en el mercado. Pero, qu le hace diferente del resto? Tres
pilares son los causantes de su gran aceptacin y rpida expansin: bajo coste (tarjetas
econmicas y con soporte para Windows, Linux y Macinthos); incorporacin de
libreras y funciones especficas que facilitan y simplifican la programacin y quiz lo
que le hace ms fuerte, software de cdigo abierto.
El lenguaje de programacin de Arduino es el wiring, que est basado en el

lenguaje processing. Processing es un lenguaje de programacin y entorno de
desarrollo integrado de cdigo abierto basado en Java, de fcil utilizacin y que est
enfocado a la enseanza y produccin de proyectos multimedia e interactivos de diseo
digital. Fue creado por Ben Fry y Casey Reas a partir de reflexiones en el Aesthetics
and Computation Group del MIT Media Lab. Processing es desarrollado por artistas y
diseadores, de ah la anterior definicin de Arduino, como una herramienta alternativa
al software propietario.
14
Con objeto de hacer esta memoria lo ms autocontenida posible, en el Anexo I se

incluye la descripcin de las placas y mdulos de extensin de Arduino ms comunes.
Las principales caractersticas de la placa Arduino utilizada en la realizacin de este
proyecto se resumen a continuacin.
15
2.2 La placa Arduino UNO
Vamos a analizar a fondo la placa elegida para nuestro proyecto: Arduino UNO.
Ilustracin 15 Placa Arduino UNO
Su tamao es de 74x53 mm. La programamos mediante una conexin USB que

tambin usaremos para alimentarla (5V). Existe la posibilidad de usar la alimentacin
externa, que ha de ser de 9V. Posee 14 pines de E/S digital (6 de las cuales pueden ser
usadas como PWM) y 6 pines analgicos. Nos da la oportunidad de alimentar nuestro
circuito con dos voltajes distintos, 5V o bien 3,3V.
Vamos a explicar a continuacin cada parte con ms detalle.
Comenzamos con la ms importante, el microprocesador ATmega328, que posee

una memoria flash de 32 KB (512 bytes son usados por el bootloader), RAM de 2KB y
1KB de memoria EEPROM. El voltaje de operacin, como ya hemos dicho, es de 5V y
la frecuencia de trabajo del reloj es de 16 MHz. Destacamos tambin la preinstalacin
del bootloader.
Dispone de un reset (botn rojo) que suministra un valor LOW que reinicia el
microcontrolador. A su lado, encontramos el conector ICSP (In Circuit Serial
Programming), que es el sistema utilizado en los dispositivos PIC para programarlos sin
ser necesario la retirada del chip del circuito del que formase parte.
Vayamos ahora conociendo las capacidades de cada pin: los pines 3, 5, 6, 9, 10 y

11 son pines provistos de 8 bits de salida PWM (modulacin por ancho de pulsos).
Estos pines nos permiten obtener informacin del exterior y que la placa acte en
funcin de dicha informacin (sensores, motores, servos,..). Los pines 0 (Rx) y 1 (Tx)
16
son los encargados de enviar y recibir datos serie TTL. La funcin de los pines 2 y 3 es
la de manejar interrupciones (Arduino UNO slo es capaz de manejar dos
interrupciones por tanto). Encontramos que los pines 10, 11, 12 y 13 sirven de apoyo a
la comunicacin SPI con la biblioteca SPI. El bus SPI (Serial Peripheral Interface) es un
estndar de comunicaciones, usado principalmente para la transferencia de informacin
entre circuitos integrados en equipos electrnicos. Es un estndar para el control de
cualquier dispositivo electrnico digital que acepte un flujo de bits serie regulado por un
reloj. Tenemos 3 pines de tierra marcados como GND (0V). La alimentacin al circuito
puede ser de 5V o 3,3V en su respectivo pin. Podemos aplicar un voltaje de entrada a la
placa mediante el pin Vin cuando sta sea alimentada por una fuente externa y conocer
el valor exacto del voltaje aplicado a la placa. Respecto a entradas analgicas, Arduino
UNO dispone de 6 distribuidas en los pines A0, A1, A2, A3, A4 y A5. Cada una de
ellas proporciona una resolucin de 10 bits (1024 valores). Por defecto se mide en estos
pines la tierra a 5V, aunque podemos cambiar la cota superior de este rango mediante el
pin AREF, que se encarga de la tensin de referencia para las entradas analgicas.
El puerto USB nos permite una comunicacin serie con el ordenador mediante el
estndar de los controladores USB COM, sin necesidad de controlador externo. La
placa nos avisa con un parpadeo de los leds Rx y Tx que la comunicacin se est
llevando a cabo.
El conector plug hembra de 2.1 mm lo podemos usar para alimentar a la placa

externamente, evitando as el uso del USB (si el sketch ya est cargado en la placa, no
necesitamos el ordenador para que la placa funcione, basta alimentarla). En el Anexo II
se incluye el datasheet de la placa para mayor informacin.
17
2.3 Entorno de programacin y funciones especficas

2.3.1 Entorno de Programacin
Para programar nuestra tarjeta Arduino UNO, acudimos a su pgina web

(http://www.arduino.cc/) y descargamos el software de nuestro sistema operativo. Este
software es bastante sencillo e intuitivo de usar (en el captulo siguiente explicaremos
cmo descargar, instalar y comenzar a utilizarlo). Es de licencia con distribucin y uso
gratuito (open-hardware). En esta misma pgina podemos acceder a un foro en que
seremos ayudados por la gran comunidad de usuarios de Arduino.
El entorno de desarrollo de Arduino lo constituye un editor de texto, donde

plasmaremos el cdigo; una consola de texto; un rea de mensajes y la tpica barra de
herramientas con sus mens.
Ilustracin 16 IDE Arduino
El cdigo lo escribiremos en un sketch (programa) en el editor de texto. El

rea de mensajes (zona inferior negra) nos mostrar el estado de carga de los programas
y los posibles errores. La barra de herramientas es bastante intuitiva: el primer botn
verifica el cdigo, el segundo carga el programa en la tarjeta, el tercero nos abre un
18
nuevo sketch, el cuarto nos da la opcin de abrir un programa que se encuentre en el

pc, el quinto es para simplemente guardar y la lupa de la derecha inicia la
monitorizacin serie.
Dentro de los cinco mens horizontales podremos encontrar diversos submens

que son los tpicos de cualquier programa estndar: edicin, trato de archivos,
configuracin de la tarjeta, seleccin del puerto com, carga de ejemplos A lo largo de
este documento iremos explicando ms a fondo cada uno de ellos.
19
2.3.2 Estructura y funciones especficas
Estructura de un programa
Arduino se programa en C++, admitiendo la gran mayora de libreras usadas en
C++ y todas sus estructuras bsicas. Todo sketch tiene siempre la misma estructura:
DECLARACIN DE VARIABLES;
void setup() {...}
void loop() {}
SETUP() La funcin setup() se establece en cuanto se inicia un sketch. Se usa

para iniciar las variables declaradas anteriormente, asignar pines, cargar libreras,
etc. Esta funcin slo se ejecuta una vez desde que se conecta la placa al pc o se
reinicia.
LOOP() Una vez inicializados y preparados todos los valores y funciones
necesarias, esta funcin, como su nombre indica, se ejecuta sucesivamente
(permitiendo al sketch cambiar y responder) hasta la desconexin de la placa.
Gracias a esta funcin controlamos activamente la placa.
Una vez visto la estructura tpica de cada programa, las funciones especficas
que posteriormente emplearemos en la realizacin de las prcticas y la maqueta final se
resumen en las siguientes tablas:
Funciones especficas
NOMBRE DESCRIPCIN SINTAXIS PARMETROS DEVOLUCIN
PIN MODE() Configuramos el pinMode(pin, modo) pin: nmero de Nada
pin especificado pin que usaremos
como entrada o modo: INPUT
salida (entrada),
OUTPUT (salida)
DIGITALWRITE() Escribimos un digitalWrite(pin, pin: el nmero de Nada
valor elctrico valor) pin que usaremos
(alto o bajo) en el valor: HIGH
pin seleccionado LOW
DIGITALREAD() Leemos el valor digitalRead(pin) pin: el nmero de HIGH LOW

en el pin pin que queremos
especificado leer (int)
(HIGH LOW)
DELAY() Pausamos el delay(tiempo_en_mseg) tiempo en Nada
programa por un milisegundos
determinado
espacio de
tiempo
Tabla 1 Control de entradas y salidas digitales
20

ANALOGREAD() Leemos el valor analogRead(pi pin: el nmero de pin int(0 a 1023)
de tensin en el n) que queremos leer (int)
pin analgico. Los
valores oscilarn
entre 0 y 1023 (8
bits) con una
resolucin de
0,0049 Voltios.
ANALOGWRITE() Escribimos un analogWrite(p pin: el nmero de pin Nada
valor analgico in, valor) PWM en el que
(PWM) en el pin generaremos la seal
deseado. Con esta cuadrada (pulso)
funcin podemos valor: ciclo de trabajo
controlar la (int de 0 [siempre
luminosidad de un apagado] a 255
LED o la [siempre encendido]
velocidad de giro
de un motor. Tras
la llamada a la
funcin, el pin
asignado genera
una seal
cuadrada estable
hasta que se la
vuelva a llamar
ATTACHINTERRUPT() Mediante esta attachInterru interrupcin: el nmero
funcin pt( de la interrupcin (int
invocamos a otra interrupcin, que puede ser 0 1)
(saltamos de una funcin, funcin: funcin a la
funcin a otra) modo) que invocamos cuando
se hace efectiva la
interrupcin. Esta
funcin no debe tener
parmetros ni devolver
nada
modo: nos define el

momento de disparo de
la interrupcin. Existen
cuatro valores vlidos:
LOW (cuando el pin se
encuentre en este
estado); CHANGE
(cuando el pin cambie
de estado); RISING
(cuando el pin pase de
LOW a HIGH) y
FALLING (cuando el
pin pase de HIGH a
LOW)
DETACHINTERRUPT Apaga la
(INTERRUPT) interrupcin
pasada como
argumento (0 1)
NOINTERRUPTS() Desactiva todas
las interrupciones
INTERRUPTS() Activa las
interrupciones
Tabla 2 Control de entradas y salidas analgicas
21

BEGIN() Mediante esta Serial.begin(velocidad) velocidad: Nada
funcin velocidad en bits
establecemos la por segundo (long)
velocidad de datos
en bits por segundo
(baudios) para la
transmisin de datos
en serie. Para
nuestro caso, la
velocidad ptima
ser de 9600 bps
END() Desactiva la Serial.end() Ninguno Nada
comunicacin con la
placa, dejando libres
los pines Tx y Rx
AVAILABLE() Nos informa del Serial.available() Ninguno Nmero de bytes
nmero de bytes disponibles para
disponibles para ser su lectura
ledos por el puerto (mximo 128
serie (tanto datos bytes)
recibidos como
disponibles en el
bfer de recepcin)
READ() Recoge los datos del Serial.read() Ninguno El primer byte
puerto serie disponible
recibido por el
puerto serie
(devolver -1 en
caso de que no
haya ningn dato)
FLUSH() Nos vaca el bfer Serial.flush() Ninguno Nada
de entrada de datos
al puerto serie
PRINT() Imprime los datos Serial.print(valor) valor: el valor que Nada
del puerto serie Serial.print(valor, queremos
como texto ASCII formato) imprimir
formato:
especifica el
nmero de la base
(para int) o el
nmero de
posiciones
decimales (para
float)
PRINTLN() Imprime los datos Serial.println(valor) valor: el valor que Nada
del puerto serie Serial.println(valor, queremos
como texto ASCII formato) imprimir
aadiendo un formato:
retorno de carro y un especifica el
avance de lnea nmero de la base
(para int) o el
nmero de
posiciones
decimales (para
float)
WRITE() Escribe datos Serial.write(valor) valor: puede ser un Nada
binarios en el puerto valor a enviar
serie como un solo byte,
un string o un
array
Tabla 3 Funciones relativas a la comunicacin entre placa y usuario.
22
2.4 Descarga e instalacin

Comenzaremos este manual explicando cmo y dnde descargar el IDE de
Arduino. Accedemos a http://www.arduino.cc/ y pinchamos la pestaa download.
Ilustracin 17 Descarga Arduino
A continuacin, clicamos la versin para nuestro sistema operativo (Windows en

nuestro caso):
Ilustracin 18 Arduino Windows
23
Descargamos el archivo (arduino-1.0.3-windows.zip de 91.2 Mb). Una vez

descargado, descomprimimos el archivo en el directorio raz: C:\arduino-1.0.3. Dentro
de la carpeta creada, buscamos el icono y abrimos el programa. Es hora

de conectar nuestra placa y esperar que el pc la reconozca. Para corroborar que todo ha
ido bien, debemos observar en la placa como el LED de PWR queda encendido.
Dependiendo de la versin de Windows, ste ser capaz de reconocer a la placa
automticamente o no. En el caso de Win7 y Vista, este paso es automtico:
descargamos los drivers de la pgina oficial y los instalamos; para el caso de XP,
deberemos instalarlos manualmente desde la ubicacin donde los hayamos guardado
(C:\.../drivers/FTDI USB Drivers)
Es hora de comenzar a usar y disfrutar de nuestra Arduino UNO. Ejecutamos el

programa y abrimos el ejemplo Blink:
Ilustracin 19 Ejemplo Blink
24
Debemos decirle ahora al programa que placa es la que le hemos conectado, ya

que como vimos, existen distintos tipos.
Ilustracin 20 Eleccin placa Arduino UNO
Ahora le decimos en que puerto serie la tenemos conectada. Como trabajamos

con USB, Windows simula un puerto seria virtual, el cual suele ser el COM3.
Ilustracin 21 Eleccin puerto serie
Por ltimo, cargamos el sketch presionando el botn Cargar: .

Si todo ha ido bien, podremos ver en el rea de mensajes Done uploading y como el
LED incorporado en la placa comienza a parpadear (color naranja).
Ya tenemos nuestra placa lista para jugar con ella e ir cargando los diferentes
programas que a continuacin vamos a exponer como ejercicios de prcticas.
25
3 CAPTULO 3. ARDUINO DESDE CERO. PRCTICAS
3.1 Prcticas con Arduino
3.1.1 Prctica 1. Control secuencial de un LED
Material necesario: Arduino UNO, 1 resistencia de 220 Ohmios y 1 LED.
Circuito:
Ilustracin 22 Esquemtico Prctica 1
Nota: La pata ms larga del LED va conectada a la resistencia (parte positiva).
26
Programa:
void setup(){
pinMode(2, OUTPUT); //Pin 2 en modo salida
}
void loop(){
digitalWrite(2, HIGH); //Pin 2 en alta (5V)Encendido
delay(2000); //Esperamos 2 segundos con el LED encendido
digitalWrite(2, LOW); //Pin 2 en baja (0V)Apagado
delay(2000); //Esperamos 2 segundos con el LED apagado
}
Con este sencillo programa, controlamos el tiempo de encendido y apagado de

un LED durante los ciclos de tiempo que le asignemos. Esta prctica es extensible al
control de hasta 14 LEDs creando secuencias de encendido y apagado independientes.
Edad recomendada: 3ESO
27
Prctica 2. Encendido de un LED (con botn)
Material necesario: Arduino UNO, 2 resistencias de 220 Ohmios, 1 LED y 1 pulsador.
Circuito:
Programa:
int boton = 0;
void setup(){
pinMode(3, INPUT); //Pin 3 en modo entrada
}
void loop(){
boton = digitalRead(3); //Leemos el estado del pulsador
if(boton == HIGH){
digitalWrite(2, HIGH); //Si est en alta, enciende el LED
}
else{
digitalWrite(2, LOW); //Si est en baja, apaga el LED
}}
28
Con este programa somos capaces de controlar el encendido y apagado del LED
mediante un pulsador. Queda como ejercicio la incorporacin de otro LED que funcione
de forma opuesta al presionar el pulsador.
Prctica 3. Arduino nos avisa si pulsan un botn
Circuito:
Programa:
int boton = 0;
void setup(){
Serial.begin(9600); //Inicia el puerto serie para comunicarnos
}
void loop(){
Serial.println(boton); //Sacamos por el puerto serie el valor leido
if(boton == HIGH){
}
else{
}
} 29
En este sketch la placa nos avisa por consola si alguien ha pulsado el botn.
Podemos ver el cambio de los valores transmitidos abriendo en
Men/Herramientas/Monitor Serial. Mostramos una imagen de la consola:
Ilustracin 25 Consola IDE Arduino
En la siguiente prctica mejoraremos la comunicacin de Arduino hacia nosotros

mostrando mensajes ms entendibles.
30
Prctica 4. Arduino nos avisa en castellano si pulsan un botn
Circuito:
Programa:
int boton = 0;
int contador = 0;
void setup(){
Serial.begin(9600);} //Inicia el puerto serie para comunicarnos
void loop(){
if(boton == HIGH){
contador = contador + 1;
Serial.print("Alguien ha pulsado el botn unas ");
Serial.print(contador);
Serial.println("veces"); //Muestra por consola
}
else{
}}
31
Ahora ya parece que vamos entendiendo a Arduino y l a nosotros. Hemos

introducido un contador que vamos incrementando conforme encendemos el LED
mediante el botn y Arduino es capaz de mostrarnos el nmero de veces que ha sido
pulsado gracias a la funcin Serial.print
32
Prctica 5. Arduino llamando a Arduino
Material necesario: 2 placas Arduino UNO, 3 LEDs, 4 resistencias de 220 Ohmios y 1

pulsador.
Circuito:
Programas:
int boton = 0; //Arduino Maestro

int contador = 0;
void setup(){
}
void loop(){
if(boton == HIGH){
contador = contador + 1;
Serial.print(contador);
}
else{
}
}
33
int antes = 0; //Arduino Esclavo

int ahora = 0;
void setup(){
pinMode(7, OUTPUT); //Pin 7 en modo entrada
}
void loop(){
if(Serial.available() > 0){ //Miramos si hemos recibido algo
ahora = Serial.read();
if(ahora > antes){ //Si el nmero recibido es mayor al que
antes = ahora; //tenamos, encendemos los LEDs
digitalWrite(6, HIGH);
delay(500);
digitalWrite(6, LOW);
digitalWrite(7, HIGH);
delay(500);
digitalWrite(7, LOW);
}
}
}
Esta prctica parece que se complica pero vamos a ver que realmente no es para
tanto. Queremos que Arduino 1 le diga a Arduino 2 lo que sucede con una de sus
entradas y ste reaccione encendiendo dos LEDs. El primer programa es casi idntico al
de la prctica anterior y con l slo pretendemos enviar a Arduino 2 el nmero de veces
que ha sido pulsado el botn y ste encienda dos LEDs si el nmero enviado es mayor
al anterior recibido.
34
Prctica 6. Monitorizacin con Arduino de entradas analgicas
Material necesario: Arduino UNO y 1 potencimetro.
Circuito:
Programa:
int valor_potenciometro = 0;
void setup(){
Serial.begin(9600);
}
void loop(){
valor = analogRead(0);
Serial.println(valor_potenciometro); //Leemos el valor del
//potencimetro
delay(500); //Damos tiempo a la comunicacin
}
Arduino nos informa de la diferencia de potencial en cada momento entre las

patillas de un potencimetro conectado al pin analgico 5. A pesar de su sencillez, nos
ayudar a desarrollar programas ms complejos. Como vimos en las especificaciones de
la placa, Arduino UNO trabaja en el rango de 0 a 1023 (8bits), por lo que los valores
que obtengamos estarn dentro de dicho rango.
35
Prctica 7. Entradas y salidas analgicas
Material necesario: Arduino UNO, 1 potencimetro, 1 LED y 1 resistencia de 220

Ohmios.
Circuito:
Programa:
int valor_potenciometro = 0;
void setup(){
Serial.begin(9600);
}
void loop(){
valor = analogRead(5); //Leemos el valor del potencimetro
Serial.println(valor_potenciometro); //Sacamos el valor del
//potencimetro
valor_potenciometro = map(valor_potenciometro, 0, 1023, 0, 255);
analogWrite(3, valor_potenciometro);
}
Apoyndonos en la prctica anterior, realizamos la que nos ocupa. Parece que ya

vamos viendo la parte prctica de este invento. Esta prctica simula el encendido de una
bombilla mediante un regulador. Como vemos, mediante el potencimetro, vamos
dando o quitando luminosidad al LED. Usamos uno de los pines para seales PWM
para, una vez ledo el valor del potencimetro y su posterior interpolacin, encender el
LED con cierta intensidad (valores de 0 a 255).

36
Prctica 8. Fotorresistencia (LDR)
Material necesario: Arduino UNO, 1 LDR, 1 LED y 2 resistencias (220 y 10k

Ohmios)
Circuito:
37
Programa:
int LDR = 0; // Asignamos el pin 0 a la fotorresistencia

int LED = 6; // Pin 6 para el control del LED
int lectura_LDR; // Donde iremos guardando los valores de la
fotorresistencia
int LDR_mapeado; // Valores interpolados para ir encendiendo el LED
void setup() {
Serial.begin(9600);
pinMode(LED,OUTPUT);
// Aunque no es necesario declarar los pines ANALOGOS como INPUTS, lo
haremos
pinMode(LDR,INPUT);
}
void loop(){
lectura_LDR = analogRead(LDR); // leemos el valor del LDR
LDR_mapeado = constrain(lectura_LDR,0,255);// Interpolamos al rango [0-255]
analogWrite(LED,LDR_mapeado); // Le pasamos al LED el valor mapeado
Serial.print("LDR mapeado = ");// Sacamos por consola el valor que se ha
asignado al LED
Serial.println(LDR_mapeado);
}
Una resistencia LDR es quiz el sensor ms barato que podemos encontrar en el

mercado. Acta como un potencimetro, pero en vez de cambiar su valor nosotros, lo
hace en funcin de la luz que recibe. Esos cambios de voltaje los podemos leer con
Arduino y especificar distintas acciones para cada rango.
En esta prctica hemos comprobado lo fcil que es controlar una fuente
luminosa (LED en este caso) en funcin de la sensibilidad de la LDR. Con este
programa podemos fabricar barreras de luz como las que se utilizan en cualquier
aparcamiento o dispositivos de deteccin de objetos.
Edad recomendada: Bachillerato
38
Prctica 9. Servomotor
Material necesario: Arduino UNO, 1 potencimetro y 1 servomotor
Circuito:
Programa:
#include <Servo.h> // Cargamos la librera servo para poder manejar

// nuestro servo
Servo miServo; // Creamos un objeto servo
int potenciometro = 0; //Asignamos el pin 0 al potencimetro
int valor; //Variable donde guardaremos los datos del potencimetro
void setup() {
miServo.attach(9); //Asignamos el pin 9 a nuestro servo
}
void loop() {
valor = analogRead(potenciometro); //Obtenemos el valor
//marcado por el potencimetro
valor = map(valor, 0, 1023, 0, 179);// Interpolamos a [0-179]
miServo.write(valor); //Le decimos al servo la posicin que debe tomar
delay(15); // Pausamos 15 milisegundos para refrescar el servo
}
Un servomotor es un motor de corriente continua dentro de una carcasa que

dispone de cierta lgica de control, la que nos permite decirle la posicin en la que
39
queremos que se site (normalmente el rango de posicin es de 0 a 180, aunque existen

servomotores de giro completo) y la velocidad de giro. Adems de la lgica de control,
dentro de la carcasa hay tambin una caja reductora que nos brinda mayor fuerza y
menor velocidad que un motor normal de continua. Dispone de tres cables para su
conexionado, alimentacin (rojo), conexin a tierra (negro) y control (blanco).
Esta prctica nos introduce en el control de servos, nos presenta algunas
funciones de la librera servo y deja entrever las numerosas utilidades que nos ofrecen
los servomotores.
40
Prctica 10. El girasol. LDR y Servomotor
Material necesario: Arduino UNO, 2 LDRs, 1 servomotor y 2 resistencias de 220

Ohmios.
Circuito:
El objetivo de esta prctica es el de orientar un servomotor hacia el lugar con

mayor luminosidad dado por las dos fotorresistencias. Esta pequea aplicacin, con
pequeas variantes, es muy utilizada en domtica y gestin de placas solares.
41
Programa:
#include <Servo.h> //Cargamos la librera servo

int valorLDR_derecha = 0; //Variables donde guardaremos valores
int valorLDR_izquierda = 0; //obtenidos por las fotorresistencias
int valor_Servo = 0; //Aqu guardaremos la posicin del servo
Servo miServo; //Creamos nuestro servo

void setup(){
Serial.begin(9600);
miServo.attach(10); //Lo ponemos en el pin 10 (los servos se
//controlan con seales PWM)
}
void loop(){
valorLDR_izquierda = analogRead(1); //Leemos el valor de la LDR
Serial.print("Sensor Izquierdo: "); //de la izquierda y lo
Serial.print(valorLDR_izquierda); //sacamos por pantalla
Serial.print(" ");
valorLDR_derecha = analogRead(0); //Igual para el de la derecha
Serial.print("Sensor Derecho: ");
Serial.print(valorLDR_derecha);
Serial.print(" ");
//Queremos que el servo se oriente hacia el "sensor" donde haya
//ms luz. El servo comienza orientado 0 (hacia la derecha)
//Si hay ms luz en el sensor derecho, se queda como estaba
if(valorLDR_izquierda < valorLDR_derecha){
valor_Servo = valor_Servo -10;
if (valor_Servo < 0){ //El servo no admite valores negativos
valor_Servo = 0; //as que los pasamos como 0
}
}
//Si hay ms luz en el sensor izquierdo, cambiamos la posicin
//a 179
else{
valor_Servo = valor_Servo +10;
if(valor_Servo > 179){ //Limitamos el valor del servo a 179
valor_Servo = 179; //ya que su rango es de 0 a 180
}
}
miServo.write(valor_Servo); //Escribimos en el servo el valor
//para que este se posicione
}
42
Prctica 11. Motor de continua controlado con chip LD293
Material necesario: Arduino UNO, 1 pulsador, 1 chip LD293, 1 resistencia de 2,2 kilo
Ohmios, 1 LED y 1 motor DC.
Circuito:
El chip LD293 es un driver diseado para proporcionar corriente a mecanismos

impulsores bidireccionales de hasta 1 Amperio con voltajes entre 4,5 y 36 Voltios con
una capacidad mxima de disipacin de potencia de 5 Wattios. Su principal
caractersticas es la alimentacin propia independiente de la alimentacin de los canales,
lo que da estabilidad al circuito en el que se monte.
43
Ilustracin 34 Esquema Chip L293D
Con este chip podemos conectar dos motores DC, uno en cada parte del chip.
En esta prctica controlaremos con la ayuda del chip presentado anteriormente el
sentido de giro del motor con la ayuda de un pulsador.
Programa:
int botonPin = 2; // Ponemos el botn al pin 2

int motorPin1 = 3; // Pata 1 del motor al pin 3
int motorPin2 = 4; // Pata 2 del motor al pin 4
int speedPin = 9; // Canal de habilitacin del chip al pin 9
void setup() {
pinMode(botonPin, INPUT);
pinMode(motorPin1 , OUTPUT);
pinMode(speedPin, OUTPUT);
digitalWrite(speedPin, HIGH); // Motor encendido desde el comienzo
}
void loop() {
if (digitalRead(botonPin) == HIGH) {
// Si pulsamos el botn, el motor cambia el sentido de giro
// mientras tengamos pulsado el botn
digitalWrite(motorPin1, LOW);
digitalWrite(motorPin2, HIGH);
}
else {
digitalWrite(motorPin2, LOW);}}
44
Prctica 12. Control de velocidad y giro de motor de continua
Material necesario: Arduino UNO, 1 chip LD293, 1 motor DC y 2 potencimetros.
Circuito:
En este sketch hemos incorporado dos mtodos auxiliares con sus respectivas
variables locales para apoyarnos en el control del sentido de giro. Destacamos tambin
la declaracin e inicializacin de los pines del motor en forma de array.
45
Programa:
int valorPot1; // Leemos el valor del potencimetro 1

int valorPot2; // Leemos el valor del potencimetro 2
int valor_interpolado; // Necesitamos interpolar el valor del
//segundo potencimetro, encargado de dar la velocidad
int motor[ ] = {9, 10}; // Array de asignacin de pines al motor
int Potenciometro1 = 0;
int Potenciometro2 = 1;
void setup() { Serial.begin(9600);
pinMode(Potenciometro1, INPUT);
pinMode(Potenciometro2, INPUT);
// Variable de apoyo para poner los pines del motor como salidas
int i; for(i = 0; i < 2; i++){
pinMode(motor[i], OUTPUT);}}
void loop() {
valorPot1 = analogRead(Potenciometro1);
valorPot2 = analogRead(Potenciometro2); // interpolamos el valor del segundo
//potencimetro al rango admitido por el motor (0-255)
valor_interpolado = map(valorPot2,0,1023,0,255);
// Para valores inferiores a la mitad (512) del primer
//potencimetro, el motor gira en sentido antihorario
if(valorPot1 <= 512){
Serial.print("Gira a Izquierdas");
// LLamamos al mtodo de Retroceso del motor y le pasamos como
//argumento el valor interpolado del segundo potencimetro
motorRetro(valor_interpolado);}
// Para valores superiores a la mitad (512) del primer potencimetro, el
//motor gira en sentido horario
if(valorPot1 > 512){ Serial.print("Gira Derechas");
// LLamamos al mtodo de Avance del motor y le pasamos como
//argumento el valor interpolado del segundo potencimetro
motorAvance(valor_interpolado);}
Serial.print("/t"); Serial.print("Revoluciones Por Minuto: ");
Serial.println(valor_interpolado);
delay(50);}
// Mtodo Avance.Una pata a cero y la otra con el valor interpolado del
//segundo potencimetro
void motorAvance(int Revoluciones1){ analogWrite(motor[0], Revoluciones1);
analogWrite(motor[1], 0);}
// Mtodo Retroceso. Ahora ponemos la pata que estaba a cero
// con el valor interpolado(cambiamos el sentido de giro) y la otra a cero.
void motorRetro(int Revoluciones2){ analogWrite(motor[0], 0);
analogWrite(motor[1], Revoluciones2);}
46
Prctica 13. Semforo simple
Material necesario: Arduino UNO, 3 LEDs (rojo, verde y amarillo), 3 resistencias de

220 Ohmios, 1 pulsador y 1 resistencia de 2,2 kilo Ohmios.
Circuito:
En esta prctica entramos en el mundo del control semafrico. Este programa

controla manualmente el funcionamiento de un semforo. Mientras tengamos pulsado el
botn, el semforo ir cambiando su estado y quedar fijo si lo soltamos. Con la funcin
delay marcamos el tiempo de encendido de cada LED, algo que como veremos en
posteriores ejercicios, nos facilitar la sincronizacin cuando introduzcamos ms
semforos.
47
Programa:
int PinRojo = 2;
int PinAmarillo = 3;
int PinVerde = 4;
int boton = 5;
int estado_actual = 0; //Estado en el que se encuentra el semforo
void setup(){
pinMode(PinRojo, OUTPUT);
pinMode(PinAmarillo, OUTPUT);
pinMode(PinVerde, OUTPUT);
pinMode(boton, INPUT);
}
void loop()
{
if (digitalRead(boton))
{
if (estado_actual == 0)//Si est en reposo
{
Luces(HIGH, LOW, LOW);//Ponemos el semforo en rojo
estado_actual = 1;
}
else if (estado_actual == 1)
{
Luces(HIGH, HIGH, LOW);
estado_actual = 2;//Ponemos el semforo en rojo y amarillo
}
{
Luces(LOW, LOW, HIGH);//Ponemos el semforo en verde
estado_actual = 3;
}
{
Luces(LOW, HIGH, LOW);//Ponemos el semforo en amarillo
estado_actual = 0;
}
delay(1000); //Esperamos 1 segundo
}}
void Luces(int Rojo, int Amarillo, int Verde)
{
digitalWrite(PinRojo, Rojo);
digitalWrite(PinAmarillo, Amarillo);
digitalWrite(PinVerde, Verde);}
48
Prctica 14. Semforo controlado por Rotary Encoder
Material necesario: Arduino UNO, 3 LEDs (rojo, verde y amarillo), 3 resistencias de

220 Ohmios y 3 resistencias de 100 kilo Ohmios.
Circuito:
Un rotary encoder no es ms que un potencimetro electromecnico que

convierte la posicin angular del potencimetro en un valor digital o en un pulso.
Vulgarmente lo podramos definir como un potencimetro sin fin con el cual obtenemos
mayor precisin. Aprovecharemos cada posicin para ir cambiando los tiempos de
encendido de cada LED, lo que nos aproxima al modelo real de funcionamiento de un
semforo. Nosotros utilizaremos uno de tres patillas como el que se muestra en la
figura:
Ilustracin 38 Rotary Encoder
49
Programa:
int PinRojo = 2;
int PinAmarillo = 3;
int PinVerde = 4;
int PinEncoderA = 6;
int PinEncoderB = 7;
int boton = 5;
int estado_actual = 0;
int PeriodoLargo = 5000; // Tiempo en verde o en rojo
int PeriodoCorto = 700; // Tiempo en amarillo
int CuentaUsada = PeriodoCorto;
int cuenta = 0;
void setup()
{
pinMode(PinEncoderA, INPUT);
pinMode(PinEncoderB, INPUT);
pinMode(boton, INPUT);
pinMode(PinRojo, OUTPUT);
pinMode(PinAmarillo, OUTPUT);
pinMode(PinVerde, OUTPUT);
}
void loop()
{
cuenta++;
if (digitalRead(boton))
{
Luces(HIGH, HIGH, HIGH);
}
else
{
int cambio = getEncoderTurn();
int nuevoPeriodo = PeriodoLargo + (cambio * 1000);
if (nuevoPeriodo >= 1000 && nuevoPeriodo <= 10000)
{
PeriodoLargo = nuevoPeriodo;
}
if (cuenta > CuentaUsada)
{
setEstado();
cuenta = 0;
}}
delay(1);}
50
int getEncoderTurn(){ // Devolver -1, 0, o +1

static int oldA = LOW;
static int oldB = LOW;
int result = 0;
int newA = digitalRead(PinEncoderA);
int newB = digitalRead(PinEncoderB);
if (newA != oldA || newB != oldB){ // Si hay algn cambio
if (oldA == LOW && newA == HIGH)
{
result = -(oldB * 2 - 1);
}}
oldA = newA;
oldB = newB;
return result;
}
int setEstado()
{
if (estado_actual == 0)
{
Luces(HIGH, LOW, LOW);
CuentaUsada = PeriodoLargo;
estado_actual = 1;
}
{
Luces(HIGH, HIGH, LOW);
CuentaUsada = PeriodoCorto;
estado_actual = 2;
}
{
Luces(LOW, LOW, HIGH);
CuentaUsada = PeriodoLargo;
estado_actual = 3;}
{
Luces(LOW, HIGH, LOW);
CuentaUsada = PeriodoCorto;
estado_actual = 0;
}}
void Luces(int Rojo, int Amarillo, int Verde){
digitalWrite(PinRojo, Rojo);
digitalWrite(PinAmarillo, Amarillo);
digitalWrite(PinVerde, Verde);}
51
4 CAPTULO 4. ARDUINO Y LABVIEW
4.1 Instalacin de Libreras
A continuacin vamos a explicar como instalar la librera LIFA que nos permitir
programar nuestra tarjeta Arduino.
Una vez instalado LabView, veamos los pasos que tenemos que seguir para
completar la instalacin de dicha librera:
1. Instalar los controladores VISA de National Instruments para nuestro sistema

operativo. http://joule.ni.com/nidu/cds/view/p/id/2251/lang/es
2. Descargar e instalar el LabRunTime de NI con Engine Z011 para nuestra versin
de LabView 10.
3. Seguidamente instalamos el paquete JKI VI (VIPM) gratuito.
http://www.jki.net/vipm
4. Instalamos la interfaz de LabView para Arduino como explica el siguiente
enlace:
http://digital.ni.com/public.nsf/allkb/A20FBBD36820669086257886004D5F4D
?OpenDocument
5. Conectamos la placa Arduino al PC como se describe a continuacin:
http://digital.ni.com/public.nsf/allkb/0F9DADF9055B086D86257841005D1773
?OpenDocument
6. Cargamos la interfaz de LabView para Arduino.
http://digital.ni.com/public.nsf/allkb/8C07747189606D148625789C005C2DD6?
OpenDocument
7. Ya podemos usar el IDE Arduino para implementar el software en la placa.
Una vez tenemos instalada la librera, debemos comunicar LabView con el IDE
Arduino. Tenemos que cargar el siguiente fichero (\National Instruments\LabVIEW
2010\vi.lib\LabVIEW Interface for Arduino\Firmware\LVIFA_Base) en la misma carpeta
donde tengamos el IDE Arduino. Ejecutamos Arduino y procedemos de la siguiente
manera:
52
1. Abrimos el IDE Arduino y abrimos desde men el fichero LVIFA_Base.pde
Ilustracin 39 Intalacin LIFA
2. Cargamos el fichero y seleccionamos nuestra tarjeta (Arduino UNO).
Ilustracin 40 Seleccin tarjeta Arduino UNO para LIFA
3. Seleccionamos el puerto COM.
Ilustracin 41 Seleccin puerto serie para LIFA
53
4. Cargamos el sketch para que el programa se cargue en la tarjeta y haga que est
preparada para comunicarse con LabView.
Ilustracin 42 Carga sketch LIFA
Una vez realizados todos los pasos anteriormente descritos, ya estamos en

disposicin de abrir LabView y realizar cualquier proyecto que queramos
implementar en nuestra placa Arduino UNO.
54
4.2 Prcticas con LabView
Prctica 1. Control secuencial de un LED
Al igual que vimos en el captulo anterior, queremos controlar el encendido y

apagado de un LED, pero esta vez lo controlaremos con LabView. Necesitaremos el
mismo material y el montaje elctrico ser el mismo.
Ilustracin 43 Esquemtico Prctica 1 LabView
Al ser esta la primera prctica, nos detendremos en la configuracin de Arduino

que ser la misma para cada proyecto. En nuestro proyecto en blanco, aadimos el
bloque init con la siguiente configuracin:
Puerto de comunicacin Nuestro caso el 14
Velocidad de transmisin 115200 bps
Tipo de tarjeta Arduino Arduino UNO
Nmero de bits de paquetes de comunicacin 15
Tipo de puerto de comunicacin USB/Serial
Ilustracin 44 Bloque Init
55
Tras la creacin del init, introducimos la estructura while loop que ser la
encargada de realizar las mismas funciones que la funcin void loop mencionada en
la estructura de Arduino. Esta estructura se ejecutar hasta que cerremos el puerto de
conexin. Es en esta estructura donde se introducirn todos los mdulos de control de la
tarjeta.
NOTA: Los pines 0 y 1 los utiliza LabView para comunicarse con la tarjeta
Arduino.
Una vez tenemos configurado nuestro while-loop, veamos que bloques
tenemos que aadir y que pin usaremos como salida. Para el ejercicio que nos ocupa
conectaremos con la placa mediante el pin 8 mediante la funcin de escritura Digital
Write Pin, quedando el diagrama de bloques en LabView de la siguiente forma:
Ilustracin 45 Diagrama de bloques Prctica 1
La secuencia de ejecucin es:

1. Inicializamos y configuramos la conexin con Arduino con la velocidad por
defecto de 115200 bps.
2. Configuramos el pin 8 como salida (OUTPUT)
3. Escribimos en el pin 8 la seal del reloj
4. Cerramos conexin con Arduino
5. Control de errores
56
Veamos a continuacin el panel que hace de interfaz entre Arduino, LabView y

nosotros:
Ilustracin 46 Panel Prctica 1
Para controlar el tiempo de encendido y apagado del LED es necesario la

implementacin de un reloj. sta se lleva a cabo en el propio while loop: aadimos un
shift register con lo que conseguiremos que se ejecute cada cierto tiempo marcado por
el usuario . Colocamos una puerta AND para poder habilitar mediante

un interruptor (salida del pin 8) el trnsito de la seal de control del reloj al bloque
Digital Write Pin. Tambin introducimos dos LEDs informativos, uno que informa si
est habilitada la seal de reloj y otro para comprobar que se ha mandado la orden de
escritura al pin 8.
57
Prctica 2. Control de un semforo simple
En esta prctica simularemos el funcionamiento de un semforo de la forma ms

sencilla posible, asignando nosotros un tiempo fijo para cada estado (rojo, mbar y
verde). El panel es bastante sencillo, mostrando los tres LEDs y un botn de parada:
El montaje elctrico visto con Fritzing es el siguiente:
La asigancin de pines y tiempo a cada LED es la siguiente:

Rojo Pin 8 Tiempo Activo 1000ms=1segundo
Verde Pin 10 Tiempo Activo 1000ms=1segundo
Amarillo Pin 9 Tiempo Activo 700ms=0.7segundos
58
El proceso de ejecucin es el siguiente:

1. Inicializamos y configuramos la conexin con Arduino mediante el init
2. Configuramos los pines 8,9 y 10 como salidas mediante el bloque Set Digital
Pin Mode de la librera Arduino
3. Generamos las tres seales (rojo, verde y mbar)
4. Asignamos cada estado a cada caso de la estructura Case Structure
5. Escribimos el valor de cada seal (rojo, verde y mbar) en sus pines
correspondientes. Las salidas del secuencializador deben ser TRUE/FALSE para
que se puedan escribir en el Digital Write Pin
6. Cerramos el puerto mediante el bloque Close
7. Tratamos los errores con Simple Error
El diagrama de bloques queda de la siguiente manera:
Comentamos a continuacin cada uno de los tres casos creados para cada estado:
Estado Rojo: La secuencia ser Rojo TRUE, mbar FALSE y verde FALSE con
tiempo 1000ms. El estado siguiente debe ser verde.
Ilustracin 50 Estado rojo
59
Estado mbar: La secuencia ser Rojo FALSE, mbar TRUE y verde FALSE con
tiempo 700 ms. El estado siguiente debe ser rojo.
Ilustracin 51 Estado mbar
Estado verde: La secuencia ser Rojo FALSE, mbar TRUE y verde FALSE con
tiempo 700 ms. El estado siguiente debe ser mbar.
Ilustracin 52 Estado Verde
60
Prctica 3. Control de un semforo ajustable
En esta prctica vamos a mejorar el control semafrico introduciendo en ella la

posibilidad de ajustar mediante el panel el tiempo de cada estado (rojo, verde y
amarillo). El panel queda:
Tenemos de nuevo tres LEDs y un botn de parada; aadimos tres objetos de entrada de
valor para ajustar los tiempos de cada estado.
El montaje elctrico es el mismo que hemos visto en la prctica 2, por lo que omitimos
su figura y explicacin.
El diagrama de bloques general es el siguiente:
El aadido de lectura del valor de tiempo para cada estado se realiza dentro de
cada estructura Case, como podemos observar en la siguiente figura:
Ilustracin 55 Estructura Case Prctica 3
61
Prctica 4. Control de dos servos
En esta prctica explicaremos como controlar la velocidad y sentido de giro de

dos servomotores as como el ngulo girado.
El panel de control queda como se indica a continuacin:
Podemos seleccionar si queremos controlar uno o dos servos, la velocidad y el

ngulo de desplazamiento.
En esta prctica introduciremos cuatro nuevos tipos de bloques de la librera Arduino:
1. Set Numbers of Servos Indicamos cuantos servos vamos a manejar.
Mediante Create Control en el men del nuevo bloque le indicamos que
genere un nmero de tipo entero (dos en nuestro caso)
Ilustracin 57 Bloque Set Number of Servos
62
2. Configure Servo Con este bloque nombramos al servo y le asignamos un

pin para su control. En nuestro caso necesitaremos dos bloques
Ilustracin 58 Bloque Configure Servo
3. Servo Write Angle Simplemente escribimos en el servo el ngulo que ha de

girar en grados
Ilustracin 59 Bloque Servo Write Angle
4. Servo Read Angle Nos indica la posicin del servo y la sacamos con un
instrumento analgico (Servo 1 en nuestro caso)
Ilustracin 60 Bloque Servo Read Angle
63
El diagrama de bloques:
El proceso de ejecucin es el siguiente:

2. Establecemos el nmero de servos a manejar mediante Set Number of Servos
3. Configuramos los dos servos asignando pines digitales para su control (pin 10 y
pin 11)
4. Escribimos un ngulo de 0 basado en la repeticin del bucle. Servo 0 nos barre
desde los 0 grados hasta el ngulo que le asignemos y la repeticin. Este ngulo
tambin se lee desde el servo y se muestra en el panel
5. Ajustamos a mano el servo 2
6. Cerramos la conexin con Arduino
El montaje elctrico:
64
Prctica 5. Control de velocidad y sentido de giro de motor de continua
Con esta prctica vamos a controlar la velocidad y el sentido de giro de un motor

de corriente continua, ayudados por el integrado L293D que ya comentamos en la
prctica 11 de Arduino. Las conexiones entre tarjeta, motor e integrado son las mismas
que en la prctica anteriormente referenciada, por lo que nos centraremos en el
diagrama de bloques de LabView.
El panel lo simplificamos a un nico mando y un botn de parada:
Veamos primero el diagrama de bloques y comentemos despus el proceso de

ejecucin.
65
Proceso de ejecucin:
2. Configuramos el pin 8 como salida para sentido DERECHA y el pin 9 para
sentido IZQUIERDA
3. Dentro del bucle colocamos una Case Structure encargada de controlar el
motor que ejecutaremos en intervalos de 200 ms. Tendremos dos casos, TRUE y
FALSE. Si es TRUE el giro es hacia la izquierda, por lo que sacaremos los
valores correspondientes a los pines 7 y 8 de Arduino y la velocidad quedar
marcada por el valor del panel. Si es FALSE, girar a derechas e invertiremos
los valores de los pines de salida 7 y 8. Veamos con una tabla los valores para
cada caso:
GIRO PIN ARDUINO VALOR PIN L293D PIN L293D

INPUT 0 INPUT 0
Derechas Pin 7 1 1 0
Pin 8 0
Tabla 4. Valores Pines Motor L293D caso FALSE
Ilustracin 65 Case giro motor a derechas
GIRO PIN ARDUINO VALOR PIN L293D PIN L293D

INPUT 0 INPUT 0
Izquierdas Pin 7 0 0 1
Pin 8 1
Tabla 5. Valores Pines Motor L293D caso TRUE
66
Ilustracin 66 Case giro motor a izquierdas
4. Colocamos los indicadores de giro para saber por pantalla hacia donde gira el
motor.
5. Detenemos el motor enviando un cero al pin 11 (salida PWM) y cerramos la
conexin con Arduino
El cambio en la Case Structure se lleva a cabo mediante un operador del tipo Greater
or Equal To 0
Ilustracin 67 Operador Greater or Equal to 0
Si recordamos, la velocidad de estos motores se escala desde -255 a 255, que es el valor
mximo admitido por un pin PWM, por lo que interpolamos nuestra escala de -100 a
100 y multiplicamos por 2.5.
67
5 CAPTULO 5. ROBOT POLOLU 3
5.1 Introduccin
Ilustracin 68 Robot Pololu 3pi
El robot Pololu 3 debe su nombre a su tamao, ya que su dimetro es en

centmetros el nmero pi multiplicado por tres. Se trata de un robot autnomo con
motores duales, cinco sensores QTR de reflectancia, una pantalla LCD, un zumbador,
cinco botones de control y se alimenta con 4 pilas AAA. El cerebro de este robot es un
microcontrolador ATMega328 programable. El que disponga de este microcontrolador
es una de las principales causas por la que elegimos este robot, ya que es totalmente
compatible con Arduino.
68
Es un gran robot para principiantes, como es nuestro caso, y con un grandsimo

abanico de opciones conforme vayamos descubrindolo. Est diseado principalmente
como un seguidor de lnea, otro motivo para nuestra eleccin, y resolucin de
laberintos.
Para su programacin necesitamos un programador AVR ISP externo como el
USB AVR Programmer.
Para ms informacin, se puede consultar el Anexo II Pololu 3pi Robot Users
Guide.
5.2 Programar nuestro 3
El robot trae precargado un programa de demostracin; pero nosotros hemos

adquirido dos robots de este tipo para que simulen dos vehculos en una maqueta. Para
ello, debemos programarlos como seguidores de lnea.
Tambin hemos adquiri un programador AVR ISP con el que pasaremos
nuestro cdigo al robot.
Necesitamos cierto software para llevar acabo nuestra tarea de programar como
seguidor de lnea nuestro Pololu 3pi:
WinAVR, entorno de desarrollo para los microcontroladores de la familia AVR

AVR Studio, paquete de desarrollo integrado de la casa Atmel con IDE que trabaja
sin problemas con el compilador WinAVRs. AVR Studio incluye el software AVR
ISP que nos permite cargar nuestros programas en el robot 3pi.
Navegando por la red hemos encontrado un archivo ejecutable que dispone de todo
lo necesario para programar nuestro Pololu 3pi. El archivo pesa 164 megas y se adjunta
en el DVD de la memoria.
69
Ilustracin 69 Instalacin Pololu AVR
Iniciamos el ejecutable y seleccionamos las aplicaciones y libreras que queramos

instalar:
Ilustracin 70 Autoejecutable AVR
Las instalamos todas, aunque podramos prescindir de Orangutan SVP Drivers.

Una vez instaladas, ya estamos listos para comenzar a programar el robot.
70
Abrimos el programa AVR Studio (nuestra versin es la 4):
Ilustracin 71 AVR Studio v4
Como hemos instalado las libreras de Pololu AVR C/C++, disponemos de

numerosos ejemplos que podemos cargar en nuestro robot. Queremos que nuestro 3pi
acte como seguidor de lnea, por lo que le vamos a cargar el programa ejemplo line-
follower que se encuentra en C:\Libpololu-avr\Examples\ATMega328P\3pi-
linefollower.
Una vez abierto, debemos seleccionar nuestro programador:
Ilustracin 72 Seleccin Programador AVR-ISP
71
Conectamos el programador con el robot mediante el cable USB y procedemos a

la carga del programa ejemplo.
Ilustracin 73 Programador AVRISP
Con la carga de este programa, ya disponemos de un robot sigue-lneas que nos

har las veces de automvil en nuestra maqueta final, aunque como se explicar en el
siguiente captulo, tendremos que modificar y adaptar el cdigo para satisfacer nuestras
necesidades.
Se adjuntan el Anexo IV Pololu USB AVR Programmer y el Anexo V AVR

Programming Quick Start.
Aclaracin: Este robot puede ser programado tambin mediante Arduino. Debido a una
incompatibilidad del programador con la versin actual de Arduino (error de
comunicacin con el puerto serie virtual) tuvimos que buscar una solucin que fue la
expuesta anteriormente.
72
6 CAPTULO 6. MAQUETA
6.1 Introduccin
El objetivo de crear esta maqueta es divulgar en alumnos de Secundaria,

Bachillerato, Mdulos Profesionales y universitarios las posibilidades que Arduino nos
brinda. Hemos visto mediante 14 prcticas lo fcil e intuitivo que es trabajar con esta
plataforma y queremos poner en prctica los conocimientos adquiridos. Para ello nos
apoyaremos en los distintos programas explicados para ensamblarlos todos en un
programa final que sea capaz de controlar nuestra maqueta.
Nuestra maqueta pretende simular el paso por un puente levadizo con su
correspondiente control semafrico. Consta de 4 barreras con sus correspondientes
semforos, el puente levadizo y dos robots Pololu 3pi que harn de vehculos. Todo ello
integrado en un tablero para su posible transporte y exposicin.
Ilustracin 74 Maqueta
73
6.2 Componentes principales
Puente levadizo
En la siguiente figura podemos observar el puente levadizo adquirido en Opitec.
Ilustracin 75 Puente Levadizo
Obviamente no viene montado, lo que lo hace ms divertido.
Ilustracin 76 Paquete de Puente Levadizo
Este puente consta de un motor de continua que eleva y desciende el puente.

Gracias a un interruptor, controlamos su subida o bajada y dos finales de carrera hacen
que se pare en la posicin deseada. Va alimentado con dos pilas de 1,5 Voltios. Dispone
de un semforo a cada lado que estarn en rojo cuando el puente est en movimiento o
elevado y en verde cuando los robots puedan pasar por l.
74
El tiempo de construccin del mismo fue de 12 horas y a continuacin podemos

ver un detalle de la caja de engranajes reductores donde se aloja el motor y el puente
terminado:
Ilustracin 77 Caja Motor y Engranajes
Ilustracin 78 Pololu en maqueta bajo puente
Nota 1: Direccin Web:http://es.opitec.com/opitec-web/articleNumber/105456/kshp/p/2

Nota 2: Debido al tamao de nuestros robots, tuvimos que modificar el paso del puente,
ensanchndolo hasta obtener 12 centmetros.
Se adjunta tambin el Anexo VI Manual de montaje puente levadizo con todas
las instrucciones de montaje y conexiones elctricas.
75
Tablero
Conseguimos en recuperacin de la UPCT un tablero verde ideal para nuestra
maqueta que tuvimos que cortar para que fuera posible su posterior transporte. Sus
medidas finales son 100x180 centmetros. Pintamos de blanco la carretera por donde
pasarn nuestros robots para mejorar el rendimiento de los cinco sensores QTR a la hora
de seguir la lnea negra (cinta aislante).
Ilustracin 79 Tablero recin pintado
Cubrimos todos los huecos con csped artificial para mejorar el aspecto.
Ilustracin 80 Maqueta II
76
Rampas de acceso al puente

Estos dos elementos han sido con diferencia los que ms problemas nos han
ocasionado. Primero se opt por utilizar arcilla para crear una estructura y sobre ella
colocar eva pero la estructura se agriet y tuvimos que pensar otra solucin.
Ilustracin 81 Rampa Acceso Arcilla
Finalmente optamos por construir prticos escalados a una cierta distancia que
nos sirvieran como estructura y unirlos con varillas para ganar estabilidad.
Ilustracin 82 Prticos Rampas Acceso
77
Semforos
Los cuatro semforos estn construidos con piezas TechCard, de cartn
pretroqueladas, recortadas y premarcadas que son muy fciles de manejar. Vienen a ser
como las estructuras Meccano pero ms econmicas.
Ilustracin 83 TechCards
En tres de sus agujeros colocamos los tres leds (rojo, verde y amarillo) sacando
las conexiones de cada uno. De cada semforo saldrn cuatro conexiones, las tres
seales de control de cada led y la masa de todos.
Ilustracin 84 Semforos
78
En el Anexo VII TechCard se explica su uso y encontraremos diversas plantillas

de simpticos proyectos.
Barreras
Nuestras cuatro barreras estn modeladas por un servomotor al que le pegamos
una cartulina que ser la encargada de tapar la lnea y hacer que el robot pare hasta
que de nuevo le ensee la lnea.
Ilustracin 85 Barreras I
En las barreras de paso por debajo del puente, pondremos dos tiras blancas antes
de las barreras para evitar que el robot quede girado a la hora de llegar a la zona de
parada; ya que al estar en lnea recta, cuando ve la barrera, tenda a girar hacia el servo.
Ilustracin 86 Detalle Barrera
79
6.3 Programas Arduino

6.3.1 Semforos programados por tiempo
Tomando como base el cdigo de la prctica 13, simplemente aadimos una

pausa entre el cambio de encendido de luz para controlar el tiempo en el que queramos
que el semforo est en verde, en transicin (amarillo) o en rojo.
int pinVerde =7;

int pinAmarillo =8;
int pinRojo =12;
void setup()
{
pinMode(pinVerde, OUTPUT);
pinMode(pinAmarillo, OUTPUT);
pinMode(pinRojo, OUTPUT);
Serial.begin(9600);
}
void loop()
{
verd();
amar();
rojo();
}
void verd()
{
digitalWrite(pinVerde, HIGH);
delay(10000);
digitalWrite(pinVerde, LOW);
}
void amar()
{
digitalWrite(pinAmarillo, HIGH);
delay(1000);
digitalWrite(pinAmarillo, LOW);
}
void rojo()
{
digitalWrite(pinRojo, HIGH);
delay(10000);
digitalWrite(pinRojo, LOW);
}
Como podemos observar en el cdigo, damos 10 segundos de semforo en

verde, un segundo en amarillo para el cambio a rojo que durar otros 10 segundos.
80
El circuito montado fsicamente queda as:
Ilustracin 87 Montaje Prueba Semforo
Realizaremos un montaje en paralelo e invirtiendo verde y rojo para controlar

los cuatro semforos con tres pines para optimizar recursos e introducir menos
corrientes parsitas.
81
6.3.2 Motor programado por tiempo con cambio de sentido
De nuevo nos apoyamos en una prctica anterior; esta vez en la prctica 11, para
programar el motor de continua que elevar y descender el puente.
int botonPin = 2;
int motorPin1 = 3;
int motorPin2 = 4;
int speedPin = 9;
void setup() {
pinMode(botonPin, INPUT);
pinMode(speedPin, OUTPUT);
digitalWrite(speedPin, HIGH); // Motor on desde principio
}
void loop() {
delay(10000);
delay(15000);
delay(8000);
delay(12000);
}
Analizando muy por encima el cdigo, veremos cmo hemos programado un

ciclo completo de subida y bajada del puente que se repetir mientras la placa de
Arduino est conectada. En cuanto alimentemos el circuito, el puente se estar elevando
durante 10 segundos; una vez transcurridos se mantendr abierto durante 15 segundos;
comenzar a descender durante 8 segundos (hay que tener en cuenta que al motor le
cuesta menos bajar que subirlo) y permanecer cerrado 12 segundos para que se pueda
circular a travs suyo.
82
El montaje en la protoboard se muestra a continuacin:
Ilustracin 88 Montaje Motor Puente
83
6.3.3 Servomotores (barreras) programadas por tiempo
En este caso manejaremos dos a dos las barreras para que cuando unas se abran
para dejar paso, las opuestas se cierren. El mtodo de control es el mismo que en los
programas anteriores: abrimos unas y cerramos otras, esperamos 8 segundos, cerramos
y abrimos y volvemos a esperar otros 8 segundos. De nuevo este proceso se repetir
mientras el circuito est alimentado.
#include <Servo.h>
Servo miServoPuente;
Servo miServoPaso;
int valor;
void setup() {
miServoPuente.attach(6);
miServoPuente.write(0);
miServoPaso.attach(5);
miServoPaso.write(90);
}
void loop() {
delay(8000);
delay(8000);
}
84
6.3.4 Programa final
Si sincronizamos y juntamos los tres programas anteriores y asignamos

correctamente los pines a cada elemento, obtendremos el programa final que ser el
encargado del control de nuestra maqueta.
#include <Servo.h> //PUENTE ABIERTO

Servo miServoPuente; digitalWrite(motorPin1, LOW);
Servo miServoPaso; digitalWrite(motorPin2, LOW);
int motorPin1 = 3; miServoPuente.write(90);
int motorPin2 = 4; miServoPaso.write(0);
int speedPin = 9; digitalWrite(pinRojo, LOW);
int pinVerde =7; digitalWrite(pinAmarillo, LOW);
int pinAmarillo =8; digitalWrite(pinVerde, HIGH);
int pinRojo =12; delay(18000);
void setup() { //CERRANDO PUENTE
pinMode(motorPin1 , OUTPUT); digitalWrite(motorPin1, HIGH);
pinMode(motorPin2 , OUTPUT); digitalWrite(motorPin2, LOW);
pinMode(speedPin, OUTPUT); miServoPuente.write(0);
digitalWrite(speedPin, HIGH); miServoPaso.write(90);
pinMode(pinVerde, OUTPUT); //Rojo AL PASO X DEBAJO
pinMode(pinAmarillo, OUTPUT); digitalWrite(pinRojo, HIGH);
pinMode(pinRojo, OUTPUT); digitalWrite(pinVerde, LOW);
Serial.begin(9600); digitalWrite(pinAmarillo, HIGH);
miServoPuente.attach(6); delay(4500);
miServoPuente.write(0); //Puente Cerrado
miServoPaso.attach(5); digitalWrite(motorPin1, LOW);
miServoPaso.write(90); digitalWrite(motorPin2, LOW);
} miServoPuente.write(0);
void loop() { miServoPaso.write(90);
//ABRIENDO PUENTE digitalWrite(pinRojo, HIGH);
digitalWrite(motorPin1, LOW); digitalWrite(pinVerde, LOW);
digitalWrite(motorPin2, HIGH); digitalWrite(pinAmarillo, LOW);
miServoPuente.write(90); delay(18000);
miServoPaso.write(0); }
//Verde al paso X DEBAJO
digitalWrite(pinRojo, LOW);
digitalWrite(pinVerde, HIGH);
digitalWrite(pinAmarillo, HIGH);
delay(5000);
85
6.4 Programa Pololu 3pi como sigue-lnea
// Incluimos la librera pololu3pi

#include <pololu/3pi.h>
//Incluimos los archivos que nos permitirn guardar los datos en el ATmega
#include <avr/pgmspace.h>
//Mensaje de bienvenida que mostrar el robo en su pantallita
const char welcome_line1[] PROGMEM = " Riky";
const char welcome_line2[] PROGMEM = "Robot";
const char demo_name_line1[] PROGMEM = "Sigue-Linea";
const char demo_name_line2[] PROGMEM = "P1e";
// Reproducimos un par de tonos almacenados
const char welcome[] PROGMEM = ">g32>>c32";
const char go[] PROGMEM = "L16 cdegreg4";
//Barras grficas
const char levels[] PROGMEM = {
0b00000,
0b00000,
0b00000,
0b00000,
0b00000,
0b00000,
0b00000,
0b11111,
0b11111,
0b11111,
0b11111,
0b11111,
0b11111,
0b11111
};
//Cargamos las barras en el LCD
void load_custom_characters()
{
lcd_load_custom_character(levels+0,0); // una barra
lcd_load_custom_character(levels+1,1); // dos barras
lcd_load_custom_character(levels+2,2); // etc...
lcd_load_custom_character(levels+3,3);
clear(); // Limpiamos el LCD
}
86
//Muestra la lectura de los cinco sensores mediante barras grficas

void display_readings(const unsigned int *calibrated_values)
{
unsigned char i;
for(i=0;i<5;i++) {
const char display_characters[10] = {' ',0,0,1,2,3,4,5,6,255};
char c = display_characters[calibrated_values[i]/101];
print_character(c);
}
}
// Iniciamos el robot con el mensaje de bienvenida, calibramos y hacemos sonar la meloda void
initialize()
{
unsigned int counter; // cuenta atrs simple
unsigned int sensors[5]; // guardamos los valores de los sensores en un array
// This must be called at the beginning of 3pi code, to set up the
// sensors. We use a value of 2000 for the timeout, which
// corresponds to
//Set up de los sensores ->2000*0.4 us = 0.8 ms en nuestro procesador de 20 MHz
pololu_3pi_init(2000);
load_custom_characters(); // Cargamos
// Suena la meloda de bienvenida y muestra un mensaje
print_from_program_space(welcome_line1);
lcd_goto_xy(0,1);
print_from_program_space(welcome_line2);
play_from_program_space(welcome);
delay_ms(1000);
clear();
print_from_program_space(demo_name_line1);
lcd_goto_xy(0,1);
print_from_program_space(demo_name_line2);
delay_ms(1000);
// Muestra el nivel de la bacteria y espera que pulsemos el botn B
while(!button_is_pressed(BUTTON_B))
{
int bat = read_battery_millivolts();
clear();
print_long(bat);
print("mV");
lcd_goto_xy(0,1);
print("PULSE B");
delay_ms(100);
}
87
// Esperamos siempre a que se pulse el botn B para que el robot empiece a moverse
wait_for_button_release(BUTTON_B);
delay_ms(1000);
//Se autocalibran los sensores girando sobre su propio eje a derechas e izquierdas
for(counter=0;counter<80;counter++)
{
if(counter < 20 || counter >= 60)
set_motors(40,-40);
else
set_motors(-40,40);
// Grabamos la posicin de mximo y mnimo percibida por los sensores
//Encendemos los emisores de infrarrojos
calibrate_line_sensors(IR_EMITTERS_ON);
delay_ms(20);
}
set_motors(0,0);
// Muestra los valores de calibracin en barra grfica
while(!button_is_pressed(BUTTON_B))
{
// Se leen los valores tomados en la posicin
unsigned int position = read_line(sensors,IR_EMITTERS_ON);
//Mostramos la posicin medida, que va desde 0 (el sensor ms a la izquierda est
//encima de la lnea) hasta 4000 (el sensor ms a la derecha est sobre la lnea)
clear();
print_long(position);
lcd_goto_xy(0,1);
display_readings(sensors);
delay_ms(100);
}
wait_for_button_release(BUTTON_B);
clear();
print("Vmonos!");
//Suena una musiquita, muestra el mensaje y arranca el robot
play_from_program_space(go);
while(is_playing());
}
88
// Funcin main
int main()
{
unsigned int sensors[5]; // Array donde guardaremos los valores de los sensores
// Inicializamos el robot
initialize();
// Funcin "main loop" que siempre se ejecuta
while(1)
{
// Obtiene la posicin de la lnea (todos los sensores)
unsigned int position = read_line(sensors,IR_EMITTERS_ON);
if(position < 1000)
{
// Est lejos la parte derecha de la lnea -> Gira a la izquierda
// Ponemos el motor a derecho a 100 y el izquierdo a 0 para girar
//El valor mximo de velocidad del motor es 255
set_motors(0,100); //0,100
// Simplemente por diversin, indica mediante los Leds azules que direccin est tomando
left_led(1);
right_led(0);
}
else if(position < 3000)
{
// Si est centrado en la lnea, corre ms y recto y enciende los dos Leds azules
set_motors(70,70);
left_led(1);
right_led(1);
}
//Hacemos que pare cuando encuentre la barrera (cartulina)
//Jugando con los valores tomados por los sensores llegamos a la conclusin de que estos
//son los ptimos para su ptimo control
//Paramos el robot y apagamos los Leds
else if(position > 3700)
{
set_motors(0,0);
left_led(0);
right_led(0);
}
//hasta aqu el control de parada
else
{
//Si estamos lejos de la parte izquierda de la lnea, gira a la derecha
set_motors(100,0); //100,0
left_led(0);
right_led(1);
}}
89
6.5 Lneas futuras de la maqueta
Una vez que disponemos de la maqueta, quedan abiertas innumerables mejoras

aplicables: incorporacin de un elevador, uso de sensores para sincronizacin
inteligente (barreras pticas), control telemtico mediante el mdulo XBee,
introduccin de cmaras IP, etc
Comentamos en el captulo 5 la compatibilidad de Pololu 3pi con Arduino

(puede programarse directamente a travs de su placa) y como ya habamos realizado el
cdigo, lo exponemos en el Anexo VIII Cdigo Pololu 3pi sigue-lnea Arduino para
su estudio y desarrollo.
90
7 Bibliografa
http://www.Arduino.cc (Entorno Arduino)

http://www.freeduino.org/ (Entorno Arduino)
http://www.ladyada.net/learn/lcd/charlcd.html (Componentes y robtica en
general)
http://www.hispavila.com/3ds/atmega/pulsadores.html (Componentes y
robtica en general)
http://www.Pololu.com (Componentes y robtica en general)
http://www.adafruit.com/forums/viewtopic.php?f=8&t=14423 (Foro entorno
Arduino)
http://www.arduinobot.pbworks.com/w/page/10175779/Motores-DC
(Componentes Electrnicos)
http://www.wikipedia.org/ (Enciclopedia electrnica)
http://www.atmel.info/dyn/resources/prod_documents/8271S.pdf
http://es.wikipedia.org/wiki/AVR
http://www.arduino.cc/es/
http://es.wikipedia.org/wiki/Arduino
http://www.multiplo.org/duinos/wiki/index.php?title=Main_Page
http://blog.bricogeek.com/noticias/arduino/duinos---sistema---operativo--
-multitarea---para---arduino/
http://www.henningkarlsen.com/electronics/a_l_ds1302.php
91

Arduino PDF

Cargado por

Copyright:

Formatos disponibles

Arduino PDF

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Arduino PDF

Cargado por

Copyright:

Formatos disponibles

Proyecto Fin de Carrera Plataforma docente para la enseanza de las TIC

basada en la maqueta de un puente colgante

1 CAPTULO 1. MOTIVACIN, OBJETIVOS Y FASES .................................................... 3

6 CAPTULO 6. MAQUETA ................................................................................................ 73

1 CAPTULO 1. MOTIVACIN, OBJETIVOS Y FASES

Aplicacin prctica en una maqueta

1.2 Trabajos relacionados

Fritzing es una aplicacin con la que podemos realizar los esquemas de

La vista protoboard nos muestra una visin realista de la implementacin del

Ilustracin 2 Fritzing Vista Protoboard

En la vista PCB (layout) podremos observar la distribucin de los componentes

Ilustracin 3 Fritzing Vista Layout

La vista esquema nos ofrece de forma abstracta los componentes y conexiones.

Ilustracin 4 Vista Esquema

Ilustracin 9 VirtualBread Boared

Ilustracin 10 Physical Etoys

S4A (Scratch) + Arduino

Ilustracin 11 S4A (Scratch) + Arduino

Ilustracin 13 Rhino + Firefly

2 CAPTULO 2. LA PLACA ARDUINO Y EL ENTORNO DE

En el presente apartado se van a describir las principales caractersticas de

Arduino basa toda su fuerza en los microcontroladores Atmega168, Atmega 328,

El lenguaje de programacin de Arduino es el wiring, que est basado en el

Con objeto de hacer esta memoria lo ms autocontenida posible, en el Anexo I se

2.2 La placa Arduino UNO

Ilustracin 15 Placa Arduino UNO

Su tamao es de 74x53 mm. La programamos mediante una conexin USB que

Vamos a explicar a continuacin cada parte con ms detalle.

Comenzamos con la ms importante, el microprocesador ATmega328, que posee

Vayamos ahora conociendo las capacidades de cada pin: los pines 3, 5, 6, 9, 10 y

El conector plug hembra de 2.1 mm lo podemos usar para alimentar a la placa

2.3 Entorno de programacin y funciones especficas

Para programar nuestra tarjeta Arduino UNO, acudimos a su pgina web

El entorno de desarrollo de Arduino lo constituye un editor de texto, donde

Ilustracin 16 IDE Arduino

El cdigo lo escribiremos en un sketch (programa) en el editor de texto. El

nuevo sketch, el cuarto nos da la opcin de abrir un programa que se encuentre en el

Dentro de los cinco mens horizontales podremos encontrar diversos submens

2.3.2 Estructura y funciones especficas

void setup() {...}

SETUP() La funcin setup() se establece en cuanto se inicia un sketch. Se usa

DIGITALREAD() Leemos el valor digitalRead(pin) pin: el nmero de HIGH LOW

NOMBRE DESCRIPCIN SINTAXIS PARMETROS DEVOLUCIN

modo: nos define el

NOMBRE DESCRIPCIN SINTAXIS PARMETROS DEVOLUCIN

2.4 Descarga e instalacin

Ilustracin 17 Descarga Arduino

A continuacin, clicamos la versin para nuestro sistema operativo (Windows en

Ilustracin 18 Arduino Windows

Descargamos el archivo (arduino-1.0.3-windows.zip de 91.2 Mb). Una vez

de la carpeta creada, buscamos el icono y abrimos el programa. Es hora

Es hora de comenzar a usar y disfrutar de nuestra Arduino UNO. Ejecutamos el

Ilustracin 19 Ejemplo Blink

Debemos decirle ahora al programa que placa es la que le hemos conectado, ya

Ilustracin 20 Eleccin placa Arduino UNO

Ahora le decimos en que puerto serie la tenemos conectada. Como trabajamos

Ilustracin 21 Eleccin puerto serie

Por ltimo, cargamos el sketch presionando el botn Cargar: .

3 CAPTULO 3. ARDUINO DESDE CERO. PRCTICAS