Arduino

ARDUINO
9 788426 721457
Iniciación a Arduino UNO
Miguel Pareja Aparicio
Primera edición, 2014
© 2014, Miguel Pareja Aparicio
© 2014 MARCOMBO, S.A.

www.marcombo.com
Diseño de la cubierta: NDENU DISSENY GRÀFIC

Corrección: Raquel Sayas Lloris
«Cualquier forma de reproducción, distribución, comunicación pública o

transformación de esta obra solo puede ser realizada con la autorización de sus
titulares, salvo excepción prevista por la ley. Diríjase a CEDRO (Centro Español de
Derechos Reprográficos, www.cedro.org) si necesita fotocopiar o escanear algún
fragmento de esta obra».
ISBN: 978-84-267-2145-7
Índice
Introducción ............................................................................................. 1
Capítulo 1. ¿Qué es arduino? ..................................................................... 3
1.1 Introducción ..................................................................................... 3
1.2 Software libre: qué es y qué me hace falta ...................................... 3
1.3 Hardware libre: ¿existe? .................................................................. 5
1.4 Pero ¿qué es arduino uno? ............................................................... 7
1.5 ¿Qué necesito para empezar?........................................................ 10
1.6 Programar: ¿qué necesito saber? .................................................. 15
1.7 Actividades propuestas .................................................................. 20
Capítulo 2. Primeros pasos ...................................................................... 23
2.1 Introducción ................................................................................... 23
2.2 Instalación de software y preparación de Arduino ........................ 23
2.3 Entorno Arduino ............................................................................. 28
2.4 Primer programa y práctica con Arduino ....................................... 30
2.5 Monitorización puerto Serial0........................................................ 35
Ejercicio resuelto 1: comunicación serial0 .............................. 36
Capítulo 3. Entradas y salidas digitales .................................................... 39
3.1 Introducción ................................................................................... 39
3.2 Pines de entrada y salida digitales en Arduino .............................. 39
3.3 Montajes i: fundamentos de electrónica........................................ 41
3.4 Montajes ii: protoboard o placa de prototipos .............................. 42
3.5 Conexionado de leds como salida .................................................. 45
Ejercicio resuelto 2: semáforo ................................................. 48
3.6 Conexionado de pulsadores como entrada .................................... 50
Ejercicio resuelto 3: conmutada .............................................. 53
Ejercicio resuelto 4: semáforo controlado por un pulsador .... 55
3.7 Actividades propuestas. ................................................................. 59
Capítulo 4. Ampliación entradas y salidas digitales .................................. 61
4.1 Introducción ................................................................................... 61
4.2 Conectando sensores a las entradas digitales ............................... 61
Ejercicio resuelto 5: comprobación interruptor
de inclinación y reed................................................................ 64
Ejercicio resuelto 6: contador.................................................. 67
4.3 Conectando más receptores a las salidas digitales ........................ 72
Ejercicio resuelto 7: led multicolor .......................................... 76
Ejercicio resuelto 8: control iluminación tras apertura
de puerta ................................................................................. 78
Capítulo 5. Salidas digitales PWM ............................................................ 85
5.1 Introducción ................................................................................... 85
5.2 Modulación por ancho de pulso (señal PWM) ............................... 85
Ejercicio resuelto 9: regulación iluminación led ...................... 87
5.3 Variar la velocidad de un motor de continua ................................. 88
Ejercicio resuelto 10: control de velocidad motor dc
con dos pulsadores.................................................................. 89
Ejercicio resuelto 11: motor con inversión
del sentido de giro................................................................... 92
5.4 Control de servomotores ................................................................ 96
Ejercicio resuelto 12: control serie posición servo ................... 99
5.5 Pines 1 y 2 .................................................................................... 100
5.6 Actividades propuestas ................................................................ 100
Capítulo 6. Entradas analógicas ............................................................. 101
6.1 Introducción ................................................................................. 101
6.2 Las entradas analógicas de Arduino ............................................ 101
Ejercicio resuelto 13: lectura potenciómetro ........................ 102
6.3 Medida de temperatura ............................................................... 105
Ejercicio resuelto 14: medida de temperatura
con LM35D ............................................................................ 107
Ejercicio resuelto 15: medida de temperatura
con TMP36 ............................................................................ 109
Ejercicio resuelto 16: medida con termistor. ......................... 109
6.4 Medida intensidad luminosa ........................................................ 111
Ejercicio resuelto 17: medida de resistencia LDR .................. 112
Ejercicio resuelto 18: interruptor crepuscular ....................... 114
con potenciómetro ................................................................ 116
6.5 Actividades propuestas ................................................................ 117
Introducción
El presente libro contiene la información básica para iniciarse en el mundo de

Arduino UNO, desde los fundamentos teóricos necesarios pasando por los
fundamentos de programación para llegar hasta las nociones básicas de electrónica
para su montaje.
Se ha estructurado en seis capítulos, de los cuales el primero pretende dar un
vistazo rápido a todo lo relacionado con Arduino, así como el material mínimo para
iniciarse. El segundo se centra en el apartado del software necesario para realizar
los programas que modelarán su funcionamiento. Del tercero hasta el quinto, se
centran en las distintas posibilidades que ofrecen sus conexiones digitales. El sexto
sirve para describir la utilización de las entradas analógicas. La pretensión es que
sea una obra práctica por lo que los conceptos teóricos se ven de forma breve y
directa sin entrar en rodeos, y por ello se acompañan de ejercicios resueltos para
que puedan ser inmediatamente implementados siguiendo las pautas indicadas.
El texto se ha escrito pensando en que sea «para todos los públicos», para
usuarios noveles, con conocimientos de electrónica o no, o conocimientos de
programación o no. Simplemente se requerirá un nivel de usuario de ordenador y
será capaz de operar con Arduino. En cosecuencia se ha estructurado de forma
secuencial la introducción de conocimientos o fundamentos a tener en cuenta. Ello
queda patente en que, conforme vaya avanzando entre las páginas, el número
de códigos y montajes a realizar irá en aumento. Lógicamente el que
tenga fundamentos de electrónica o programación podrá avanzar más rápido
que el que no los tiene. Pero si no es así, no le será un impedimento si sigue cada
uno de los capítulos.
Su estructura secuencial permite que conforme vaya avanzando tendrá que
asimilar nuevos conceptos y montajes, sin olvidar los vistos en páginas
anteriores, de tal forma que se puede estructurar en varias sesiones, según
capítulos, para ser utilizado en cursos de introducción a Arduino, con un tiempo
limitado. Por ello, cada capítulo dispone de ejemplos que permitirán asimilar los
conceptos vistos. Además, al final de los capítulos se incluyen una serie de
1
Introducción
actividades propuestas para que sean realizadas por los alumnos para verificar la
asimilación de los conceptos vistos previamente.
Esta obra es la primera de una serie que pretende centrarse en el mundo de
Arduino UNO, puesto que se trata de un mundo bastante amplio y en continua
evolución. Dedicar un único libro puede tener un tamaño considerable y ello lo hace
menos práctico para su manejo, por lo que al distribuirlo por niveles y aplicaciones,
el usuario puede escoger el que más se adapte a sus necesidades.
2
1. ¿Qué es Arduino?
1.1 Introducción
Este primer capítulo pretende dar a conocer qué es Arduino, así como las
herramientas y material necesario para empezar a trabajar. Siguiendo una de las
principales filosofías asociadas a Arduino, el usuario o técnico debería empezar a
trabajar con este dispositivo con conocimientos básicos de electrónica y con un nivel
de usuario de programación. En este primer capítulo se va a presentar esta placa de
circuito impreso y se incluirán los fundamentos de programación a tener en cuenta.
Se incluyen a modo aclaratorio algunos conceptos sobre el término libre asociado
al hardware y al software. Los conceptos puramente electrónicos se irán tratando a lo
largo del texto. En los próximos capítulos se irán viendo en más detalle cada uno de los
componentes según sean necesarios para los montajes mostrados y propuestos.
La estructura de este capítulo es distinta a los próximos capítulos, ya que lo
hemos enfocado como una serie de preguntas a las cuales se les ha intentado dar
respuesta con la máxima claridad y con la mayor brevedad posible. Por el contrario,
los próximos capítulos serán mucho más prácticos.
1.2 Software libre: qué es y qué me hace falta

Que una aplicación de software sea libre indica que se puede usar, distribuir,
modificar y redistribuir, siempre y cuando la nueva aplicación creada sea
redistribuida con la misma licencia, es decir, continúe siendo libre. Para ser libre
también debe ir acompañada de su código fuente. Al acceder a la página web, en
la sección de descargas, es fácil encontrar la siguiente información: la versión
ejecutable y estable (totalmente funcional sin errores lista para ser usada), la
versión beta o de prueba (añade nuevas funcionalidades pero no asegura que esté
libre de errores) y código fuente (source code).
3
Cuando se habla de software libre se suele confundir con el concepto de

aplicación gratuita (freeware), la cual se distribuye gratuitamente, y en ocasiones
se ofrece el código fuente (aunque no suele ser usual que lo acompañe), y en este
último caso se denomina de código abierto. Además la aplicación suele mantener
el copyright del autor. Asimismo una variación de las denominadas como
aplicaciones gratuitas es el shareware, que consiste en versiones limadas de un
software comercial. Suelen ser: las limitadas en el tiempo (denominadas también
trial) o limitadas en alguna de sus características (denominadas también de
demostración o demo). En consecuencia cuando se habla de shareware, se trata de
una aplicación gratuita pero con algunas restricciones.
Volviendo al software libre, dichas aplicaciones utilizan la denominada
licencia GPL (General Public License o licencia pública general). Se trata de una
licencia creada por la Free Software Foundation a mediados de los años ochenta, y
orientada principalmente a proteger la libre distribución, modificación y uso de
software, es decir a favorecer el uso de software libre.
Si se lee el primer punto de una licencia GPL que acompaña a las aplicaciones
libres, queda patente el fin principal de dicha licencia. A continuación se muestra
una traducción de dicho punto:
Usted puede copiar y distribuir copias literales del código fuente del
programa, según lo has recibido, en cualquier medio, siempre y cuando,
y de forma adecuada y bien visible, publique en cada copia un anuncio del
copyright adecuado y un repudio de garantía, mantenga intactos todos
los anuncios que se refieran a esta licencia y a la ausencia de garantía, y
proporcione a cualquier otro receptor del programa una copia de esta
licencia junto con el programa.
Puede cobrar un precio por el acto físico de transferir una copia, y puede,
según su libre albedrío, ofrecer garantía a cambio de unos honorarios.
En el caso particular de Arduino, se trata de algo físico, que en un principio
no es software libre, pero sí se tiene en cuenta que se necesitan algunas
aplicaciones para realizar la programación. El software necesario se puede obtener
directamente de la siguiente página web:
http://www.arduino.cc/en/Main/Software
4
Tal y cómo se indica, se trata de software de código abierto, y se puede

descargar el código fuente o la aplicación funcional para diversas plataformas
(Windows, Linux o Mac). Está escrito en Java, por lo que se necesitará tenerlo
instalado, y basado en Processing (entorno de programación), avr-gcc (lenguaje de
programación) y otros programas también de código abierto.
1.3 Hardware libre: ¿existe?

Si tomamos como referencia el software libre (que permite: libertad de uso, de
estudio, modificación y distribución, y redistribución con las mejoras), estas
libertades no pueden ser aplicadas directamente sobre el hardware libre, ya que se
trabaja con partes físicas que cuestan un cierto desembolso económico y parte de
ello es lo que ha provocado que sufra cierto retraso respecto al software libre.
Así pues, generalizando se habla sobre hardware libre o abierto a la
documentación asociada a los diseños informáticos o electrónicos. De tal forma que
cualquiera pueda acceder a dicha documentación y crear sus propios diseños.
Ahora bien, si se utiliza una aplicación (libre, gratuita o de pago) para realizar
el diseño y se distribuyen los ficheros necesarios, no solo para crear la parte física
(como podría ser crear la placa de circuito impreso) sino para modificar el diseño y
su documentación asociada, entonces se encuentra ante un hardware abierto o
libre. Es decir, el hardware libre ofrece las mismas cuatro libertades que el software
libre pero aplicado a los esquemas del hardware.
El hardware libre se puede clasificar en:
• El hardware libre estático, cuando el esquema del circuito

electrónico está formado por dispositivos electrónicos concretos,
cuya funcionalidad está determinada.
• El hardware libre reconfigurable es cuando el circuito que representa

el esquema tiene una estructura física concreta pero que permite
modificar su funcionalidad mediante la programación de cierto
dispositivo, por ejemplo: PLD, CPLD, FPGA o microcontrolador.
Ambos tipos tienen sus ventajas e inconvenientes, siendo la primera la que
puede presentar cierta simplicidad y funcionabilidad en función de la aplicación.
Por el contrario, el segundo tipo presenta ventajas respecto a la funcionalidad
5
puesto que con un mismo circuito su funcionamiento puede cambiar realizando

modificaciones mediante software.
Por ejemplo, si yo encuentro un circuito que se adapta a mis necesidades,
entonces puedo acceder al esquema y montarlo. El problema radicaría en si deseo
realizarle alguna modificación. Además, el usuario debe realizar: la fabricación de
la placa de circuito impreso, la compra de componentes, el montaje y la
comprobación del diseño. Todo ello lleva asociado un coste tanto económico como
de tiempo requerido. Por el contrario, al utilizar un circuito electrónico que
contiene un microcontrolador con un mismo circuito puedo realizar distintas
aplicaciones modificando la programación del mismo. En este segundo caso
también se tendría que realizar el proceso de montajes y compra de materiales. Sin
embargo, si se diseña una placa genérica que puede servir para multitud de
aplicaciones, entonces dicha placa se puede fabricar a gran escala y en
consecuencia el precio será menor.
Arduino correspondería al denominado como hardware configurable, y
aunque se puede descargar toda la documentación para fabricarse sus propias
placas, puede resultar más económico el comprarla ya fabricada. En parte esta ha
sido su gran ventaja, el comprar a un precio muy reducido (cuesta menos comprarla
ya fabricada que construirse su propia placa de circuito impreso con todos los
componentes y soldarlos) y que una vez recibida puede empezar a realizar alguna
programación sencilla para verla en funcionamiento. Es decir, con unos
conocimientos básicos o nulos de electrónica, y conocimientos de informática a
nivel de usuario, puede estar realizando diseños o montajes. Además, si se dispone
de ciertos conocimientos puede pasar a realizar sus propios diseños.
Por ejemplo desde la siguiente página web puede acceder a todos los
documentos para la realización de la placa de circuito impreso:
http://arduino.cc/en/uploads/Main/arduino_Uno_Rev3-02-TH.zip
Los ficheros que se descargan han sido realizados con la aplicación Eagle a
partir de la versión 6.0 o superior. Además se indica que en el esquema se ha
utilizado el patillaje del microcontrolador Atmega8, pero el esquema es el mismo
para los modelos 168 o 328, porque la configuración de los pines es la misma.
6
1.4 Pero ¿qué es Arduino UNO?

Arduino UNO (figura 1.1) es una placa de circuito impreso para el microcontrolador
ATmega328. En la placa de circuito impreso ya se encuentra disponible todo el
hardware necesario para que el usuario lo conecte vía USB al ordenador y pueda
empezar a utilizarlo. Las principales características son:
• Microcontrolador: ATmega328.
• Tensión de operación: 5 voltios.
• Tensión de entrada recomendada: de 7 a 12 voltios.
• Tensión de entrada límite: de 6 a 20 voltios.
• Pines de entrada y salida digitales: 14 (de los cuales 6
proporcionan una salida PWM).
• Pines de entrada y salida analógicos: 6.
• Corriente de cada pin de entrada y salida: 40 miliamperios.
• Corriente para la salida de 3,3 voltios: 50 miliamperios.
• Memoria Flash: 32 KB (ATmega328) de los cuales 0.5 KB son
usados por el bootloader o gestor de arranque.
• SRAM: 1 kilobyte.
• EEPROM: 1 kilobyte.
• Clok Speed: 16 megahercios.
Figura 1.1. Arduino UNO vista frontal (Cortesía de www.arduino.cc).
7
También existe otra versión de la misma placa, pero con la versión SMD
(montaje superficial) del microcontrolador, (figura 1.2).
Puede encontrar más información concreta de este microcontrolador en la
siguiente página web:
http://www.atmel.com/Images/doc8161.pdf
Figura 1.2. Arduino UNO versión SMD (Cortesía de www.arduino.cc).
Si observa las fotos de la figura 1.1 y 1.2, se puede apreciar en la serigrafía

para qué sirve cada pin de conexión:
• Power: alimentación o potencia. Sirve para obtener valores de tensión
(3,3V y 5V) cuando se utiliza alimentación externa (Vin) o a través del
puerto USB (limitación de corriente).
• Analog in: entradas o salidas analógicas. Acepta valores de 0 a 5
voltios.
• Digital: entradas o salidas digitales, tenga o no tensión a la salida. Se
utiliza para entradas como sensores on/off o interruptores o
pulsadores. Los pines indicados con el símbolo ∼ sirven para el control
por ancho de pulso (PWM).
• GND: terminal de valores de referencia para los valores de tensión.
Nota: en los próximos capítulos se verá con mayor detalle la configuración y

conexionado de Arduino.
8
En resumen, las ventajas que ofrece Arduino son:

• Asequible: porque el coste de una placa es bastante económico, sobre
todo si se compara con la fabricación propia u otros sistemas con
microcontroladores.
• Multi-plataforma: el software necesario sirve para trabajar en varios
sistemas operativos: Windows, Linux y Mac. Sin embargo, otros
sistemas con microcontroladores pueden estar limitados a un sistema
operativo concreto.
• Lenguaje de programación simple y directa: se basa en Processing
(derivado de Java), que al tratarse de un lenguaje de alto nivel es fácil
de utilizar por principiantes, pero por sus características es
suficientemente flexible para usuarios avanzados.
• Software de código abierto: al tratarse de software libre puede ser
modificado o adaptado por programadores más experimentados para
la mejora del entorno de programación.
• Hardware de código abierto: al estar disponible los esquemas y con
licencia libre, esto puede provocar que diseñadores de circuitos
electrónicos incluyan nuevas versiones de los módulos, ampliándolo u
optimizándolo.
Aunque este texto se centra en el Arduino UNO, están disponibles otras
placas con algún cambio o ampliación, también disponibles para su compra, por
ejemplo:
• Arduino MEGA: más potente, con más pines y más memoria, pero
también más caro y más grande.
• Arduino Bluetooth: incorpora en la misma placa un módulo para
la transmisión por bluetooth hasta 100 metros.
• Arduino Pro: versión de Arduino UNO más compacta y robusta
para montajes portátiles, con todos los componentes de montaje
en superficie y sin conectores para las entradas y salidas, lo cual
permite reducir su espesor.
• Arduino Mini: versión en miniatura del Arduino UNO con
microcontrolador ATmega168, pero con menor memoria y
transmisión del programa más lenta.
• Arduino Nano: versión del Arduino Mini con pines para ser
incluida en una placa de prototipos.
9
• Arduino Pro Mini: versión mejorada del Arduino Mini, con mayor
memoria para programa al incluir el Atmega 328.
Otra de las ventajas de Arduino respecto a otros sistemas con
microcontroladores es la capacidad de colocar o disponer de placas o módulos que
le añaden mayores funcionalidades con una conexión prácticamente instantánea.
Son los denominados como shield. Por ejemplo, como algunas de las
funcionalidades para comunicaciones: conexión de red (Ethernet) o inalámbrica
(XBEE). Aunque como el objetivo del presente libro es a modo de iniciación no se
verán en el presente texto.
1.5 ¿Qué necesito para empezar?

Una buena forma de adentrarse en el mundo de Arduino es el recurrir a la compra
de kits, que no son más que una placa Arduino ya montada con una serie de
complementos. En algunos casos se acompaña de manuales o referencias digitales
para que el usuario realice de forma guiada una serie de pasos y así aprenda los
conceptos de montaje y programación.
Además se suele vender en formato más económico puesto que en un único
pedido se podrá disponer de todo el material necesario para la realización de los
montajes básicos sobre Arduino. Para los aficionados a la electrónica que ya
disponen de algunos componentes, podrán adquirir solo la placa de Arduino que le
interese. En este punto, será el usuario quien realice la selección de qué comprar y
dónde comprar, aunque es recomendable para iniciarse el recurrir a una serie de
kits que dispondrán de un poco de todo y permitirán la realización de varios
montajes. Después ya irá aumentando las adquisiciones y el material más específico
según las necesidades de los diseños que vaya realizando.
Los componentes básicos, con el Arduino incluido o no, que se van a
necesitar son los siguientes:
• Módulo Board o placa de prototipos, de 400 pines.
• Cables y/o jumper. También hay cajas que tienen cables de
distintas longitudes para el montaje en la placa de prototipos.
• Resistencia/s variable, potenciómetro, principalmente de 10 k.
10
Figura 1.3. Kit básico de Arduino (cortesía de www.electan.com).
• Led RGB (que tiene 3 pines).

• Leds de colores, rojo y verde principalmente (en algunos, también
amarrillo).
• Condensadores electrolíticos, principalmente de 100 uF.
• Resistencias de valores: 330 Ω, 1 kΩ y 10 kΩ.
• Fotorresistencia.
• Diodo rectificadores, principalmente 1n4007 o similares.
• Pulsadores.
• Cable de conexión USB.
Otros componentes que se pueden incluir en algunos kits, que a su vez
aumentarán las posibilidades de los montajes a realizar son:
• Más componentes resistivos y de varios valores: resistencias,
condensadores y resistencias variables.
• Mini Servo.
• Zumbador.
• Sensor de inclinación.
• Termistor.
11
• Fotorresistencia.
• Interruptores.
• Sensor de temperatura.
• Transistores, principalmente 2N2222 o similar.
Además en algunos casos también incluyen algún tipo de documentación:

montajes tipo, CD-ROM, hoja con los valores de resistencias, caja para guardar el
material, etc. Aquí el usuario decide qué va a hacer, incluso puede ir a la tienda de
electrónica e ir comprando conforme vayan aumentando sus necesidades.
En este punto podemos incluir un par de kits interesantes: el primero
consiste en realizar un diseño modular denominado Grove (figura 1.4) y el segundo
ofrece facilidades de montaje denominado SparkFun Inventor’s (figura 1.5).
Figura 1.4. Kit de iniciación Grove (Cortesía seeed studio).
Figura 1.5. Kit Inventor’s (Cortesía de SparkFun).
12
El primero simplifica mucho las conexiones por lo que permite realizar

pruebas sin necesidad de tener conocimientos de electrónica. Por el contrario, el
segundo ofrece más posibilidades de interacción y ampliación, aunque el primero
dispone de una gran cantidad de módulos adicionales con multitud de sensores y
elementos de control. Por el contrario, al estar disponible en placas de circuito
impreso montadas y la realización de las conexiones mediante conectores
específicos, se traduce en que el precio será mayor.
Por otro lado, debemos tener en cuenta que los componentes que se han
comentados son los básicos para iniciarse a trabajar con Arduino, pero se puede
encontrar una gran cantidad de elementos adicionales que aportarán al montaje o
diseño mayores posibilidades. Destacamos los siguientes: barra de leds, conexión
bluetooth, receptor de infrarrojos, receptores de radiofrecuencia, etc. Pero como
el objetivo de este texto es a modo de iniciación y como base, entonces con los
componentes que puede encontrar en los kits de iniciación será suficiente para
realizar todos los montajes propuestos en el libro. Después, cuando se adentre más
en este campo, verá que irá necesitando más material o componentes concretos
para una u otra utilización, como por ejemplo: integración con Android, pequeños
montajes de robótica, controles de sistemas de riego agrícola, domótica, etc.
El Arduino necesita una alimentación que sirva para que empiece a trabajar,
no hay que olvidar que se trata de un circuito electrónico formado principalmente
por un microcontrolador, también dispone de conexiones para alimentar a los
propios periféricos o sensores que se conecten y ello añadirá limitaciones.
En los actuales Arduino UNO, al conectar el cable USB, este suministra
energía para que funcione, además de poder establecer la comunicación con el
ordenador, por lo que no será necesaria una fuente de alimentación externa.
Requerirá de una fuente de alimentación externa cuando se utilicen placas
adicionales (debido a un aumento del consumo) o si Arduino tiene una conexión en
serie en vez de USB.
Existe una limitación de corriente de 500 miliamperios para el puerto USB,
aunque para que no se sobrepase este valor se dispone en la propia placa de
elementos de protección con posterior rearme. En consecuencia, para pequeños
montajes no será necesario conectar la fuente de alimentación externa. Pero si el
montaje es considerable o si se desea que el sistema sea autónomo sin conexión al
ordenador, sí que se necesitará.
13
La forma de conectar una fuente de alimentación externa es a través de los

pines: Vin y GND, o a través del conector jack (figura 1.6). La condición a destacar
es que los rangos de trabajo de la fuente externa son de 6 a 25V, teniendo en cuenta
la polaridad correcta del conector (positivo el interior y negativo el exterior).
También se puede utilizar la alimentación a través de pilas alcalinas como el caso
del kit de inicialización de Grove, para conectar a Vin, o incluir un portapilas con
conector jack.
Del mismo modo se puede disponer de una fuente de alimentación de
laboratorio con opciones adicionales muy interesantes, por ejemplo: pantalla de
visualización de tensión y corriente, limitadores de corriente, variación de la
tensión de salida, circuitos de protección contra sobretensiones y sobrecorrientes.
Esta última opción, aunque es la mejor, es la más cara, y después si se desea llevar
el circuito para integrarlo es algo engorroso, por lo que esa fuente de alimentación
podría ser sustituida por: fuentes de alimentación portátiles, diseñar la propia
fuente de alimentación, reutilizar viejos cargadores de baterías de móviles (siempre
que se ajusten a los requisitos de tensiones y corrientes comentados) o a reutilizar
una fuente de alimentación de un ordenador en desuso.
Figura 1.6. Conector jack de alimentación exterior Arduino UNO.
Nota: no olvidar conectar el terminal de GND o negativo cuando se utilice una

fuente de alimentación externa.
El procedimiento es sencillo si se decide reutilizar una fuente de alimentación

de ordenador. Para ello hay que utilizar los cables ya disponibles y eliminar el resto
de cables, es decir, los que no se necesiten. En la figura 1.7 se muestra un esquema
de conexionado para la fuente de alimentación a partir de una fuente ATX
14
manteniendo el código de colores que se suele utilizar. Además se muestra la forma

de conexión de los leds, de tal forma que el led verde se encenderá cuando la fuente
de alimentación esté en funcionamiento (aprovechando la alimentación de +5V) y
el led amarrillo para indicar que la fuente de alimentación está conectada al
suministro eléctrico (aprovecha la alimentación de reserva denominada +5VDC
Standby Voltage). La puesta en marcha se realiza con el interruptor que conmuta
entre Ps-On a masa para poner en funcionamiento la fuente de alimentación o lo
deja en circuito abierto para que permanezca apagada. Para los menos atrevidos se
muestra en la figura 1.7 un kit que permite conectar directamente el conector de
salida de la fuente de alimentación sin tener que desmontar o quitar cables de la
propia fuente de alimentación.
Figura 1.7. Esquema conexionado reutilización fuente ordenador.
1.6 Programar: ¿qué necesito saber?

Como se ha comentado anteriormente, se utiliza un lenguaje de programación
basado en Java o C++, y similar al lenguaje C. Por ello, los usuarios que tengan
nociones sobre estos lenguajes les resultará muy fácil su programación. Los que no
15
tengan conocimientos sobre estos lenguajes no tendrán grandes dificultades,

porque se trata de un lenguaje de alto nivel.
Llegados a este punto conviene conocer ciertas definiciones que se irán
utilizando en los próximos capítulos:
• Constantes: son datos cuyo valor no cambia durante la ejecución del
programa.
• Variables: son datos que tomarán cierto valor, que luego podrá ser
modificado o no durante la ejecución del programa. Se identifican por
un nombre definido por el usuario. En Arduino, al definir la variable,
se le asigna un valor y un tipo. El tipo definido determinará los valores
que puede tomar. Los tipos disponibles son:
- int (integer): almacena un número en 2 bytes (corresponde a 16
bits). Cuando no es necesario valores con decimales, puede tomar
valores desde -32.768 hasta 32.767.
- long: cuando no es suficiente con un int se recurre a un long.
Almacena un número en 4 bytes (corresponde a 32 bits), y puede
tomar valores desde -2.147.483.648 hasta 2.147.483.647. No
almacena valores decimales, solo enteros.
- boolean: solo puede almacenar dos valores true (verdad) o false
(falso). Solo utiliza 1 bit para almacenar el valor.
- float: cuando se requiere operaciones con decimales, almacena
un número en 4 bytes (32 bits) y puede tomar valores desde -
3.4028235·1038 hasta 3.4028235·1038.
- char: almacena un carácter utilizado en código ASCII. Por ejemplo,
la letra A se almacena con el valor 65. Para almacenar valores se
utiliza 1 byte (8 bits).
La forma de definirlo en Arduino es como se muestra a continuación:
int variable=12; // tipo nombre=valor
Nota: como se habrá dado cuenta, para asignar un resultado de una operación
matemática o valor a una variable, se utiliza el símbolo =. No se debe confundir con
la condición de comparación que es = =.
16
• Operadores: es un símbolo que indica una cierta operación sobre uno

o varios objetos del lenguaje. Pueden ser: operadores lógicos y
operadores matemáticos.
Los operadores lógicos sirven para establecer comparaciones o
condiciones, de tal forma que si se cumple devuelve true y si no se
cumple devuelve false. Se utiliza en la condiciones de las estructuras
de control y son: igual (= =), distinto (!=), menor que (<), mayor que
(>), menor o igual (< =) y mayor igual (> =).
Cuando se tiene que cumplir más de una condición se utilizan los
operadores booleanos, los cuales son: and (&&) y or (||). El primero,
para cuando quiera que se cumplan ambas condiciones. Y el segundo,
para cuando se cumpla una de las dos condiciones.
Los operadores matemáticos se utilizan para manipular valores, y son:
suma (+), resta (-), multiplicación (*) y división (/).
• Palabras reservadas o clave: son un grupo de palabras con una
finalidad determinada.
• Comentarios: sirve para introducir aclaraciones del código escrito. Si
se utilizan en la misma línea se puede utilizar //. Si el inicio y el final
del comentario se encuentran en distintas líneas entonces se utiliza /*
xxxx*/ (donde xxx corresponde al propio comentario).
• Funciones: se trata de un código ya escrito que puede ser utilizado
varias veces escribiendo solo el nombre de la función. Por ejemplo, en
Arduino existe una función que al escribirla leerá el estado de una
entrada digital, cuya función es digitalRead(). Entre paréntesis se
incluye la configuración de la función, es decir, si necesita un dato de
partida (variable/s de entrada/s) y/o da un resultado (variable/s de
salida/s). En el libro se irán viendo las funciones conforme sea
necesario para la realización de cada montaje y su respectivo código
de programación.
• Librerías: son un conjunto de funciones agrupadas en un fichero. Se
escriben al inicio del programa (precedidas de una almohadilla, #) y si
no se incluyen, entonces no se podrán utilizar las funciones que
contengan. Tienen la extensión *.h. Por ejemplo, cuando se vaya a
utilizar la pantalla serie LCD se requerirá disponer de la librería
serialLCD.h, la cual sirve para utilizar la función slcd.print(), y si no se
ha incluido dará un error en la compilación.
17
Del mismo modo conviene conocer ciertas estructuras de programación,

tales como:
• Estructuras de control selectivas: denominadas condicionales, porque
se utilizan para la toma de decisiones en función de la evolución del
valor las variables. Las palabras clave para este tipo de estructuras son:
if, else y switch.
• Estructuras de control iterativas: denominadas bucles, porque
permiten la ejecución repetitiva de sentencias durante un número
determinado de veces, controlado y definido por un algoritmo. Las
palabras clave para este tipo de estructuras son: while, for y do while.
A continuación se muestran las estructuras comentadas. La primera
corresponde a if y else. Para una mejor comprensión se puede utilizar su traducción,
es decir, si se cumple lo que hay entre paréntesis entonces se ejecuta lo que hay
entre corchetes a continuación del if. Si no se cumple, se ejecuta lo que hay entre
corchetes, a continuación del else. La estructura es la que se muestra a
continuación:
if ( condición ){
//Bloque que se ejecuta si se cumple la condición
} // Fin if
else{
//Bloque que se ejecuta si no se cumple la condición
} // Fin else
La segunda corresponde a switch, cuya traducción es ‘cambiar’, es decir, en

función del valor de la variable entre paréntesis cambia de una opción a otra
ejecutándose el código que hay a continuación; y si no cumple ninguna de las
opciones indicadas, se ejecutará en código indicado a continuación de la opción por
defecto, default. La palabra break indica que la ejecución salta afuera de los
corchetes. La estructura es la que se muestra a continuación:
switch ( variable ){
case opción 1: //Si variable == 1* ejecutar siguiente código
break;
18
case opción 2: //Si variable == 2* ejecutar siguiente código

break;
default: // Sino es uno de los casos anteriores
break; // Salta fuera de la función
} // Fin switch
La tercera corresponde a while, cuya traducción es ‘mientras’, es decir,

mientras se vaya cumpliendo la condición entre paréntesis se estará ejecutando
continuamente el código incluido entre corchetes. La estructura es la que se
muestra a continuación:
while ( condición ){
//Bloque de instrucciones a ejecutar
} //fin while
La cuarta y última que se muestra es for, y se utilizar para ejecutar cierto

código una cantidad de veces determinada, por ello entre paréntesis hay tres
condiciones separadas por punto y coma. El primer término sirve para indicar la
condición inicial, a continuación se ejecutará el código entre corchetas hasta que
se cumpla la condición del segundo término, y cada vez que se ejecute el código
entre corchetes se ejecutará lo indicado en el tercer término. Por ejemplo si se
desea que algo se repita 10 veces, se utilizará una variable cuyo valor inicial será
asignarle el valor 0, la condición para que se siga ejecutando el valor es que sea
menor o igual a 10, y cada vez que se ejecute el valor de la variable se incrementará
en 1. La estructura es la que se muestra a continuación:
for( dar valores iniciales ; condiciones ; incrementos ){

// Conjunto de instrucciones a ejecutar en el bucle
} //fin for
Comentar, llegado a este punto, que el código que se escribe se podría decir que
es secuencial; es decir, empieza por lo escrito por la línea 1 hasta la última línea escrita.
Aunque puede haber saltos condicionales utilizando las estructuras comentadas en los
párrafos anteriores. También se podrá encontrar con que dentro de una estructura hay
otra estructura distinta. Por ejemplo, dentro de un while encontrarme con un for; o
19
encadenar estructuras, por ejemplo, dentro de una condición if encontrarse con otro
if. Como ya verá más adelante, a mayor dificultad de la aplicación, más condiciones
tendrá que cumplir y, en consecuencia, más líneas tendrá de código. Como
consecuencia, el tamaño del fichero será mayor. Pero por ahora no se preocupe, ya
veremos más adelante algunos y comenzará a practicar. Llegados a este punto, una
recomendación, que se irá repitiendo a lo largo del texto, es la de incluir todos los
comentarios que crea pertinentes porque lo escrito ya no se olvida.
1.7 Actividades propuestas

1. Realice una búsqueda por Internet para ver si realmente es interesante la
compra en formato de kit de todo el material para iniciarse en el mundo de
Arduino.
2. Indique si las siguientes afirmaciones son verdaderas o falsas. En caso de ser
erróneas, corríjalas.
a) La sentencia for se utiliza para ejecutar unas líneas de código una
cantidad de veces.
b) La sentencia switch se utiliza para ejecutar un código mientras se
cumpla una determinada condición.
c) La palabra break se utiliza con la sentencia while.
d) Las sentencias iterativas o bucles son: if, else y switch.
e) Las sentencias selectivas o condicionales son: if, else y switch.
3. Teniendo en cuenta el siguiente ejemplo de la sentencia for para que se
repita 10 veces, realice los cambios para que la sentencia se repita 5 veces.
Nota: se ha utilizado la variable cuenta.
for( cuenta=0 ; cuenta<=10 ; cuenta++){
// Código a ejecutar
} // Fin for
4. ¿Qué cree que sucedería si se ponen 2 iguales en vez de 1 en el primer

término de la estructura for?
5. ¿Qué cree que indica o para qué puede servir el siguiente código?
while (cuenta<10){
//Código a ejecutar}
20
6. Defina una variable denominada digital que solo puede tomar dos valores: 0
y 1.
7. Podría definir la variable suma sabiendo que solo puede tomar valores
enteros desde -1000 hasta 1000 como float. ¿Se podría definir de otro tipo
para que ocupe menos espacio?
8. ¿Qué estructura de control utilizarías si se desea que se active una salida
cuando una variable sea mayor que 10 y se desactive en caso contrario?
Intente escribir el código a continuación.
21
2. Primeros pasos
2.1 Introducción
En este capítulo se describen los primeros pasos a realizar para empezar a utilizar
Arduino, es decir, el software necesario y el proceso de comuniación entre placa y
ordenador.
Por tanto, este capítulo es una introducción al manejo de la aplicación y una
indicación de dónde se pueden obtener todos los ficheros. Finalmente se verá un
ejemplo que servirá como muestra de la estructura del código de un programa para
Arduino.
2.2 Instalación de software

y preparación de Arduino
El primer paso es acceder a la página oficial de Arduino y en la sección de descargas
se podrá obtener la última versión de la aplicación, o acceder directamente a la
siguiente página web:
http://arduino.cc/en/Main/Software
Simplemente hay que hacer clic y se descargará en un fichero comprimido
de extensión *.zip para Windows y Mac, y *.tgz para Linux. También está disponible
la opción de descarga del código fuentes de la propia aplicación. Tal y como se
muestra en la figura 2.1.
Para este libro se ha utilizado la última versión disponible a la hora de
redacción del libro, que se corresponde con la versión Arduino 1.5.2.
23
2. Primeros pasos
Figura 2.1. Descarga software.
La instalación de la aplicación simplemente consiste en descomprimirla. Es

recomendable realizarlo en el directorio raíz (es decir, en C:/Arduino). Si después
se desea utilizar nuevas versiones, se puede utilizar el mismo directorio y a
continuación crear un acceso directo al fichero ejecutable: arduino.exe. Al tratarse
de una aplicación desarrollada en Java no requiere de instalación y simplemente
con hacer doble clic sobre dicho fichero ya se ejecutará la aplicación.
Si se descomprime, observará que en dicho fichero se encuentran varios
ficheros y subdirectorios. Allí encontrará ejemplos y los drivers necesarios para la
instalación de la comunicación con Arduino.
Nota: se va probando la aplicación en distintas versiones de Windows desde el
Windows 2000 hasta el Windows 7. También en distribuciones Linux basadas en
Ubuntu.
24
Figura 2.2. Ficheros y carpetas fichero descomprimido de Arduino.
Figura 2.3. Arduino 1.5.2.
25
2. Primeros pasos
En la figura 2.2 se muestra el directorio una vez se ha descomprimido, con

todas las carpetas y el fichero ejecutable. En la figura 2.3 podemos ver el entorno
de edición de Arduino.
El siguiente paso es instalar los drivers USB. Para ello simplemente hay que
conectar el cable USB al ordenador y en Windows XP o superior te pedirá que
instales los drivers para el chip FTDI de la placa Arduino. Es decir, se ejecuta el
asistente para instalar hardware. Los ficheros se encuentran en la
carpeta drivers/FTDI USB Drivers. También se puede instalar desde el panel
de control accediendo a Administrador de dispositivos. El proceso de instalación
se muestra de la figura 2.4 a la 2.6. En la primera de ellas se muestra cuando
se detecta el hardware. En la segunda, el proceso de instalación. Y en la
tercera, cómo queda cuando ya se haya instalado (en la vista del administrador
de dispositivos).
Figura 2.4. Detección de nuevo hardware.
26
Figura 2.5. Instalación del hardware.
Figura 2.6. Drivers instalados administrador de dispositivos.
27
2. Primeros pasos
2.3 Entorno Arduino

El entorno de programación Arduino recibe el nombre de IDE de Arduino,
correspondiente a las siglas de Integrated Development Environment o entorno de
desarrollo integrado.
Los ficheros que se manejan con el entorno de Arduino se denominan sketch
y, por defecto, son renombrados del siguiente modo:
sketch+fecha+letra
El texto sketch es fijo. La fecha corresponderá al día en el cual fue creado. La

letra indica el orden del fichero creado en ese día, es decir, a para el primero, b para
el segundo y así sucesivamente.
Al guardar el fichero, automáticamente se creará un directorio con dicha
denominación dentro de la carpeta de Arduino en documentos del ordenador, y no
en la carpeta descomprimida para el proceso de instalación. El fichero que contiene
el código del programa tiene la extensión *.ino.
Llegados a este punto se van a comentar solo los accesos directos y lo que se
ve al ejecutar el entorno. No se va a entrar en detalle en cada uno de los menús
desplegables, sino que se irán viendo conforme se necesiten, puesto que algunas
opciones son las típicas disponibles para cualquier aplicación.
En la figura 2.7, se muestran los 6 iconos de acceso rápido, cuya función es:
• Verify: verifica y compila el sketch en el cual se está trabajando.

También se encuentra en el menú Sketch.
• Upload: compila el sketch en el cual se está trabajando. En el caso de
no haber errores y la tarjeta Arduino esté correctamente conectada,
entonces envía el ejecutable al microcontrolador. También se
encuentra en el menú File.
• New: crea un nuevo sketch. También se encuentra en el menú File.
• Open: abre un sketch ya creado. Por defecto mostrará el último en el
cual se estuviera trabajando. También se encuentra en el menú File.
• Save: guarda el sketch con el mismo nombre con el cual se esté
trabajando. También se encuentra en el menú File.
28
• Serial Monitor: abre un sistema de monitorización que permite

visualizar los datos enviados por el microcontrolador. También se
encuentra en el menú Tools.
Figura 2.7. Iconos acceso rápido entorno Arduino.
Debajo de los iconos de acceso rápido se muestra el área de trabajo, donde

se escribirá el código para a continuación compilarlo y transferirlo a la placa. Nada
más ejecutar la aplicación se verá como aparece en la figura 2.8, en donde se
muestran dos funciones (aunque se podrán incluir tantas como sea necesario):
• setup (): el código situado entre estos corchetes se ejecutará una sola
vez al iniciarse el sistema, es decir, cuando se ponga en marcha el
microcontrolador.
• loop (): el código incluido entre estos corchetes se ejecutará
indefinidamente.
Figura 2.8. Área de trabajo entorno Arduino.
29
2. Primeros pasos
Debajo del área de trabajo se encuentra el área de notificaciones, que es

donde el compilador proporciona información sobre posibles errores en la
compilación o en la conexión en el puerto. En el caso de que haya un error en la
compilación del código, entonces indicará en qué línea está el error.
2.4 Primer programa y práctica con Arduino

En esta primera práctica se procede a conectar Arduino e instalar todo el software
siguiendo las pautas indicadas anteriormente.
Una vez conectado a la placa el cable USB, se encenderá el led de
alimentación ON (figura 2.9). A continuación, abriremos el sketch denominado
blink, que se encuentra en el menú Archivo/Ejemplos/01.Basics.
Nota: pueden encontrarse partes del texto de la aplicación traducida, dependerá
de la versión que se utilice (la que se haya descargado).
El fichero se abrirá en una nueva ventana, cuyo código es el que se muestra
a continuación, en donde se han modificado los comentarios del original para
incluir aclaraciones:
/*Blink: el led conectado al pin 13 las placas Arduino parpadea con un frecuencia
de 0,5 hercios */
// Se define una variable que modificándola se cambia la salida
int led = 13;
// Se ejecuta una vez o cada vez que se pulse el botón de reset
void setup() {
// Sirve para indicar que el pin 13 se utiliza como salida
pinMode(led, OUTPUT); } // Fin setup
// El siguiente bloque de código está ejecutándose continuamente
void loop() {
digitalWrite(led, HIGH); // Activa la salida 13
delay(1000); // Retando de 1000ms=1s
digitalWrite(led, LOW); // Desactiva la salida 13
delay(1000); // Retardo de 100ms=1s
} // Fin loop
30
Se ha elegido el presente ejemplo porque no hay que realizar ninguna

modificación en el hardware, ni es necesario realizar ningún tipo conexionado. En
la figura 2.9 se muestra dónde se encuentra el led conectado al pin 13 y el led de
alimentación que se tiene que encender una vez se haya conectado el USB.
Figura 2.9. Leds Arduino UNO.
Observando el código anterior, ya se puede ver a grandes rasgos la estructura

de un programa sketch, tal y como se muestra a continuación:
/* Descripción general de que tiene que hacer el sketch */

#include <librería.h> // Para incluir librerías si hiciera falta
int variable=0; // Para definir variables globales
void setup(){} // Se ejecuta 1 vez para realizar la configuración
void loop(){} // Que tiene que estar haciendo Arduino
Comentar que la aplicación diferencia entre minúsculas y mayúsculas, es

decir, no es lo mismo led que LED, prueba a realizar el cambio y comprueba que no
se enciende el led conectado al pin 13. Puede realizar cambios en la función retardo
y observar qué cambios se producen:
delay (tiempo en ms);
31
2. Primeros pasos
Figura 2.10. Configuración puerto serie.
Figura 2.11. Selección Placa.
32
Para configurar o seleccionar el puerto de comunicaciones se realiza desde

el menú Herramientas/Puerto serie (figura 2.10).
También es importante seleccionar qué placa de Arduino se va a programar.
Para ello se realiza desde el menú Herramientas/Board (figura 2.11). Anteriormente
no se ha comentado nada porque por defecto la aplicación tiene seleccionada a
Arduino UNO.
Si no hay ningún error al realizar la compilación, en el área de notificaciones
indicará que se ha creado el fichero binario (que será el que transferirá al
microcontrolador) y el tamaño que ocupa, con una indicación respecto al total de
la memoria ocupada respecto a la memoria de 32 kilobytes que tiene Arduino. Por
ejemplo, al compilar el código anterior indica que ocupa el 3 % del total con un
tamaño de fichero de 1,116 bytes (figura 2.12).
Figura 2.12. Área de notificaciones programa parpadeo led.
Un ejemplo de un error de compilación se muestra en la figura 2.13, en

donde se indica que la variable led utilizada no ha sido declarada o definida para
las funciones setup () y loop (). Si observa el código podrá ver que se ha modificado
en la definición de la variable las mismas letras pero en mayúscula, en consecuencia
el error se subsana haciendo que todas las palabras que hacen referencia a dicha
variable sean iguales.
Nota: los cambios realizados en el sketch se podrán guardar con otro nombre en la
carpeta de documentos del ordenador.
33
2. Primeros pasos
Figura 2.13.- Ventana de resultado de compilación con error.
Comentar que durante el proceso de carga del fichero binario en la placa

Arduino, se produce un flujo de información entre ambos dispositivos, por lo que
el led de transmisión y recepción (serigrafiados sobre la placa como TX y RX,
respectivamente) se pondrán a parpadear (figura 2.14).
Figura 2.14. Leds transfiriendo programa.
34
2.5 Monitorización puerto Serial0

Consiste en una ventana en la que se podrá monitorizar el puerto serie del
ordenador, es decir, el conectado a la placa Arduino. Dicha herramienta
proporciona información (visualizándolas) en tiempo de ejecución de variables o
enviar datos al microcontrolador. Esto la convierte en una herramienta para la
detección de fallos, viendo qué valor va tomando cada variable. La ventana se
muestra en la figura 2.15. Hay que tener en cuenta que cada vez que se ejecuta el
microcontrolador se reinicia (como si se pulsara el reset).
Figura 2.15. Ventana monitor Serial0.
Se debe configurar la velocidad en el sketch y el monitor. En el monitor se

realiza desde los menús desplegables en la parte inferior (figura 2.15) y desde el
sketch se utiliza la siguiente función:
Serial.begin(velocidad de comunicación);
Nota: por si no te hubieras dado cuenta hasta ahora, al final de cada línea de código
escrita se debe poner el punto y coma (;) o de lo contrario dará error.
35
2. Primeros pasos
La función que se utiliza para enviar texto al ordenador es la que se muestra

a continuación, en donde lo que se quiere enviar desde Arduino hasta el ordenador
se incluye entre comillas:
Serial.println ("caracteres a enviar");
Si se desea enviar el valor de una variable al ordenador se utiliza la función
tal y como se muestra a continuación:
int variable;
Serial.println (variable);
Si por el contrario se desea enviar desde el ordenador a Arduino, hay que
tener en cuenta que solo se puede enviar caracteres por lo que la variable en la cual
se almacene el valor enviado será definida como char. A continuación se muestran
las funciones que se utilizan para enviar desde el Arduino:
char caracter;
/* La siguiente condición sirve para comprobar si hay algún dato en el buffer de
entrada, de tal forma que si llega un dato lo lee y lo almacena en la variable*/
if (Serial.available()>0){
caracter=Serial.read();}
Nota: comentar que las funciones mostradas se escriben tal cual se ha indicado,
respetando las mayúsculas y minúsculas.
Ejercicio resuelto 1: comunicación serial0

A continuación se muestra un sketch tomando como referencia el visto en el
ejemplo del apartado anterior (led parpadeando). Sin embargo, esta vez se debe
abrir el monitor y visualizar el estado de las variables y enviar un carácter que
indique la velocidad a la cual parpadeará el led de la placa. Se incluyen los
suficientes comentarios para que quede claro el código:
/*Blink: el led conectado al pin 13 las placas Arduino parpadea con un frecuencia
configurable mediante monitor del Serial0*/
// Se define de variables
int led = 13; // Pin 13
int retardo=1000; // Valor de retardo por defecto
36
char caracter; // Variable para almacenar carácter enviado

// Se ejecuta una vez o cada vez que se pulse el botón de reset
void setup() {
// Sirve para indicar que el pin 13 se utiliza como salida
pinMode(led, OUTPUT);
// Configuración inicio comunicación a 9600 bit por segundo
Serial.begin(9600);} // Fin setup
// El siguiente bloque de código está ejecutándose continuamente
void loop() {
// Si hay un carácter en el buffer de entrada lo almacena
caracter=Serial.read();}
// Según el carácter se modifica el valor de la variable retardo
if(caracter=='r'){
retardo==500; // 0,5s encendido y 0,5s apagado
Serial.println("rapido");}
if(caracter=='l'){
retardo==2000; // 2s encendido y 2s apagado
Serial.println("lento");}
if(caracter=='d'){
retardo==1000; // 1s encendido y 1s apagado
Serial.println("defecto");}
digitalWrite(led, HIGH); // Activa la salida 13
delay(retardo); // Retando de 1000ms=1s
digitalWrite(led, LOW); // Desactiva la salida 13
delay(retardo); // Retardo de 100ms=1s
Serial,println(retardo); // Envía valor de variable retardo
} // Fin loop
37
2. Primeros pasos
Nota: no se necesita realizar ninguna conexión adicional a la placa.
En la figura 2.16, se muestra la ventana del monitor para el ejemplo de código

mostrado en las líneas anteriores. Además verá como el led de la placa de Ardunio,
al modificar el retardo de tiempo entre encendido y apagado, este se encenderá y
apagará más rápido o más lento.
Figura 2.16. Ventana monitor del ejemplo.

1. Realizar un sketch utilizando el monitor de tal forma que cuando se envíe
el carácter e, el led conectado al pin 13 se encienda y muestre el texto
encendido. Por el contrario, si se envía el carácter a, que el led conectado
al pin 13 se apague y muestre el texto apagado. Conecte Arduino al
ordenador y verifique el funcionamiento del código escrito.
2. Realizar un sketch que provoque que el led conectado al pin 13 parpadee,
y envíe un 1 al ordenador cuando esté encendido y un 0 cuando esté
apagado. Conecte Arduino al ordenador y verifique el funcionamiento del
código escrito.
38
3. Entradas y salidas digitales
3.1 Introducción
En este tercer capítulo se verán las nociones de programación para operar con los
pines de entrada y salida digital. Además, se mostrarán las nociones básicas a tener
en cuenta sobre fundamentos de electrónica necesarios para la realización de los
montajes propuestos.
En el próximo capítulo se mostrarán nuevas funciones de las conexiones
digitales.
3.2 Pines de entrada y salida digitales en Arduino

En la placa de Arduino UNO aparecen, en un lateral, las conexiones denominadas
DIGITAL (figura 3.1), cuyo valor puede tomar dos valores de tensión, que se
corresponden con activado y desactivado. Estos dos valores se identifican en el
software como TRUE para activado y FALSE para desactivado. En la realidad se
corresponden con dos valores distintos de tensión, cuyos valores típicos son 0
voltios para desactivado y 5 voltios para activado.
Figura 3.1. Conexiones pines digitales.
Estas conexiones se pueden configurar como entrada o salida. Por tanto, se

deben configurar primero y se utilizarán después. Por defecto se encuentran
definidas como entrada, aunque para seguir los mismos pasos lógicos, en todos los
39
diseños propuestos (código) que se muestran en el libro se definen tanto si son

entradas o salidas. El código para definirlo se incluirá en la función setup(), tal y
como se muestra a continuación:
pinMode (número del pin, modo);
pinMode (13, INPUT); // Pin 13 configurado como entrada
pinMode (13, OUTPUT); // Pin 13 configurado como salida
Una vez configurado el pin como entrada o salida, se procede a utilizarlo. En

el caso de que sea definido como salida mediante software se podrá activar o
desactivar ese pin. Para ello se utiliza el siguiente código:
digitalWrite (número del pin, valor);
digitalWrite (13, HIGH); // Activar pin 13
digitalWrite (13,LOW); // Desactivar pin 13
Si se configura como entrada, se podrá leer en su estado. Para ello se puede

definir una variable de tipo int, cuyo valor es HIGH si tiene presencia de tensión
(entrada activa) o LOW si no tiene presencia de tensión (entrada desactivada).
También se puede utilizar la propia función en una condición en estructuras de
control. El código utilizado es el que se muestra a continuación:
int digitalRead(número del pin);
int entrada=0; // Definir variable
entrada=digitalRead (13); // Leer estado del pin 13
Al configurar un pin digital como salida, en realidad se está configurando

como de alta impedancia (entrada) o de baja impedancia (salida), de tal forma que
al configurarlo como alta impedancia no es capaz de entregar corriente y cuando
está configurado a baja impedancia es capaz de entregar valores elevados de
corriente. Aunque Arduino presenta limitaciones en la corriente entregada, con un
valor máximo de 200 mA, sin embargo, es recomendable no sobrepasar los 20 mA
para proteger la placa, ya que de lo contrario se puede deteriorar esa conexión o el
propio microcontrolador. En consecuencia, no es recomendable conectar salidas
directamente a los actuadores a excepción de si solo se conecta un diodo led. Para
ello se utilizan otros elementos auxiliares como: transistores, relés,
optoacopladores o transistores MOSFET.
40
3.3 Montajes I: fundamentos de electrónica

Llegados a este punto y antes de comenzar a realizar los montajes con
componentes electrónicos, se incluye este apartado con una breve descripción
sobre nociones básicas a tener en cuenta sobre electrónica.
• Fuerza electromotriz: se corresponde con la fuerza necesaria para

desplazar los electrones desde el polo negativo al positivo, creándose
una diferencia de potencial. A dicha diferencia de potencial se le
denomina fuerza electromotriz. En la figura 3.2.a, se puede ver el
ejemplo real de un circuito, en donde se ha conectado una pila a una
carga lumínica, así como el desplazamiento de los electrones
necesario para crear la diferencia de potencial. Se simboliza como
f.e.m. y sus unidades son voltios (V).
• Intensidad de corriente eléctrica: la intensidad de corriente eléctrica
es la cantidad de carga (q en culombios) que atraviesa una sección del
conductor (S) por unidad de tiempo (t en segundos) (figura 3.1.b). Se
simboliza por una I y las unidades que lo definen son los amperios (A).
Hay que tener en cuenta que el sentido de la corriente eléctrica es
contrario al flujo de electrones (figura 3.2.c).
Figura 3.2. Complementos definiciones.
• Resistencia eléctrica: se define la resistencia como la oposición que

presenta el conductor al paso de la corriente, es decir, la dificultad que
encuentran los electrones para circular entre los átomos del
conductor. Se simboliza con una R, y sus unidades son lo ohmios que
se simbolizan con Ω. Su valor será dependiente del: material
(resistividad, ρ, unidades Ω·m), longitud (l, unidades m) y la sección (S,
unidades m2), siguiendo la siguiente ecuación:
l
R = ρ· [Ω]
S
41
• Potencia eléctrica: es el trabajo eléctrico (W, unidades en julios, J)

realizado por unidad de tiempo. Se simboliza con una P, y sus unidades
son vatios y se simbolizan como W, siguiendo la siguiente ecuación:
W
P= [W ]
t
Vistas las definiciones básicas sobre electrónica, hay que comentar la ley de
Ohm, que define la relación entre la tensión aplicada entre dos puntos de un
conductor (V) y la intensidad de corriente (I) que circula. Dicha relación es constante
y se corresponde con la resistencia eléctrica, tal y como se indica en la siguiente
ecuación:
V = R·I [V ]
Del mismo modo se establece para cargar resistivas que la potencia
consumida (P) por la misma es igual al producto de la caída de tensión (V) por la
corriente que lo atraviesa (I). Se indica en la siguiente ecuación:
P = V ·I [W ]
En la figura 3.3, se muestra el circuito más simple que representa la ley de
ohm, así como el círculo de equivalencias que sirve de guía para establecer
relaciones entre los términos de las ecuaciones mostradas anteriormente.
Figura 3.4. Ley de Ohm.
3.4 Montajes II: protoboard o placa de prototipos

Una de las ventajas que ofrece Arduino es la facilidad de conexionado mediante
unos simples cables. Sin embargo, para añadir y realizar pruebas se requiere de otro
42
elemento que facilita el montaje y las conexiones entre los componentes. Este
dispositivo es la protoboard o placa de prototipos (figura 3.5). En el mercado existen
de varios tamaños y pueden incluir conexiones adicionales para facilitar la conexión
de una fuente de alimentación exterior, lo que va asociado a un aumento del coste.
Tanto la que se ha mostrado en la figura 3.5 como la que se distribuye en los
principales kits de Arduino es la de 400 pines, y con esta es suficiente para la
realización de los montajes que se van a realizar. De todos modos, si continúa en
su andadura por el mundo de Arduino puede necesitar unas placas de prototipo
con mayor número de conexiones.
Figura 3.5. Protoboard o placa de prototipos (Cortesía de www.electan.com).
Figura 3.6. Kit de conexiones (Cortesía de Molgar).
Para facilitar las conexiones se puede disponer de un rollo de hilo, aunque

para los iniciados es interesante disponer de un kit con trozos de hilo ya cortados,
lo cual facilita en gran medida la realización de los montajes (figura 3.6). Algunos
kits ya ofrecen un conjunto con aislamientos de diferentes colores, lo cual es mejor
43
para no equivocarse al realizar las conexiones o en la revisión ante fallos o

modificaciones.
Una placa de prototipos no es más que una placa con múltiples orificios, que
se encuentran distribuidos de forma que los que se hallan en la misma fila están
interconectados mediante unas chapas metálicas. Además, para facilitar la
conexión al introducir el terminal del componente, este ejerce suficiente presión
para separarlas pero estas a su vez ejercen la suficiente presión para sujetar el
componente y asegurar la conexión eléctrica. Se muestra en la figura 3.7.
Figura 3.7. Interior placa de prototipos (Cortesía Spankfun).
Las conexiones en dos columnas situadas en los laterales se utilizan para la

alimentación de los circuitos, normalmente una para el valor de tensión positivo y
otro para el negativo (GND o de referencia). En la parte central se dispone de dos
columnas diferenciadas de 5 pines cada una. Estas se encuentran conectadas entre
cada fila, pero cada columna separada por una hendidura. Por ejemplo, en la figura
3.8, desde a hasta e están conectadas entre sí, y desde f hasta j están conectadas
entre sí, pero entre ellas no hay conexión. Puede verlo de forma más clara en la
figura 3.8, donde se detallan las conexiones.
44
Figura 3.8. Conexionado placa de prototipos.
3.5 Conexionado de leds como salida

En el capítulo interior ya se encendía un led, pero este está incorporado en la placa,
además de que solo hay uno, y se pueden utilizar más salidas para encender varios.
Pero ¿cómo se conectan?
En este punto si no se desea saber cómo funciona o se conecta, puede
recurrir a los kits modulares que permiten conectar una salida digital de Arduino a
otra placa con unos cables ya disponibles, sin posibilidad de realizar un conexionado
erróneo (Grove). Pero si no disponemos de dicho kit o queremos conectar varios
leds, entonces tendríamos que comprar varios módulos y el coste sería mayor. Por
tanto, vamos a tener en cuenta una serie de observaciones.
El diodo led es un dispositivo semiconductor que se utiliza como indicador,
en este caso para saber que se ha activado una salida. Su funcionamiento se basa
en que al aplicar una diferencia de potencial este provoca una corriente, que al
atravesar el diodo y alcanzar cierta caída de tensión, este se enciende. El símbolo
utilizado es el que se muestra en la figura 3.9 junto a una resistencia, la cual provoca
una oposición al paso de corriente y a su vez una caída de tensión en sus extremos.
La utilidad de la resistencia es que al poder ajustar su valor estoy ajustando su caída
de tensión (puesto que cuando un led tiene una caída de tensión fija) estoy
limitando la corriente que circulará por el led y a su vez sirve de protección y
regulación de la luminosidad.
45
Figura 3.9. Circuito polarización del diodo.
Llegados a este punto hay que tener en cuenta que el diodo led tiene
polaridad, de tal forma que si se conecta al revés este no se encenderá. Para indicar
cuál es terminal de ánodo (A) y cátodo (K), hay que saber que la corriente tiene que
circular del ánodo al cátodo.
Para identificar los terminales hay que tener en cuenta que:
• El ánodo será el más largo de las dos conexiones.

• El cátodo será la conexión que se encuentra al lado que presenta un
corte.
Figura 3.10. Identificación terminales diodo led.
Otro aspecto a tener en cuenta es que se ha indicado la utilización de una

resistencia, pero si observa las que tenga disponibles (en el kit por ejemplo) verá
que todas son iguales (incluso del mismo tamaño), y se diferencian por unas rayas
de colores. Entonces, ¿cuál escoger?
46
Las resistencias disponibles comercialmente no abarcan todos los valores,

sino que siguen unos estándares. El más utilizado es el denominado como E24 y se
suelen denominar como valores normalizados. Ahora bien, para identificar de qué
valor es una resistencia hay que leer esas rayas de colores que se han comentado;
es decir, hay un código de colores, tal y como se muestra en la tabla 3.1, que sigue
el orden que se muestra en la figura 3.11.
Figura 3.11. Identificación valores de resistencias.
Color de la banda 1.ª cifra 2.ª cifra Multiplicador Tolerancia
Negro 0 0 1 -
Marrón 1 1 10 ± 1%
Rojo 2 2 100 ± 2%
Naranja 3 3 1 000 -
Amarillo 4 4 10 000 ± 4%
Verde 5 5 100 000 ± 0,5%
Azul 6 6 1 000 000 ± 0,25%
Morado 7 7 10000000 ± 0,1%
Gris 8 8 100000000 ± 0,05%
Blanco 9 9 1000000000 -
Dorado - - 0,1 ± 5%
Plateado - - 0,01 ± 10%
Tabla 3.1. Código de colores de resistencias.
47
El valor típico de la resistencia utilizado para los diodos led suele ser de 330 Ω.
También es común encontrar valores de 220 Ω, para una tensión de alimentación
de 5 voltios.
Ejercicio resuelto 2: semáforo

El siguiente montaje o diseño se basa en el funcionamiento de un ascensor. Para
ello se utilizan los pines 13 a 11, y seguiremos la siguiente secuencia:
1. Se enciende el led rojo conectado al pin 13.
2. Pasados 5 segundos el led rojo se apaga y se enciende el led amarrillo
conectado al pin 12.
3. Pasados otros 5 segundos el led amarillo se apaga y se enciende el led
verde conectado al pin 11.
4. Pasados otros 5 segundos el led verde se apaga y se enciende el led rojo.
Repetiremos la secuencia.
Figura 3.12. Circuito semáforo con Arduino.
El esquema de montaje se muestra en la figura 3.12, donde se utilizan

resistencias de 330 Ω con el código de colores siguiente:
Amarrillo-Amarillo-Marrón
El código del sketch a introducir es el que se muestra a continuación. Puede
intentar realizarlo antes de ver la solución.
48
/* Capítulo 3 libro curso de introducción Arduino.

Semáforo:
5s Rojo->5s Amarillo->5s Verde->5s Amarillo->repetir */
int rojo=13; // Asignación variables a pines
int amarillo=12;
int verde=11;
void setup() {
// Configuración de los pines 11 al 13 como salidas
pinMode(rojo,OUTPUT);
pinMode(amarillo,OUTPUT);
pinMode(verde,OUTPUT);
} // Fin setup
void loop() {
digitalWrite(rojo,HIGH); // Enciende rojo
delay(5000); // Retardo 5 segundos
digitalWrite(rojo,LOW); // Apaga rojo
digitalWrite(amarillo,HIGH); // Enciende amarillo
digitalWrite(amarillo,LOW); // Apaga amarillo
digitalWrite(verde,HIGH); // Enciende verde
digitalWrite(verde,LOW); // Apaga rojo
digitalWrite(amarillo,LOW); // Enciende amarillo
} // Fin loop
49
3.6 Conexionado de pulsadores como entrada

Para conectar pulsadores a las entradas digitales de Arduino, se utiliza la conexión
mediante resistencias pull-down (figura 3.13), de tal forma que siempre haya un
estado lógico a la entrada del microcontrolador; es decir, 5 o 0 voltios. De tal forma
que si no se pulsa se conecta la entrada a gnd (0 voltios) a través de la resistencia,
y cuando se pulsa a través del pulsador se conecta la entrada a 5 voltios.
Cambiando la resistencia por el pulsador y viceversa, el funcionamiento es a
la inversa; es decir, cuando se pulsa se conecta a través del pulsador la entrada a
gnd (0 voltios) y cuando no se pulsa la entrada está a 5 voltios a través de la
resistencia. Esta configuración recibe el nombre de resistencia pull-up (figura 3.14).
Figura 3.13. Pulsador pull-down.
Figura 3.14. Pulsador pull-up.
50
Nota: para la resistencia con los pulsadores, tanto pull-up o pull-down, tiene valores
típicos de 10 o 22 kΩ.
Se puede implementar la resistencia pull-up mediante el propio hardware del
microcontrolador, utilizando el siguiente código en el setup():
void setup (){
pinMode (número del pin,INPUT); // Configura pin como salida
digitalWrite (número del pin, HIGH); // Activar R de pull-up
} //Fin setup
Mirando los pulsadores que hay en los kit y los utilizados para los montajes en
placas de circuito impreso (usados en electrónica), tienen 4 pines, y los símbolos
mostrados en las figuras 3.13 y 3.14, solo hay dos conexiones. Entonces, ¿cómo se
conecta?
Para los familiarizados con la electrónica puede ser una tarea obvia o recurrir
a utilizar un instrumento de medida para realizar comprobaciones, pero en realidad
no hace falta conociendo un poco más al componente en cuestión. Por ello se
muestra en la figura 3.15 las medidas y circuito interno de un pulsador. Ahora
observando el circuito interno (figura 3.15 parte inferior derecha) se puede
entender que dos terminales están interconectadas (la 4 con el 3 y el 2 con el 1) y
entre medio se encuentra la conexión que se cierra al pulsarlo; es decir, cuando se
pulsa los cuatro pines se encuentran interconectados.
Figura 3.15. Pulsadores.
51
Ahora bien, también se puede realizar un simple montaje que me va a

permitir comprobar el funcionamiento, de utilizar una resistencia pull-up o pull-
down. Para ello simplemente necesitará: 4 resistencias (2 de 330 Ω y 2 de 10 kΩ), 2
diodos y 2 pulsadores. El montaje se muestra en la figura 3.16, y para la realización
del montaje requerirá realizar las conexiones en la placa de prototipos. El código
de la resistencia de 10 kΩ es:
Marrón-Negro-Amarillo
Figura 3.16. Montaje prueba pulsadores con diodos.
Nota: la alimentación del circuito de la figura 3.16 se ha obtenido de un portapilas

con 4 pilas tipo AAA de 1,5 V cada una. Se podría obtener del pin de 5 V de Arduino
y el negativo del terminal GND. En este caso deberá estar conectado al
ordenador mediante USB para obtener el valor tensión. También se puede
recurrir a otras fuentes de tensión externas de 5 voltios.
52
Ejercicio resuelto 3: conmutada

Conectando dos pulsadores, a los pines 2 y 3, se desea controlar el encendido de 1
led conectado al pin 13. El funcionamiento es similar a una conmutada instalada en
una vivienda (control de un punto de luz desde dos puntos); es decir, al pulsar
cualquiera de los dos pulsadores, si el led está encendido, se apagará; y si está
apagado, se encenderá. Así pues con los dos pulsadores puedo controlar el
encendido y apagado del led.
El esquema de montaje se muestra en la figura 3.17, donde se utilizan
resistencias pull-up de 10 kΩ.
Figura 3.17. Circuito conmutado con Arduino.
El código del sketch a introducir es el que se muestra a continuación. Puede

intentar realizarlo antes de ver la solución.
Conmutada:
Con dos pulsadores en pines 1 y 2 controlamos un led en el pin 13*/
int pulsador1=2;
int pulsador2=3;
boolean encendido=0; // Variable led encendido o apagado
53
void setup() {
// Configuración de los pines 1 y 2 como entrada y 13 como salida
pinMode(pulsador1,INPUT);
pinMode(pulsador2,INPUT);
} // Fin setup
void loop() {
//Detecta si se ha pulsado
if(digitalRead(pulsador1)==LOW ||digitalRead(pulsador2)==LOW){
if(encendido==0){ // Si está apagado el led se enciende
encendido=1;
digitalWrite(rojo,HIGH);}
else{ // Si está encendido el led se apaga
encendido=0;
digitalWrite(rojo,LOW);}
/* La siguiente línea es un bucle cerrado estará en él hasta que se suelte el
pulsador */
while(digitalRead(pulsador1)==LOW||digitalRead(pulsador2)==LOW){}
} // Fin if
} // Fin loop
Comentar que aunque se han incluido comentarios en el propio texto, se van
a comentar algunos puntos:
• En la comparación se han incluido dos condiciones que se han unido

por operando lógico OR (||) cuyos símbolos se encuentran mediante
la siguiente combinación de teclas Alt Gr+1, y cuyo significado es que
para que se cumpla dicha condición se debe cumplir una u otra
condición. El operando lógico para indicar que se cumplan dos
condiciones es AND (&&).
• Si no se incluye el while, el código no para de ejecutarse y no se
encenderá y apagará como se espera. La solución es que cuando se
cumpla que se ha pulsado cualquiera de los dos pulsadores, entradas
54
2 y/o 3 pasen a nivel bajo (0V, LOW) se ejecute el if y a continuación

se quede en el bucle while hasta que se deje de pulsar.
• La variable encendido sirve para indicar si el led está encendido o
apagado, de tal forma que el primer if detecta si se ha pulsado alguno
de los dos pulsadores y el segundo se utiliza para cambiar el valor de
la variable encendido; es decir, si vale 0, entonces se activa la salida
poniendo la variable encendido a 1. Si no, apaga la salida poniendo la
variable encendido a 0.
Ejercicio resuelto 4: semáforo controlado por un pulsador

Partiendo del ejercicio resuelto 1 que muestra el ejemplo secuencial de encendido
de un semáforo, se quiere controlar el encendido y apagado del sistema, de tal
forma que al poner en marcha el Arduino, no se encenderá nada pero con el
pulsador conectado al pin 2 se pondrá en marcha el funcionamiento del semáforo
(ejercicio resuelto 1). Para que se apague se debe pulsar de nuevo el pulsador.
Entonces, independientemente de que el led esté encendido, este se apagará. Si se
vuelve a pulsar de nuevo el pulsador, volverá a ponerse en marcha el semáforo
empezando por el led rojo. La asignación de pines para la conexión de los diodos es
la misma que la del ejercicio resuelto 1. De todas formas, para una mejor aclaración
el montaje a realizar se muestra en la figura 3.18.
Figura 3.18. Semáforo controlador con un pulsador.
55
Comentar que la función delay utilizada pausa el programa. Como

consecuencia: no se leen sensores, no se hacen cálculos y no se puede manipular
los pines. Es decir, hace que casi toda la actividad se pare. En consecuencia, si se
encuentra utilizando la función delay cuando se pulse, entonces no se parará el
sistema y no se apagarán los leds.
Nota: solo siguen en funcionamiento con la función delay: la comunicación serie de

los pines de recepción, los valores de PWM con la función analogWrite, los estados
de los pines y las interrupciones.
Para evitar eso se utiliza la función millis. Dicha función devuelve los
milisegundos transcurridos desde que se arrancó la placa Arduino con el programa
actual. Este número se desbordará (volverá a cero) después de aproximadamente
50 días. El valor se debe guardar en una variable tipo long (sin signo), utilizando el
siguiente código:
unsigned long tiempo=0;
tiempo=millis();
En consecuencia se puede utilizar la función millis en sustitución a la función
delay. Leyendo el valor de tiempo, se ejecuta un bucle hasta que pase el tiempo
prefijado, de tal forma que no se pare el sistema y pueda leer el estado de las
entradas. El código utilizado sería el siguiente para un tiempo de 500 milisegundos
de retardo para la lectura de las pulsaciones (por ejemplo, para un contador) y
utilizando resistencia de pull-up:
unsigned long tiempoPrevio=0;
tiempoPrevio=millis();
digitalRead(pin) //leer dato
// Si han pasado 500 ms de la lectura y el pulsador no está pulsado
if (millis()-tiempoPrevio>500 && digitalRead(pin)==HIGH){
// Entonces continúa con el código para incrementar variable
} // fin if
Otro método en el cual se puede utilizar lo indicado anteriormente es
mediante while para que realice la misma función que el delay. Pero si mientras está
esperando si se pulsa una entrada externa, deje de esperar y continúe ejecutando el
56
código. Por ejemplo, a continuación se muestra el código que sustituiría a un retardo

de 1 segundo (1000 milisegundos) utilizando la función millis:
while(millis()-tiempoPrevio<1000 && condición inversa de salida){}
Los mismos ejemplo vistos con if y while, pero teniendo en cuenta que se ha
realizado la conexión con el pulsador con una resistencia pull-down. El
funcionamiento es a la inversa y habría que introducir un cambio: para que la tecla
no esté pulsada esta estará a nivel bajo, y por tanto, lo único que habría que
cambiar en el código sería:
…..&& digitalRead(pin)==LOW){
Una vez se ha indicado lo que tiene que hacer, a continuación se muestra el
código del ejercicio resuelto. Teniendo en cuenta que la condición de salida para
que pare el retardo de tiempo que se ha establecido de 5 segundos que está
encendido cada led es que se pulse el pulsador conectado al pin 2.
Semaforo controlador con un pulsador:
5s Rojo->5s Amarillo->5s Verde->5s Amarillo->repetir con un pulsador conectado al
pin 2 se controla la marcha y parada*/
int amarillo=12;
int verde=11;
int pulsador=2;
boolean encendido=0; // Variable led encendido o apagado
unsigned long tiempoPrevio=0; // Para lectura tiempo con millis()
void setup() {
pinMode(amarillo,OUTPUT);
57
// Configuración del pin 2 como salida

pinMode(pulsador,INPUT);
} //fin setup
void loop() {
if(digitalRead(pulsador)==LOW){ //Detecta si se ha pulsado
if(encendido==0){ // Si está apagado el led se enciende
encendido=1;
digitalWrite(rojo,HIGH);} // Fin if
else{ // Si está encendido el led se apaga
encendido=0;} // Fin else
/* La siguiente línea es un bucle cerrado y estará en él hasta que suelte el
pulsador */
while(digitalRead(pulsador)==LOW){}
} // Fin if
if(encendido==1){
while((millis()-tiempoPrevio)<5000 && digitalRead(pulsador)==HIGH){}
digitalWrite(rojo,LOW); // Apaga rojo
digitalWrite(verde,HIGH); // Enciende verde
digitalWrite(verde,LOW); // Apaga rojo
58

} // Fin if
} // Fin loop

Tomando el montaje que se muestra en la figura 3.19, con 4 diodos (conectados a
los pines: 10, 11, 12 y 13) y dos pulsadores (2 y 3).
Figura 3.18. Circuito para actividades propuestas.
1. Realiza el encendido secuencial de todos los leds empezando del pin 13

hasta el del pin 10. Cuando se hayan encendido todos los leds entonces
se apagarán los 4 y se volverá a repetir el ciclo. Puede tomar un tiempo
entre el encendido de cada led y el apagado de los 4 leds de 1 segundo
(1000 ms).
2. Ídem que el anterior pero en orden inverso: del pin 10 al pin 13.
3. Utilizando el pulsador conectado al pin 2, se debe controlar el encendido
y apagado del led conectado al pin 10. Para ello, hay que tomar como
referencia el ejercicio resuelto 2.
59
4. Controlar el encendido y apagado del led conectado al pin 13, de tal

forma que con el pulsador conectado al pin 2 se enciende y con el
pulsador conectado al pin 3 se apaga.
5. Controlar el encendido de los leds conectados a los pines 10 y 11, cuyo
funcionamiento sea:
• Si solo se acciona el pulsador conectado al pin 2, se enciende el led
• Si solo se acciona el pulsador conectado al pin 3, se enciende el led
• Si se pulsan ambos pulsadores, se apagarán los leds.
6. Controla el encendido de los leds conectados a los pines 12 y 13,
controlados por un pulsador conectado al pin 2, y cuyo funcionamiento
sea:
• Cuando se alimenta no estén ninguno de los dos leds encendidos.
• Si se acciona el pulsador, se debe encender el led conectado al pin
13 durante 2 segundos.
• A los 2 segundos se debe apagar y encender el led conectado al pin
12 durante 2 segundos, repitiéndose el ciclo.
• El ciclo debe mantenerse hasta que se vuelva a pulsar el pulsador,
momento en el cual y de forma independiente a qué led esté
encendido este se tiene que apagar, y no se encenderán ningún led
hasta que se vuelva a accionar otra vez el pulsador.
60
4. Ampliación entradas y salidas digitales
4.1 Introducción
En este capítulo no encontrará nuevos fundamentos sobre programación sino que
se centra en el aspecto más electrónico, destacando cómo conectamos otros tipos
de receptores (salidas) y sensores (entradas).
El objetivo es que se familiarice más con el montaje de componentes
electrónicos en la placa de prototipos y al mismo tiempo que repase los fundamentos
de programación vistos, analizando los ejemplos resueltos e intentando resolver los
problemas propuestos.
Se ampliará con otros sensores en el capítulo 6 con las entradas analógicas.
4.2 Conectando sensores a las entradas digitales

En el capítulo anterior se veía la utilización de un pulsador como dispositivo de
entrada digital. Ahora bien, en el mundo que nos rodea se puede utilizar una
variedad de dispositivos que nos permiten obtener información de nuestro
ambiente y procesar la información para activar o desactivar un dispositivo.
Teniendo en cuenta que las entradas digitales solo pueden tomar dos
valores, hay tensión o hay 0 voltios (es recomendable que siempre haya una
conexión en el pin de entrada que se utilice en Arduino).
A continuación se muestra una breve descripción de los sensores más
utilizados y cómo se conectan a Arduino:
• Tilt switch o interruptor de inclinación (figura 4.1): sirve para detectar

cambios de orientación o vibraciones. Su estructura se basa en un
recipiente en cuyo interior hay una bola metálica o material conductor
(por ejemplo, mercurio) de tal forma que en función de la orientación
61
establece una conexión o no entre los dos terminales (compruébelo

acercándoselo al oído y moviéndolo, oirá como que hay algo en el
interior). El conexionado es igual que con el pulsador pero
sustituyendo este por el interruptor de inclinación.
Figura 4.1. Tilt switch o conmutador de inclinación (cortesía de light country Co.).
• Reed switch o interruptor de lengüeta (figura 4.2): sirve para detectar

la proximidad de un campo magnético. Está compuesto por una
cápsula al vacío en cuyo interior hay dos lengüetas conectadas a los
terminales, de tal forma que al aproximar un campo magnético (imán)
estas lengüetas se unen o separan (según fabricación), cerrando o
abriendo el circuito entre ambos terminales (compruébelo cómo se
mueven las lengüetas al aproximar el imán). Este tipo de sensores se
utilizan para detectar la apertura de puertas, en donde se instala en la
parte móvil el imán y en la parte fija el interruptor de lengüeta para
facilitar el cableado. El conexionado es igual que con el pulsador pero
sustituyendo este por el interruptor de lengüeta.
Figura 4.2. Reed switch o interruptor de lengüeta (cortesía de Standex Meder).
62
• Finales de carrera (figura 4.3): sirven para detectar la posición del

elemento móvil. Disponen de una parte móvil. Se utiliza para realizar
el contacto y dicha pieza accionará un vástago que provocará que haya
un contacto entre dos de sus terminales. Su constitución eléctrica esta
normalmente compuesta por 3 terminales, de los cuales uno es común
para los otros dos, y los otros establecerán una conexión en función
de si se ha accionado el vástago (NA) o no (NC). El conexionado es igual
que con el pulsador pero sustituyendo este por el interruptor de
lengüeta.
Figura 4.3. Finales de carrera (cortesía BricoGeek).
Existen en el mercado otros dispositivos, como interruptores crepusculares

(que accionan un interruptor cuando se alcanza cierta intensidad lumínica) o
termostatos (que accionan un interruptor cuando se alcanza cierto valor de
temperatura), los cuales se podrían incluir en este apartado. Pero no es del todo
correcto porque dichos dispositivos requieren de un montaje electrónico adicional.
Para ello se verá en el capítulo 5 cómo conectar sensores para la medida de dichos
parámetros: fotorresistencia y sensor de temperatura.
Un ejemplo claro y que conviene comentar es el módulo de sensor PIR (figura
4.4) que dispone de 2 potenciómetros para ajustar el tiempo de respuesta entre
0,3 s y 25 s y la distancia de detección hasta 6 metros. Otro ejemplo podría ser el
seguidor de línea (figura 4.5), el cual incluye emisor y receptor de infrarrojos (RS-
06WD) con un circuito comparador que proporciona una salida digital, la cual le
permite detectar una línea negra sobre fondo blanco o viceversa. Con estos
ejemplos el lector podrá percatarse de la versatilidad que le ofrece Arduino y la
facilidad de añadir opciones mediante el uso de dispositivos modulares con unos
conocimientos básicos de electrónica, así como posibles aplicaciones.
63
Figura 4.4.- Sensor digital PIR (cortesía Seeed studio).
Figura 4.5.- Seguidor de línea (cortesía Seed studio).
Por ejemplo: el interruptor de lengüeta y el sensor digital PIR se pueden

utilizar en sistemas de seguridad. Otro ejemplo: el final de carrera y el seguidor de
línea se pueden utilizar en sistemas de robótica. Y así podríamos seguir líneas y
líneas, pero como esta no es la finalidad de este libro, sino que se pretende realizar
una presentación de cómo empezar y realizar sus primeros montajes y
programaciones, entonces si desea ampliar más información puede consultar otras
publicaciones más específicas.
Ejercicio resuelto 5: comprobación interruptor

de inclinación y reed
Conectaremos a los pines 2 y 3 un interruptor de lengüeta y un interruptor de
inclinación, respectivamente. De este modo, se desea controlar el encendido de
64
dos leds conectados a los pines 12 y 13, de tal forma que el interruptor de
inclinación accione el led conectado al pin 13 y el interruptor de lengüeta accione
el led conectado al pin 12.
El funcionamiento consiste en que cuando se detecte cualquiera de los dos
sensores se encienda el led correspondiente. Es decir, que si no hay modificación
de la inclinación o no se acerca el imán, no se encenderá ningún led (no habrá
tensión en el pin 2 o 3 correspondiente). Por el contrario, si se modifica la
inclinación o se acerca el imán, se encenderá el led (en ese caso habrá tensión en
el pin 2 o 3 correspondiente). Ello se consigue colocando una resistencia de pull-
down; es decir, la resistencia de 10 kΩ se conectará entre el pin de entrada y masa
para que cuando no se accione el sensor no haya tensión, y el sensor se conectará
entre la alimentación de 5 voltios y el pin de entrada para que cuando se accione el
sensor haya tensión. El esquema del montaje a realizar se muestra en la figura 4.6.
Figura 4.6. Conexión interruptor de inclinación y reed.
A continuación se muestra el código a implementar para que realice dicha

función:
Conexionado interruptor inclinación y reed:
con cada sensor se controla un led diferente */
int ledInclinacion=13; // Asignación variables a pines
65
int ledReed=12;
int sensorInclinacion=3;
int sensorReed=2;
void setup() {
pinMode(ledInclinacion,OUTPUT);
pinMode(ledReed,OUTPUT);
// Configuración de los pines 2 y 3 como salidas
pinMode(sensorInclinacion,INPUT);
pinMode(sensorReed,INPUT);
} // Fin setup
void loop() {
// Si está activa la entrada 3 activa salida 13
if(digitalRead(sensorInclinacion)==HIGH){
digitalWrite(ledInclinacion,HIGH);}
else{
digitalWrite(ledInclinacion,LOW);}
// Si está activa la entrada 2 activa salida 12
if(digitalRead(sensorReed)==HIGH){
digitalWrite(ledReed,HIGH);}
else{
digitalWrite(ledReed,LOW);}
} // Fin loop
Nota: aunque habrá comprobado que el programa no es complicado, el objetivo del
mismo es que trabaje con ambos sensores y se dé cuenta de cómo funcionan. El
sensor de inclinación si lo coloca sobre la placa de prototipos tendrá que modificar
la inclinación y oirá el movimiento de la pieza interna y cómo realiza la conexión
porque en cuanto haya contacto se encenderá el led. Del mismo modo verá como al
acercar al interruptor reed se desplazan las lengüetas y se encenderá el led.
66
Ejercicio resuelto 6: contador

Este ejercicio consiste en conectar un interruptor de lengüeta al pin 2, que controlará
el encendido de un led conectado al pin 12. El led se encenderá cuando haya
detectado 10 veces el interruptor, para ello tiene que pasar por cero. También se
dispondrá de un pulsador (conectado al pin 3) que reiniciará la cuenta; es decir, se
dispone de una variable que almacenará la cuenta y cuando se accione el pulsador el
valor pasará a 0. El esquema del montaje a realizar se muestra en la figura 4.7.
A modo informativo, se utilizan los siguientes elementos:
• Led conectado al pin 13, el cual se encenderá nada más poner en

marcha Arduino.
• Led conectado al pin 11, que se encenderá al accionar el pulsador.
• Led conectado al pin 10, que se encenderá cada vez que se accione el
sensor de lengüeta.
Figura 4.7. Conexionado función contador con Arduino.
A continuación se muestra el código a implementar para que realice dicha

función:
67

Contador:
cuenta hasta 10 con sensor reed, con 10 cuentas se activa el led pin 12, led marcha
13, led pulsador reset 11 y led interruptor reed 10*/
int ledInicio=13; // Asignación variables a pines
int ledFinCuenta=12;
int ledReset=11;
int ledReed=10;
int pulsador=3;
int sensorReed=2;
int cuenta=0; // Variable para almacenar la cuenta
int finCuenta=10; // Variable máxima cuenta
void setup() {
pinMode(ledInicio,OUTPUT);
pinMode(ledFinCuenta,OUTPUT);
pinMode(ledReset,OUTPUT);
pinMode(ledReed,OUTPUT);
// Configuración de los pines 2 y 3 como salidas
pinMode(pulsador,INPUT);
Serial.begin(9600); // Configuración comunicación
digitalWrite(ledInicio,HIGH); // Programa en marcha
} // Fin setup
void loop() {
// Detecta si hay una pulsación e incrementa el valor de cuenta
if(digitalRead(sensorReed)==LOW&&digitalRead(pulsador)==HIGH){
digitalWrite(ledReed,HIGH); // Indica qué detecta
cuenta++; // Incrementa valor de cuenta
68
Serial.println(cuenta); // Envía valor cuenta

if(cuenta==finCuenta){ // Si llega al valor final
digitalWrite(ledFinCuenta,HIGH);} // Se enciende el led
/* La siguiente línea es un bucle cerrado estará en él hasta que suelte el pulsador
*/
while(digitalRead(sensorReed)==LOW&&digitalRead(pulsador)==HIGH){}
} // Fin if para incrementar cuenta
else{
digitalWrite(ledReed,LOW);} // Fin else
// Si hay una pulsación reinicia la variable de cuenta
if(digitalRead(pulsador)==LOW){
digitalWrite(ledReset,HIGH); // Indica que se pulsa reset
digitalWrite(ledFinCuenta,LOW); // Lo apaga si está encendido
cuenta=0;
Serial.println(cuenta); // Envía valor cuenta
// Espera a que deje de pulsar el pulsador
} // Fin if para reiniciar valor cuenta
else{
digitalWrite(ledReset,LOW);} //Fin else
} // Fin loop
Para controlar el valor de la variable se va a utilizar el monitor del serial0 visto
en el capítulo 2. En él se visualizará el valor de dicha variable, para realizar el control
y supervisión del programa. Las líneas necesarias para incluirlo no afectan sobre el
funcionamiento del programa. En la figura 4.8, se muestra lo que se vería en la
ventana del monitor.
Nota: para probar el circuito, si no dispone de un sensor reed, lo puede realizar
sustituyéndolo por un pulsador simplemente para comprobar que la programación
es la correcta.
69
Figura 4.8. Ventana monitor contador.
Comentar que también se podría haber utilizado el siguiente código para

incrementar la variable cuenta:
cuenta=cuenta+1;
Si prueba el código mostrado con el programa, verá que si realiza unas

detecciones o pulsaciones rápidas, verá que en la ventana del monitor los números
cambian muy rápido; es decir, lo que yo considero como una pulsación Arduino lo
considerará como varias pulsaciones. Esto es debido a los denominados rebotes,
tal y como se muestra en la figura 4.9, para la cual se ha utilizado un osciloscopio
(instrumento de medida que permite observar los valores de tensión en función del
tiempo) y la señal de entrada a Arduino. Aunque dependiendo del estado del
pulsador, este efecto se intensifica a causa del desgaste del muelle (imagen que se
muestra en el cuadro inferior derecho de la figura 4.9). Este efecto se produce
debido a que la conexión no es perfecta e instantánea puesto que se compone de
dos partes de metálicas que entran en contacto; es decir, choca una con la otra al
pulsarlo. A simple vista para las personas esto no es perceptible pero para un
microcontrolador que trabaja a altas velocidades, del orden de megahercios, sí.
Para solucionar este problema hay dos soluciones una de hardware y otra de
software; o añadiendo algo al código del programa o añadiendo algo al montaje
electrónico exterior.
70
Figura 4.9. Rebotes en pulsadores.
Lo más sencillo es incluir un retardo para evitar esas fluctuaciones. Se puede

recurrir a la función delay, pero ya se comentó en el capítulo anterior el problema
que presentaba, por lo que es más común utilizar la función millis. Para ello, se
sustituye el siguiente código:
….
/* La siguiente línea es un bucle cerrado estará en él hasta que suelte el pulsador
*/
while(digitalRead(sensorReed)==LOW&&digitalRead(pulsador)==HIGH){}
….
….
Por el siguiente código con un retardo de 200 milisegundos:
unsigned long tiempoPrevio=0; // Para lectura millis
….
while((millis()-tiempoPrevio)<200&&digitalRead(pulsador)==HIGH){}
….
while((millis()-tiempoPrevio)<200){}
….
71
Mediante hardware hay varias opciones dependiendo de la dificultad. La

solución más simple es colocar un condensador en paralelo con el sensor o
pulsador. Un valor típico para estos montajes es utilizar un condensador cerámico
de 100 nanofaradios. Un condensador es un dispositivo electrónico que almacena
y es capaz de almacenar energía, de tal forma que al aplicar una tensión este se
carga hasta alcanzar el valor de la tensión de alimentación. Del mismo modo, si
se conecta un receptor este es capaz de entregar la energía almacenada. Una
mejora es añadir un circuito RC (que consiste en añadir una resistencia y
condensador juntos), y una puerta lógica inversora trigger Smith. Esta puerta
establece que si en la entrada hay 0 voltios en la salida hay 5 voltios, mientras
que si hay 5 voltios en la salida hay 0 voltios, y en particular las puerta inversora
trigger Smith asegura a la salida 0 o 5 voltios, aunque no sean dichos valores
exactos en la entrada. Además, el circuito RC establece un retardo de tiempo
determinado por el tiempo necesario para cargar y descargar el condensador. El
circuito y montaje se muestra en la figura 4.10.
Figura 4.10. Circuito retardo RC con disparador trigger Smith.
Se pueden utilizar ambas soluciones o una de ellas. Todo dependerá de las

nociones que tenga el usuario. Si no está muy familiarizado con el montaje de
circuitos de electrónica es suficiente con incluir las modificaciones en el programa,
solución por software.
4.3 Conectando más receptores a las salidas digitales

Hasta este punto solo se han conectado como salidas digitales un diodo led, pero
hay muchos otros receptores que permiten añadir más funcionalidades a Arduino.
Se van a comentar la utilización de un diodo RGB y el uso de un relé.
72
El diodo RGB, a diferencia de los diodos que se han visto hasta el momento,
tiene 4 terminales, y ello es porque su constitución interna es como si se tratará de
3 diodos led con el cátodo común (figura 4.11). El método de conexionado es similar
al diodo, teniendo en cuenta que el terminal más largo se corresponde con el
cátodo. Otro método de identificar este terminal es colocando la muesca a la
izquierda y sigue la siguiente correspondencia:
1: cuando se alimenta se ilumina el color rojo.
2: común a los 3 diodos.
3: cuando se alimenta se ilumina el color verde.
4: cuando se alimenta se ilumina el color azul.
Figura 4.11. Diodo RGB
En consecuencia se podría sustituir este diodo por los 3 diodos utilizados en

el montaje del semáforo del capítulo 3. La diferencia es que con dos pines se
obtendrían los colores, alimentando solo los terminales de rojo y verde, puesto que
se pueden conseguir otros colores con la mezcla de los 3 colores, por ejemplo:
Amarillo: Rojo + Verde.
Magenta: Rojo + Azul.
Cian: Verde + Azul.
Blanco: Rojo + Azul + Verde.
El relé se utiliza para alimentar receptores que acepten otros niveles de
tensión que los proporcionados por las salidas digitales de Arduino, también por la
limitación de corriente que pueden entregar este tipo de salida (es recomendable
no sobrepasar los 20 mA). El uso de utilizar el relé requiere la utilización de un
transistor que sirve de interfaz para que actúe el relé. Se puede ver un ejemplo en
la figura 4.12.
73
Figura 4.12. Conexión relé (cortesía Seeed studio).
El circuito para activar el relé (figura 4.2) consiste en conectar la salida de

Arduino a la base de un transistor por medio de una resistencia (cuyo valor es de
4,7 kΩ porque la tensión de alimentación es de 5 voltios (Vcc). Además la bobina
del relé debe indicar que es para 5 voltios. Si el circuito se alimenta a otros valores
de tensión este valor cambiará. Por ejemplo, para una tensión de alimentación de
12 voltios se requerirá una resistencia de 8,2 kΩ. Esto es debido a que la resistencia
de la bobina del relé cambia en función de la tensión de alimentación a la cual fue
diseñada, por lo tanto se modifica la corriente de colector del transistor. El
transistor que se ha utilizado es de montaje superficial (SMD) pero para montajes
en la placa de prototipos es común utilizar el transistor 2N2222 (figura 4.13).
Figura 4.13. Transistor 2N2222.
74
Se utiliza un diodo que se conecta en antiparalelo con la bobina del relé, y su

función es la de absorber los picos de corriente que se producen en la bobina en
los procesos de conmutación; es un elemento de protección.
El diodo es un dispositivo semiconductor que permite el paso de corriente en
un sentido; y en el contrario, la bloquea. Para su conexión se debe tener en cuenta
que en el sentido de la corriente viene indicado por una raya que indica su polaridad,
el terminal que lleva la raya corresponde con el cátodo y la que no con el ánodo,
teniendo en cuenta que la corriente circula de ánodo a cátodo (figura 4.14).
Figura 4.14. Diodo.
Además el circuito que se muestra en la figura 4.12 ha incluido un diodo led

con una resistencia que indica que la bobina del relé está alimentada, aunque esta
conexión no afecta sobre el funcionamiento del circuito.
Figura 4.15. Relé (cortesía de Finder).
75
Finalmente el relé dispone de unas conexiones que aceptan valores de

tensión y corriente elevados, puede disponer de varios contactos. El relé que se
muestra en la figura 4.15 dispone de dos contactos, que permiten la conexión de
dispositivos de 230 voltios y 8 amperios. Por ejemplo, se podría utilizar un contacto
para que activara un indicador acústico (sirena) y otro contacto para que activara
una señal luminosa (lámpara), todo controlado desde la misma salida de Arduino.
Además el relé que se muestra en la figura 4.15, tiene la posibilidad de ser soldado
a una placa de circuito impreso, montaje en placa de prototipos o utilizando un
zócalo.
Nota: parece complicado pero en realidad cuando realice los próximos montajes
verá como no es tanta dificultad, y seguro que le vendrán a la mente varias
aplicaciones nuevas.
Ejercicio resuelto 7: led multicolor

Se pretende conectar un diodo RGB a los pines 11, 12 y 13, y se desea que siga la
siguiente secuencia de colores continuamente:
Rojo→Magenta→Azul→Cian→Verde→Amarillo→Blanco
Figura 4.16. Montaje con diodo RGB, led multicolor.
El esquema del montaje se muestra en la figura 4.16, y el código a

implementar es el siguiente:
76

Semáforo con led RGB:
Rojo-magenta-azul-cian-verde-amarillo-blanco */
int verde=12;
int azul=11;
int retardo=200;
void setup() {
pinMode(azul,OUTPUT);
} // Fin setup
void loop() {
digitalWrite(azul,LOW); // Apagar azul
digitalWrite(verde,LOW); //Apagar verde
delay(retardo); // Retardo 0,2 s
digitalWrite(azul,HIGH); // Añadir azul--> magenta
delay(retardo);
digitalWrite(rojo,LOW); // Apagamos rojo-->azul
delay(retardo);
digitalWrite(verde,HIGH); // Añadir verde-->cian
delay(retardo);
digitalWrite(azul,LOW); // Apagamos rojo-->verde
delay(retardo);
digitalWrite(rojo,HIGH); // Añadir rojo-->amarillo
delay(retardo);
77
digitalWrite(azul,HIGH); // añadir azul-->blanco

delay(retardo);
} // Fin loop
Ejercicio resuelto 8: control iluminación tras apertura de puerta

Controlar el encendido de una lámpara colocada en un vestíbulo, de tal forma que
cuando se abra la puerta de entrada esta permanezca encendida durante 1 minuto.
Si la lámpara está encendida y se vuelve a abrir la puerta, el tiempo se debe
reiniciar. Por ejemplo, si se deja la puerta abierta la lámpara siempre estará encendida.
Para el control de apertura de la puerta se utilizará un interruptor reed
colocado en el marco de la misma (figura 4.17).
Figura 4.17.- Detector magnético, interruptor reed (cortesía Security Honeywell).
Figura 4.18. Montaje con relé e interruptor reed para control iluminación.
78

Control iluminación: Tras abrir una puerta se mantiene 1 minuto activo un punto
de luz*/
int luz=13; // Asignación variables a pines
int sensorReed=2;
int encendido=0; // Para saber si está encendida
int segundos=0; // Se incrementa cada segundo
int tiempo=60; // Duración temporalización en seg.
unsigned long tiempoPrevio=0; // Variable para utilizar millis
void setup() {
// Configuración del pin 13 como salida
pinMode(luz,OUTPUT);
// Configuración del pin 2 como entrada
Serial.begin(9600);// Configuración comunicación
} // Fin setup
void loop() {
// Si detecta que se abre la puerta que se encienda
if(digitalRead(sensorReed)==LOW){
digitalWrite(luz,HIGH);
encendido=1;
delay(200);}
// Si se ha encendido se activa el temporizador
if(encendido==1){
for(segundos=0;segundos<tiempo;segundos++){
// Temporizador 1 segundo
79
// Retardo 1 s, que finaliza si se activa el interruptor reed

while((millis()-tiempoPrevio)<1000&&digitalRead(sensorReed)==HIGH){}
Serial.println(segundos); // Envía valor
if(digitalRead(sensorReed)==LOW){
segundos=0;}// Para reiniciar la cuenta si se vuelve a activar
} // Fin for
if(digitalRead(sensorReed)==HIGH){
digitalWrite(luz,LOW);
encendido=0;} // Apaga si pasa tiempo sin reiniciar
} // Fin if
} // Fin loop
Figura 4.19. Monitor variable segundos.
En el código se ha utilizado el Serial0 del Arduino para comprobar la cuenta

y ver que dicho valor se iba modificando y se reinicia. Para simplificar el proceso de
revisión del tiempo se ha incluido en el código la variable llamada segundo que se
incrementa pasado un segundo. En la figura 4.19 se muestra cómo se visualiza el
valor de dicha variable en el monitor.
80
Comentar, para los menos familiarizados con el montaje, que en la figura

4.18 los contactos del relé se han dejado con un conector. Para la prueba del
circuito puede simplificarlo utilizando un pulsador como interruptor reed (si no
dispone de dicho componente) y oirá un tac (golpe seco de las placas metálicas en
su interior) cada vez que se accione el relé (cuando se alimente su bobina). Para los
más atrevidos puede realizar el montaje (en función de su disponibilidad), con una
lámpara de 12 voltios de corriente continua (como en los coches) o una de 230
voltios (como la que se encuentran en las viviendas), en todo caso se trabaja con
tensiones peligrosas y deberá tener mucho cuidado (figura 4.20).
Figura 4.20. Conexión de lámpara de 230 V a la salida de Arduino con relé.
Figura 4.21. Montaje punto de luz con relé de estado sólido (cortesía Seed studio).
81
Llegados a este punto comentar que existe la posibilidad de utilizar los

denominados relés de estado sólido, que ofrecen ventajas como que al no tener
partes mecánicas no hace ruido en las conmutación (útil en instalaciones
domésticas para evitar ruidos) o trabajar a frecuencias más altas. A modo de
ejemplo se muestra en la figura 4.21 un módulo con relé de estado sólido para
montaje modular y la facilidad de montaje sin conocimientos de electrónica.

1. Se desea preparar el automatismo para un cuarto de aseo, de tal forma
que al entrar se accione un pulsador y durante 2 minutos se pondrá en
marcha un punto de luz y un extractor. Propón un circuito de cómo se
conectaría y realice el programa para Arduino. El pulsador se conecta al
pin 2, el punto de luz al pin 3 y el extractor al pin 4.
2. Estudie cómo funciona un minutero de escalera de una pequeña finca de 3
plantas, con un pulsador por cada planta y un punto de luz en cada tramo
de escalera. ¿Cree que podría implementarlo con Arduino? ¿Tiene
bastantes pines digitales? ¿Los puntos de luz funcionan a 230 V a 50 Hz que
se necesitaría? Empiece a nombrar los pines desde 13 para abajo.
3. Realice un juego de luces utilizando un diodo RGB con tres pulsadores,
uno para cada color. Realice un programa en Arduino que lo controle y
compruebe las distintas combinaciones de colores. Los pulsadores se
conectan a los pines 2, 3 y 4; mientras que las conexiones al diodo RGB
se conectan a los pines 11, 12 y 13.
4. Conectando un diodo RGB y un interruptor de inclinación, programe el
Arduino de tal forma que, en posición horizontal el led se ilumine de
color blanco y al cambiar la orientación que se ponga a parpadear rojo
y blanco hasta que vuelva a la posición horizontal. Se conecta el
interruptor de inclinación al pin 2 y las conexiones al diodo RGB se
conectan a los pines 11, 12 y 13.
5. Se desea controlar una puerta de garaje con Arduino, para ello se
dispone de dos finales de carrera, uno para indicar que la puerta está
cerrada y otro para indicar que está abierta. Para accionar la maniobra
se utiliza un pulsador, de tal manera que si está cerrada y se pulsa, la
puerta se tiene que abrir; si está abierta y se pulsa, la puerta se tiene
que cerrar. Si mientras se está cerrando o abriendo la puerta, se pulsa,
la puerta se debe parar. Y cuando se vuelva a pulsar, la puerta se tiene
que abrir.
82
Para indicar que la puerta se está abriendo o cerrado se utilizan las

salidas de un relé, de tal forma que se activará la salida 12 para subir la
puerta y se activará la salida 11 para bajar la puerta. Debe tener en
cuenta que no se pueden activar ambas salidas al mismo tiempo ya que
de lo contrario puede provocar un cortocircuito. Para realizar pruebas
puede realizar el montaje conectando a ambas salidas un diodo led.
La entrada se conecta al pin 2, mediante un pulsador para iniciar la
maniobra.
6. Añada al programa del ejercicio anterior que cuando la puerta esté
subiendo, utilice un diodo RGB que parpadee con los colores rojo y
amarillo con un tiempo de cambio de colores de 0,5 segundos.
83
5. Salidas digitales PWM
5.1 Introducción
En este capítulo se verá otra funcionalidad más de los pines digitales de Arduino,
de tal forma que mediante una función se puede controlar una señal PWM
(modulación por ancho de pulso). Lo primero que habrá que tener en cuenta es que
solo los pines 3, 5, 6, 9, 10 y 11 tienen esta funcionalidad. Lo segundo es saber qué
es modulación por ancho de pulsos. Y tercero qué receptores o cómo se conectan
a dichas salidas.
Figura 5.1. Pines digitales PWM.
5.2 Modulación por ancho de pulso (señal PWM)

Una señal modulada de ancho de pulso consiste en una señal de frecuencia
determinada (mismo período) con dos valores fijos de tensión, cuyo tiempo está a
nivel alto o bajo, o se modifica, siendo representado el valor en tanto por ciento
denominado ciclo de trabajo. Por ejemplo, un ciclo de trabajo del 50 % de una señal
cuyo período es 1 s, estará a nivel alto (5 voltios) 0,5 segundos y estará a nivel bajo
(0 voltios) 0,5 segundos. Si es un ciclo de trabajo del 75 % estará 0,75 segundos a
nivel alto y 0,25 segundos a nivel bajo. También se utiliza el término de ancho de
pulso para indicar el tiempo que la señal está a nivel alto. Lógicamente, si se calcula
el valor medio de ambas señales (ciclo de trabajo al 50 % y 75 %), el valor será mayor
85
para la señal cuyo ciclo de trabajo sea mayor (es decir 75 %), de ahí el nombre
utilizado por la función en Arduino, puesto que Arduino no es capaz de suministrar
un valor analógico de salida.
En Arduino se utiliza la siguiente función:
analogWrite(número de pin, valor);
En donde el número pin tiene que ser uno de los 6 pines comentados (figura
5.1) y el valor tiene que ser un número entero de 0 hasta 255, de tal forma que el
cero corresponde a un ciclo de trabajo del 0 % y 255 corresponde a un ciclo de
trabajo del 100 %. Todo lo comentado se muestra gráficamente en la figura 5.2.
Figura 5.2. Señal PWM en Arduino (Cortesía de Spankfun).
A continuación se muestran algunos ejemplos de utilización de dicha función

(tomando como referencia el pin 11):
analogWrite(11, 0); // Ciclo de trabajo del 0 %
Cabe comentar que la frecuencia de dicha señal es bastante próxima a
500 Hz (490 Hz) lo que equivale a períodos de 2 milisegundos (el período es la
inversa de la frecuencia) cada uno.
86
Ejercicio resuelto 9: regulación iluminación led

Hasta ahora las salidas digitales se conectaban a un led, y tenía dos estados:
encendido o apagado. Sin embargo, ahora, aplicándole una señal PWM podré variar
el ciclo de trabajo de la señal aplicada al diodo, de tal forma que la intensidad
lumínica del diodo se modificará desde 0 hasta el 100 % y viceversa.
El montaje consiste en conectar al pin 11 un diodo led con una resistencia de
330 Ω. La programación consiste en dos bucles for para realizar el incremento de
intensidad y el decremento de la misma.
El código es el siguiente:
Varía la intensidad en led mediante señal PWM */
int led=11; // Asignación variable a pin
int intensidad=0;
int retardo=250;
void setup() {
// Configuración pin como salida
pinMode(led,OUTPUT);
} // Fin setup
void loop() {
// Incremento progresivo del ciclo de trabajo 0->255
for(intensidad=0;intensidad!=255;intensidad=intensidad+15){
analogWrite(led,intensidad);
Serial.println(intensidad);
delay(retardo);}
// Decremento progresivo del ciclo de trabajo 255->0
for(intensidad=255;intensidad!=0;intensidad=intensidad-15){
analogWrite(led,intensidad);
Serial.println(intensidad);
87
delay(retardo);}
} // Fin loop
Para visualizar los cambios en la variable intensidad, la cual ajustará el valor
del ciclo de trabajo y la intensidad del led, se utiliza la visualización del monitor por
serial0. En la figura 5.3 se puede ver cómo va variando este valor.
Figura 5.3. Monitor variable intensidad.
5.3 Variar la velocidad de un motor de continua

Este tipo de control me va a permitir conectar nuevos receptores que a su vez
proporcionan más posibilidades a los diseños con Arduino. Una de ellas es conectar
a una salida un pequeño motor de continua de 5 voltios de continua. El esquema de
montaje a realizar se muestra en la figura 5.4. Con este tipo de motor, además, si se
conecta a una salida PWM, se permitirá modificar su velocidad.
Se puede apreciar su similitud con el circuito para activar un relé pero
sustituyendo las conexiones de la bobina del relé por las conexiones del motor,
incluido el diodo conectado en antiparalelo. Si el motor a controlar requiere un
mayor consumo o tensiones diferentes a los 5 voltios, se podría recurrir al relé para
su puesta en marcha y parada pero no para variar su velocidad. En el caso de querer
88
variar la velocidad se deber recurrir a otro circuito adicional cuyo funcionamiento

es similar al del relé pero que es capaz de trabajar a mayores frecuencias. Por
ejemplo, un relé de estado sólido, o montajes con transistores Mosfet.
También se puede recurrir a dispositivos (integrados) específicos para el control de
motores concretos, como los motores paso a paso, muy útiles en montajes sobre
robótica. Debido a que el objetivo de esta obra es a modo introductorio y principios
básicos para el manejo de Arduino, si desea ampliar esta información deberá
recurrir a una bibliografía más específica.
Figura 5.4. Control motor de 5 voltios dc con Arduino.

con dos pulsadores
Se desea controlar mediante dos pulsadores la velocidad de un motor dc conectado
al pin 6, mediante dos pulsadores conectados a los pines 2 y 3. El pulsador
conectado al pin 2 permite aumentar la velocidad del motor progresivamente
(aumentando en 15 su valor), mientras que el pulsador conectado al pin 3 permite
reducir la velocidad del motor progresivamente (disminuyendo en 15 su valor).
Inicialmente el motor estará parado (valor 0 para la variable velocidad), y la
velocidad a la cual se haya seleccionado mediante los pulsadores se mantendrá
mientras no se pulse ningún pulsador.
89
Cuando se llegue al valor máximo (valor 255 para la variable velocidad),

aunque se continúe pulsando para aumentar la velocidad, el valor de la variable no
se verá modificado.
Figura 5.5. Montaje control velocidad motor 5 voltios con Arduino.

Varía velocidad de motor con dos pulsadores */
int motor=5; // Asignación variable a pin
int pulsadorSubir=2;
int pulsadorBajar=3;
int velocidad=0;
int retardo=200;
void setup() {
pinMode(motor,OUTPUT);
90
// Configura pines 2 y 3 como entradas

pinMode(pulsadorSubir,INPUT);
pinMode(pulsadorBajar,INPUT);
} // Fin setup
void loop() {
// Incrementar valor variable velocidad
if(digitalRead(pulsadorSubir)==LOW&&digitalRead(pulsadorBajar)==HIGH){
if(velocidad<255){
velocidad=velocidad+15;}
else{
velocidad=255;}
Serial.println(velocidad); // Enviar dato
while((millis()-tiempoPrevio)<retardo&&digitalRead(pulsadorBajar)==HIGH){}
} // Fin if
// Decrementar valor variable velocidad
if(digitalRead(pulsadorBajar)==LOW&&digitalRead(pulsadorSubir)==HIGH){
if(velocidad>0){
velocidad=velocidad-15;}
else{
velocidad=0;}
Serial.println(velocidad); // Enviar dato
while((millis()-tiempoPrevio)<retardo&&digitalRead(pulsadorSubir)==HIGH){}
} // Fin if
analogWrite(motor,velocidad); // Ajustar velocidad
} // Fin loop
91
Para visualizar la variación de la variable velocidad, que ajustará el valor del

ciclo de trabajo y la velocidad del motor controlado a través de los pulsadores, se
utiliza la visualización del monitor por serial0. En la figura 5.6 se puede ver cómo va
variando este valor en saltos de 15 en 15.
Figura 5.6. Monitor variable velocidad.
Ejercicio resuelto 11: motor con inversión del sentido de giro

Aunque existen en el mercado circuitos integrados y módulos específicos para
controlar estos dispositivos, un método sencillo de manejo del motor visto en el
ejercicio anterior es que se puede modificar el sentido de giro invirtiendo la
tensión de alimentación. Para ello se utiliza el denominado como puente H, tal y
como se muestra en la figura 5.7. Todo ello controlado por dos salidas que actúan
sobre dos relés.
Observando el esquema de la figura 5.7, girará en un sentido cuando se
cierren los interruptores S1 y S4, y en el sentido contrario cuando se cierren los
interruptores S2 y S3, puesto que se invierte la alimentación en las conexiones
del motor.
92
Figura 5.7. Conexión puente en H inversión sentido de giro.
Figura 5.8. Conexionado puente H con dos relés controlados por Arduino.
Para realizar estas conexiones se pueden realizar a través de dos relés

conectados a dos salidas, con dos contactos cada uno. Hay que tener especial
cuidado en que no actúen ambos relés puesto que ello provocará un cortocircuito
en la fuente de alimentación (figura 5.8).
93
El ejercicio consiste en cambiar el sentido de giro controlado por dos

pulsadores. Se utilizan las salidas 12 y 13 para controlar dos relés, K1 y K2 de la
figura 5.8. Si solo se alimenta K1 y K2 no, se tendrá un extremo del motor conectado
a positivo y el otro a negativo. Por el contrario, si se alimenta K2 y K1 no, se tendrá
la conexión a la inversa. En el caso de que no se alimenten ninguno habrá negativo
en ambos extremos del motor y no girará, si se alimentan ambos tendrá 5 voltios
en ambos extremos del motor y no girará (no es conveniente que esta condición se
produzca porque en otros montajes cuya lógica es la misma el circuito para el
control de un motor puede provocar cortocircuitos en la fuente de alimentación).
Figura 5.9. Funcionamiento puente H sentido motor dc.
Para el control del sentido de giro se utilizan tres pulsadores conectados a

los pines: 2 (girará hacia la izquierda), 3 (girará hacia la derecha) y 4 (para el motor).
El funcionamiento es el siguiente: estando el motor parado, si se acciona el
pulsador conectado al pin 2 o 3 el motor se pondrá en marcha en el sentido
correspondiente, pero ya no se pondrá en marcha en el otro sentido si no se ha
parado previamente el motor. A modo informativo se envía una cadena de texto
para indicar en qué sentido está girando el motor.
El código a implementar es el siguiente:
Inversor giro motor dc mediante pulsadores de paso por cero */
int motorDerecha=13; // Asignación de pines
int motorIzquierda=12;
int pulsadorParada=4;
94
int pulsadorDerecha=3;
int pulsadorIzquierda=2;
int marcha = 0; // variable marcha-paro
void setup() {
// Configuración pines 13 y 12 como salida
pinMode(motorDerecha,OUTPUT);
pinMode(motorIzquierda,OUTPUT);
// Configura pines 2, 3 y 4 como entradas
pinMode(pulsadorParada,INPUT);
pinMode(pulsadorIzquierda,INPUT);
pinMode(pulsadorDerecha,INPUT);
} // Fin setup
void loop() {
/* Mientras que no se pulse la parada y esté parado el motor, se podrá poner en
marcha en cualquier sentido */
while(digitalRead(pulsadorParada)==HIGH&&marcha==0){
// Pone en marcha en sentido a la izquierda
if(digitalRead(pulsadorIzquierda)==LOW&&digitalRead(pulsadorDerecha)==HIGH){
digitalWrite(motorIzquierda,HIGH);
Serial.println("Izquierda"); // Envía texto
marcha=1;} //Fin if
// Pone en marcha en sentido a la derecha
if(digitalRead(pulsadorIzquierda)==HIGH&&digitalRead(pulsadorDerecha)==LOW){
digitalWrite(motorDerecha,HIGH);
Serial.println("Derecha");
marcha=1;} //Fin if
} // Fin while
95
//Cuando se para resetea la variable marcha y desactiva salidas

if(digitalRead(pulsadorParada)==LOW){
digitalWrite(motorIzquierda,LOW);
digitalWrite(motorDerecha,LOW);
Serial.println("Parada");
marcha=0;
delay(200);
} // Fin if
} // Fin loop
Nota: este montaje no corresponde directamente al control con salida digital PWM
pero se ha considerado incluirlo en este apartado por similitud a los conceptos vistos.
5.4 Control de servomotores

Los servomotores (figura 5.10) tienen engranajes integrados y un eje que se puede
controlar con precisión. Los servomotores estándares permiten que el eje se sitúe
en varios ángulos, por lo general entre 0 y 180 grados, aunque también hay de
rotación continua, que permiten la rotación del eje a distintas velocidades. Son
ampliamente utilizados en montajes relacionados con la robótica.
Figura 5.10. Servomotor (Cortesía Bricogeek).
Los servomotores tienen tres conexiones: alimentación, masa y señal. El

cable de alimentación suele ser rojo, y debe ser conectado al pin de 5 V de la placa
Arduino; el de masa es normalmente de color negro o marrón y se debe conectar
96
al pin GND de la placa Arduino; y el cable de señal es generalmente de color

amarillo, naranja o blanco y debe ser conectado a un pin digital en la placa Arduino.
Hay que tener en cuenta que los servos consumen energía
considerablemente, por lo que si tienes que manejar más de uno o dos,
probablemente tendrás que alimentarlos mediante una fuente independiente (es
decir, no del pin +5 V en la placa de Arduino). Asegúrate de conectar la tierra del
Arduino y la fuente de alimentación externa (figura 5.11).
Para el manejo de este dispositivo Arduino posee la librería Servo.h, la cual
se debe añadir al principio del código. Una vez incluida estará disponible la
siguiente función:
#include<Servo.h>
servo servo1; // Objeto servo
myservo.attach(número pin); // Pines 9 y/o 10
myservo.write(posición);
Figura 5.11. Montaje conexión servo.
La variable posición puede tomar los valores de 0 a 180, y corresponderán

con los valores que irá tomando. El funcionamiento consiste en que envía impulsos
de 1,25 milisegundos (0 grados) hasta 1,74 milisegundos (180 grados). Esta librería
permite manejar dos servos que se conecten a los pines 9 y 10.
A modo de ejemplo y para que sirva de guía de cómo utilizar las funciones
que contiene la librería, se muestra el siguiente código que realiza un
97
desplazamiento desde la posición 0 hasta la 180 y viceversa. A modo informativo

envía la información de la posición por puerto serial0 para ser visualizados sus
valores. Por ello se utiliza un retardo de 200 milisegundos para que sea capaz de
ver cómo varía dicho valor:
Manejo básico del servo */
#include <Servo.h>
Servo myservo; // crea un objeto tipo servo para controlar el servo
int posicion = 0; // variable para almacenar la posición del servo
void setup()
{
myservo.attach(9); // establece conexión al pin 9 de un servo
} // Fin setup
void loop()
{
// Desplazamiento posición 0 a 180 en pasos de 1 grado
for(posicion=0;posicion<180; posicion++){
myservo.write(posicion); // Posicionar servo
Serial.println(posicion); // Envía variable
delay(200); // retardo 200ms
} // Fin for
// Desplazamiento posición 180 a 0 en pasos de 1 grado
for(posicion=180;posicion>=1; posicion--){
myservo.write(posicion); // Posicionar servo
Serial.println(posicion); // Envía variable
delay(200); // retardo 200ms
} // Fin for
} // Fin loop
98
Ejercicio resuelto 12: control serie posición servo

Se pretende realizar un programa que mediante el control por serial0, e
introduciendo el valor desde el monitor, este posicione el servo en dicho ángulo.
Como solo se pueden enviar caracteres (código ASCII de dicho carácter si se
almacena en una variable int), se escribe un número del 0 al 9 en el monitor para
indicar las posiciones que se pueden tomar:
0-20-40-60-80-100-120-140-160-180
No requiere realizar ningún montaje adicional al mostrado en la figura 5.11,
y el código para implementar es el siguiente:
Control posición del servo por serial0 */
#include<Servo.h>
Servo myservo; // crea un objeto tipo servo
int posicion=0; // variable con posición del servo
void setup() {
myservo.attach(9); // establece conexión al pin 9 de un servo
} // Fin setup
void loop() {
// Si hay un carácter en el buffer de entrada lo almacena
posicion=Serial.read(); // Almacena código ASCII recibido
posicion=(posicion-48)*20; // Aplica conversión
myservo.write(posicion); // Coloca posición
Serial.println(posicion); // Envía dato
} // Fin if
} // Fin loop
Nota: el código ASCII de los números 0 hasta 9 son del 48 al 57 respectivamente.
99
5.5 Pines 1 y 2
Llegados a este punto se habrá preguntado cómo hemos llegado al último punto,
en donde se menciona las entradas y salidas digitales, si no se ha hablado nada de
ellas. Además le habrá resultado curioso que cada vez que se empezaba a nombrar
los pines que iban a ser utilizados se iniciaba a partir del 2. ¿Por qué?
Esto es porque dichos pines son las mismas conexiones que se utilizan para
la comunicación serie, para la transmisión y recepción de datos. Por ello estos pines
no pueden ser utilizados como entradas y salidas cuando se utiliza la comunicación
serie mediante serial0. Por ello se decidió no utilizarlos en ningún ejercicio resuelto,
debido a que a lo largo del libro se está utilizando en varios ejercicios resueltos el
serial0, de tal forma que no hubiera confusión por el hecho de que unas veces se
utilizara y otras no.

1. Implemente un montaje y la programación para controlar la regulación
de la velocidad de un motor dc a través del serial0, de tal forma que se
controle la velocidad de 0 a 9, siendo 9 la velocidad máxima y 0 la
velocidad mínima. La escala de velocidades sigue la siguiente
correspondencia:
30-55-80-105-130-155-180-205-230-255
2. Realiza el control de inversión de giro de un motor dc a través del serial0,
de tal forma que: enviando el carácter d gire a derecha (active salida
conectada al pin 13), enviando el carácter i gire a izquierda (active salida
conectada al pin 12) y enviando el carácter p para parar el motor. Para
realizar el arranque del motor (independientemente del sentido de giro)
el motor debe estar parado.
3. Realice el control de intensidad de un led conectado a una salida 11
PWM, mediante serial0, de tal forma que con el carácter + se aumenta
la intensidad y con el carácter – se disminuye (los incrementos y
decrementos son de un valor entero de 15). Visualice el valor.
4. Controle la posición de un servo (conectado al pin 9) utilizando dos
pulsadores conectados a los pines 2 y 3.
100
6. Entradas analógicas
6.1 Introducción
En este último capítulo se muestra el uso de las entradas analógicas en Arduino
(figura 6.1). Del mismo modo se muestra cómo conectar y obtener datos de
sensores que proporcionan valores variables, tales como: temperatura e intensidad
lumínica.
Figura 6.1. Entradas analógicas.
6.2 Las entradas analógicas de Arduino

Arduino UNO dispone de 6 entradas analógicas con una resolución de 10 bits, es
decir, que cada valor que se mida por dichas entradas tomará valores de 0 a 1023.
Además, como la tensión de referencia es de 5 voltios, entonces cuando haya 5
voltios en una entrada digital se corresponderá con el valor 1023; y cuando la
tensión en una entrada digital sea de 0 voltios, se corresponderá con el valor 0. Se
puede modificar dicho valor de referencia utilizando la siguiente función:
analogReference();
En este caso utilizará como valor de referencia el valor que se introduzca por
el pin AREF que se encuentra junto a los pines de entrada y salida digitales.
La resolución de estas entradas analógicas (qué valores puede tomar) viene
determinada por la tensión de referencia y la cantidad de valores que se puede
101
tomar. En este caso la resolución es de 0,00488 voltios (4,88mV); es decir, si lee un

10 es que hay presentes 48,8 mV en la entrada.
Las entradas analógicas no hay que definirlas como en el caso de los pines
digitales, porque por defecto ya están definidas como entrada. Para leer un dato se
utiliza la siguiente función, la cual devuelve un número entero:
int medida;
medida=analogRead(número del pin)
// La numeración del pin, es de 0 hasta 6 (figura 6.1)
Otra alternativa que ofrecen estas entradas analógicas es la de utilizarlas
como entradas o salidas digitales. Su funcionamiento sería como el descrito en los
capítulos anteriores pero para definirlas corresponderían con los pines 14 al 19.
Ejercicio resuelto 13: lectura potenciómetro

A modo de ejemplo, y llegado a este punto, se va a conectar un potenciómetro (se
trata de una resistencia variable de tal forma que entre sus extremos se
corresponde con el valor resistivo y en la posición central se dispone de un cursor
que permite presenta un valor resistivo en función del recorrido que deba
atravesar, que va desde 0 Ω hasta el valor máximo, presente en los extremos del
potenciómetro), a la entrada analógica 0 y el dato medido se mostrará en el
monitor a través de serial0.
El montaje es el que se muestra en la figura 6.2. Para conectar el
potenciómetro hay que tener en cuenta que la variación de resistencia se produce
en el terminal central, de tal forma que al variar la resistencia se está variando la
caída de tensión, de modo que si la tensión de alimentación en extremos es de 0 a
5 voltios, se puede obtener un valor que oscile entre dichos valores simplemente
moviendo el eje del potenciómetro.
102
Figura 6.2. Medida tensión entrada analógica con potenciómetro.

Manejo entrada analógica:
Lectura valor de tensión utilizando potenciómetro */
int potenciometro=0; // Pin conexión potenciómetro
int valor=0; // Variable para almacenar medida
void setup(){
} // Fin setup
void loop(){
valor=analogRead(potenciometro); // Lee valor
Serial.println(valor); // Envía datos
delay(200); // Para visualizar mejor los valores
} // Fin loop
103
Habrá podido observar en el monitor que toma valores entre 0 y 1023 (figura
6.3 izquierda), pero no el valor medido de tensión. Para ello se incluyen las
siguientes líneas de código que realizan la conversión para enviar el valor de tensión
(figura 6.3 derecha) y, además, se incluye la condición para que solo envíe datos si
el valor cambia. El código resultante es el siguiente:
Manejo entrada analógica: Lectura valor de tensión utilizando potenciómetro, se
añade al anterior la conversión valor de tensión*/
int potenciometro=0; // Pin conexión potenciómetro
int valorPrevio=10; // Saber si hay que enviar dato
float conversion=0; // Variable de conversión a tensión
void setup(){
} // Fin setup
void loop(){
valor=analogRead(potenciometro); // Lee valor
conversion=valor*(0.00488); //Relación lineal de conversión
// Envía dato si se ha realizado modificación
if(valor!=valorPrevio){
Serial.println(valor); // Envía datos medido
Serial.println(conversion,4); // Envía datos tras conversión
}// Fin if
valorPrevio=valor; // Guardar dato medido
delay(10); // Pequeño retardo
} // Fin loop
104
Figura 6.3. Monitor medida tensión.
En el código anterior observará que se ha añadido un segundo parámetro

opcional a la función Serial.println(), el cual se utiliza para cuando se envía un dato
en coma flotante (float) especificando el número de posiciones decimales a usar.
También sirve para especificar la base (o formato) a usar. Es decir, si el valor a enviar
es: BYTE, BIN (binarios o base 2), OCT (octales o base 8), DEC (decimales o base 10),
HEX (hexadecimales o base 16).
6.3 Medida de temperatura

Para la medida de la temperatura se utilizan los integrados que proporcionan un
valor de tensión linealmente proporcional a la temperatura en grados
centígrados. Por ejemplo, el LM35D proporciona una variación de 10 mV por
grado centígrado.
El rango de temperatura a la que puede trabajar estos dispositivos suele
ser de -55 a 150 °C pero este valor puede variar, por lo que habrá que consultar
las hojas de características. Su consumo es de unos 60 microamperios (muy
pequeña), lo que le proporciona unas buenas características para los montajes de
Arduino.
Para la lectura de temperatura hay que tener en cuenta que la señal
analógica puede tomar valores de 0 a 1023 para valores de 0 a 5 voltios, y el sensor
de temperatura entrega 0 voltios para 0 °C y con cada variación se produce un
aumento o disminución de la tensión, a relación de 10 mV por 1 °C, por ejemplo
para 10 °C se obtiene 100 mV.
105
Nota: otro dispositivo similar incluido también en varios kits es el TMP36 con
características similares. Incluso mantiene el mismo orden de conexiones de
los terminales. Cambia el valor de tensión que entrega en función de la temperatura.
Para una temperatura de 0 °C hay un offset de 500 mV. A partir de este valor las
variaciones de temperatura son a 10 mV por cada 1 °C. Por ejemplo, para 25 °C se
tendrá7 50 mV.
En consecuencia para realizar una medida correcta, hay que realizar primero
la lectura a través del puerto analógico. Después hay que cambiar del valor medido
al valor de tensión y, a partir de dicho valor de tensión, se obtiene el valor de
temperatura.
El LM35D dispone de un encapsulado TO92; es decir, que si lo observa será
igual que el transistor 2N2222 montado en el capítulo anterior. Dispone de un
terminal que se alimenta a tensión positiva (5 voltios) otro que se conecta a masa
(GND) y un tercero que proporciona un valor de tensión proporcional a la
temperatura (figura 6.4).
Figura 6.4. Sensor de temperatura LM35D.
Figura 6.5. Módulo medida de temperatura con termistor (cortesía Seeed studio).
106
Otro dispositivo para realizar las medidas de temperatura es el uso de

termistores, que consisten en resistencias cuyo valor depende de la temperatura.
Así pues, mediante un pequeño circuito se puede obtener un valor de tensión en
función de la temperatura. En la figura 6.5 se muestra el módulo de medida de
temperatura, junto con su circuito y la curva. Este tipo de circuitos proporcionan un
valor de tensión que es proporcional a un valor resistivo. Así pues, cuando se
conozca el valor medido se tendrá el valor de resistencia del termistor y conociendo
los datos ofrecidos por el fabricante se puede obtener el valor de tensión. Si busca
las hojas de características (o realiza una búsqueda en Internet) le aparecerán las
siglas NTC (Negative Temperature Coefficient) para indicar que la resistencia
disminuye con el aumento de temperatura, o las siglas PTC (Positive Temperature
Coefficient) para indicar que la resistencia aumenta con la temperatura.
Ejercicio resuelto 14: medida de temperatura con LM35D

Se pretende medir la temperatura a través de un sensor LM35D, conectado a la
entrada analógica 0. Dicho valor se realizará con las conversiones pertinentes y se
enviará vía serial0 de Arduino. Se incluyen los mensajes oportunos para mejorar la
visualización realizada. Para ello, se utiliza la siguiente función para que el texto o
datos enviados no cambien de línea tal y como se ha utilizado hasta ahora:
Serial.print(“carácter”); // Vista misma línea monitor
También se ha incluido la variable carácter para introducir después en el
texto el símbolo de grados para ser incluido en la visualización en el monitor del
serial0.
El esquema del montaje se muestra en la figura 6.6, los mensajes del monitor
en la figura 6.7, y el código a implementar es el siguiente:
Medida de temperatura con LM35D*/
int temperatura=0; // Pin conexión temperatura
int valorPrevio=10; // Saber si hay que enviar dato
float conversion=0; // Variable de conversión a tensión
char grados='º'; // Carácter para mostrar datos
107
void setup(){
} // Fin setup
void loop(){
valor=analogRead(temperatura); // Lee valor
conversion=valor*(0.00488); // Convierte valor a tensión
conversion=100*conversion; // Convierte a temperatura
if(valor!=valorPrevio){ // Envía dato si cambia
Serial.print("Temperatura: "); // Envía datos medido
Serial.print(conversion); // Envía datos tras conversión
Serial.print(grados); // Arreglo muestra de datos
Serial.println("C");
}// Fin if
} // Fin loop
Figura 6.6. Montaje sensor de temperatura LM35D o TMP36.
108
Figura 6.7. Monitor temperatura.
Ejercicio resuelto 15: medida de temperatura con TMP36

Si en vez de utilizar el sensor LM35D se utiliza el TMP36 hay que ajustar un offset
de medida, debido a las características que posee dicho sensor. El esquema de
montaje sería el que se muestra en la figura 6.6 pero cambiando el integrado,
siendo la numeración la misma para ambos integrados. Respecto al código solo se
cambia la ecuación de conversión del ejercicio resuelto anterior:
conversion=valor*(0.00488)-0.5;// Convierte valor a tensión incluye offset
Ejercicio resuelto 16: medida con termistor

A modo de ejemplo del manejo de termistores, se recurre a utilizar el montaje
modular que se muestra en la figura 6.8, en donde no se requiere de ningún
conocimiento sobre electrónica para realizar la conexión.
109
Figura 6.8. Montaje modular termistor (Cortesía Seeed studio).

Medida de temperatura con Termistor*/
#include<math.h> // Librería de funciones matemáticas
int pinTemperatura=0; // Pin conexión temperatura
float valor=0; // Variable para almacenar medida
float valorPrevio=10; // Saber si hay que enviar dato
float resistencia=0; // Variable conversión de resistencia
float temperatura=0; // Variable convertir a temperatura
int B=3975; // Valor dependiente del termistor
char grados='º'; // Carácter para mostrar datos
void setup(){
} // Fin setup
110
void loop(){
valor=analogRead(pinTemperatura); // Lee valor
resistencia=(1023-valor)*10000/valor; // Obtener valor de resistencia
// Conversión según hojas de características
temperatura=1/(log(resistencia/10000)/B+1/298.15)-273.15;
// Envía dato si se ha realizado modificación
if(valor!=valorPrevio){
Serial.print("Temperatura: "); // Envía datos medido
Serial.print(temperatura); // Envía datos tras conversión
Serial.print(grados); // Arreglo muestra de datos
Serial.println("C");
} // Fin if
} // Fin loop
6.4 Medida intensidad luminosa

Para realizar esta medida se utiliza una fotorresistencia, que consiste en una
resistencia cuyo valor varía en función de la radiación de luz incidente. Se suelen
denominar como LDR (Light Dependent Resistor).
El valor de resistencia respecto a la intensidad luminosa es inversamente
proporcional, es decir, que al aumentar la intensidad luminosa el valor de
resistencia disminuye.
La forma de conectarlo es utilizando el denominado divisor de tensión (verá
que el montaje es similar a los utilizados con los pulsadores) en donde una de las
resistencias es una fotorresistencia (figura 6.9). El valor de tensión a la entrada de
Arduino será máximo cuando tengamos el LDR conectado en la parte inferior
(esquema izquierdo figura 6.9) y aparezca oscuro, ya que estará oponiendo el
máximo de su resistencia al paso de la corriente. Si lo utilizamos en la parte superior
(esquema derecho figura 6.9), el resultado será el inverso, tendremos la tensión
111
máxima cuando esté completamente iluminado, ya que su valor resistivo es muy

pequeño, del orden de 50 Ω o 100 Ω.
Figura 6.9. Fotorresistencia y conexionado.
Ejercicio resuelto 17: medida de resistencia LDR

Se pretende realizar la medida de la resistencia de una fotorresistencia que se
conecta en serie con una resistencia de 10 kΩ y el punto central se conecta con el
pin 0 analógico. El valor medido se envía por serial0 y se muestran los valores de
forma ordenada en la ventana de monitorización.
Hay que tener en cuenta que el sistema no está calibrado, que consiste en
establecer la relación entre intensidad lumínica y el valor de resistencia. Ello se
consigue realizando medidas y comparando los valores medidos con valores reales.
En este caso no es un parámetro tan importante porque la mayoría de aplicaciones
suelen destinarse a la construcción de un interruptor crepuscular. Por ejemplo, que
se encienda un punto de luz al hacerse de noche o que empiece el riego al
amanecer.
Nota: cuando esté realizando las medidas de resistencia tape el sensor y verá cómo
va variando su valor.
112
Figura 6.10. Montaje LDR.
Figura 6.11. Monitor resistencia LDR.
El esquema del montaje se muestra en la figura 6.10, los mensajes del

monitor en la figura 6.11, y el código a implementar es el siguiente:
Medida de resistencia sensor LDR*/
int pinLDR=0; // Pin conexión LDR
113
float tension=0; // Variable almacenar tensión

float resistencia=0; // Variable valor de resistencia
void setup(){
} // Fin setup
void loop(){
tension=analogRead(pinLDR); // Lee valor 0 a 1023
tension=tension*(0.0048); // Calculo tensión 581023=0,0048
resistencia=(5-tension)*(1000/tension); // Calculo resistencia
Serial.print("Resistencia LDR: "); // Envía datos medido
Serial.print(resistencia); // Envía datos tras conversión
Serial.println(" ohmios"); // Arreglo muestra de datos
Serial.println(tension);
} // Fin loop
Ejercicio resuelto 18: Interruptor crepuscular

Se desea controlar un punto de luz de una habitación, de tal forma que cuando se
haga de noche automáticamente se encienda una luz controlada por el pin digital
1. Para saber cuándo es de noche, se dispone de una fotorresistencia conectada al
pin 0 analógico.
Además se desea que el sistema funcione de forma automática (como se ha
descrito). Se utiliza un interruptor conectado al pin digital 0, de tal forma que si está
accionado funciona de forma automática y si no está accionado el punto de luz
siempre estará apagado.
El valor que se ha establecido para que realice la conmutación es el
siguiente: se considera que es de noche cuando tiene una resistencia por
encima de los 10 kΩ.
114
Figura 6.12. Montaje interruptor crepuscular.

Interruptor Crepuscular*/
int pinLDR=0; // Pin conexión temperatura
int pinInterruptor=0; // Pin interruptor
int pinRele=1; // Pin salida a relé
float tension=0; // Variable almacenar tensión
float resistencia=0; // Variable valor de resistencia
float rCambio=10000; // Valor de resistencia activar relé
void setup(){
pinMode(pinInterruptor,INPUT); // Pin como entrada
pinMode(pinRele,OUTPUT); // Pin como salida
} // Fin setup
void loop(){
// Solo hace algo si está pulsado el interruptor resistencia pull-up
while(digitalRead(pinInterruptor)==HIGH){
tension=analogRead(pinLDR); // Lee valor 0 a 1023
tension=tension*(0.0048); // Cálculo tensión 581023=0,0048
115
resistencia=(5-tension)*(1000/tension);// Cálculo de la resistencia

if (resistencia>rCambio){
digitalWrite(pinRele,HIGH); // Activa relé de punto de luz
} // Fin if
else{
digitalWrite(pinRele,LOW); // Desactiva relé de punto de luz
} // Fin else
} // Fin while
} // Fin loop

con potenciómetro
Se desea controlar mediante un potenciómetro, conectado al pin 0 analógico,
la velocidad de un motor dc conectado al pin 6. Al aumentar la tensión
aumenta la velocidad del motor mediante relación directa. Inicialmente el motor
arrancará a la velocidad prefijada por el potenciómetro, y variará conforme se vaya
modificando su posición.
Figura 6.13. Montaje variador de velocidad motor dc con potenciómetro.
116
Como los valores que puede tomar a través de los pines analógicos van de 0
hasta 1023, y el valor de regulación de una salida digital PWM es de 0 hasta 255, y
como se busca una relación directa (para 1023 de valor en la entrada analógica le
corresponde 255 de valor de ajuste de la señal PWM) se utiliza la siguiente función:
map (xx, origen mínimo, origen máximo, destino mínimo, destino máximo);
La función map consiste en ajustar un valor (xx) comprendido entre dos
rangos (origen) al mismo situado entre dos rangos distintos (destino). La función
devuelve el mismo valor pero mapeado; es decir, para el nuevo rango (según
valores mínimo y máximo).
Varia velocidad de motor con un potenciómetro */
int potenciometro=0; //Asignación pin potenciómetro
int motor=6 // Asignación pin salida motor
int velocidad=0; // Variable velocidad del motor
void setup() {
pinMode(motor,OUTPUT);
} // Fin setup
void loop() {
velocidad=analogRead(potenciometro); // Lee valor
velocidad=map(velocidad,0,1023,0,255);// mapear valor
analogWrite(motor,velocidad); // Ajustar velocidad
} // Fin loop

1. Para controlar la intensidad lumínica de un diodo led conectado a la
entrada digital PWM 3, a partir de un potenciómetro conectado a la
entrada 0 analógica, visualice ambos valores en el monitor del serial0.
117
2. Se desea que un led conectado a una salida digital parpadee, pero la

velocidad de parpadeo se desea controlar a través de un dispositivo
externo (potenciómetro). Realice un croquis de conexionado en Arduino
seleccionando los pines que considere oportunos.
3. Realice el programa para Arduino que controle un calefactor, para que
se ponga en marcha cuando alcance la temperatura mínima (Tmin) y se
pare cuando alcance la temperatura máxima (Tmax). El control de
puesta en marcha se realiza a través de un relé conectado al pin digital
1, y el sensor de temperatura a la entrada 0 analógica.
4. Para iluminar una zona del jardín se desea que se ponga en marcha
cuando sea de noche y se apague al amanecer. Como adorno se utiliza
un diodo RGB (elige la secuencia de colores que consideres oportuna).
Elige los pines a utilizar.
5. En la entrada de una vivienda se dispone de un punto de luz que
normalmente está encendido pero cuando hay suficiente iluminación
esta se apaga. Elige los pines a utilizar, así como el material necesario
para llevar a cabo el montaje.
6. Realice el programa para Arduino que active un led conectado al pin
digital 12, que se ponga en marcha al accionar un pulsador conectado a
la entrada 3, y se apague pasado un tiempo. Dicho tiempo se ajustará
mediante un potenciómetro conectado a la entrada analógica 0. Si
estando el led encendido se vuelve a pulsar, el tiempo se reinicia. El
tiempo máximo es de 3 segundos y el tiempo mínimo es de 0 segundos.
Utilice el serial0 para que muestre el tiempo ajustado con el
potenciómetro.
118

Arduino

Cargado por

Información del documento

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

Cargado por

Copyright:

Formatos disponibles

ARDUINO

Primera edición, 2014

© 2014, Miguel Pareja Aparicio

© 2014 MARCOMBO, S.A.

Diseño de la cubierta: NDENU DISSENY GRÀFIC

«Cualquier forma de reproducción, distribución, comunicación pública o

El presente libro contiene la información básica para iniciarse en el mundo de

1.2 Software libre: qué es y qué me hace falta

Cuando se habla de software libre se suele confundir con el concepto de

Tal y cómo se indica, se trata de software de código abierto, y se puede

1.3 Hardware libre: ¿existe?

• El hardware libre estático, cuando el esquema del circuito

• El hardware libre reconfigurable es cuando el circuito que representa

puesto que con un mismo circuito su funcionamiento puede cambiar realizando

1.4 Pero ¿qué es Arduino UNO?

Figura 1.1. Arduino UNO vista frontal (Cortesía de www.arduino.cc).

Figura 1.2. Arduino UNO versión SMD (Cortesía de www.arduino.cc).

Si observa las fotos de la figura 1.1 y 1.2, se puede apreciar en la serigrafía

Nota: en los próximos capítulos se verá con mayor detalle la configuración y

En resumen, las ventajas que ofrece Arduino son:

1.5 ¿Qué necesito para empezar?

Figura 1.3. Kit básico de Arduino (cortesía de www.electan.com).

• Led RGB (que tiene 3 pines).

Además en algunos casos también incluyen algún tipo de documentación:

Figura 1.4. Kit de iniciación Grove (Cortesía seeed studio).

Figura 1.5. Kit Inventor’s (Cortesía de SparkFun).

El primero simplifica mucho las conexiones por lo que permite realizar

La forma de conectar una fuente de alimentación externa es a través de los

Figura 1.6. Conector jack de alimentación exterior Arduino UNO.

Nota: no olvidar conectar el terminal de GND o negativo cuando se utilice una

El procedimiento es sencillo si se decide reutilizar una fuente de alimentación

manteniendo el código de colores que se suele utilizar. Además se muestra la forma

Figura 1.7. Esquema conexionado reutilización fuente ordenador.

1.6 Programar: ¿qué necesito saber?

tengan conocimientos sobre estos lenguajes no tendrán grandes dificultades,

• Operadores: es un símbolo que indica una cierta operación sobre uno

Del mismo modo conviene conocer ciertas estructuras de programación,

La segunda corresponde a switch, cuya traducción es ‘cambiar’, es decir, en

case opción 2: //Si variable == 2* ejecutar siguiente código

La tercera corresponde a while, cuya traducción es ‘mientras’, es decir,

La cuarta y última que se muestra es for, y se utilizar para ejecutar cierto

for( dar valores iniciales ; condiciones ; incrementos ){

1.7 Actividades propuestas

4. ¿Qué cree que sucedería si se ponen 2 iguales en vez de 1 en el primer

2.2 Instalación de software

Figura 2.1. Descarga software.

La instalación de la aplicación simplemente consiste en descomprimirla. Es

Figura 2.2. Ficheros y carpetas fichero descomprimido de Arduino.

Figura 2.3. Arduino 1.5.2.

En la figura 2.2 se muestra el directorio una vez se ha descomprimido, con

Figura 2.4. Detección de nuevo hardware.

Figura 2.5. Instalación del hardware.

Figura 2.6. Drivers instalados administrador de dispositivos.

2.3 Entorno Arduino

El texto sketch es fijo. La fecha corresponderá al día en el cual fue creado. La

• Verify: verifica y compila el sketch en el cual se está trabajando.

• Serial Monitor: abre un sistema de monitorización que permite

Figura 2.7. Iconos acceso rápido entorno Arduino.

Debajo de los iconos de acceso rápido se muestra el área de trabajo, donde

Figura 2.8. Área de trabajo entorno Arduino.

Debajo del área de trabajo se encuentra el área de notificaciones, que es

2.4 Primer programa y práctica con Arduino

Se ha elegido el presente ejemplo porque no hay que realizar ninguna

Figura 2.9. Leds Arduino UNO.