Curso Arduino

CEFIRE ESPECÍFICO DE F.P.
SERVICIO DE FORMACIÓN DEL PROFESORADO
FAMILIA PROFESIONAL ELECTRICIDAD - ELECTRÓNICA

CICLOS FORMATIVOS
CURSO BÁSICO
Impartido a distancia
18 / 04 / 2016 -- 29 / 05 / 2016 ( 30 HORAS )
Ponente : Juan Carlos López Gordillo

Coordinadora : María Asunción León Blasco
SILLA 2016
INDICE DE CONTENIDOS
Objetivos 1
Planificación de contenidos 2
Comparación entre las placas de Arduino Oficiales y no oficiales. 4
Arduino Shields. 22
Introducción al Arduino. El Arduino UNO y el Arduino Mega 2560. 23
El IDE oficial de Arduino. Instalación, configuración y primeros pasos. 31
Software relacionado con Arduino. 41
El lenguaje de programación de Arduino. 51
Librerias para Arduino. 69
Manejo de Motores. 74
Como usar la memoria EEPROM de Arduino 86
Sensores I : Luminosidad (LDR) y Ultrasonidos (HC-SR04) 94
Sensores II : Infrarrojos (IR) 103
Rebotes 105
Los Strings en Arduino 110
Manejo de una LCD 16x2 112
Módulo transmisor y receptor de datos a 433,92 MHz 115
Sensores III : Humedad y Temperatura (DTH11, LM35 y DS18B20) 121
Introducción al lenguaje HTML. La placa Ethernet Shield. 126
Comentarios finales 133
Bibliografía 134
Indice de Prácticas 135

Curso básico de Arduino
Objetivos
 Conocer las placas de Arduino y los shields existentes.

 Obtener recursos didácticos de aplicación en el aula.
 Conocer los fundamentos básicos de los sistemas basados en Arduino para poder
determinar las capacidades y necesidades de un diseño.
 Realizar la programación básica de un Arduino por medio del IDE y del lenguaje y así
disponer de la base que permita desarrollar algoritmos sencillos de control.
 Resolver los errores de sintaxis y de programación que puedan ocurrir.
 Realizar aplicaciones basados en Arduino de complejidad baja / mediana que funcionen de
forma autónoma o por medio de conexión a un PC.
 Realizar prácticas con la placa shield de Ethernet, realizando páginas webs muy sencillas y
comunicarse con Arduino.
Juan Carlos López Gordillo Página 1

Planificación de contenidos
Recomiendo que se dividan los contenidos de la siguiente forma :
Primera semana (Del Lunes 18/04/2016 al Viernes 22/04/2016 ) :
 Comparación entre las placas de Arduino Oficiales y las compatibles.

 Arduino Shields.
 Introducción al Arduino. El Arduino UNO y Arduino Mega 2560.
 El IDE oficial de Arduino. Instalación,configuración y primeros pasos.
Segunda semana ( Del Lunes 25/04/2016 al Viernes 29/04/2016 ) :
 Software relacionado con Arduino.

 El lenguaje de programación de Arduino.
 Práctica 1.
 Librerías para Arduino.
Tercera semana : ( Del Martes 03/05/2016 al Viernes 06/05/2016 ) :
 Manejo de Motores.
 Como usar la memoria EEPROM de Arduino.
 Práctica 2.
 Sensores I : Luminosidad (LDR) y ultrasonidos (HC-SR04).
 Práctica 3.
Cuarta semana ( Del Lunes 09/05/2016 al Viernes 13/05/2016 ) :
 Sensores II : Infrarrojos (IR)

 Rebotes.
 Práctica 4.
 Los Strings en Arduino.
 Manejo de una LCD 16x2.
 Módulo TX y RX por Radiofrecuencia (433,92 MHz ).
 Práctica 5.
Quinta semana ( Del Lunes 16/05/2016 al Viernes 20/05/2016 ) :
 Sensores III : Humedad y Temperatura (DHT11, LM35 y DS18B20).

 Práctica 6.

Sexta semana ( Del Lunes 23/05/2016 al Viernes 27/05/2016 ) :
 Introducción al lenguaje HTML. La placa Ethernet Shield.

 Práctica 7.
 Entrega de prácticas atrasadas.
 Prácticas extras o Proyecto libre.
Se utilizará la plataforma Moodle para realizar la comunicación entre los asistentes al

curso y el ponente.
Todas las prácticas deben ser entregadas (subidas) antes de finalizar la fecha que el
ponente indicará en la plataforma Moodle.

Comparación entre las placas de Arduino Oficiales y no oficiales
Como ocurre con las distribuciones Linux, Arduino también cuenta con multitud de
ediciones, cada una pensada para un público concreto o para una serie de tareas específicas.
Existen tal variedad de modelos oficiales, no oficiales y compatibles que es normal que la
gente no sepa diferenciar con exactitud las características de cada una de estas maravillosas
placas.
Vamos a detallar todos los modelos oficiales existentes hoy por hoy, así como exponer
algunos de los no oficiales y compatibles interesantes. Debemos tener presente que los
modelos oficiales de Arduino ascienden más de 16 por el momento y que pueden haber
cientos si sumamos los compatibles y los no oficiales.
Arduinos oficiales y no oficiales o compatibles
Haremos una distinción entre oficiales, no oficiales o compatibles, puesto que no son lo
mismo. Veamos las diferencias entre estos grupos de placas:
 Oficiales : son aquellas placas oficiales manufacturadas por la compañía italiana Smart
Projects y algunas han sido diseñadas por la empresa estadounidense SparkFun
Electronics (SFE) o por la también estadounidense Gravitech. Arduino Pro, Pro Mini y
LilyPad son las manufacturadas por SFE y Arduino Nano por Gravitech, el resto se
crean en Italia. Estas placas son las reconocidas oficialmente, incluyen el logo y son las
únicas que pueden llevar la marca registrada de Arduino.

 No oficiales o compatibles : son placas compatibles con Arduino pero no pueden estar
registradas bajo el nombre de Arduino. Por supuesto son diseñadas y fabricadas por
otras compañías ajenas. Estos desarrollos no aportan nada al desarrollo propio de
Arduino, sino que son derivados que han salido para cubrir otras necesidades. Estas
frecuentemente utilizan un nombre que integra el sufijo “duino” para identificarlas,
como por ejemplo Freeduino del que ya hablaremos.
Nosotros mismos podemos crearnos nuestra propia placa compatible con Arduino a
medida y en este caso pasaría a ser una placa no oficial. Y el nombre bajo el que registremos
nuestro invento no puede contener la
palabra Arduino. Incluso puede que
nuestro diseño sea lo suficientemente
atractivo y llamativo que los
miembros de la comunidad de
desarrollo de Arduino lo incluyan
como una placa oficial. Están
esperando con los brazos abiertos a
recibir otras placas mejores y basadas
en otro tipo de arquitecturas (por
ejemplo, distintas a ARM y a ATmega
AVR, como x86, PIC, …).
Incluso en el menú Herramientas de Arduino IDE existe una opción que se llama Grabar
secuencia de arranque. Esta opción puede servir para grabar la secuencia de bootloader
(cargador de inicio) en el microcontrolador de Arduino oficial que por algún motivo ha
quedado desconfigurado o se ha sustituido el chip microcontrolador por otro. Pero también es
una práctica herramienta para programar un microcontrolador nuevo que hemos introducido
en nuestra propia placa “duino”.
No todas son compatibles al mismo nivel.
Por ejemplo, existen placas compatibles a nivel del entorno de desarrollo, es decir,
solo nivel de software (pudiendo emplear Arduino IDE para programarlas). Otras son
compatibles a nivel de hardware y eléctricamente para poder emplear los shields y módulos
existentes para Arduino sin problema.
A la hora de seleccionar la placa para nuestro proyecto tenemos que tener esto muy
presente para no llevarnos sorpresas. Puede que nos interese una placa compatible por ciertas
cualidades del hardware que no posee Arduino o por cuestiones de licencias y sin embargo
querer que sea compatible con el entorno de desarrollo Arduino IDE. En otras ocasiones puede
que simplemente se desee compatibilidad en cuanto a los shields pero se tiene la necesidad de
emplear otro compilador (AVR Studio, Makefiles,…).

Características generales
Lo principal que debemos saber es que tipo de proyectos vamos a implementar. Con
esto nos da una idea de la cantidad de pines analógicos y digitales (normales y de tipo PWM o
modulados por ancho de pulso para simular una salida analógica) que necesitamos para
nuestro trabajo. Este primer escrutinio nos permite descartar algunas placas más simples que
no tengan suficientes pines o, al contrario, descartar las de mayor número de ellos para
reducir los costes puesto que con menos pines nos conformamos.
También podemos deducir el tamaño de código que vamos a generar para nuestros
sketchs. Un programa muy largo, con muchas constantes y variables demandará una cantidad
mayor de memoria flash para su almacenamiento, por lo que se debe elegir una placa
adecuada para no quedarnos cortos.
En los Arduino’s oficiales podemos diferenciar entre dos tipos fundamentales de

microcontroladores, los de 8 y 32 bits basados en ATmega AVR y los SMART basados en ARM
de 32 bits y con un rendimiento superior, ambos creados por la compañía Atmel.
Por último, en cuanto al voltaje, no importan demasiado a nivel electrónico, excepto

en algunos casos, para tener en cuenta la cantidad de tensión que la placa puede manejar para
montar nuestros circuitos.
La placa más vendida y que es la más aconsejable para la mayoría de proyectos, sobre
todo si estás empezando, es la Arduino UNO. Es suficiente para la mayoría de proyectos, tiene
un buen precio y dispone de unos parámetros equilibrados.
Placas oficiales
De entre las placas oficiales puedes encontrar multitud de modelos. Todos especialmente
pensados para un fin, compatibles con los shields y módulos oficiales, así como con Arduino
IDE. Vamos a intentar detallar sus principales características para poder diferenciarlos entre sí:
 Arduino UNO : es la plataforma más extendida y la primera que salió al mercado, por
ello nos podemos basar en esta para hacer la
comparativa con el resto de placas. Todas las
características de esta placa estarán
implementadas en casi todas las placas
restantes, a excepción de algunas que ya
veremos. Se basa en un microcontrolador
Atmel ATmega320 de 8 bits a 16Mhz que
funciona a 5v. 32KB son correspondientes a la
memoria flash (0,5KB reservados para el
bootloader), 2KB de SRAM y 1KB de EEPROM.
En cuanto a memoria es una de las placas más limitadas, pero no por ello resulta
insuficiente para casi todos los proyectos que rondan la red. Las salidas pueden
trabajar a voltajes superiores, de entre 6 y 20v pero se recomienda una tensión de
trabajo de entre 7 y 12v. Contiene 14 pines digitales, 6 de ellos se pueden emplear
como PWM. En cuanto a pines analógicos se cuenta con hasta 6. Estos pines pueden
trabajar con corriente de hasta 40mA.

 Arduino Zero : en aspecto es similar a Arduino UNO, pero esta placa esconde
sorpresas con respecto a la plataforma UNO.
En vez del microcontrolador Atmel ATmega
basado en arquitectura AVR de 8 bits, el Zero
contiene un potente Atmel SAMD21 MCU de
48Mhz con un core ARM Cortex M0 de 32 bits.
Con 256 KB de memoria flash, 32 KB de SRAM y
una EEPROM de más de 16KB por emulación. El
voltaje en el que opera es de 3v3/5v (7mA) y
contiene 14 pines E/S digitales, de los cuales 12
son PWM y UART. En el terreno analógico se
dispone de 6 entradas para un canal ADC de 12 bits y una salida analógica para DAC de
10 bits. En definitiva, esta placa va destinada para los que Arduino UNO se les quede
corto y necesitan algo más de potencia de procesamiento.
 Arduino Yun : se basa en el microcontrolador ATmega32u4 y en un chip Atheros

AR9331 (que controla el host USB, el puerto para micro-SD y la red Ethernet/WiFi),
ambos comunicados mediante un puente. El
procesador Atheros soporta la distribución Linux
basadas en OpenWrt llamada OpenWrt-Yun. Se
trata de una placa similar a Arduino UNO pero
con capacidades nativas para conexión Ethernet,
WiFi, USB y micro-SD sin necesidad de agregar o
comprar shields aparte. Contiene 20 pines
digitales, 7 pueden ser usados en modo PWM y
12 como analógicos. El microcontrolador
ATmega32u4 de 16Mhz trabaja a 5v y contiene una memoria de solo 32KB (4KB
reservados al bootloader), SRAM de solo 2,5KB y 1KB de EEPROM. Como vemos, en
este sentido queda corto. Sin embargo se complementa con el AR9331 a 400Mhz
basado en MIPS y trabajando a 3v3. Este chip además contiene RAM DDR2 de 64MB y
16MB flash para un sistema Linux embebido.
 Arduino Leonardo : es una placa basada en un microcontrolador ATmega32u4 de bajo

consumo y que trabaja a 16Mhz. La memoria flash tiene una capacidad de 32KB (4KB
para el bootloader) y 2.5KB de SRAM. La
EEPROM es de 1KB, también muy similar a
Arduino UNO en cuanto a capacidades de
almacenamiento. A nivel electrónico y de
voltajes es igual al UNO. Pero este
microcontrolador puede manejar 20 pines
digitales (7 de ellos pueden ser manejados como
PWM) y 12 pines analógicos. Como vemos,
contiene los mismos pines que Yun, solo que
prescinde de las funcionalidades de red. El
volumen ocupado por Leonardo es inferior al de UNO, puesto que carece de las
inserciones de los pines y en su lugar posee perforaciones con pads de conexión en la
propia placa. Además las dimensiones del conector USB de la placa es mucho menor,
ya que en vez de una conexión USB emplea una mini-USB para ahorrar espacio. Por
eso es idóneo para proyectos en los que se requiera ahorrar algo de espacio, pero todo
al mismo precio que UNO.

 Arduino Due : es una placa con un microcontorlador Atmel SAM3X8E ARM Cortex-M3
de 32 bits. Este chip que trabaja a 84 Mhz
(3,3v) aporta una potencia de cálculo bastante
superior a los anteriores microcontroladores
vistos. Por eso es idóneo para todos aquellos
que necesiten de un proyecto con alta
capacidad de procesamiento. Al tener un core
a 32 bits permite realizar operaciones con
datos de 4 bytes en un solo ciclo de reloj.
Además, la memoria SRAM es de 96KB, superior al resto de placas vistas
anteriormente e incorpora un controlador DMA para acceso directo a memoria que
intensifica el acceso a memoria que puede hacer la CPU. Para el almacenamiento se
dispone de 512KB de flash, una cantidad muy grande de memoria para cualquier
código de programación. En cuanto a soporte de voltajes en intensidades es idéntica a
UNO, solo que el amperaje de los pines se extiende hasta los 130-800mA (para 3v3 y
5v respectivamente). El sistema dispone de 54 pines de E/S digitales, 12 de ellos
pueden ser usados como PWM. También tiene 12 analógicos, 4 UARTs (serie, frente a
los dos de UNO), capacidades de conexión USB OTG, dos conexiones DAC (conversión
digital a analógico), 2 TWI, un power jack, SPI y JTAG. Como vemos en cuanto a interfaz
de conexionado está muy completo y permite multitud de posibilidades.
 Arduino Mega : su nombre proviene del microcontrolador que lo maneja, un

ATmega2560. Este chip trabaja a 16Mhz y con un voltaje de 5v. Sus capacidades son
superiores al ATmega320 del Arduino UNO,
aunque no tan superiores como las soluciones
basadas en ARM. Este microcontrolador de 8 bits
trabaja conjuntamente con una SRAM de 8KB,
4KB de EEPROM y 256KB de flash (8KB para el
bootloader). Como puedes apreciar, las
facultades de esta placa se asemejan al Due,
pero basadas en arquitectura AVR en vez de
ARM. En cuanto a características electrónicas es bastante similar a los anteriores,
sobre todo al UNO. Pero como se puede apreciar a simple vista, el número de pines es
parecido al Arduino Due: 54 pines digitales (15 de ellos PWM) y 16 pines
analógicos. Esta placa es idónea para quien necesita más pines y potencia de la que
aporta UNO, pero el rendimiento necesario no hace necesario acudir a los ARM-based.
 Arduino Ethernet : Es un Arduino UNO y un shield Ethernet integrado. Esta placa es

bastante similar a la UNO, incluso en el
aspecto, pero tiene capacidades de red. Su
microcontrolador es un ATmega328 que
trabaja a 16Mhz (5v). Va acompañado de 2KB
de SRAM, 1KB de EEPROM y 32KB de flash. El
resto de características electrónicas son como
las de UNO solo que añade capacidad para
conexión Ethernet gracias a un controlador
W5100 TCP/IP embebido y posibilidad de
conectar tarjetas de memoria microSD. Los
pines disponibles son 14 digitales (4 PWM) y 6 analógicos. Hay que tener en cuenta es
que Arduino reserva los pines 10-13 para ser usado para SPI, el 4 para la tarjeta SD y el
2 para el interruptor W5100.

 Arduino Fio : Es una placa Arduino reducida a la mínima expresión. Por su tamaño es
especialmente considerado para proyectos
móviles inalámbricas o para ser insertados en
espacios reducidos. Funciona con un
microcontrolador ATmega328P, una versión
similar a la del Ethernet pero que trabaja a una
frecuencia inferior, 8Mhz. Al ser tan reducida
carece de ciertas comodidades, por ejemplo,
para subir los sketches hay que usar un cable FTDI o una placa adicional adaptadora
Sparkfun. Igualmente, las tensiones con las que se trabaja se ven mermadas hasta los
3.35-12v máximo. 14 pines digitales (6 PWM) y 8 pines analógicos serán los únicos
disponibles en esta placa. Tampoco ayuda sus 2KB de SRAM, 32KB de flash y 1KB de
EEPROM, todo esto limitará mucho el tamaño de los sketchs y del circuito del
proyecto.
 Arduino Nano : Empezaron incorporando un ATMega328 como el de otras placas

vistas anteriormente, pero tras la revisión 2.x se sustituyó por un ATmega168 a 16Mhz.
Sus dimensiones son aún más reducidas que
las de Fio, de tan solo 18,5×43.2mm. Su
reducido tamaño no le quitan la posibilidad de
ser una placa completa, pero sí que necesita
de un cable mini-USB y no posee conector de
alimentación externa. Esta versión fue
diseñada y producida por la compañía
Gravitech, especialmente pensado para
aplicaciones de reducido costo y donde el tamaño importe. A nivel eléctrico se
comporta como un UNO, con 14 pines digitales (6 PWM) y 8 analógicos. Pero sus
capacidades han ido a menos con las nuevas revisiones en pos de un menor consumo.
Por ello se ha pasado de 32 a 16KB de flash (2 reservados al cargador de arranque), de
2 a 1KB de SRAM y de 1KB a 512 bytes de EEPROM.
 Arduino LilyPad : Especial para ser integrado en prendas y textiles, es decir, es una
versión de Arduino “ponible”. Fue desarrollado
por Leah Buechley y SparkFun Electronics para
ser empleado con los mismo fines que otros
Arduino’s solo que con ciertas limitaciones a
cambio de sus capacidades de integración y su
base flexible. Se basa en dos versiones de
microcontrolador diferentes, ambas de bajo
consumo denominadas Atmega168V y
ATmega328V, esta segunda más potente.
Ambos trabajan a 8Mhz, pero la primera
trabaja a solo 2,7v y a segunda a 5,5v. Dispone
de 14 pines digitales (6 PWM) y 6 analógicos a
lo largo de su perímetro. Además integra 16KB
de memoria flash para el código del programa, 1KB de SRAM y 512 bytes de EEPROM.

 Arduino Pro : Contiene un microcontrolador ATmega168 o Atmega328, con

versiones de 3.3V y 8Mhz o 5v para 16Mhz.
Contiene 14 pines de E/S digitales (6 de ellos son
PWM) y 6 pines analógicos. Esta placa diseñada
y construida por SparkFUn Electronics integra
entre 32KB y 16KB de flash según el
microcontrolador en el que se base (2KB
reservados para el gestor de arranque). Lo que sí
es común para todos los modelos es el KB de
SRAM y los 512 bytes de EEPROM. A pesar de su
nombre, la versión Pro no es una de las más
potentes como podemos apreciar. Pero se ha
concebido para usuarios avanzados que
necesitan flexibilidad y precios bajos.
 Arduino Pro Mini : Es la hermana pequeña de la versión

Pro. Además de la flexibilidad y precios bajos hay que
añadirle su reducido tamaño. Para reducir coste y tamaño
dispone de los componentes mínimos (sin conector USB
Integrado ni conectores de pin). El resto de características
son muy similares a la versión Pro.
 Arduino Mega ADK : Placa basada en un ATmega2560 como la versión Mega vista
anteriormente. Pero su principal ventaja
es que dispone de una interfaz preparada
para ser conectada mediante USB a
dispositivos móviles basados en Android,
gracias a su IC MAX3421e. Esto permite
contar con todas las capacidades de una
placa Arduino Mega (igual en cuanto al
resto de características) más las
posibilidades de desarrollo conjuntas con
una plataforma Android.
 Arduino Esplora : Se diferencia del resto de placas, a parte de su reducido tamaño y

por su forma, en que dispone de una serie de sensores onboard. Es bueno para las
personas que comienzan a dar sus
primeros pasos en el mundo de la
electrónica y están aprendiendo, de ahí su
nombre. Incluye unos sensores
(acelerómetro, temperatura, luz),
zumbador, botones, joystick, micrófono y
un socket para conectar una pantalla a
color TFT LCD. Funciona con un microcontorlador ATmega32u4 que trabaja a 16MHz y
5v, con SRAM de 2,5KB y 1KB de EEPROM. La flash llega a los 32KB con 4KB reservados
al bootloader. El mayor problema es su capacidad de conectividad, casi nula, ya que
todo lo tiene integrado para los principiantes.

 Arduino Micro : Diseñado por Adafruit y pensado para una autonomía elevada y con
un reducido tamaño. Su precio es
bajo con respecto a otros modelos.
Sin embargo cuenta con
características similares a otros
diseños, como un microcontrolador
ATmega32u4 a 16Mhz, 20 pines
digitales (7 de ellos PWM) y 12
analógicos. En muchos aspectos es similar a Leonardo, pero con capacidad de
comunicación USB built-in, eliminando la necesidad de un segundo procesador.
 Arduino BT : es una placa Arduino con un módulo

Bluetooth incorporado y que permite
comunicación inalámbrica sin necesidad de
comprar un shield independiente. El módulo
bluetooth incorporado es un Bluegiga WT11. El
resto de características son similares al Arduino
UNO, con microcontrolador ATmega168 o 328 a
16MHz.
 Arduino Duemilanove : Apareció en 2009, con microcontrolador ATmega168 o 368, 14

pines digitales (6 con posibilidad PWM) y 6
analógicos. Contiene conexión USB, entrada de
alimentación, una cabecera ISCP, botón de
reset,… todo bastante parecido a UNO ya que
se trata de una versión previa que fue
sustituida por UNO en la actualidad.
 Arduino Diecimila : Otra placa antigua basada en

chip DIP ATmega168 a 16Mhz, con 14 pines
digitales (6 PWM) y 6 analógicos. El resto de
características son similares al más moderno UNO
que se ha sacado al mercado para sustituir a estos
diseños más primitivos. El modelo “Diecimila”
debe su nombre a “diez mil” en italiano, modo en
el que se festejó el hecho de haber vendido más
de 10.000 placas Arduino en la época en la que se
sacó a la venta. Fue una de las placas más antiguas
de Arduino, sacada en 2007.

Placas no oficiales (compatibles)
Solo analizaremos las más famosas puesto que como ya comenté existen centenares de
ellas y probablemente cada día nazcan más de estas placas. Sí que es verdad que la mayor
atención la debemos tener sobre los modelos oficiales por cuestiones de soporte y de
comunidad de desarrolladores que resultan obvias, pero hay que reconocer que algunas placas
compatibles son ciertamente interesantes:
 AVR.duino U+: SlicMicro es el creador de esta placa compatible, tanto en hardware como
en software, con Arduino UNO Rev3. Esta
plataforma de hardware open source añade
características frente al oficial. Para pasar el código
desde Arduino IDE debemos seleccionar la opción
Arduino UNO Rev3 como si ésta fuese nuestra
placa y el código cargará sin problemas. Las
características adicionales que integra (SlicBus
Port, un LED adicional, potenciómetro, pulsador).
El resto es igual al Arduino, incluido su ATmega328
que comparte con algunas versiones oficiales. Esta
placa es interesante para aquellos que buscan las características combinadas de Arduino
UNO y de Esplora, aunque más limitada en gadgets onboard que esta última. Lo que sí es
una ventaja es su puerto SlicBus que permite conectar módulos especiales fabricados por
SlicMicro.
 SainSmart UNO y Mega : son dos placas SainSmart totalmente compatibles con Arduino
UNO y con Arduino Mega que han seguido a la rama oficial
paso a paso, incluso en las revisiones (véase SainSmart UNO
Rev3). Incluso en el aspecto físico y color son bastante
idénticas a las oficiales, por no decir en sus características
técnicas, empleando hasta el mismo microcontrolador. El
precio de Mega ronda los 15 euros y la versión UNO los 8
euros. Podemos comprobar que la gran baza de estas placas es
su precio frente a las oficiales. Algunas características es la
utilización de un chip ATmega8u2 programado para controlar
el USB y convertirlo a serie en vez del método empleado
anteriormente con chip controlador. También es distinta el
encapsulado de los chips, que en estas placas es más avanzado que el primitivo DIP del
UNO oficial.
 Brasuino: se basa en UNO con LEDs re-ordenados, conector mini-USB, alteración de la

patilla 13 del circuito para reiniciar el LED y una
resistencia que no interfiere en la función del pin
cuando actúa como una entrada. Fue diseñado con
software libre como KiCAD y se distribuye bajo
licencia GPLv2. Por el resto de características es
idéntico al oficial y totalmente compatible con
éste. Ha sido creado por los brasileños de
Holoscopio para estudiantes, diseñadores y
aprendices del mundillo de la electrónica. Pero
tengan en cuenta que su disponibilidad está más

limitada que el stock de los oficiales.
 ChibiDuino2: creado por los nipones de TiisaiDipJp. Es compatible con UNO e incluye dos
mini-USB B, un puerto para un LCD 1602 y un área breadboard.
Por el resto es de características similares al oficial, excepto en
su tamaño, que es más reducido, por su distribución y su
precio es bastante económico.
 Diavolino: Creado por Evil Mad Scientist Laboratories es una versión compatible con el
layout (es decir, los pines se encuentran en el mismo sitio y
por tanto es compatible con los shields oficiales) de Arduino
UNO y diseñada para el uso de un cable USB-TTL serial. Su
diseño es atractivo porque rompe con el colorido
convencional. El diseño surge de la necesidad de un hacker
de San Francisco de tener una placa de bajo coste para la
enseñanza.
 Freeduino : Es uno de los más famosos de entre los

no oficiales creado por Solarbotics, es una placa
totalmente libre para los amantes del código abierto. Se
vende en versiones SB, NANO y Mega, entre otras, y
compatibles 100% con sus respectivas versiones
oficiales. En la imagen podemos apreciar Freeduino SB
(compatible con Duemilanove), con un diseño muy
rudimentario que casi da sensación de casero. Pero no se
deben dejar engañar por las apariencias, sus posibilidades son las mismas que las de los
oficiales.
 Rascal: Compatible con los shields de Arduino oficiales, pero se programa en lenguaje de
programación Python. Esto hace que sea
interesante para los iniciados en el mundo de la
programación, ya que Python posiblemente sea el
mejor lenguaje para comenzar a programar,
sencillo y simple. Esto contrasta con las
posibilidades avanzadas que permite
implementar. Rascal Micro ha creado esta placa
con un microcontrolador basado en ARM, el
AT91SAM9G20. Esta placa nació en Massachusetts, en 2011 y aunque su precio es elevado
(unos 175 dólares), puede ofrecer posibilidades que ninguna oficial tiene. Se podría decir
que es una mezcla entre un mini-PC con posibilidad de ejecutar Linux, con puertos de red y
slot SD para el almacenamiento, y una placa de Arduino compatible con sus shields.
Además incluye software para crear un servidor web con ella. Desde el propio sistema se
puede programar usando un editor basado en web muy sencillo y practico.

 Romeo 2012: DFRobot ha creado esta placa especialmente pensada para los amantes
de la robótica o la mecatrónica. Es totalmente
compatible con Arduino UNO Rev3 pin a pin y
sus características electrónicas y de
programación son similares. Lo interesante es
que incluye una serie de características
onboard que no tienen los oficiales,
destacando por ejemplo el controlador de
motores (de dos direcciones y hasta 2A). Otra
características es un socket Xbee que permite
iniciar el proyecto inmediatamente, sin
necesidad de un controlador de motor
adicional o shields Wireless. Funciona además con un microcontrolador Atmega32u4,
acompañado de multitud de pulsadores programables y un socket para un módulo
APC220 y Bluetooth.
 Roboduino : es un derivado de Arduino UNO diseñado

para robótica credo por Curious Inventor. Es
compatible con el oficial, con un precio de unos 30
euros. Como puedes apreciar en la fotografía, tiene una
serie de pines paralelos para conectar sensores y
servomotores de una manera más fácil, al igual que
incluye conexiones de alimentación y comunicación
serial adicionales.
 Seeeduino : SeeedStudio ha creado esta placa compatible, tanto a nivel físico como a
nivel de software, con Arduino Diecimila oficial.
Por tanto no habrá problema al emplear
Arduino IDE y los shields oficiales. En su versión
primera poseía un ATmega168, pudiendo optar
por un ATMega328 a partir de la v2.21. Ciertas
partes han sido remodeladas para aportar
mayor flexibilidad y una buena experiencia de
usuario.
 Twenty Ten: Freetronics creó esta placa compatible y

basada en Duemilanove con un área de prototipado
incluida, LEDs, conector mini-USB y un pin 13 alterado
para que el LED y resistencia no interfieran con la
función del pin cuando está activado como entrada.

Zigduino: Logos Electromechanical ha creado este kit que es más que una simple placa. Integra
un microcontrolador ATmega128RFA1, un ZigBee para
conexiones a red inalámbrica (IEEE 802.15.4). También
incluye un jack externo RPSMA y es totalmente
compatible con Arduino Duemilanove. Al implementar
estas funcionalidades de red sin necesidad de shields
externos, el precio de la placa supera los 50 euros.
 Faraduino: es una placa desarrollada por Middlesex University Teaching Resources. Es

compatible con los shields oficiales, con un
circuito H-bridge integrado, con terminales
para montar motores de corriente continua
integrados (3 servos), etc. Por cierto, para los
más curiosos, su nombre se debe al famoso
Michael Faraday. Todo se ofrece en un kit que
podemos adquirir junto a unos complementos
para Faraduino especialmente pensados para
la educación en las escuelas y el aprendizaje de la robótica.
 Motoduino: Guibot ha sido la encargada de crear esta placa con un ATMega328 y un

L293D con doble puente en H para el control
de motores sin necesidad de elementos
externos adicionales. Por el resto de
características, esta placa china es compatible
con Arduino. Esta placa resulta interesante
para crear vehículos con motores eléctricos y
el uso de motores en pequeños robots.
 FlyDuino Mega : diseñado por Paul Bake para ser

compatible totalmente con Arduino Mega pero con
características especiales para ser utilizado para el
diseño de vehículos autopilotados y autónomos con
multirotor para aeronave. Es interesante si eres un
apasionado de los aviones caseros o de los tan de
moda drones. Su tamaño es reducido, como
comprenderás muy importante para este tipo de vehículos donde el volumen y el peso
son críticos.
 Banguino: es una placa diseñada por Dimitech y con un ATmega328 como base. Esta
placa es compatible a nivel de software, pero no a nivel físico.
Se trata de una placa con un reducido tamaño. En cuanto a
características es similar a Arduino UNO, solo que mejorado
en un socket estándar PLCC68 para ser integrado en proyectos
de reducido tamaño.

 Boarduino : es una placa creada por Adafruit y compatible a nivel de software con
Arduino, pero no a nivel físico. Así que no
podrá ser usada con los shields oficiales. Sus
características son similares a un Arduino
Diecimila, pero su tamaño es más reducido y
su precio bastante más barato. Está
especialmente pensado para ser pinchado en
una placa tipo breadboard.
 Femtoduino: placa ultra pequeña de tan solo 20.7×15.2mm, apenas es mayor que una
moneda. Esta placa fue diseñada por Fabio
Varesano para proyectos muy pequeños.
Integra un ATMega3298P-MU y es compatible
a nivel de software con Arduino.
 JeeNode: JeeLabs ha creado una placa de bajo coste,

reducido tamaño, compatible a nivel de software con
Arduino y con un Hope RF RFM12B integrado para
comunicación sin cables.
 Moteino: LowPowerLab ha creado una mini placa del tamaño de una tarjeta SD con
posibilidades de comunicación sin cables gracias al chip RFM12B o RFM69W/HW/CW
de HoperRF. Es compatible a nivel de software,
así que se puede programar con Arduino IDE
empleando un adaptador FTDI o directamente
mediante interfaz USB en la versión Moteino
USB.
 PicoDuino : Peter Misenko creó esta diminuta

placa compatible con Arduino IDE, aunque se
recomienda programar con Digispark IDE. Se basa
en un microcontrolador diminuto denominado
ATTiny85. Tan solo tiene 22x12mm de tamaño.
Cuenta con un LED RGB, botón reset y es ideal
para proyectos de tamaño reducido.

 Sanguino : compatible con Arduino a nivel de software y basado en un ATmega644. A

pesar de su reducido tamaño, integra 64KB de
flash, 4KB SRAM y 32 pines de propósito
general. Fue desarrollado en conjunto con el
proyecto de impresora 3D RepRap.
 SODAQ: con el tamaño de una placa Raspberry Pi,

SODAQ es una placa construida por Solar Powered
Data Acquisition. Dispone de una serie de sockets de
conexión adicionales para módulos Xbee, Rfbee,
Bluetoothbee y GPRSbee para comunicaciones. Tiene
una fuente de alimentación con batería de Li-Po de
3.7v o por microUSB. La batería se puede cargar por
placas solares y dispone de un panel para ello de
2.5w, además de un monitor de batería que indica su
estado. Integra un switch de encendido y apagado, un RTC DS3231 y un sensor de
temperatura para el control de la batería, y una cabecera de programación ICSP.
 TinyDuino : TinyCircuits ha implementado una placa compatible con Arduino a nivel de

software y con las mismas funcionalidades de Arduino
UNO, pero con un reducido tamaño. Tiene forma de
botón y puede ser expandido con diversos shields
apropiados.
 TinyLily : del mismo fabricante que TinyDuino nos llega esta versión
que pretende sustituir a LilyPad oficial o por lo menos competir en el
mismo sector. Es muy pequeño y diseñado para el diseño de e-
textiles. Contiene unas pestañas para la comunicación y
programación.
 Versalino Uno : Virtualbotix crea este diseño compacto y compatible a nivel de

software con Arduino. Su principal
característica es la distribución de sus
componentes, que ha permitido hacer una
placa muy compacta y de menor tamaño, así
como la colocación de sus pines de conexión
que no están colocados de forma transversal a
la placa, sino en paralelo para ahorrar espacio.

 Leaflabs Maple : casi todos los modelos se basan en chips Atmega AVR o chips de
Atmel basados en ARM. Pero esta placa rompe
con ese esquema e integra un ARM STM32 (ARM
Cortex-M3 de 32 bits y a 72MHz) fabricado por
STMicroelectronics. Leaflabs ha creado esta placa
con diseño compacto que es compatible con los
shields, a pesar de su arquitectura. La
programación puede hacerse empleando Open
Source Maple IDE que implementa el lenguaje
Arduino para no tener que re-aprender otro
lenguaje de programación, así como librerías
nativas a bajo nivel.
 Bambino 210: esta placa acepta los shields de

Arduino, pero no es compatible con Arduino IDE
por que utilizan microcontroladores muy diferentes
a los vistos anteriormente. Microint USA ha dotado
a esta placa de un procesador NXP LPC4330, un
dualcore ARM Cortex M4/M0 con 264KB SRAM,
4MB flash, Ethernet, 8MB flash, microSD y socket
para complementos Xbee. Es decir, una placa muy
potente para grandes proyectos.
 Parallax Propeller (comprarla en eBay): la famosa

compañía Parallax, conocida por las placas BASIC Stamp entre otras, ha querido unirse
esta iniciativa creando una placa Propeller
compatible con los shields de Arduino, pero no
a nivel de software (se programa con una
herramienta gratuita llamada Propeller Tool o
una alternativa IDE Tool). Contiene un chip
Parallax P8X32A Propeller, con arquitectura
multicore con CPUs RISC de 32 bits. Su
programación se realiza en lenguaje
ensamblador o en lenguaje Spin (diseñado por
Chip Gracey y el ingeniero Jeff Martin de
Parallax). Esta placa, con sus 32KB de RAM y
32KB de ROM, junto con el resto de características la hace idónea para los más
profesionales. El mayor problema es que no es una placa open-source.
 TheUno: diseñado por MyFreescaleWebPage, contiene un microcontrolador Freescale

(antiguas fábricas de Motorola) S08DZ60 de 8
bits y puede admitir shields de Arduino. En
cuanto a programación, no es compatible con
Arduino y tiene que ser programado por un IDE
CodeWarrior de Freescale (basado en Eclipse).
Los lenguajes empleados son C y ensamblador,
dos potentes lenguajes para optimizar al
máximo el rendimiento de esta placa. Para los
interesados, también existe una placa llamada
BigBrother de los mismos creadores que
TheUno y que integra un Freescale MCF51AC256 (Coldfire) más potente que su
hermano pequeño. Por el resto de características es similar a TheUno.

 Goldilocks: Thin Layer Embedded diseñó esta placa basada en un FPGA (Altera Cyclone
IV, con RAM DDR2, SRAM, flash, oscilador y un
Atmel ATSHA204 Authentication IC/EEPROM)
para ofrecer una flexibilidad extrema. Es
compatible con los shields de Arduino, pero en
este caso no solo podrás programarlo a nivel de
software, sino también a nivel de hardware
gracias a su FPGA. Esta misma compañía también
tiene otro modelo muy similar denominado
Breadstick con unos pines macho especialmente
pensados para insertarlo en una protoboard.
 Pinguino: es una placa de desarrollo open-source tipo “duino” con microcontrolador

PIC. El cerebro que comanda esta placa es un
chip PIC18F2550 de la compañía Microchip. Al
tener un módulo USB integrado en el
microcontrolador, no necesita una interfaz
UART/USB, como en el caso de Arduino, para
comunicarse con el PC. Su hardware es simple y
posee un entorno de desarrollo integrado (IDE)
similar al Arduino IDE, pero no es compatible
con éste. El código se puede escribir en lenguaje
de programación Python, un lenguaje extremadamente sencillo. Estupenda placa para
los iniciados y los interesados en dominar la programación de sistemas basados en
PICxxx.
 pcDuino : es un miniPC como la Raspberry Pi, solo que combina las características de
una placa de desarrollo como Arduino. Dispone de un puerto HDMI para conectarlo a
una pantalla o a tu TV para usarla como monitor
del sistema, además de otros puertos USB y slot
para tarjetas de memoria microSD Así podrás
conectar periféricos como en el caso de la Raspi,
incluidos los que agregan funcionalidades de red.
Puede arrancar sistemas operativos como Ubuntu
o Android ICS, entre otras distribuciones Linux.
Para mover estos sistemas holgadamente dispone
de 1GB de RAM, 2GB flash onboard, procesador
ARM Cortex A8 (basado en ARM11) de 1Ghz y una
GPU Mali 400 (la misma que integran los Samsung
Galaxy S3). Todo esto la hacen la compañera perfecta de los usuarios más avanzados
que quieran un todo en uno (plataforma duino + miniPC) y con un hardware superior
al de la Raspberry Pi.
 Netduino Plus 2: es una placa de desarrollo muy similar

a Arduino, pero con una peculiaridad muy llamativa,
utiliza la plataforma .NET Micro Framework para su
programación, mediante el IDE Visual C# Express
Edition. Posee un ATmel ARM de 32 bits a 120Mhz,
compatible con la mayoría de shields de Arduino.

 Freaduino : placa compatible con Arduino

oficial creada por Elecfreaks. Muy similar
también a la RedBoard de Sparkfun y cuyos
creadores han tomado como base la Arduino
UNO para su creación. Su hardware y
prestaciones son como las de Arduino, pero
su precio baja a los 18,60$. 100% compatible
a nivel electrónico y de software con Arduino
UNO.
 Teensy : es una placa de desarrollo basada en un microcontrolador, como todas, pero

viene presentada en una pequeña placa. Se
conecta al PC mediante un cable USB mini.
Puede adquirirse en distintas versiones que
varían en sus especificaciones y tamaño. Su
precio no varía mucho en función de la versión,
ya que en todos los casos se mantiene por
debajo de los 24$. Las versiones 2.0 se basan en
un microcontrolador AVR (un ATMega de ATmel
como los de Arduino), mientras que la versión
3.x se basa en un chip ARM. EL software para programarlo no es compatible con el
Arduino IDE pero existe un add-on llamado Teensyduino para éste. Otras opciones de
software son emplear el compilador WinARV C y otros.
 Funduino : es una copia de la placa oficial. Este

clon tiene diversas ediciones como la oficial,
como UNO, DUEMILANOVE, NANO, MEGA,
etc…, pero sus características técnicas y
programación es idéntica a la oficial. Es más, ni
siguiera se han molestado en cambiar el color.
 Ruggeduino: es una placa compatible con Arduino UNO (incluido a nivel de software) e
igual en casi todos los aspectos a la oficial. Tan
solo encontramos algunas variaciones muy
interesantes para los electrónicos, como son la
integración de protección electrónica contra ESD
en sus pines y conexiones eléctricas, cosa de la
que UNO oficial carece. Su precio asciende a los
39,95$.
Cada vez aparecen más y más placas basadas en Arduino, sobre todo no oficiales. Pero
como se puede comprobar en lo que hay que fijarse a la hora de adquirir una placa es si
queremos tenemos compatibilidad hardware, compatibilidad software o ambas.
Seguidamente veremos si la placa que queremos adquirir dispone del hardware que
queremos utilizar. No obstante a día de hoy, para educación y por la diferencia de precio,
yo recomiendo adquirir o la Arduino UNO, o la Arduino Mega 2560 con mayores
prestaciones.

Veamos una tabla comparativa entre algunas placas de Arduino :

Los Arduino Shields
Un shield es una placa impresa que se pueden conectar en la parte superior de

la placa Arduino para ampliar sus capacidades, pudiendo ser apilada una encima de la
otra.
Es posible apilar varias shields aunque la imagen superior ya es un caso

extremo no recomendable.
Las shields suelen ser diseños bastante

simples y en general de código abierto, el
diseño suelen ser publicados libremente.
Podemos encontrar shields un poco más
sofisticadas, incluyendo una unidad de medida
inercial con una estructura en seis giroscopios
DOF para su uso como parte de un piloto
automático en un avión modelo.
Como puede imaginarse, existen muchísimas Shields diseñadas por diversos

fabricantes, otras diseñadas por personas colaboradoras y otras que son diseñadas por
particulares con necesidades específicas. Existe una lista de shields con los detalles de
sus conexiones y la especificación básicas aquí en esta web :
http://shieldlist.org/
Sugiero al lector que se meta en esa web y analice la información de diferentes

shields, nosotros en este curso, usaremos la shield Ethernet, que nos permitirá realizar
aplicaciones que puedan ser controladas y/o monitorizadas a través de la web.

Introducción al Arduino
Arduino es una plataforma de desarrollo de computación física (physical computing)
de código abierto, basada en una placa con un sencillo microcontrolador y un entorno de
desarrollo para crear software (programas) para la placa.
Podemos usar Arduino para crear objetos interactivos, leyendo datos de una gran
variedad de interruptores y sensores y controlar multitud de tipos de luces, motores y otros
actuadores físicos. Los proyectos con Arduino pueden ser autónomos o comunicarse con un
programa (software) que se ejecute en un ordenador.
La placa y el software de desarrollo es abierto y lo podemos descargar gratis desde la

página www.arduino.cc/en/ . Arduino puede ser alimentado a través de la conexión USB o
con una fuente de alimentación externa. La fuente de alimentación se selecciona
automáticamente.
Hardware y cable USB
Especificaciones técnicas

El Arduino UNO
La constitución de la placa Arduino UNO es la siguiente :
1.- Microcontrolador ATmega328

Es un microcontrolador de la compañía .
Características
Voltaje de Operación: 5V
Memoria Flash: 32 KB de los cuales 512 bytes
son utilizados por el bootloader.
SRAM 2 KB, EEPROM 1 KB, Velocidad del Reloj
16 MHz, Bootloader preinstalado.
2.- Botón Reset : Suministrar un valor

LOW(0V) para reiniciar el microcontrolador.
3.- ICSP : Conector para la programación ICSP (In Circuit Serial Programming, o Programación
Serial en circuito). El ICSP es el sistema utilizado para poder programar los dispositivos sin
necesidad de tener que retirar el chip del circuito del que forma parte.
4, 5, 6 y 7 : Pines Digital Inputs/Outputs :
Cada uno de los 14 pines digitales se puede utilizar

como una entrada o una salida.
Pueden proporcionar o recibir un máximo de 40

mA y tienen una resistencia de pull-up
(desconectado por defecto) de 20 a 50 KΩ.
Algunos pines tienen funciones especializadas como:
 Pin 0 (RX) y 1 (TX). Se utiliza para recibir (RX) y transmitir (TX) datos serie TTL.
 Pines 2 y 3. Interrupciones externas. Se trata de pines encargados de interrumpir el
programa secuencial establecido por el usuario. Pueden ser configurados para
activar una interrupción en un valor bajo, un flanco ascendente o descendente, o
un cambio en el valor.
 Pines 3, 5, 6, 9, 10 y 11. PWM (modulación por ancho de pulso, en inglés pulse-
width modulation).
Constituyen 6 bits de salida PWM con la función analogWrite ().
 Pin 13. LED. Existe un LED SMD con su resistencia limitadora conectado a este
pin. Además es el único pin que contiene una resistencia limitadora integrada en la
placa Arduino en serie con el pin. Pudiendo conectar un Led externo entre este pin y
GND directamente.
 SPI : 10 (SS), 11 (MOSI), 12 (MISO), 13 (SCK). Estos pines sirven de apoyo a la
comunicación SPI con la biblioteca de SPI. El Bus SPI (del inglés Serial Peripheral
Interface) es un estándar de comunicaciones, usado principalmente para la
transferencia de información entre circuitos integrados en equipos electrónicos.

8.- GND : Pines de tierra.
9.- AREF : Tensión de referencia para las

entradas analógicas. Se utiliza con
analogReference ().
10.- USB : Arduino Uno tiene una serie de

facilidades para comunicarse con una
computadora usando los canales de
comunicación de esta serie a través de USB y
aparece como un puerto COM virtual en el
ordenador. Utiliza el estándar de los controladores USB COM, y no necesita ningún controlador
externo. Sin embargo, en Windows es necesario un archivo .inf. El RX y TX LED de la placa
parpadean cuando se transmiten datos a través del USB al chip serie y viceversa.
11.- Conector de alimentación :Plug hembra de 2.1mm para la conexión de alimentación en la

placa.
12, 13, 14, 15 y 16 . - Pines de alimentación (Power Pins)
Si alimentamos al Arduino mediante la conexión

USB o mediante una fuente externa (de 7 a 12V),
vamos a tener unas salidas de tensión continua
debido a unos reguladores de tensión y
condensadores de estabilización que posee.
Estos pines son :
 VIN: Pin de entrada para una fuente tensión externa que servirá para
alimentar al Arduino.
 5V: Pin de salida, fuente de tensión regulada de 5V, esta tensión puede
provenir ya sea de pin VIN, del conector USB o de otra fuente de 5V
regulada.
 3.3V: Pin de salida, fuente de 3.3 voltios generados por el chip FTDI
integrado con un consumo máximo de corriente de 50mA.
 GND: pines de tierra.
 Reset : Se puede aplicar un valor LOW(0V) para reiniciar el
microcontrolador. Típicamente usado para añadir un botón de reset a los
shields que no dejan acceso a este botón en la placa.

17.- Analog In : Arduino UNO tiene 6 entradas

analógicas, y cada una de ellas proporciona
una resolución de 10bits (1024 valores). Por
defecto se mide de tierra a 5 voltios, aunque
es posible cambiar la cota superior de este
rango usando el pin AREF ( 9 en el gráfico) y la
función analogReference().
18.- Cristal : Un cristal oscilador a 16MHz.
Aquí podemos observar los Leds que tiene

integrados la placa Arduino UNO, así como la
resistencia limitadora en serie con el pin 13.
El microcontrolador ATMEGA328 como ya se comentó, lo fabrica ATMEL, su datasheet

se puede descargar de :
http://www.atmel.com/devices/atmega328.aspx
Para un estudio de mayor profundidad o para una asignatura donde se estudie

microcontroladores, se debería estudiar el microcontrolador internamente, pero en este caso,
nos vamos a limitar a utilizar este microcontrolador a partir de la placa Arduino y con el
bootloader instalado.
No obstante, a lo largo de este curso es posible que se haga alguna mención de alguna
característica de este microcontrolador y debamos consultar el datasheet para aclarar el
funcionamiento.


El Arduino MEGA 2560
Podemos observar que el Arduino MEGA

2560 es más grande en cuanto a placa se refiere
con respecto al Arduino UNO. Además dispone
de 54 entradas/salidas digitales, 16 entradas
analógicas. Dispone de tres comunicaciones
serie TTL, 5 Interrupciones externa y posibilidad
de configurar hasta 14 patillas como salida
PWM. Siendo totalmente compatible con
Arduino UNO en cuanto al software. Los shields
diseñados para Arduino UNO son totalmente
compatibles como se puede comprobar en la
figura, pero hay que tener cuidado de colocarla
en su lugar correcto ( Fijarse en el pin 0 digital )



IMPORTANTE :
Según la placa que dispongamos, tendremos que seleccionarla en el IDE de Arduino.
En este manual se ha utilizado la placa de Arduino UNO y la placa de Arduino Mega.
El IDE oficial de Arduino
Instalación del IDE de Arduino

Conviene que para depositar en nuestro ordenador este software y que no se nos
pierda por ahí, abramos una carpeta para todo lo que se refiere a Arduino, que podemos
llamar de cualquier forma, pero yo sugiero que se llame “Arduino”. En esta carpeta en distintas
subcarpetas iremos guardando ordenadamente todos los ficheros que se generen.
Descargar el software necesario
Necesitamos instalar el software IDE ( integrated development environment ) de

desarrollo, y también instalar los controladores de Arduino, (device drivers). Todo el material
que necesitamos, le bajamos de
http://arduino.cc/en/Main/Software
Existe una página en castellano cuya dirección es http://www.arduino.cc/es/ pero no se

encuentra actualizada, por lo que usaremos la página en inglés.
Descargaremos la última versión del IDE de la sección (Download), que estará

disponible para los siguientes sistemas operativos, Windows, Mac OS X y Linux: 32 bit y 64 bit.
También disponemos para la descarga las fuentes de esos programas, (sources), ya que se
trata de software OPEN SOURCE.
En nuestro caso, nos descargaremos la versión para Windows. Al finalizar la descarga

obtendremos una carpeta comprimida, (del tipo .zip) que debemos descomprimir en la carpeta
“Arduino”, manteniendo la estructura de la carpeta que hemos descargado.

Instalar los “drives” del Arduino
Para instalar los drivers en Windows realizaremos los siguientes pasos :
1. Conectar Arduino UNO al PC mediante el cable USB de tipo A-B
2. El sistema operativo Windows 7 detecta el dispositivo e intentará instalar los

drivers, pero no lo instalará porque no los encuentra.
3. Accederemos al botón “Inicio” – “Panel de control” y pulsamos en

“Administrador de dispositivos”
4. En la ventana del Administrador de dispositivos, en “Otros dispositivos” nos

debe mostrar “Arduino Uno” con una exclamación en un círculo amarillo,
pulsaremos con el botón derecho del ratón y seleccionaremos “Actualizar
software de controlador”

5. Pulsaremos en “Buscar software de controlador en el equipo. Buscar e instalar

el software de controlador de forma manual”. Pulsaremos en el botón
“Examinar” para seleccionar la carpeta donde se encuentran los drivers.
6. Seleccionaremos la carpeta “Arduino” y, dentro de esta, la carpeta “Arduino

1.0.x/drivers” y pulsar “Siguiente”.
7. El asistente para instalar un nuevo controlador nos mostrará un aviso de

seguridad, pulsamos “Instalar este software de controlador de todas formas”.

8. Si todo es correcto, el asistente nos habrá instalado el controlador para

Arduino UNO y nos lo mostrará en una ventana. La exclamación con el círculo
amarillo debe haber desaparecido.
9. En el Administrador de dispositivos de Microsoft Windows 7 nos mostrará el

nuevo controlador instalado, en “Puertos (COM y LPT)”. Es importante que
anotemos el nombre asignado al puerto COM para Arduino, en nuestro caso
COM3, pues lo necesitaremos seleccionar en el IDE de Arduino
Primeros pasos con Arduino

Una vez que hemos estudiado la placa Arduino UNO, hemos instalado
el IDE de desarrollo y los drivers adecuados, conectamos Arduino UNO
mediante el cable USB a nuestro PC y ejecutamos el IDE de desarrollo haciendo
doble clic en el fichero “arduino.exe”.
Nos aparecerá una ventana como la siguiente :
Debemos fijarnos en primer lugar, que

disponemos de 4 zonas diferenciadas.
Zona de menús, Zona de iconos, Zona de trabajo y
Zona de mensajes o notificaciones.
Una vez abierta la aplicación debemos configurar algunos

parámetros, para ello, lo primero debemos pinchar en
“Herramientas”, después en “Tarjeta” y elegiremos la placa que
disponemos , es decir “Arduino UNO”.
Después iremos otra vez a “Herramientas” y pincharemos

esta vez en “Puerto Serial” (si se encuentra desactivado significa

que la aplicación no ha encontrado nuestro Arduino) y seleccionamos el Puerto donde el

sistema ha reconocido nuestro Arduino ( ver punto 9 de la instalación de drivers).
Por último, pincharemos en “Archivo” y después en “Preferencias”, y modificamos la

ventana según la siguiente figura :
La ubicación del Sketchbook ( Arduino llama a

los programas Sketch, dibujo en castellano)
puede ser cualquiera, nosotros usaremos
“C:\Arduino\MisSketch”, será donde se
guarden todos nuestros Sketch (Programas).
Activaremos las casillas para que nos muestre

el resultado detallado durante la compilación,
que verifique el código después de cargar y
que asocie de forma automática los archivos
con extensión “.ino” con el IDE de Arduino.
Descripción de los menús
- Menú Archivo :
Posee las mismas opciones que cualquier programa
basado en Windows (Nuevo, Abrir, Cerrar, etc…) y
algunas opciones añadidas como por ejemplo:
Sketchbook : Si nos situamos encima se desplegarán
todos los Sketch que hemos guardado dentro de nuestro
Sketchbook.
Ejemplos : Si nos situamos encima se desplegarán todos
los ejemplos que trae el IDE de Arduino por defecto.
Cargar : Sirve para enviar el sketch a la placa Arduino.
Cargar usando Programador : Sirve para enviar el sketch
a la placa Arduino usando un programador externo.
- Menú Editar :
Posee las mismas opciones que cualquier programa

basado en Windows (Deshacer, Rehacer, Cortar, etc…) y
algunas opciones añadidas como por ejemplo :
Copiar para el foro,copiar como HTML, incrementar

margen , reducir margen, etc…., cuya función se puede
comprobar de forma fácil y no son importantes para el
funcionamiento del sketch.

- Menú Sketch :
Este menú dispone de las opciones de
Agregar Archivo e Importar Librería,
añaden a nuestro Sketch un archivo o
una librería.
Las opciones de Verificar / Compilar y

Mostrar la carpeta de Sketch, realizan la
función que describen.
- Menú Herramientas :
Formato Automático :
Establece
adecuadamente las
tabulaciones para
nuestro sketch
Archivar el Sketch : Comprime todos los sketch abiertos en el IDE y los guarda por defecto
en la carpeta Arduino de la carpeta documentos de nuestro PC. Crea un único archivo *.zip
Reparar Codificación y recargar : Compila y carga el sketch en el que estamos trabajando,

descartando todos los cambios efectuados desde la última vez que se guardó.
Monitor Serial : Abre un sistema de monitorización que nos permite visualizar datos
enviados por el microcontrolador o enviarlos al microcontrolador.
Tarjeta : Escogemos el tipo de placa Arduino con la que estamos trabajando.
Puerto serie : Escogemos el puerto donde tenemos conectado la placa Arduino.
Programador : Escogemos el tipo de programador en caso de que no usar la propia placa

Arduino como programador.
Grabar Secuencia de Inicio : Nos da la posibilidad de grabar el bootloader de Arduino en

un microcontrolador para poder usar el IDE de Arduino.

- Menú Ayuda :
Como podemos observar, tenemos varias

opciones que al pinchar sobre ellas, abren
una página web que tiene relación con la
opción elegida. La opción más usada va a
ser Referencia, la cual nos ayudará a
buscar las funciones, librerías, etc… del
lenguaje utilizado por Arduino.
Descripción de la zona de iconos
Al pulsar sobre estos iconos, se realizan las funciones ya explicadas anteriormente. Se

trata de iconos de acceso rápido a funciones que se realizan de forma habitual.
Verificar Abrir Nuevo
Cargar Guardar Monitor Serial
Descripción de la zona de notificaciones
La área de notificaciones es la zona del IDE de Arduino donde el compilador nos dará
información sobre posibles errores, qué placa tenemos conectada y a qué puerto. También nos
indica en que línea tenemos el cursor dentro del área de trabajo.

Descripción de la zona de trabajo
El área de trabajo es la zona editable del IDE de Arduino donde escribiremos nuestro
código para posteriormente, compilarlo y transferirlo a la placa. En el entorno Arduino
podemos tener tantas funciones como queramos (definidas por el usuario) pero como mínimo
tendremos dos: setup( ) y loop( ).
El IDE de Arduino,
asigna un nombre
automático al sketch
compuesto por “sketch_”
seguido de los 3 primeros
caracteres del mes “mar”,
seguido de 2 dígitos
numéricos de la fecha “10”
y seguido de una letra comenzando por “a” e incrementándose según vayamos creando
nuevos sketch. En el ejemplo de la figura es el primer sketch “a”, que se ha realizado el día 10
de Marzo “mar”. Por supuesto, el nombre se puede modificar.
Los nombres que llevan el carácter § al final, es porque han sido modificados y no han
sido guardados.
El código situado en la función setup(), se ejecutará solo una vez, al iniciarse el sistema,
es decir, al arrancar el microcontrolador (no confundir con el bootloader). Se suelen configurar
los pines como entradas o salidas en esta función o inicializar algún dispositivo. El código que
situemos en la función loop() en cambio, se ejecutará indefinidamente (loop significa lazo en
inglés).
En el entorno Arduino, las palabras reservadas por el compilador, cambian

automáticamente de formato. Otra característica es el tratamiento diferenciado de las letras
mayúsculas y minúsculas.

Programa ejemplo Blink
En 1972 Dennis Ritchie y Brian W. Kernighan publicaron “El lenguaje de programación

C”. 40 años después, es considerado como el inicio de la programación en alto nivel, base de la
mayoría de los lenguajes que hoy conocemos y donde aparece el famoso ejemplo de “Hello
World”. Desde entonces es habitual nombrar, como lo hicieron Dennis y Brian, “Hola Mundo”
cuando se realiza la primera prueba en cualquier lenguaje de programación. En el mundo de la
computación física, el equivalente a “Hello World” es “Blink” (parpadear en inglés), alternar
entre un estado alto y bajo en un pin digital configurado como salida. A continuación vamos a
cargar nuestro “Blink” en nuestro Arduino.
Abrimos el IDE de Arduino y

hacemos click en :
Archivo – Ejemplos- Basics –
Blink
A continuación se estudia el ejemplo “Blink” aunque no es imprescindible que el lector

entienda completamente cada línea, si es importante que se entienda el algoritmo que se
utiliza.
Descripción : Se puede empezar el código con una breve descripción de la funcionalidad de

nuestro sketch. Fijémonos que utilizamos las instrucciones “/*” y “*/” para introducir
comentarios de más de una línea.
Función setup( ) : Esta función se ejecuta solo una vez al arrancar el sistema. En este caso solo
la utilizamos para configurar el pin 13 de nuestro Arduino UNO, como salida. Utilizamos la
función pinMode para ello. Cuando el comentario ocupa una sola línea utilizamos la doble
barra “//”. El pin 13 tiene un led conectado en la propia placa en casi todos los modelos de
Arduino.

Función loop( ) : Esta función se ejecutará mientras la placa esté alimentada y no esté en
reset. Con la función digitalWrite ( led, HIGH ), escribimos un estado alto en el pin 13 (si
medimos la tensión en el pin, mediremos 5V). Después hacemos que el microcontrolador
espere un tiempo con la función delay. Esta función provoca una espera en milisegundos en
función del parámetro utilizado en su llamada. Más adelante comentaremos cosas de esta
famosa pero peligrosa función. Pasada la espera, escribimos un estado bajo en el mismo pin
con la función digitalWrite ( led, LOW ), (si medimos la tensión en el pin, mediremos 0V) y
antes de volver a escribir un estado alto, volvemos a realizar una pequeña espera de 1000
milisegundos.
Si consideramos que esta función se ejecuta indefinidamente, ya tenemos el parpadeo del pin
como queríamos.
Para comprobarlo, hacemos click en el icono “cargar” y

transcurrido un tiempo veremos cómo nuestro led comienza a
parpadear.
A partir de ahora, todos los sketch que hagamos se cargarán en Arduino de la misma
manera, por lo que ya no se volverá a explicar el proceso de carga de un sketch en Arduino.

Software relacionado con Arduino
Una de las ventajas de Arduino es, a parte de su sencillez, la posibilidad de

elaborar nuestro código mediante entornos gráficos a base de iconos, una buena opción
si no queremos perder mucho tiempo creando el software o si queremos aprender las
bases de la programación.
Minibloq
Minibloq es una herramienta que nos permite programar cualquier placa

Arduino, ya sea Mega, UNO, Duemilanove, etc, y también sus variantes como Seeduino
o Duinobot. Mediante sencillos iconos, es posible crear códigos complejos con poco
esfuerzo. Además, me llamó la atención el hecho que es posible ver el código en C++
de Arduino equivalente a la lista de instrucciones que hemos creado. Para más
información y enlaces de descarga visitar su blog.
Entorno de programación Minibloq
Modkit (alpha)
Modkit permite programar una gran variedad de microcontroladores: Arduino,

Seeduino, LillyPad y una larga lista. Además permite ver el código que hemos creado
con iconos y además modificarlo, lo cual está muy bien no sólo para los iniciados, sino
para ahorrar tiempo y trabajo a los más experimentados. Actualmente se encuentra en
versión alpha, y habrá una versión gratuita y una de pago. Para más información visitar
la web oficial del proyecto.

Ejemplo de un programa con Modkit
S4A
S4A o Scratch for Arduino es una modificación del popular Scratch pensada
exclusivamente para placas Arduino. S4A busca ofrecer una plataforma de iniciación al
mundo de la programación, así como una herramienta potente y de alto nivel para
programadores que usen Arduino. Es totalmente gratuito y se puede descargar desde la
web oficial del proyecto.
Scratch 4 Arduino

Ardublock
Ardublock es una potente herramienta que permite programar de forma similar a

Modkit o S4A. Sus principales ventajas son el hecho de poder configurar rápida y
fácilmente gran cantidad de módulos y sensores a partir de bloques que vienen ya por
defecto, además de ser compatible con la IDE de programación de Arduino. Más
información en el blog.
Ardublock permite configurar rápidamente sensores y componentes
Physical Etoys
Physical Etoys es una herramienta para programación gráfica con fines

didácticos que permite programar distintos dispositivos entre los que se encuentra
Arduino. Está basado en Etoys, lenguaje de programación gráfico orientado a la
educación y la enseñanza de los niños. Se puede descargar desde aquí.

Physical Etoys permite programar todo tipo de dispositivos físicos
Simular Arduino con 123D Circuits
Es una aplicación web que permite crear proyectos de arduino con layout de
protoboard o PCB. Dichos proyectos pueden ser compartidos de manera que se hagan
cooperativos, se pueden encargar los PCBs que hagamos de manera muy parecida a la
que nos ofrece Fritzing y además tenemos un IDE de programación online, de manera
que podemos seguir picando código desde nuestra tablet.

Es una plataforma muy atractiva por lo fácil y potente al mismo tiempo que
resulta. Además es muy buena herramienta para la enseñanza, ese espíritu que tanto
gusta a la comunidad Arduino. ¡Y por supuesto puedes simular tu código online!
¿Cómo empezar a desarrollar en 123D Circuits?
Vamos a el sitio 123d.Circuits.io y nos registramos, lo cual es muy fácil y

rápido. Una vez que tenemos nuestra cuenta la pantalla principal será esta:
Como podemos ver nos ofrecerá empezar con layout de protoboard estilo
Fritzing o bien con aspecto de PCB, esta última es buena opción si queremos encargar
una shield personalizada de Arduino que diseñemos nosotros. Si queremos acceder a
nuestros proyectos hacemos click en nuestra fotográfica. Y si queremos ver proyectos
que ha hecho la comunidad podemos verlos haciendo scroll en la web, esto es
interesante ya que como si de git se tratara podemos hacer “fork” de proyectos ajenos
y así basarnos en sus diseños.
Una vez que nos decidimos a crear un proyecto accedemos a la siguiente pantalla.

Cuando tengamos el circuito empezamos con el código (no es estrictamente

necesario seguir ese orden).
Y una vez hayamos terminado el código, es tan fácil como dar a “upload &
run” para empezar a ver como tu creación cobra vida. La única pega que tiene la
plataforma es que si tu código no compila no te va a decir dónde está el error, aunque
este sea pura sintaxis. Si no encuentras tu error, puedes dar a “download code” o un
simple copiar y pegar en nuestro IDE arduino para verificar, corregir y volver a copiar.
Como vemos simula muchos componentes y además también simula una terminal serie.
Fritzing
Fritzing es una de una de las mejores

herramientas que existen en la actualidad
para el diseño y creación de circuitos
electrónicos, y es tan potente y completo,
que puede ser utilizado de manera
profesional para crear todo tipo de circuitos.
Fritzing cuenta con características
interesantes en cuanto al espacio de trabajo,
pose una interfaz IDE, de esta manera se
permite arrastrar y soltar los elementos en
el área de trabajo. Fritzing cuenta con un
área de trabajo, que es capaz de crear
esquemas de circuitos muy detallados para
la creación de los prototipos de nuestros
proyectos en poco tiempo.
Fritzing incorpora un apartado visual

bastante completo que permite crear los circuitos de forma dinámica, arrastrando los
símbolos de cada componente electrónico hacia el área de trabajo. Así, la creación de
circuitos electrónicos será tan sencillo como dibujarlos en una hoja, y quedará un
esquema completo que podrá convertirse en un prototipo real rápidamente.

Fritzing posee 3 tipos de vistas.
La vista de Protoboard (Placa de Prototipos), esta vista está diseñada para verse como
un protoboard Real.
La vista de Esquema, esta representación es similar a los diagramas para representar un

circuito electrónico.

Vista de PCB, donde se pueden ver o realizar las conexiones de nuestro esquema
en PCB.
VirtualBreadboard - Simulador de Arduino y PIC
VirtualBreadboard es un entorno de simulación y

desarrollo para aplicaciones embebidas que usan
microcontroladores. Es fácil de usar y puede
reemplazar un protoboard para experimentar con nuevos diseños.
VBB simula muchos microcontroladores de las líneas PIC16 y PIC18, ahora también
con la emulación de Arduino. En adición se encuentran una amplia variedad de
componentes simulados como LCDs, servos, lógica y otros dispositivos de E/S que
pueden ser usados para modelar y simular circuitos de alto nivel."
En sus primeras versiones, VBB era libre, ahora se ha convertido en una aplicación de
pago.
Funciona en base a una librería de componentes virtuales que vienen incluidos en el

paquete de software: botones pulsadores, LEDs, potenciómetros, displays LCD, motores
servo y steppers, chips de lógica e incluso memorias EEPROM y convertidores ADC y
DAC. Adicionalmente VBB incluye una plataforma llamada Micromorph CDK (Kit de
Desarrollo de Componentes Micromorph) que te permite construir y añadir tus propios
componentes con simulación de entradas y salidas.

Algunos componentes del VirtualBreadboard
Crear y simular un proyecto es simple e implica básicamente lo siguiente:
1. Interconectar todos los componentes necesarios en la ventana de conexiones

(breadboard virtual).
2. Escribir el código que debe correr en el microcontrolador. Para el Arduino se usa el
lenguaje de Arduino y para los PICs actualmente sólo soporta lenguaje ensamblador.
3. Simular la ejecución del código y el comportamiento de los componentes.
4. Realizar los ajustes necesarios en el hardware y código.
El VBB en su última versión al momento de esta publicación viene con numerosos

proyectos de ejemplo para Arduino, PIC16 y PIC18, la plataforma Amicus y Netduino,
listos para correrlos y analizarlos. A continuación se muestra las ventanas de breadboard
virtual y código de un ejemplo sencillo con Arduino, un LED y un potenciómetro:

Ventajas y Limitaciones de VirtualBreadboard
VBB es una excelente opción de entrada para aprender a programar Arduino si no se

cuenta con la placa real y para quienes desean probar primeramente la plataforma y
verificar que se ajusta a sus necesidades y expectativas, antes de arriesgarse a realizar la
inversión económica en la compra de la placa de hardware.
Respecto a la simulación de los PICs sería excelente si el VBB soportara la simulación

de lenguaje C; actualmente solo soporta el lenguaje ensamblador asociado al PIC, el
cual es complejo y no muy recomendable para principiantes, sin embargo es posible que
en el futuro soporte lenguaje C también.
Desde ya cualquier plataforma de simulación tiene sus limitaciones. Para los

principiantes el VBB es una excelente herramienta para el aprendizaje; para los que
tienen más experiencia es útil para pruebas y prototipos sencillos y rápidos; pero no
muy útil para realizar proyectos de complejidad media o alta en los cuales por lo general
se requiere contar con el hardware implementado para pruebas reales no simuladas.
Proteus
PROTEUS es un entorno de desarrollo CAD de la

empresa Labcenter Electronics Ltd, el cual integra diversas
herramientas de software para las tareas más comunes en el
desarrollo de proyectos electrónicos tales como: captura de
esquemáticos, fabricación de circuitos impresos y simulación
basada en PSPICE.
Las herramientas que conforman a PROTEUS son los siguientes:
 ISIS ( “Intelligent Schematic Input System” ). El cual es módulo de captura de

diagramas esquemáticos.
 VSM ( “Virtual System Modelling” ). El cuál es el módulo de simulación, incluyendo
PROSPICE.
 ARES ( “Advanced Routing and Editing Software” ). El cuál es el módulo para la
realización de circuitos impresos o PCB.

El lenguaje de programación de Arduino
El lenguaje de programación de Arduino se basa en C / C++. A continuación realizaré

un resumen del lenguaje, aunque se puede consultar toda la referencia en la siguiente
dirección :
http://arduino.cc/es/Reference/HomePage
Se tratará de resumir lo máximo posible y hacer referencia a los matices que son
necesarios para desarrollar sketch lo más claros posibles.
Estructura básica de un programa :

La estructura básica del lenguaje de programación de Arduino es bastante
simple y se compone de al menos dos partes. Estas dos partes necesarias, o funciones,
encierran bloques que contienen declaraciones, estamentos o instrucciones.
void setup( )
{
estamentos;
}
void loop( )
{
estamentos;
}
En donde setup( ) es la parte encargada de recoger la configuración y loop( )

es la que contienen el programa que se ejecutará cíclicamente (de ahí el termino loop
–bucle-). Ambas funciones son necesarias para que el programa trabaje.
La función de configuración debe contener la declaración de las variables. Es la
primera función a ejecutar en el programa, se ejecuta sólo una vez, y se utiliza para
configurar o inicializar pinMode (modo de trabajo de las E/S), configuración de la
comunicación en serie y otras.
La función bucle (loop) siguiente contiene el código que se ejecutara
continuamente (lectura de entradas, activación de salidas, etc) Esta función es el
núcleo de todos los programas de Arduino y la que realiza la mayor parte del trabajo.
Setup ( )
La función setup( ) se invoca una sola vez cuando el programa empieza. Se

utiliza para inicializar los modos de trabajo de los pins, o el puerto serie. Debe ser
incluido en un programa aunque no haya declaración que ejecutar.
void setup( )
{
pinMode(pin, OUTPUT); // configura el 'pin' como salida
}

Loop ( )
Después de llamar a setup( ), la función loop( ) hace precisamente lo que

sugiere su nombre, se ejecuta de forma cíclica, lo que posibilita que el programa este
respondiendo continuamente ante los eventos que se produzcan en la tarjeta
void loop( )
{
digitalWrite(pin, HIGH); // pone en uno (on, 5v) el ´pin´
delay(1000); // espera un segundo (1000 ms)
digitalWrite(pin, LOW); // pone en cero (off, 0v.) el ´pin´
delay(1000);
}
Funciones
Una función es un bloque de código que tiene un nombre y un conjunto de

estamentos que son ejecutados cuando se llama a la función. Son funciones setup( ) y
loop() de las que ya se ha hablado. Las funciones de usuario pueden ser escritas para
realizar tareas repetitivas y para reducir el tamaño de un programa. Las funciones se
declaran asociadas a un tipo de valor “type”. Este valor será el que devolverá la
función, por ejemplo 'int' se utilizará cuando la función devuelva un dato numérico de
tipo entero. Si la función no devuelve ningún valor entonces se colocará delante la
palabra “void”, que significa “función vacía”. Después de declarar el tipo de dato que
devuelve la función se debe escribir el nombre de la función y entre paréntesis se
escribirán, si es necesario, los parámetros que se deben pasar a la función para que se
ejecute.
type nombreFunción (parámetros)
{
estamentos;
}
{ } Entre llaves
Las llaves sirven para definir el principio y el final de un bloque de

instrucciones. Se utilizan para los bloques de programación setup( ), loop( ), if.., etc.
type funcion( )
{
estamentos;
}
Una llave de apertura “{“ siempre debe ir seguida de una llave de cierre “}”, si
no es así el programa dará errores. El entorno de programación de Arduino incluye una
herramienta de gran utilidad para comprobar el total de llaves. Sólo tienes que hacer
click en el punto de inserción de una llave abierta e inmediatamente se marca el
correspondiente cierre de ese bloque (llave cerrada).

; El punto y coma
El punto y coma “;” se utiliza para separar instrucciones en el lenguaje de

programación de Arduino. También se utiliza para separar elementos en una
instrucción de tipo “bucle for”.
int x = 13; // declara la variable 'x' como tipo entero de valor 13
Nota: Olvidarse de poner fin a una línea con un punto y coma se traducirá en un error
de compilación. Las instrucciones pueden estar escritas una en cada línea o varias en
una misma línea, pero siempre separadas por ‘ ; ‘.
Bloques de comentarios /*…. */
Los bloques de comentarios, o multi-línea de comentarios, son áreas de texto

ignorados por el programa que se utilizan para las descripciones del código o
comentarios que ayudan a comprender el programa. Comienzan con / * y terminan
con * / y pueden abarcar varias líneas.
/* esto es un bloque de comentario

no se debe olvidar cerrar los comentarios
estos deben estar equilibrados
*/
Debido a que los comentarios son ignorados por el programa y no ocupan

espacio en la memoria de Arduino pueden ser utilizados con generosidad y también
pueden utilizarse para "comentar" bloques de código con el propósito de anotar
informaciones para depuración.
Nota: Dentro de una misma línea de un bloque de comentarios no se puede escribir
otra bloque de comentarios (usando /* .. */ )
Línea de comentarios //
Una línea de comentario empieza con / / y terminan con la siguiente línea de

código. Al igual que los comentarios de bloque, los de línea son ignoradas por el
programa y no ocupan espacio en la memoria.
// esto es un comentario
Una línea de comentario se utiliza a menudo después de una instrucción, para

proporcionar más información acerca de lo que hace esta o para recordarla más
adelante.

Variables
Una variable es una manera de nombrar y almacenar un valor numérico para

su uso posterior por el programa. Como su nombre indica, las variables son números
que se pueden variar continuamente en contra de lo que ocurre con las constantes
cuyo valor nunca cambia. Una variable debe ser declarada y, opcionalmente, asignarle
un valor.
int variableEntrada = 0; // declara una variable y le asigna el valor 0
variableEntrada = analogRead(2);// la variable recoge el valor analógico del PIN2
Nota: Las variables deben tomar nombres descriptivos, para hacer el código más
legible. Nombres de variables pueden ser “contactoSensor” o “pulsador”, para ayudar
al programador y a cualquier otra persona a leer el código y entender lo que
representa la variable. Nombres de variables como “var” o “valor”, facilitan muy poco
que el código sea inteligible. Una variable puede ser cualquier nombre o palabra que
no sea una palabra reservada en el entorno de Arduino.
Declaración de variables
Todas las variables tienen que declararse antes de que puedan ser utilizadas.
Para declarar una variable se comienza por definir su tipo como int (entero), long
(largo), float (coma flotante), etc, asignándoles siempre un nombre, y, opcionalmente,
un valor inicial. Esto sólo debe hacerse una vez en un programa, pero el valor se puede
cambiar en cualquier momento usando aritmética y reasignaciones diversas.
int entradaVariable = 0;
Una variable puede ser declarada en una serie de lugares del programa y en
función del lugar en donde se lleve a cabo la definición esto determinará en que partes
del programa se podrá hacer uso de ella.
Una variable puede ser declarada al inicio del programa antes de la parte de
configuración setup( ), a nivel local dentro de las funciones, y, a veces, dentro de un
bloque (no recomendable), como para los bucles del tipo if.. for.., etc.
En función del lugar de declaración de la variable así se determinara el ámbito
de aplicación, o la capacidad de ciertas partes de un programa para hacer uso de ella.
Una variable global es aquella que puede ser vista y utilizada por cualquier
función y estamento de un programa. Esta variable se declara al comienzo del
programa, antes de setup( ).
Una variable local es aquella que se define dentro de una función o como parte
de un bucle (no recomendable). Sólo es visible y sólo puede utilizarse dentro de la
función en la que se declaró.

int variable0; // ‘variable0’ es visible para cualquier función

void setup( )
{
Byte variable1; // ‘variable1’ solo es visible dentro de la función setup ( )
……..
……..
}
void loop( )
{
Int variable2; // ‘variable2’ sólo es visible dentro de la función loop ( )
for (int i=0; i<20;) // ‘ i ’ solo es visible dentro de la función loop ( )
{
i++;
}
float f; // ‘ f ‘ es visible solo dentro de la función loop ( )
}
En el ejemplo anterior, aunque es posible declarar las variables como se indica, se

recomienda declarar siempre las variables al comienzo del programa o al principio de las
funciones, por lo tanto, las variables ‘ f ’ e ‘ i ‘, se recomienda que se declaren junto con la
variable ‘ variable2’, quedando la función loop, de la siguiente forma :
void loop( )
{
Int variable2;
Int i; float f;
for (i=0; i<20;)
{
i++;
}
}
Tipos de variables ( ver todos en : http://arduino.cc/es/Reference/Extended )
 Byte : Almacena un valor numérico de 8 bits sin decimales. Tienen un rango entre 0 y
255.
 Char : Es un tipo de dato que ocupa un byte de memoria con signo Tienen un rango
entre -128 y 127. Para un dato de un byte (8bits), utilice el tipo de dato "byte".
 Int : Enteros son un tipo de datos primarios que almacenan valores numéricos de 16
bits sin decimales comprendidos en el rango -32768 y 32767.
 Long : Enteros (tipo 32 bits) sin decimales que se encuentran dentro del rango
-2147483648 a 2147483647.
 Float : Números con decimales. Los números de punto flotante tienen una mayor
resolución que los de 32 bits con un rango comprendido entre
-3.4028235E+38 a 3.4028235E+38.
Nota: Los números de punto flotante no son exactos, y pueden producir resultados
extraños en las comparaciones. Los cálculos matemáticos de punto flotante son
también mucho más lentos que los del tipo de números enteros, por lo que debe
evitarse su uso si es posible.

Arrays
Un array es un conjunto de valores a los que se accede con un número índice.

Cualquier valor puede ser recogido haciendo uso del nombre de la matriz y el número del
índice. El primer valor de la matriz es el que está indicado con el índice 0, es decir el primer
valor del conjunto es el de la posición 0. Un array tiene que ser declarado y
opcionalmente asignados valores a cada posición antes de ser utilizado
int miArray[] = {valor0, valor1, valor2...} ;
Del mismo modo es posible declarar una matriz indicando el tipo de datos y el tamaño
y posteriormente, asignar valores a una posición especifica :
int miArray[5] ; // declara un array de enteros de 6 posiciones

miArray[3] = 10 ; // asigna el valor 10 a la posición 4
Para leer de un array basta con escribir el nombre y la posición a leer :
x = miArray[3] ; // x ahora es igual a 10 que está en la posición 4 del array
Aritmética
Los operadores aritméticos que se incluyen en el entorno de programación son suma,

resta, multiplicación, división y resto.
y = y + 3;
x = x - 7;
i = j * 6;
r = r / 5;
a= b % 10; // devuelve el resto de b/10
Las operaciones se efectúa teniendo en cuenta el tipo de datos que hemos definido
para los operandos (int, dbl, float, etc..), por lo que, por ejemplo, si definimos 9 y 4 como
enteros “int”, 9 / 4 devuelve de resultado 2 en lugar de 2,25 ya que el 9 y 4 se valores
de tipo entero “int” (enteros) y no se reconocen los decimales con este tipo de datos.
Esto también significa que la operación puede sufrir un desbordamiento si el resultado

es más grande que lo que puede ser almacenada en el tipo de datos. Recordemos el
alcance de los tipos de datos numéricos que ya hemos explicado anteriormente.
Si los operandos son de diferentes tipos, para el cálculo se utilizará el tipo más grande
de los operandos en juego. Por ejemplo, si uno de los números (operandos) es del tipo
float y otra de tipo integer, para el cálculo se utilizará el método de float es decir el
método de coma flotante.

Asignaciones compuestas
Las asignaciones compuestas combinan una operación aritmética con una variable
asignada. Estas asignaciones compuestas pueden ser:
x ++ // igual que x = x + 1, o incrementar x en + 1

x -- // igual que x = x - 1, o decrementar x en -1
x += y // igual que x = x + y, o incrementar x en +y
x -= y // igual que x = x - y, o decrementar x en -y
x *= y // igual que x = x * y, o multiplicar x por y
x /= y // igual que x = x / y, o dividir x por y
Operadores de comparación
Las comparaciones de una variable o constante con otra se utilizan con frecuencia en
las estructuras condicionales del tipo if.. para testear si una condición es verdadera. Tipos de
operadores :
x == y // x es igual a y
x != y // x no es igual a y
x<y // x es menor que y
x>y // x es mayor que y
x <= y // x es menor o igual que y
x >= y // x es mayor o igual que y
Operadores lógicos
Los operadores lógicos sirven para comparar dos expresiones y devolver un valor
‘VERDADERO’ o ‘FALSO’ dependiendo del operador. Existen tres operadores lógicos, AND (&&),
OR (||) y NOT (!), que a menudo se utilizan en estamentos de tipo if.. :
if (x > 0 && x < 5) // cierto sólo si las dos expresiones son ciertas
if (x > 0 || y > 0) // cierto si una cualquiera de las expresiones es cierta
if (!x > 0) // cierto solo si la expresión es falsa
Constantes
El lenguaje de programación de Arduino tiene unos valores predeterminados, que son

llamados constantes. Se utilizan para hacer los programas más fáciles de leer. Las
constantes se clasifican en grupos.
 TRUE / FALSE / HIGH / LOW : Son constantes booleanas que definen los niveles de
tensión HIGH (alto) y LOW (bajo) cuando estos se refieren al estado lógicos de las
salidas digitales. FALSE se asocia con 0, mientras que TRUE se asocia con 1, pero TRUE
también puede ser cualquier otra cosa excepto cero. Por lo tanto, en sentido
booleano, -1, 2 y -200 son todos también se define como TRUE. (esto es importante
tenerlo en cuenta)
 INPUT / OUTPUT : Estas constantes son utilizadas para definir, al comienzo del
programa, el modo de funcionamiento de los pines mediante la instrucción pinMode
de tal manera que el pin puede ser una entrada INPUT o una salida OUTPUT.

Sentencia IF (si) / IF …. Else (si…sino)
if es un estamento que se utiliza para probar si una determinada condición se ha

alcanzado, como por ejemplo averiguar si un valor analógico está por encima de un
cierto número, y ejecutar una serie de declaraciones (operaciones) que se escriben
dentro de las llaves, si es verdad. Si es falso (la condición no se cumple) el programa salta y
no ejecuta las operaciones que están dentro de las llaves.
El formato para if es el siguiente:
if (unaVariable ?? valor)
{
ejecutaInstrucciones;
}
En el ejemplo anterior se compara una variable con un valor, el cual puede ser una
variable o constante. Si la comparación, o la condición entre paréntesis se cumple (es
cierta), las declaraciones dentro de las llaves se ejecutan. Si no es así, el programa
salta y continúa.
Nota: Tenga en cuenta el uso especial del símbolo '=', poner dentro de if (x = 10),
podría parecer que es válido pero sin embargo no lo es ya que esa expresión asigna el
valor 10 a la variable x, por eso dentro de la estructura if se utilizaría x==10 que en
este caso lo que hace el programa es comprobar si el valor de x es 10.
‘if… else’ viene a ser un estructura que se ejecuta en respuesta a la idea “si esto no se
cumple haz esto otro”. Por ejemplo, si se desea probar una entrada digital, y hacer una
cosa si la entrada fue alto o hacer otra cosa si la entrada es baja, usted escribiría que de
esta manera:
if (inputPin == HIGH) // si el valor de la entrada inputPin es alto

{
instruccionesA; //ejecuta si se cumple la condición
}
else
{
instruccionesB; //ejecuta si no se cumple la condición
}
‘Else’ puede ir precedido de otra condición de manera que se pueden establecer varias
estructuras condicionales de tipo unas dentro de las otras (anidamiento) de forma que
sean mutuamente excluyentes pudiéndose ejecutar a la vez.

if (inputPin < 500)

{
instruccionesA; // ejecuta las operaciones A
}
else if (inputPin >= 1000)
{
instruccionesB; // ejecuta las operacione B
}
else
{
instruccionesC; // ejecuta las operaciones C
}
El bucle For / Next
La declaración for se usa para repetir un bloque de sentencias encerradas entre llaves
un número determinado de veces. Cada vez que se ejecutan las instrucciones del bucle se
vuelve a testear la condición. La declaración for tiene tres partes separadas por ( ; )
for (inicialización; condición; expresión)

{
ejecutaInstrucciones;
}
La inicialización de una variable local se produce una sola vez y la condición se testea cada vez
que se termina la ejecución de las instrucciones dentro del bucle. Si la condición sigue
cumpliéndose, las instrucciones del bucle se vuelven a ejecutar.
Cuando la condición no se cumple, el bucle termina.
Los bucles While ( mientras ) / do….While ( hacer….mientras )
Un bucle del tipo while es un bucle de ejecución continua mientras se cumpla la

expresión colocada entre paréntesis en la cabecera del bucle. La variable usada como
comparación, tendrá que cambiar para salir del bucle. La situación podrá cambiar a expensas
de una expresión dentro el código del bucle o también por el cambio de un valor en una
entrada de un sensor.
while (unaVariable ?? valor)

{
ejecutarSentencias;
}

El bucle ‘do…. While’ funciona de la misma manera que el bucle while, con la salvedad
de que la condición se prueba al final del bucle, por lo que el bucle siempre se ejecutará al
menos una vez. do
{
Instrucciones;
} while (unaVariable ?? valor);
Es importante darse cuenta del ‘ ; ‘ del final del bucle, detrás de la comparación.
pinMode ( pin , modo )
Esta instrucción es utilizada en la parte de configuración setup ( ) y sirve para

configurar el modo de trabajo de un PIN pudiendo ser INPUT (entrada) u OUTPUT (salida).
pinMode(pin, OUTPUT); // configura ‘pin’ como salida
digitalRead ( pinDigital )
Lee el valor de un pin (definido como digital) dando un resultado HIGH (alto) o LOW
(bajo). El pin se puede especificar ya sea como una variable o una constante (0-13).
valor = digitalRead(Pin); // hace que 'valor sea igual al estado leído en ´Pin´
digitalWrite ( pin, valor )
Envía al ´pin´ definido previamente como OUTPUT el valor HIGH o LOW (poniendo
en 1 o 0 la salida). El pin se puede especificar ya sea como una variable o como una
constante (0-13).
digitalWrite(pin, HIGH); // deposita en el 'pin' un valor HIGH (alto o 1)
Funciones delay ( ) y millis ( )
 La función delay (tiempo ) detiene la ejecución del programa la cantidad de tiempo en

ms que se indica en la propia instrucción. No se recomienda su uso, en su lugar se
recomienda usar la función millis ( ).
delay(1000); // espera 1 segundo
 La función millis ( ) devuelve el número de milisegundos transcurrido desde el inicio

del programa en Arduino hasta el momento actual. Normalmente será un valor grande
(dependiendo del tiempo que esté en marcha la aplicación después de cargada o
después de la última vez que se pulsó el botón “reset” de la tarjeta).
valor = millis(); // valor recoge el número de milisegundos
Nota: Este número se desbordará (si no se resetea de nuevo a cero), después de

aproximadamente 50 días  unsigned long = 232 ms = 49 dias, 17 h y 2m.

analogRead(pin)
Lee el valor de un determinado pin definido como entrada analógica. La placa Arduino
posee 6 canales conectados a un conversor analógico digital de 10 bits. Esto significa que
convertirá tensiones entre 0 y 5 voltios a un número entero entre 0 y 1023. Esto proporciona
una resolución en la lectura de :
5 voltios / 1024 unidades, es decir, 0.0049 voltios (4.9mV) por unidad.
valor = analogRead(pin); // asigna a valor lo que lee en la entrada ´pin'
Nota: Los pins analógicos (0-5) a diferencia de los pines digitales, no necesitan ser
declarados como INPUT u OUPUT ya que son siempre INPUT´s. El rango de entrada
puede ser cambiado usando la función analogReference( ).
analogWrite(pin,valor)
Escribe un valor analógico (PWM) en un pin. Puede ser usado para controlar la
luminosidad de un LED o la velocidad de un motor. Después de llamar a la función
analogWrite( ), el pin generará una onda cuadrada estable con el ciclo de trabajo especificado
hasta que se vuelva a llamar a la función analogWrite( ) ( o una llamada a las funciones
digitalRead( ) o digitalWrite( ) en el mismo pin ).
La frecuencia de la señal PWM será de aproximadamente 490 Hz. los valores de

analogRead van desde 0 a 1023 y los valores de analogWrite van desde 0 a 255.
Parámetros :
 pin: Es el pin en el cual se quiere generar la señal PWM.
 valor: El ciclo de trabajo deseado comprendido entre 0 (siempre apagado)
y 255 (siempre encendido).
val = analogRead(analogPin);
analogWrite(ledPin, val / 4);
analogReference(EXTERNAL)
Con esta instrucción le estamos diciendo a nuestro Arduino, que no use su tensión de
referencia por defecto ( +5 V ), sino la que nosotros introduzcamos por el pin AREF de nuestra
placa.

Comunicación Serie
Se utiliza para la comunicación entre la placa Arduino y un ordenador u otros

dispositivos. Todas las placas Arduino tienen al menos un puerto serie. Se comunica a través
de los pines digitales 0 (RX) y 1 (TX), así como con el ordenador mediante USB. Por lo tanto, al
utilizar estas funciones, no podremos usar los pines 0 y 1 como entrada o salida digital.
Podemos utilizar el monitor del puerto serie incorporado en el entorno Arduino para
comunicarnos con la placa Arduino. Se debe seleccionar la misma velocidad en baudios
utilizada en la llamada Serial.begin( ).
Serial.begin (velocidad)
Establece la velocidad de datos en bits por segundo (baudios) para la

transmisión de datos en serie. Para comunicarse con el ordenador, utilice una de estas
velocidades: 300, 1200, 2400, 4800, 9600, 14400, 19200, 28800, 38400, 57600 o
115200.
Serial.begin(9600);
Serial.read( )
Lee los datos entrantes del puerto serie.
Byte = Serial.read( );
Serial.print( val, [format] )
Imprime los datos al puerto serie como texto ASCII.

 val : el valor a imprimir, de cualquier tipo
 format : Opcional, especifica la base (formato) a usar, puede ser :
- BYTE
- BIN (binario , base 2)
- OCT (octal, base 8)
- DEC (decimal, base 10)
- HEX (hexadecimal, base 16).
Para números de coma flotante, este parámetro especifica el número
de posiciones decimales a usar.
Serial.print(78); // imprime "78"

Serial.print('N'); //imprime "N"
Serial.print(78, BYTE); //imprime "N"
Serial.print(78, DEC); //imprime "78”
Serial.println(1.23456, 2); //imprime "1.23"
Serial.println( val,[format] )
Imprime los datos al puerto serie como texto ASCII seguido de un retorno de
carro (ASCII 13, o '\r') y un carácter de avance de línea (ASCII 10, o '\n').
Serial.println(analogValue); // imprime como ASCII decimal

Serial.println(analogValue, HEX); // imprime como ASCII hexadecimal

Serial.available( )
Devuelve el número de bytes (caracteres) disponibles para ser leídos por el

puerto serie. Se refiere a datos ya recibidos y disponibles en el buffer de recepción del
puerto (que tiene una capacidad de 128 bytes).
if (Serial.available( ) > 0)
{
//realiza la lectura del puerto serie
}
min ( x, y )
Calcula el mínimo de dos números para cualquier tipo de datos devolviendo el

número más pequeño.
valor = min(valor, 100); // asigna a valor el más pequeños de los dos números especificados.
max ( x, y )
Calcula el máximo de dos números para cualquier tipo de datos devolviendo el

número mayor de los dos.
valor = max(valor, 100); // asigna a valor el mayor de los dos números 'valor' y 100
randomSeed(valor)
Establece un valor, o semilla, como punto de partida para la función random( ).

randomSeed(valor); // hace que valor sea la semilla del random
Debido a que Arduino es incapaz de crear un verdadero número aleatorio,

randomSeed le permite colocar una variable, constante, u otra función de control
dentro de la función random, lo que permite generar números aleatorios "al azar". Hay
una variedad de semillas, o funciones, que pueden ser utilizados en esta función,
incluido millis ( ) o incluso analogRead ( ) que permite leer ruido eléctrico a través de
un pin analógico.
random( max ) / random( min, max )
La función random devuelve un número aleatorio entero de un intervalo de valores

especificado entre los valores min y max. Si no se especifica min, se toma como 0.
valor = random(100, 200); // asigna a la variable 'valor' un numero aleatorio comprendido entre 100-200
Nota : Usar esta función después de usar randomSeed( ).

El siguiente ejemplo genera un valor aleatorio entre 0-255 y lo envía a una salida
analógica PWM :
int randNumber; // variable que almacena el valor aleatorio
int led = 10; // define led como 10
void setup() { } // no es necesario configurar nada
void loop()
{
randomSeed(millis( )); // semilla aleatorio a partir de la función millis()
randNumber = random(255); // genera número aleatorio entre 0-255
analogWrite(led, randNumber); // envía a la salida led de tipo PWM el valor
delay(500); // espera 500 ms = 0,5 s.
}
Switch / Case
Como las sentencias if, switch...case controla el flujo de programas permitiendo a los
programadores especificar diferentes códigos que deberían ser ejecutados en función de
varias condiciones.
En particular, una sentencia switch compara el valor de una variable con el valor
especificado en las sentencias case. Cuando se encuentra una sentencia case cuyo valor
coincide con dicha variable, el código de esa sentencia se ejecuta.
La palabra clave break sale de la sentencia switch, y es usada típicamente al final de

cada sentencia case. Sin una sentencia break, la sentencia switch continuaría ejecutando las
siguientes expresiones ("falling-through") hasta encontrar un break, o hasta llegar al final de la
sentencia switch. También se puede usar en bucles do, for, while y sirve para salir del bucle en
el instante en el que se ejecuta break.
switch (var)
{
case 1: //hacer algo cuando sea igual a 1
break;
case 2: //hacer algo cuando sea igual a 2
break;
default: // si nada coincide, ejecuta el "default"
// el "default" es opcional
}
continue
La sentencia continue omite el resto de iteraciones de un bucle (do, for, o while).
Continúa saltando a la condición de bucle y procediendo con la siguiente iteración.
for (x = 0; x < 255; x ++)

{
if (x > 40 && x < 120)
{
continue; // crea un salto en estos valores
}
digitalWrite(PWMpin, x);
delay(50);
}
return
Termina una función. Puede devolver un valor a la función que la llama.
return;
return valor; // ambas formas son correctas

#define
Permite al programador dar un nombre a un valor constante antes de que se compile

el programa. El compilador remplaza las referencias a estas constantes con el valor definido en
tiempo de compilación.
#define ledPin 3 // El compilador reemplaza ledPin con el valor 3 en tiempo de compilación.
Nos debemos fijar que no debe terminar en punto y coma “ ; “

#include
Es utilizado para incluir librerías externas en el sketch. Esto otorga al programador

acceso a una gran cantidad de librerías C estándar (grupos de funciones ya hechas), y también
librerías escritas especialmente para Arduino.
La principal página de referencia para librerías AVR C (AVR hace referencia a los chips Atmel en
los cuales se basa Arduino) se encuentra en :
http://www.nongnu.org/avr-libc/user-manual/modules.html
Igual que “#define” no debe terminar en punto y coma “ ; “
Operadores a nivel de bits
Los operadores bit a bit realizan sus cálculos a nivel de los bits de las variables. Ayudan
a resolver muchos de los problemas más comunes a nivel de programación. La mayoría del
material que sigue está sacado de un excelente tutorial de matemática lógica, que puede ser
encontrado en ( http://www.arduino.cc/playground/Code/BitMath )
Podemos tener 6 tipos de operadores para trabajar a nivel de bits :
 & ( and )
 | ( or )
 ~ ( not )
 ^( xor )
 << ( desplazamiento a la izquierda )
 >> ( desplazamiento a la derecha )
Un trabajo común de los operadores a nivel de bits es leer, modificar o escribir en un

puerto. En los microcontroladores, un puerto es un número de 8 bits que representa la
condición (estado) de cada pin. Escribir en un puerto controla todos los pines de ese puerto a
la vez.

PORTD es una constante definida para referirse a los estados de salida de los pines
digitales 0, 1, 2, 3, 4, 5, 6 y 7. Si hay un 1 en una determinada posición, ese pin se encuentra a
nivel alto (HIGH). (Los pines necesitan estar declarados como salida usando la instrucción
pinMode). Entonces, si escribimos PORTD = B00010100; , pondremos los pines 2 y 4 a nivel
alto. Un ligero problema es que, al asignarle un valor al puerto directamente, se puede
modificar el valor de otro pin, por ejemplo, el valor del bit 0 y 1 del puerto D, usados por el
Arduino en comunicaciones serie, por lo que podríamos estar interfiriendo en esa
comunicación.
Bits y bytes
lowbyte ( variable ) : Extrae el byte de orden inferior (derecha) de una variable .
valor = lowByte(x);
highbyte ( variable ) : Extrae el byte de orden superior (izquierda) de una variable .
valor = highByte(x);
bitRead( variable, posición) : Lee el bit que se encuentra en la posición n de una

variable. La posición n, comienza en 0 ( bit menos significativo ).
valor = bitRead(x, n);
bitWrite(variable, posición, valor) : Escribe en la posición n de una variable x, el valor

(“0”, “1”).
bitWrite(x, n, b);
bitSet( variable, posición ) : Pone a uno el bit de la posición n de una variable.
bitSet(x, n);
bitClear( variable, posición ): Pone a cero el bit de la posición n de una variable.
bitClear(x, n);
bit( posición) : Calcula el valor del bit especificado (bit 0 es el 1, bit1 es el 2, bit2 es 4,
etc.).
bit(n);

Prácticas ( I ) Entradas y/o salidas digitales
Todas las prácticas y/o proyectos que se realicen, se tendrán que montar de forma
práctica en la placa de Arduino, sobre una placa board y/o diseñando el PCB adecuado.
P1a) Lectura del estado de un Pulsador y visualización en un Led.

Usando Proteus, montaremos el siguiente esquema :
Los componentes utilizados son :
El valor se puede observar en
ARDUINO
el esquema. El pulsador “P”
microcontrolandos.blogspot.com
dispone de una resistencia AREF
RESET
“R1” en configuración pull-
PB5/SCK
PB4/MISO
53/26
52/25
51/24
~PB3/MOSI/OC2A
50/23
P down, tal que cuando

~ PB2/SS/OC1B
~ PB1/OC1A
PB0/ICP1/CLKO
49/22
48/21
ATMEGA328P-PU
1121
DIGITAL (~PWM)
pulsemos “P” introduciremos 47/20

ANALOG IN
PD7/AIN1
46/19
7/34 ~ PD6/AIN0
PC0/ADC0 45/18
8/35 ~ PD5/T1
PC1/ADC1 44/17
9/36
10/37
11/38
PC2/ADC2
PC3/ADC3
D1
5V (+Vcc) por la patilla digital 5 de Arduino.
PD4/T0/XCK
~ PD3/INT1
PD2/INT0
43/16
42/15
PC4/ADC4/SDA 41/14
12/39 TX PD1/TXD
PC5/ADC5/SCL
R2
R1
El led “D1”, dispone de una resistencia RX PD0/RXD
40/13 LED-GREEN
10k
220
ARDUINO UNO R3
limitadora “R2” conectado a la patilla digital
2 de Arduino.
Una vez diseñado el circuito, lo grabaremos en la carpeta “C:\MisSketch\P1”, con el
nombre “P1.dsn”. A continuación procederemos a escribir el programa en el entorno de
Arduino y lo grabaremos con el nombre P1 en la misma carpeta.
Como recomendación siempre que tengamos código que se
encuentre entre llaves ( { , } ), insertaremos un tabulador, de
esa forma podremos tener el código más legible.
En todos nuestros proyectos, intentaremos tener siempre la
misma estructura en el programa, es decir, todas las variables
las escribiremos al principio del programa, si son globales (
“pinPulsador” y “pinLed”) y al principio de la función
correspondiente, si son locales ( “pulsador” ).
Siempre que podamos, usaremos variables para los pines que
vamos a usar, con el nombre “pin” seguido del nombre que
queramos.
Cuando dispongamos de entradas, en la función loop después
de la definición de las variables, asignaremos todas las
funciones que lean entradas (digitalRead en nuestro caso), a sus variables correspondientes
(“pulsador” en nuestro caso). Todas las funciones de salida (digitalWrite en nuestro caso),
intentaremos escribirlas al final de la función loop y entre medias de las funciones de lectura y
de escritura, incluiremos el resto de nuestro programa (decisiones, bucles, asignaciones, etc….)
Pero siempre, intentaremos que nuestro programa, bien si está escrito entero en la función
loop o bien si está escrito en varias funciones, nunca debe hacer que el microcontrolador deje
de leer las entradas o que tarde un tiempo excesivo en volver a leer las entradas, es decir, que
nuestro programa debe entrar en la función loop, llegar hasta el final donde normalmente se
encontrarán nuestras asignaciones de las salidas y volver a ejecutar la función loop.

Por tal motivo, debemos tener especial cuidado con las variables locales que se definan, ya
que siempre que comience la ejecución dela función loop, las variables locales, volverán a
inicializarse. Si usamos funciones como delay(), haremos que el microcontrolador espere un
determinado tiempo y no ejecute ninguna instrucción durante ese tiempo, por tanto, las
entradas serán leídas con un retardo y en la práctica se traduce que nuestro circuito no
responderá inmediatamente ante un evento externo, por lo tanto intentaremos no usar
funciones ni bucles de este tipo.
A continuación compilaremos nuestro sketch, ejecutando nuestro proyecto para ver el
funcionamiento.
Como podemos observar, al pulsar “P”, el Led se enciende y al soltar “P”, el led se apaga.
Se deja como ejercicio, modificar la posición del pulsador y la resistencia de

R3
10k
entrada, es decir, usando la configuración pull-up y comprobar que al pulsar “P”
introduciremos un “0” y al soltar introduciremos un “1” por la patilla de entrada
digital, encendiendo y apagándose el led al contrario del ejercicio anterior.
Modificar el sketch para que el funcionamiento sea igual al ejercicio desarrollado,
es decir, al Pulsar “P”, el led se enciende y al soltar “P”, el led se apaga.
P1b) Pulsadores de Marcha y Paro : Siguiendo el mismo procedimiento que la práctica 1, se

debe añadir un pulsador de forma que uno de ellos encenderá el led y el otro lo apagará, los
llamaremos “P.MARCHA” y “P.PARO”.
A veces, puede ser interesante
utilizar conexiones con
ARDUINO
terminales, de esta forma
P. MARCHA P. PARO
reducimos el cableado en el AREF
53/26
RESET
esquema. En este caso elPB5/SCK
PB4/MISO
~PB3/MOSI/OC2A
52/25
51/24
marcha paro
50/23
~ PB2/SS/OC1B
terminal “marcha” del~ PB1/OC1A
PB0/ICP1/CLKO
49/22
48/21
ATMEGA328P-PU
1121
DIGITAL (~PWM)
R1 R3 47/20
ANALOG IN
7/34
8/35
PC0/ADC0
pulsador es un terminal de ~
PD7/AIN1
~ PD6/AIN0
PD5/T1
46/19
45/18
marcha
paro 10k 10k
PC1/ADC1 44/17
9/36 D1 PD4/T0/XCK
10/37
11/38
PC2/ADC2
PC3/ADC3
PC4/ADC4/SDA
salida que se encuentra ~ PD3/INT1
PD2/INT0
43/16
42/15
41/14
12/39 TX PD1/TXD
PC5/ADC5/SCL 40/13
R2 conectado con el terminal RX PD0/RXD LED-GREEN
220
ARDUINO UNO R3
“marcha” (entrada) del pin 7

digital de Arduino. Lo mismo
ocurre con “paro”.

El código que debemos introducir, es el siguiente :
Como se puede observar, seguimos con los

mismos criterios anteriores; tabuladores,
variables al comienzo, funciones de entrada al
principio, funciones de salida al final y las
decisiones entre estas funciones.
Cabe destacar que para facilitar la lectura, se ha
agrupado las variables de los pines de entrada
en una sola línea y las de salida en otra, lo
mismo destacamos cuando se configura los
pines en la función setup.
Las expresiones “if” usadas, solo disponen de
una acción a realizar en caso de que se cumpla
la condición, en tal caso para reducir las líneas
de programa, es conveniente escribir todo en
una única línea, es decir podríamos escribir :
If (pulsadorMarcha==1) { salida=1; }
If (pulsadorParo==1) { salida=0; }
Compilar el sketch, montar el circuito en una placa board y comprobar el funcionamiento real.
En las siguientes prácticas se intentará usar los mismos criterios explicados y se utilizará
preferentemente la configuración de resistencia pull-down, de forma que en el estado de
reposo, es decir sin pulsar, introduciremos un “0” al Arduino y al pulsar el pulsador, se
introducirá un “1” al arduino, pero es posible que en algún proyecto debamos usar la
configuración de resistencia pull-up.
Librerias para Arduino
Antes de nada, ¿qué es una librería para arduino?

Sin meternos en absoluto en detalles técnicos, una librería es un fichero de código al que se va
a llamar desde un programa hecho para arduino, con la finalidad de que realice una tarea
concreta.
Existen multitud de librerías que permiten dotar a arduino de nuevas funcionalidades, como
por ejemplo crear un GPS, enviar mensajes SMS, manejar pantallas LCD o TFT, etc.
Podemos crear nuestras propias librerías para no reescribir código o bien usar otras creadas
por terceras personas. En cualquier caso, una vez se dispone de ellas, hay que instalarlas.

Instalación de nuevas librerías:
1. Comprobar si en la carpeta "sketchbook" de nuestra carpeta personal existe otra

llamada "libraries". Si no es así hay que crearla.
2. Descargar al escritorio la librería deseada, por ejemplo una llamada "Time"
(http://www.arduino.cc/playground/uploads/Code/Time.zip) y descomprimirla.
3. En este paso hay dos posibilidades:
o Si la carpeta descomprimida tiene en su interior otra con el mismo nombre,
ésta última hay que copiarla en la carpeta "libraries" del primer paso.
o En caso contrario hay que copiar la carpeta descomprimida directamente en la

carpeta "libraries".

El resultado final debe ser este:
Observación:
Otra opción es instalarlas como administrador en la carpeta donde están las librerías que trae
por defecto el software Arduino (los pasos son los mismos): /usr/share/arduino/libraries
Usar nuevas librerías:
 El procedimiento para usar la librería añadida es el mismo que para usar cualquier otra
de las que vienen con Arduino por defecto:

Librerías estándar
 EEPROM - reading and writing to "permanent" storage

 Ethernet - for connecting to the internet using the Arduino Ethernet Shield
 Firmata - for communicating with applications on the computer using a standard serial
protocol.
 GSM - for connecting to a GSM/GRPS network with the GSM shield.
 LiquidCrystal - for controlling liquid crystal displays (LCDs)
 SD - for reading and writing SD cards
 Servo - for controlling servo motors
 SPI - for communicating with devices using the Serial Peripheral Interface (SPI) Bus
 SoftwareSerial - for serial communication on any digital pins. Version 1.0 and later of
Arduino incorporate Mikal Hart's NewSoftSerial library as SoftwareSerial.
 Stepper - for controlling stepper motors
 TFT - for drawing text , images, and shapes on the Arduino TFT screen
 WiFi - for connecting to the internet using the Arduino WiFi shield
 Wire - Two Wire Interface (TWI/I2C) for sending and receiving data over a net of
devices or sensors.
Due Only Libraries
 Audio - Play audio files from a SD card.

 Scheduler - Manage multiple non-blocking tasks.
 USBHost - Communicate with USB peripherals like mice and keyboards.
Esplora Only Library
 Esplora - this library enable you to easily access to various sensors and actuators
mounted on the Esplora board.
Arduino Robot Library
 Robot - this library enables easy access to the functions of the Arduino Robot
Arduino Yún Bridge Library
 Bridge Library - Enables communication between the Linux processor and the Arduino
on the Yún.
USB Libraries (Leonardo, Micro, Due, and Esplora)
 Keyboard - Send keystrokes to an attached computer.

 Mouse - Control cursor movement on a connected computer.

Contributed Libraries
Communication (networking and protocols):
 Messenger - for processing text-based messages from the computer

 NewSoftSerial - an improved version of the SoftwareSerial library
 OneWire - control devices (from Dallas Semiconductor) that use the One Wire
protocol.
 PS2Keyboard - read characters from a PS2 keyboard.
 Simple Message System - send messages between Arduino and the computer
 SSerial2Mobile - send text messages or emails using a cell phone (via AT commands
over software serial)
 Webduino - extensible web server library (for use with the Arduino Ethernet Shield)
 X10 - Sending X10 signals over AC power lines
 XBee - for communicating with XBees in API mode
 SerialControl - Remote control other Arduinos over a serial connection
Sensing:
 Capacitive Sensing - turn two or more pins into capacitive sensors

 Debounce - for reading noisy digital inputs (e.g. from buttons)
Displays and LEDs:
 GFX - base class with standard graphics routines (by Adafruit Industries)
 GLCD - graphics routines for LCD based on the KS0108 or equivalent chipset.
 Improved LCD library fixes LCD initialization bugs in official Arduino LCD library
 LedControl - for controlling LED matrices or seven-segment displays with a MAX7221
or MAX7219.
 LedControl - an alternative to the Matrix library for driving multiple LEDs with Maxim
chips.
 LedDisplay - control of a HCMS-29xx scrolling LED display.
 Matrix - Basic LED Matrix display manipulation library
 PCD8544 - for the LCD controller on Nokia 55100-like displays (by Adafruit Industries)
 Sprite - Basic image sprite manipulation library for use in animations with an LED
matrix
 ST7735 - for the LCD controller on a 1.8", 128x160 TFT screen (by Adafruit Industries)
Audio and Waveforms:
 FFT - frequency analysis of audio or other analog signals

 Tone - generate audio frequency square waves in the background on any
microcontroller pin
Motors and PWM:
 TLC5940 - 16 channel 12 bit PWM controller.

Timing:
 DateTime - a library for keeping track of the current date and time in software.
 Metro - help you time actions at regular intervals
 MsTimer2 - uses the timer 2 interrupt to trigger an action every N milliseconds.
Utilities:
 PString - a lightweight class for printing to buffers

 Streaming - a method to simplify print statements
Como podrá comprobar librerías existen muchas, y siguen apareciendo muchas más
a medida que van saliendo más componentes y/o shields para arduino, por lo que en este
curso nos dedicaremos a utilizar las librerías más importante y se explicarán a medida
que nos hagan falta.
En un curso más avanzado de arduino veremos cómo crear nuestras propias

librerías, ahora nos limitaremos únicamente a utilizarlas.
Manejo de Motores
Vamos a dar un repaso breve a los distintos tipos de motores que vamos a utilizar y sus
circuitos de control más habituales. Podemos encontrarnos con motores de corriente continua
y motores de corriente alterna.
a) Motores de corriente continua

a1) Motores CC :
Son de los más comunes y económicos, se pueden encontrar en la
mayoría de los juguetes a pilas, constituidos, por lo general, por dos
imanes permanentes fijados en la carcasa y una serie de bobinados de
cobre ubicados en el eje del motor, que habitualmente suelen ser tres.
Disponen de dos bornes que se conectan a la fuente de alimentación y según la
forma de conexión el motor girará en un sentido u otro.
Para controlar en sentido de giro, usaremos el siguiente circuito :
Como se puede comprobar, Q1 y Q4 se encontrarán en saturación

cuando introduzcamos en C.1 =”0” y en C.2=”1”, mientras que Q2 y Q3 están en
corte, por lo que el motor gira en un sentido (flecha roja). Si modificamos las

entradas, introduciendo en C.1=”1” y en C.2=”0”, haremos que Q2 y Q3 entren

en saturación y Q1 y Q4 en corte, por lo que el motor estará polarizado de
forma inversa y girará en sentido contrario al anterior (flecha azul).
Estos circuitos son conocidos como puente en H o H-Bridge, que
podemos encontrar en circuitos integrados, lo cual facilita el diseño de
nuestros circuitos, tales como el UCN5804, el BA6286, el L293B, L297, L298 o
también con el ULN2803 o el ULN2003, estos dos últimos son arrays de
transistores, pero podemos también utilizarlos en nuestros circuitos.
Como ejemplo, el integrado

L293B, dispone de 4 drivers.
El patillaje y la tabla de
verdad son las que se
muestran.
Para controlar el sentido de giro de un motor de c.c., tendremos que

usar 2 drivers del integrado, es decir, el esquema será :
Por lo tanto, con un L293B, podremos controlar el sentido de giro a 2

motores de c.c.
a2) Motores paso a paso (PaP)

Un motor paso a paso, como todo motor, es en esencia un conversor
electromecánico, que transforma energía eléctrica en mecánica. Mientras que
un motor convencional gira libremente al aplicarle una tensión, el motor paso
a paso gira un determinado ángulo de forma incremental (transforma impulsos
eléctricos en movimientos de giro controlados - pasos), lo que le permite
realizar desplazamientos angulares fijos muy precisos.
El ángulo de giro de estos motores es muy variado pasando desde los

90º hasta los 1.8º e incluso 0.72º, cada ángulo de giro, se efectúa enviando un
pulso en uno de sus terminales, es decir que por ejemplo en motores que
tienen 90º de giro por paso, se requiere 4 pulsos para dar una vuelta completa,
mientras que en los de 1,8º son necesarios 200 pulsos.

Sus principales aplicaciones se pueden encontrar en robótica,

tecnología aeroespacial, control de discos duros, flexibles, unidades de CDROM
o de DVD e impresoras, en sistemas informáticos, manipulación y
posicionamiento de herramientas y piezas en general.
Según la construcción de las bobinas del estator, podemos distinguir dos tipos:
 Bipolares :
La corriente que circula
por los bobinados cambia de
sentido en función de la
tensión que se aplica, por lo
que un mismo bobinado
puede tener en uno de sus extremos, distinta
polaridad (bipolar).
Para identificar los terminales 1a, 1b, 2a y 2b, se utilizará un

óhmetro, midiendo la resistencia entre cada par de terminales, los
extremos 1a y 1b deben tener la misma resistencia que los extremos
2a y 2b, si se mide la resistencia en forma cruzada no marcará nada ya
que corresponden a bobinas distintas.
Para controlar estos motores debemos invertir las polaridades

de los terminales de las bobinas 1 y 2 en una determinada secuencia
para lograr un giro a derechas, y en secuencia opuesta para que gire a
izquierdas, la secuencia sería la que se muestra en esta tabla :
T
i
e
n

Como ejemplo, se muestra el siguiente esquema para el control del

motor :
Donde L1 y L2 son las bobinas de nuestro motor.
 Unipolares :
Se llaman así porque
la corriente que circula por los
diferentes bobinados siempre
circula en el mismo sentido.
Tienen las bobinas con un arrollamiento

único. Comparado a los bipolares tienen sus
ventajas, a pesar de tener más de 4 cables son
más fáciles de controlar, esto se debe a que tienen un terminal común
en ambas bobinas. Algunos motores tienen los bobinados de tal
manera que en función de puentes pueden convertirse en unipolares
o bipolares. Estos motores poseen 5 o 6 cables.
- Si disponemos de 6 cables, cuatro corresponden a cada uno de los

extremos de las dos bobinas existentes (1a, 1b, 2a y 2b), mientras
que los otros dos corresponden al punto medio de cada una (Com1
y Com2).
- Si disponemos de 5 cables, cuatro corresponden a cada uno de los

extremos de las dos bobinas existentes (1a, 1b, 2a y 2b), mientras
que el cable restante corresponde al punto medio de cada bobina
unidos internamente (Com1 y Com2 unidos internamente).

Para identificar los terminales, una vez localizados dichos cables

mediremos la resistencia con un óhmetro. De esta
forma localizamos las dos bobinas (los tres cables
cuya resistencia entre sí sea distinta de infinito
corresponden a una bobina). Podemos decir que
tenemos dos grupos de tres cables (A, B, C) y
(D, E, F). Mediremos ahora la resistencia entre A y B, B y C y entre A y
C. El par anterior cuya lectura sea más alta corresponde a los extremos
de la bobina (1a y 1b), mientras que el restante es el punto medio de la
misma (Com1). Para la otra bobina, usaremos el mismo procedimiento
pero usando el grupo de cables (D, E y F).
Para saber la secuencia del motor necesitaremos una fuente de

tensión continua del valor característico del motor (5 V). Conectaremos
por ejemplo el polo positivo de la fuente a los dos
cables (Com1 y Com2) unidos entre sí (Com). El polo
negativo de la fuente, lo conectaremos a uno de los
cuatro cables restantes (A, B, C o D) y observamos
hacia qué lado se produce el paso. Procedemos igual
con los otros, probando en distinto orden, hasta que
los cuatro pasos se hayan producido en la misma dirección. De esta
forma ya habremos hallado la secuencia del motor.
Para el control, usaremos el integrado ULN2003 o el ULN2803
Se trata de un array de transistores Dárlington capaz de

manejar hasta 500mA en sus salidas, sólo se debe tener en cuenta que
las salidas están invertidas respecto de las entradas. El montaje será :

Debemos fijarnos que los bobinados del motor requieren un

pulso negativo para ser activados, como el ULN tiene sus salidas
invertidas, cuando reciba un "1" por el pin INn enviará un "0" a la salida
OUTn.
Estas secuencias siguen el orden indicado en cada tabla para
hacer que el motor gire en un sentido, si se desea que gire en sentido
opuesto, sólo se debe invertir dicha secuencia.
Se pueden controlar de 3 formas :
- La primera, es realizar una secuencia que activa una bobina por

pulso.
Al polarizar una
sola bobina se
pierde un poco el
torque del
motor.
- La segunda, es activar las bobinas de a dos, en este caso el campo

magnético se
duplica, y en
consecuencia el
motor tiene
mayor fuerza de
giro y retención.
- La tercera, es una combinación de las dos anteriores, y conocida

como secuencia de medio paso. Las dos formas de control vistas
anteriormente se respetan la cantidad de pasos preestablecidas
para cada motor,
por ejemplo, si
tiene un ángulo de
giro de 90º, con 4
pasos dará una
vuelta completa,
con este
procedimiento, se
puede hacer con 8
pasos.

También podemos usar el integrado L298N, y en concreto este módulo

que se puede adquirir o montar fácilmente :
Como podemos ver, disponemos

de unos switchs para activar la salida A
y/o la salida B (A enable / B enable), un
switch para activar +5V internos
mediante el regulador 78M05 integrado,
de esa forma no sería necesario la
entrada de +5V power. El módulo se
alimenta mediante la entrada +12V
power. Las entradas Input, serán conectadas a las salidas digitales de nuestro
Arduino y los motores irán conectados en las salidas “output A” y/o “output
B”.

a3) Servomotores
Un servomotor (también llamado Servo) es un
dispositivo similar a un motor de corriente continua,
que tiene la capacidad de ubicarse en cualquier
posición dentro de su rango de operación, y
mantenerse estable en dicha posición.
Está conformado por un motor, una caja
reductora (Engranajes), un potenciómetro y un
circuito de control. Los servos se utilizan
frecuentemente en sistemas de radio control y en
robótica, pero su uso no está limitado a estos. Es
posible modificar un servomotor para obtener un
motor de corriente continua que, si bien ya no
tiene la capacidad de control del servo, conserva la fuerza, velocidad y baja
inercia que caracteriza a estos dispositivos.
Los servomotores tienen 3 terminales :

 Terminal positivo: Recibe la alimentación del motor.
 Terminal negativo: Referencia tierra del motor.
 Entrada de señal: Recibe la señal de control del motor.
Según el fabricante, el color del terminal varía, aquí expongo los fabricantes
más conocidos.
Para controlar un Servo, debemos alimentarlo con la tensión que nos

indique el fabricante y su polaridad adecuada y por la línea de datos enviar una
señal cuadrada de una determinada frecuencia (generalmente entre 50Hz o
100Hz) en la que el ciclo de trabajo (Duty Cicle), determinará la posición en la
que queremos que se posicione nuestro servomotor.
La electrónica interna del servomotor (analógica o digital), genera una
señal de error entre la posición demandada y la posición actual del
servomotor. El servomotor se moverá hasta que las dos posiciones sean la
misma, manteniéndose en esa posición si continua recibiendo la misma señal
por la línea de datos.

El estándar de la señal controladora para todos los servos de este tipo,

elegido para facilitar el uso en radiocontrol, es un pulso de onda cuadrada de
1,5 milisegundos que se repite a un ritmo de entre 10 a 22 ms, aunque es
aconsejable siempre consultar el fabricante.
Mientras el pulso se mantenga en

ese ancho, el servo se ubicará en la
posición central de su recorrido. Si el
ancho de pulso disminuye, el servo se
mueve de manera proporcional hacia un
lado. Si el ancho de pulso aumenta, el
servo gira hacia el otro lado. Generalmente
el rango de giro de un servo de éstos cubre
entre 0° y 180° de la circunferencia total, o
un poco más, según la marca y modelo.
En los servos digitales, la señal está separada por unos 3,3 ms. La
separación entre pulsos varía en cada marca de servo digital, pero el ritmo de
llegada de los pulsos es de al menos 300 veces por segundo versus 50 a 100 en
un analógico.
Para que un servo pueda girar 360 º, igual que un motor c.c. pero
manteniendo el torque, debemos desmontar el sistema actual, por lo que
tenemos que quitar los cuatro tornillos que sujetan la tapa inferior del
conjunto servo y sacaremos con cuidado la tapa superior del servo que,
contiene el reductor de velocidad, en ningún momento se debe forzar ninguna
pieza, todas se desmontan sin esfuerzo.
Para que gire 360º, debemos cortar o limar el tope plástico del
engranaje, de manera que no quede ninguna rebaba ni deformar los dientes
del engranaje, en la imagen de abajo, un detalle comparativo de cómo deberá
quedar el engranaje.

A continuación, extraer con

cuidado, el bloque compuesto por el
circuito impreso al que está soldado el
motor y el resto del control de velocidad.
A partir de este punto, podemos elegir
entre, eliminar toda la parte de control
electrónico o mantener dicho sistema.
Si eliminamos toda la parte de control

electrónico, dejando únicamente el motor,
después debemos usar un Puente en H como el
estudiado anteriormente (L293 o similar).
Si mantenemos la parte de control electrónico, debemos hacer que el

circuito electrónico detecte siempre un valor fijo en los pines donde se
encuentra el potenciómetro soldado, este valor, debe ser el que se obtenga al
posicionar el potenciómetro en su punto medio. Como este potenciómetro se
encuentra unido con el motor, de forma que, cuando el motor gira, el eje del
potenciómetro también, debemos evitarlo, por lo que entonces podemos
optar por varias soluciones :
- Cortar el eje del potenciómetro para que no gire al moverse el

motor, ajustarlo en su punto medio con ayuda de un óhmetro,
pegar el eje con loctite para que no se mueva de su punto medio y
volver a meterlo en la carcasa del servo.
- Eliminar el potenciómetro y
sustituirlo por otro (por ejemplo
multivuelta) y preparar la carcasa
para realizar un agujero en el lugar
adecuado, para que mediante un
destornillador, podamos variar la resistencia del potenciómetro
introducido para ajustarlo en su punto medio.
- Eliminar el potenciómetro y sustituirlo por 2
resistencias fijas cuyo valor sea igual a la mitad
del valor total del potenciómetro original.
Soldarlas en su lugar adecuado para hacer creer
al circuito electrónico que el potenciómetro se
encuentra en su punto medio. Las resistencias
deben ser del 1 % de tolerancia.

b) Motores de corriente alterna y motores de tensiones elevadas.

Los motores de corriente alterna usados en domótica, suelen ser monofásicos,
aunque también podemos encontrarnos algunas veces con motores trifásicos. El
motor típico de un toldo o persiana en domótica suele ser monofásico y el control se
realiza de una forma muy sencilla :
Como podemos observar el motor dispone

de 3 terminales ; Neutro, subir y bajar.
Cuando aplicamos la fase al terminal de
subir, el motor gira en un sentido, cuando
aplicamos la fase al terminal de bajar, el
motor gira en sentido contrario. Además
estos motores disponen de finales de carrera
internos regulables, por lo que podemos
modificar las vueltas que debe dar el motor
para que la persiana suba o baje
completamente.
Para controlar este tipo de motores, debemos tener en cuenta que la tensión
de trabajo normalmente es de 230 V, y Arduino trabaja con 5V, por lo que, además de
los circuitos de cambio de giro estudiados anteriormente, será necesario usar unos
circuitos que nos permita trabajar con tensiones elevadas, estos circuitos pueden ser
alguno de estos :

En caso de tener un motor trifásico, el circuito de control sentido de giro es :
Usando contactores Sin usar contactores
Aquí se puede observar un control de un motor de corriente continua de

potencia elevada.
Utilizando relés Sin utilizar relés

Criterio importante :
A continuación haremos unos ejercicios prácticos usando distintos tipos de motores
explicados anteriormente. Se debe tener presente que debido al escaso material que se
dispone, y para no demorar mucho las prácticas, podemos simular el sentido de giro de los
motores usando diodos leds, de tal forma que, tendremos un led que indicará que el motor se
encuentra girando en un sentido y otro led, para indicar que el motor se encuentra girando en
sentido contrario, y cuando los dos leds se encuentren desactivados, el motor se encontrará
parado. También tendremos presente que cuando se mencione que un dispositivo se
encuentra activado, significará que se encontrará encendido, girando en un sentido, pulsado,
etc….. es decir el estado lógico será “1” y cuando se mencione que se encuentra desactivado,
significará que se encuentra apagado, parado, sin pulsar, etc…. es decir el estado lógico será
“0”. Los pulsadores y finales de carrera serán todos normalmente abiertos (N.O.)
Por lo tanto a partir de ahora y durante todo este manual, se aplicará este criterio y en
caso contrario se indicará debidamente.

Cómo usar la memoria EEPROM de Arduino
Vamos a ver cómo usar la memoria EEPROM de Arduino para reutilizar los
datos importantes, recuperar la configuración de Arduino o incluso pasar datos de un
sketch a otro.
Generalmente la memoria EEPROM de Arduino suele

estar bastante desaprovechada. No sé si será por
desconocimiento o miedo a la hora de utilizarla
pero es una lástima ya que, con unas cuantas
líneas de código y por menos de 1kB de aumento
en el tamaño del sketch, se puede tener un recurso
realmente interesante.
Utilizar la EEPROM es especialmente útil a la hora de

guardar la configuración de Arduino (como por ejemplo las direcciones MAC e IP )
pero su uso va mucho más allá. Si se quiere calibrar un sensor (por ejemplo una LDR)
para fijar sus valores límite, no se tiene que utilizar un código que siempre calibre el
sistema al iniciarse (en el setup), se puede implementar un código que calibre y guarde
los datos en la memoria EEPROM y, una vez guardado, utilizarlos en otro sketch.
Gracias a ello ahorraremos espacio en el microcontrolador y nos aseguraremos

de que esos datos no dependan del día o la zona en la que utilicemos el sistema
(volviendo al ejemplo de la LDR, podemos conseguir, por ejemplo, que si reiniciamos
Arduino por la noche, conserve los datos almacenados durante el día).
Capacidad de la memoria EEPROM de Arduino
Cada modelo de placa posee una EEPROM distinta. con las diferentes
capacidades de las memorias EEPROM:
Para más información sobre las

características de las distintas placas de
Arduino visita este link.

Programando la EEPROM
Podemos programar la memoria EEPROM de Arduino utilizando la librería

EEPROM.h.
En la memoria de Arduino debemos trabajar por direcciones y byte a byte

tanto para leer como para escribir. Esto significa que para una memoria de 1KB
tendremos desde la dirección 0 hasta la 1023 y podremos utilizar valores de 0 a 255. En
caso de valores mayores habrá que dividirlos por bytes.
Ejemplo utilizando un Byte
1 /*Uso De La Memoria EEPROM Con Bytes*/

2
3 //Se incluye la librería EEPROM
4 #include <EEPROM.h>
5
6 //Se crea una variable con el valor de la posición de memoria
7 //en la que se va a almacenar el byte.
8 int Direccion = 0;
9
10 //Se crean una variables para leer los valores de la memoria EEPROM
11 byte Val1;
12 byte Val2;
13
14 void setup()
15 {
16 Serial.begin(9600);
17 //Se almacena la información a guardar en un byte.
18 byte Informacion = B11001;// La "B" indica que el formato es binario
19
20 //También es posible almacenar la información leída a través de un
21 //sensor. Hay que tener en cuenta que el valor máximo de una variable
22 //tipo int es de 1023, mientras que el mayor valor que se puede almacenar
23 //en un solo byte es 255. Por tanto, se divide el valor resultante entre 4
24 //y a la hora de utilizar el valor se vuelve a multiplicar por 4. En el
25 //proceso se pierde precisión.
26 // need to divide by 4 because analog inputs range from
27 int Valor = analogRead(0) / 4;
28
29 //Se almacenan consecutivamente los valores anteriores.
30 EEPROM.write(Direccion, Informacion);
31 EEPROM.write(Direccion+1, Valor);
32 }
33
34 void loop()
35 {
36 Val1 = EEPROM.read(Direccion);
37 Val2 = EEPROM.read(Direccion+1);
38

39 Serial.print("En la dirección ");

40 Serial.print(Direccion);
41 Serial.print(" se encuentra la información: ");
42 Serial.print(Val1, DEC);// DEC para datos en decimal.
43 delay(100);
44 Serial.print("En la dirección ");
45 Serial.print(Direccion+1);
46 Serial.print(" se encuentra la información: ");
47 Serial.print(Val2, DEC);// DEC para datos en decimal.
48 delay(100);
49 }
Ejemplo utilizando dos Bytes
1 //Se tiene una variable compuesta por 2 bytes, por ejemplo un tipo int.
2 int A =800;
3
4 //Se crean dos variables de tipo byte para almacenar la información.
5 byte L;
6 byte H;
7
8 //Se almacenan los bytes más y menos significativos.
9 H = highByte(A);
10 L = lowByte(A);
11
12 //Se escriben los bytes en direcciones de memoria contiguas.
13 EEPROM.write(Direccion, H);
14 EEPROM.write(Direccion+1, L);
Ejemplo utilizando más Bytes
Aunque existen varios algoritmos, veamos uno :
 Almacenar el dato entero en una variable auxiliar (para no perder el dato

original).
 Comprobar el número de bytes que tiene el dato.
 Guardar el byte más significativo en una variable de tipo byte.
 Almacenar el byte en la EEPROM.
 Desplazar ocho bits (un byte) de la variable auxiliar hacia la izquierda, de forma
que el segundo byte de esa variable pase a ser el más significativo.
 Repitir la operación tantas veces como grande sea el tamaño de la variable
inicial.

1 //Se utiliza un elemento de tipo long (contiene 4 bytes).

2 long Dato = 123456789;
3 int i;
4 //Se almacena el dato en una variable auxiliar.
5 long AuxDato = Dato;
6
7 //Se define un byte para almacenar la información en la EEPROM.
8 byte B;
9
10 //La instrucción sizeof() devuelve el número de bytes de una variable
11 for (i = 0; i < sizeof(Dato); i++)
12 {
13 B = highByte(AuxDato); //Se guarda el byte más significativo
14 EEPROM.write(i, B);
15 //Se desplazan 8 bits hacia la izquierda de modo que los 8 primeros
16 //bits se pierden y los 8 siguientes pasan a ser los primeros
17 AuxDato = AuxDato << 8;
18 }
Componiendo Bytes
Después de separar una variable en bytes para almacenarla en la memoria

EEPROM de Arduino surge el problema de volverla a componer para recuperar la
información. Si, por ejemplo, tenemos una variable de tipo long separada en cuatro
bytes dentro de la EEPROM, al leer esos datos lo que tenemos son cuatro bytes, no un
long.
De nuevo existen varias formas de solucionar este problema, veamos una :
 Crear una variable del tipo que queramos recuperar y asignarla el valor 0 (de
forma que todos sus bits seran 0).
 Definir otra variable igual a la anterior (la variable auxiliar).
 Leer un byte de la memoria EEPROM y almacenarla en la variable auxiliar
utilizando la instrucción OR, con lo que el byte queda almacenado en los ocho
bits menos significativos de la variable auxiliar.
 Desplazar los bits de la variable auxiliar hacia la izquierda de modo que queden
en la posición que nos interese.
 Realizar una nueva operación OR entre la variable auxiliar y la final.
 Limpiar la variable auxiliar y repetir el proceso tantas veces como sea necesario.

1 //Variable que almacenará el resultado final.

2 long Dato = 0;
3 //Variable auxiliar (utilizada al mismo tiempo como byte).
4 long B;
5 int i;
6 for (i = sizeof(Dato); i > 0 ; i--)
7 {
8 //Se almacena el valor de la EEPROM en los bits menos significativos.
9 B = EEPROM.read(i-1);
10
11 //Se desplazan los bits tantos bytes como sea necesario, teniendo en
12 //cuenta que el byte final no debe ser desplazado.
13 if (i != 1)
14 { B = B << (8*i); }
15
16
17 //Se almacena en la variable final el resultado de la operación OR de
18 //ambos datos. Al realizar la operación OR con una variable que solo
19 //contiene ceros (variable Dato), el resultado es el valor de la otra
20 //variable. OR implica => 0+0=0, 0+1=1, 1+0=1, 1+1=1.
21 Dato = Dato | B;
22 //Se limpia la variable auxiliar para que en las siguientes iteraciones
23 //no se cambie el resultado de los otros bytes.
24 B = 0;
25 }

Prácticas ( II ) Gancho móvil
P2a) Realizar el control de un gancho móvil, cuyo esquema es el siguiente :

En el estado de reposo, los finales de carrera Fa
y Fb se encuentran desactivados, el motor se
encuentra parado, y los pulsadores de marcha
( Ma ) y paro ( P ) desactivados.
El sistema en el estado inicial, se encuentra
activando Fa. El pulsador de paro “P” se
encuentra desconectado (no se usa en este
ejercicio).
El funcionamiento debe ser el siguiente :
Con el sistema en el estado inicial, un operario, pulsa M a por lo que el

gancho se desplaza hacia la derecha (Md=”1”, Mi=”0”), hasta que se active Fb,
en ese caso, el gancho debe cambiar su sentido hacia la izquierda (M i=”1”,
Md=”0”). Cuando el gancho llegue y active Fa, el gancho se parará,
permaneciendo parado hasta una nueva pulsación de Ma.
El operario, sólo activa el sistema cuando el gancho se encuentra

activando Fa, es decir, si el gancho se encuentra en movimiento, ya sea hacia la
derecha o la izquierda si el operario pulsa Ma no debe realizar ningún efecto. El
pulsador de paro “P” en este ejercicio, no tiene ningún efecto. El motor usado,
es un motor de corriente continua de 5V.
P2b) Modificar el ejercicio P2a para que cuando el gancho active “Fb” se pare, pero no
Se ponga en marcha hasta que el operario vuelva a pulsar Ma.
P2c) Modificar el ejercicio P2b, añadiendo el pulsador de paro “P”, de tal forma que,
cuando se pulse “P”, el gancho deberá detenerse en cualquier lugar, esperando
que el operario pulse de nuevo “Ma”, en cuyo caso el gancho se desplazará en el
sentido en el que se había detenido.
P2d) Analizar la librería EEPROM y realizar un programa utilizando la memoria EEPROM

de nuestro Arduino para que en caso de una pérdida de energía eléctrica, el
automatismo se pare y cuando vuelva la energía , el automatismo continue con su
funcionamiento normal, en el punto donde se paró.

El código a introducir es el siguiente :


Sensores ( I )
Luminosidad - Resistencia LDR
Una LDR (Light Dependent Resistor o resistencia dependiente de la

luz ) es una resistencia que varía su valor en función de la luz recibida, cuanta
más luz recibe, menor es su resistencia.
El rango de resistencia que nos puede dar un LDR desde la total oscuridad
hasta la plena luz, nos va a variar de un modelo a otro, pero en general oscilan entre unos 50 Ω
a 1000 Ω cuando están completamente iluminadas y entre 50 KΩ y varios MΩ cuando está
completamente a oscuras.
Una de las cosas a tener en cuenta es el tiempo que tarda en variar la resistencia
cuando cambia la luz que recibe, hay modelos con diferentes tiempo de respuestas, además
no varía de igual manera de luz a oscuridad, que de oscuridad a luz. De todas maneras, salvo
que necesitemos una respuesta de variación extremadamente rápida y precisa, el LDR nos
servirá para la mayoría de proyectos que vayamos a utilizar.

Ultrasonidos - HC-SR04
Alimentación : 5V
Angulo de sensado : 15°
Rango de distancia : 2 a 500 cm
Número de pines : 4 ( Vcc,Trig,Echo,Gnd )
Si la velocidad del sonido a 20ºC en el aire es de 343 m/s y sabiendo que el eco debe ir
y volver tardando “t” segundos. Entonces tenemos que la distancia “d” en metros es :
2d = 343 · t de donde obtenemos d = (343 · t) / 2
Para hacer una lectura con el HC-SR04 basta con seguir estos pasos :
1) Enviar un pulso de mínimo 10 µs por el pin TRIG (disparo) para iniciar la lectura.
2) El sensor enviara 8 pulsos de ultrasonido y colocara su salida ECHO a alto,
debemos detectar este evento e iniciar un "conteo de tiempo".
3) La salida ECHO se mantendrá en alto hasta recibir el eco reflejado por el obstáculo
a lo cual el sensor pondrá su pin ECHO a bajo, es decir, terminaremos de "contar el
tiempo".
4) La distancia es proporcional a la duración del pulso y podemos calcularla con las
siguientes formulas:
d (m) = (343 · t(s) ) / 2 = 171,5 · t(s)
d (cm) = t (µs) · 0,01715  distancia en cm, t en µs

d (inch) = t (µs) · 0,00675  distancia en pulgadas, t en µs
Nota : Si la duración del pulso es mayor a 30 ms significará que no hay obstáculo.
El diagrama de tiempos es el siguiente :
Esto es la teoría y no nos va a hacer falta para utilizar este sensor ya que hay
una librería que nos devuelve la distancia en centímetros o en pulgadas llamada
Ultrasonic.

Debemos descomprimirla en el directorio libraries del compilador IDE. Las

patillas “Trig” y “Echo”, van conectadas a 2
entradas digitales de Arduino a nuestra elección.
Para el ejemplo, conectaremos “Trig” a la 9 y
“Echo” a la 8.
Abrir el IDE de Arduino, pinchar sobre “Archivos” - “Ejemplos”, después buscar

“Ultrasonic” y seleccionar “Serial”.
El programa Serial de ejemplo es el siguiente :
La primera línea “ #include <Ultrasonic.h> ”, lo que hace es incluir en nuestro

código, las funciones necesarias para poder utilizar el módulo HC-SR04. La siguiente
línea “ Ultrasonic ultrasonic(9,8); “, declara un objeto llamado “ ultrasonic ” que
pertenece a la clase “ Ultrasonic ” y enviamos 2 parámetros, el pin del Arduino donde
hemos conectado TRIG y el pin del Arduino donde hemos conectado ECHO.
Después se puede comprobar que se hace uso del Monitor Serial, el cual se
comunica con Arduino a través del puerto serie RX (pin 0 de Arduino) y TX (pin 1 de
Arduino , por lo que esos pines no debemos usarlos. El puerto serie del Arduino se
comunica con el PC a través del cable USB, por lo que no debemos desconectarlo
cuando usemos el puerto serie. Además vemos que ha configurado la velocidad del
puerto serie en 9600 bps (baudios).
Por último, la línea donde se encuentra “ ultrasonic.Ranging(CM) “, devuelve

la distancia a la que se encuentra el objeto detectado en centímetros (CM) y lo
muestra por el puerto serie, si quisiéramos que nos lo indique en pulgadas, debemos
sustituir CM por INC.

Esta librería tal cual viene tiene un timeout o tiempo de espera de 3 ms por lo
que la distancia máxima que medirá será de 51 cm algo escaso. La ventaja de tener un
timeout tan bajo es que se pueden hacer muchas mediciones en poco tiempo.
Podemos modificar este timeout, en el fichero “Ultrasonic.cpp”.
Buscamos Time_out = 3000 y lo modificamos a 30000 para 5 metros.
Nota importante :
El IDE de Arduino está en constante desarrollo, saliendo versiones nuevas cada cierto
tiempo. Hasta antes de la versión 1.0, las librerías necesitaban incluir el archivo “WProgram.h”,
pero a partir de la versión 1.0, se modificó el nombre del archivo por “Arduino.h”, y además se
incluyó varias funciones más, con la aparición del Arduino Due, se prevé que habrá una nueva
modificación, pero a fecha de hoy, aún no existe ninguna información. Muchas aplicaciones
para Arduino que encontramos por Internet se desarrollaron para las primeras versiones del
IDE de Arduino, por lo que en los ficheros “.cpp” y “.h” contienen la llamada al archivo
“WProgram.h”, si utilizamos la versión 1.0 o posterior del IDE de Arduino, al compilar nos dará
un error, indicando que no encuentra el fichero “WProgram.h”, la solución a este problema es,
editar el fichero “.cpp” o “.h” afectado, y sustituir la línea #include "WProgram.h" por
#include "Arduino.h".
Otra solución más elegante y que hará que el compilador decida por sí solo, que
fichero incluir, en función de la versión del IDE de Arduino utilizado es borrar la línea #include
"WProgram.h" y en su lugar escribir este código :
#if ARDUINO >= 100

#include "Arduino.h"
#else
#include "WProgram.h"
#endif

Prácticas ( III )
P3a) Regulación de luz en un jardín
Vamos a utilizar una LDR, para simular una hipotética compensación lumínica
de 5 niveles, es decir, a través de una resistencia que varía su valor dependiendo de la
luz recibida, aprovecharemos dicha variación para hacer un programa que nos
encienda o apague una serie de LEDs dependiendo de si hay más luz o menos luz, esto
podríamos extrapolarlo a un sistema de regulación de luz de un jardín con cinco líneas
de luz que se vayan encendiendo según va cayendo la noche compensando
progresivamente la deficiencia de luz.
Además le hemos implementado un potenciómetro para ajustar el nivel crítico

mínimo de luz que queremos soportar, a partir del cual se activará nuestro circuito y
empezará a aumentar la luz del lugar progresivamente.
En el circuito de la izquierda, nos dará la

tensión máxima cuando tengamos el LDR en plena
oscuridad, ya que presentará su máxima resistencia,
obteniendo en Vout una tensión elevada.
En el circuito de la derecha, el resultado será el
inverso, tendremos la tensión máxima cuando esté
completamente iluminado, ya que se comportará
prácticamente como un cortocircuito, con una
resistencia de 50 Ω o 100 Ω.
Nosotros usaremos el circuito de la derecha, de manera que cuanta más luz

haya, más tensión tendremos a la entrada de nuestra entrada analógica pudiendo
ajustar así, de una manera muy intuitiva, la tensión de referencia. Por lo tanto, nuestra
LDR, hará que Vout = 0 , cuando esté completamente a oscuras, y +5 V aprox. cuando
esté completamente iluminada, situaciones que pueden ser difíciles de conseguir
dependiendo del entorno en el que trabajemos, y por otra parte, ese rango de 0v a 5v
habrá que dividirlo en 1024 “pasos” que va a leer nuestro Arduino, pero quizás solo
vayamos a trabajar en 500 o 600 pasos, desperdiciando mucha resolución.
Para solucionar esto, además de evitar cambiar el programa de Arduino cada

vez que lo cambiemos de entorno, usaremos una función que nos proporciona Arduino
muy interesante, el pin “Aref”.
Debemos tener en cuenta que este pin lleva internamente una resistencia de
32 KΩ para evitar dañar el chip, de manera que si vamos a conectar el pin mediante
una resistencia fija, se va a producir un nuevo divisor de tensión, con lo que habrá que
calcular la resistencia adecuada para la tensión exacta que queremos introducir
mediante una sencilla fórmula :

Dónde:
 Vin = Tensión que introducimos a Aref
 Rinterna = Resistencia interna de Arduino de 32 KΩ
 Rexterna = Resistencia mediante la cual alimentamos Aref
 Vrefencia = La tensión sobre que tomará referencia nuestro programa.
De manera que si por ejemplo, estamos introduciendo una tensión de +3 V a

través de una resistencia de 5 KΩ, la tensión real de referencia en nuestro Arduino será
de:
Variando la señal de referencia, le estamos diciendo al convertidor analógico a

digital del Arduino, que nos tome 1024 valores entre 0 V una determinada tensión
máxima, y el reparto de esos valores ya los hemos fijado equitativamente en nuestro
programa para que haga una activación progresiva de las líneas de iluminación, por
tanto, aunque tengamos un rango muy bajo de iluminación con el que jugar, de 1 V por
ejemplo, nos va a distribuir siempre proporcionalmente la activación de las salidas.
Esa tensión de referencia, será el punto de iluminación a partir del cual, si

decrece la luz ambiente, empezará a decrecer los valores obtenidos en la señal
analógica de entrada.
Si ponemos esa referencia muy baja, empezará a funcionar los leds con menos
luz ambiente que si ponemos una señal muy alta, recordemos:
Más luz = Menos Resistencia = Mayor Vout

Menos luz = Mayor resistencia = Menor Vout
Veamos el esquema eléctrico del circuito al completo:

El esquema será la siguiente :
RV1
10k
+5V
50%
+88.8
Volts
ARDUINO
+5V R1 D1 LED-RED
AREF 220
53/26 R2 LED-RED
PB5/SCK
52/25 D2
1
PB4/MISO
RESET 51/24
~PB3/MOSI/OC2A 220
LDR1 ~ PB2/SS/OC1B
50/23
49/22 R3 LED-RED
TORCH_LDR ~ PB1/OC1A
48/21
D3
PB0/ICP1/CLKO
ATMEGA328P-PU
1121
220
DIGITAL (~PWM)
47/20
ANALOG IN
PD7/AIN1
2
46/19 R4 LED-RED
7/34
PC0/ADC0
~ PD6/AIN0
45/18
D4
8/35 ~ PD5/T1
PC1/ADC1 44/17
9/36 PD4/T0/XCK 220
PC2/ADC2 43/16
10/37 ~ PD3/INT1
+88.8 R6 11/38
PC3/ADC3
PD2/INT0
42/15 R5 D5 LED-RED
Volts 1k PC4/ADC4/SDA 41/14
12/39 TX PD1/TXD
PC5/ADC5/SCL 40/13
RX PD0/RXD 220
ARDUINO UNO R3
El código a introducir, es el siguiente :
Montar el circuito y comprobar el funcionamiento real.

P3b) Puerta automática de acceso a supermercados, hospitales, etc…

En el estado de reposo, la puerta se
encuentra cerrada, activando “Fb”.
Cuando un objeto (persona) entra en la
zona de detección de los sensores “Fc1”
o “Fc2”, hará que la puerta se abra,
haciendo girar al motor en sentido
“Ma”. Cuando la puerta accione a “Fa”,
hará que el motor se pare. Al cabo de 3s
si los sensores “Fc1” y “Fc2” no detectan ningún objeto, la puerta se cerrará, girando el
motor en sentido “Mc”. Si antes de transcurrir 3s, detecta algún objeto, se tendrá que
esperar otros 3s para el cierre de la puerta. Si la puerta se está cerrando, es decir “Mc”
se encuentra activado, y los sensores “Fc1” o “Fc2” detectan algún objeto, la puerta
deberá volver a abrirse. Si los sensores “Fc1” y “Fc2” no detectan ningún objeto, la
puerta se cerrará completamente, accionando a “Fb” y volviendo al estado de reposo.
Nota : Para el temporizador, se debe usar la función millis ( ). Como sensor de

presencia usaremos el módulo HC-SR04 , teniendo en cuenta que debemos configurar
el archivo “.cpp” para detectar 5 m.
Para simplificar el montaje, usaremos solo un sensor HC-SR04, teniendo en

cuenta que si queremos usar los 2 en un montaje real, deberemos tener en cuenta que
en cuanto uno de los 2 sensores detecte presencia deberá abrirse la puerta.

Montar el circuito y comprobar su funcionamiento.

Sensores ( II ) – Infrarrojos (IR)

Barrera de luz infrarroja para nuestros proyectos
En muchos de nuestros proyectos, necesitaremos una barrera de luz infrarroja

para detectar el paso de objetos, personas, etc…. Para ello vamos a utilizar un diodo
(fotodiodo) emisor CQY99 y un transistor (fototransistor) receptor BPW77.
Diodo CQY99 emisor de Infrarrojos  Denominación de fabricante : TSUS5402
Especificaciones :
Tipo de emisor infrarrojo LED
Longitud de onda λ 950 nm
Lente de diodo transparente, azul
Ángulo de visión 44°
Fototransistor BPW77 receptor de Infrarrojos
Se trata de un fototransistor de tipo NPN, cuyas características

son las siguientes :
Otra alternativa más casera, es aprovechar los fotodiodos y fototransistores de los

ratones de PC antiguos de bola, de forma que al desmontar el ratón, tendremos :

En realidad, cada elemento anterior de 3 patillas, son 2 fototransistores conectados de

la siguiente manera :
Donde podemos observar que el terminal del

centro, se corresponde con los colectores de los
fototransistores y los terminales de los extremos se
corresponden con los emisores de los fototransistores.
Los fotodiodos disponen de un punto rojo,

indicando el cátodo, además en caso de duda se puede
recurrir a un óhmetro para averiguarlo.
Para nuestro propósito, podemos unir los dos emisores, con lo que tendremos el
terminal del centro que sería el colector y los otros 2 unidos que serán el emisor.
El circuito que utilizaremos es el siguiente :
Este circuito es válido para

+5V
cualquiera de los fotodiodos y

+5V fototransistores que se han
R3
R2
10k
1k
descrito anteriormente.
Q3
PN2222
R1
56
Q2 La placa de PCB se puede
PN2222
D1
Q1 1
J1 diseñar de forma que tanto los
FotoTransistor R4 2
LED_IR
470
Salida
fotodiodos como los
fototransistores se puedan colocar
en los lugares a detectar.

Rebotes
Hemos visto cómo podemos realizar la lectura del estado del pin, pero, ¿ qué pasa si
deseamos contar el número de veces que cambia de estado ?. No queremos detectar el
estado en el que se encuentra el pin sino que queremos contar el número de veces
que cambia de estado. Esto puede ser necesario cuando un mismo pulsador nos debe
determinar comportamientos diferentes o simplemente, para implementar un contador.
Encontraremos el temido problema de los rebotes (debounce). Son los indeseables

cambios de estado que se producen cuando un contacto mecánico cambia de estado.
Una forma de minimizar los rebotes es utilizar hardware externo, por ejemplo :
Aquí podemos ver un circuito R-C conectado al circuito
típico de resistencia pull-down, de forma que cuando
accionemos el pulsador, el condensador C1, se cargará de 0V a5V
a través de R1, con una constante de tiempo Ƭ=R1 · C1, como
vemos esa señal es llevada a un inversor 7414 Trigger Smith.
Cuando llega a 1.7 V, el inversor convierte a un estado bajo que
leerá el pin del Arduino.
Cuando el pulsador se desactiva, C1 pasa de 5V a 0V. Al
llegar a 0.9V, la puerta Trigger Smith convierte ese estado a un
estado alto. Este estado alto es el que lee el pin de nuestro
Arduino.
Otra forma de minimizar el efecto de los rebotes es usar software, podemos crear un
algoritmo basado en temporizadores (millis( )…..), usando interrupciones o mediante la
siguiente función :
Como podemos
observar, la función la
he llamado antirebotes y
como parámetros de
entrada recibe una
variable de tipo byte y
devuelve el resultado
también como un byte.
Si tenemos una variable (“miVariable”) a la cual debemos quitar los rebotes, haremos
la llamada a esta función de la siguiente forma ;
if ( antirebotes ( miVariable ) )
{
…………………….
Este código, sólo se ejecuta una vez
…………………….
}

Al hacer la llamada “miVariable” se copia en “variableConRebote” por lo que

“miVariable” debe ser de tipo byte. A continuación se declara la variable “flanco” de tipo byte
estática y se le asigna el valor “0”, esto significa que la variable “flanco” la primera vez que se
declare, tendrá el valor “0” y además guardará su valor al salir de la función como si fuera una
variable global. A continuación se realiza una comparación de “variableConRebote” con el
valor en reposo de esa variable, que deberemos modificar para cada ejercicio. Si suponemos
que estamos presionando un pulsador
Prácticas ( IV )
P4a) Diferentes modos de funcionamiento de un Pulsador
Vamos a diseñar un circuito que disponga de 2 pulsadores conectados a una

entrada analógica, un display que lo usaremos para el modo 3 y un led con su
resistencia limitadora para ver el funcionamiento del modo elegido.
 Modo 0 : Modo normal, en este modo al pulsar “P” el led se enciende, al

soltar “P” el led se apaga.
 Modo 1 : Modo Interruptor, en este modo, al pulsar y soltar “P”, el led

cambia de estado.
 Modo 2 : Modo palmadas, en este modo, simularemos que cuando se den

2 palmadas (o dos sonidos fuertes), el led cambie de estado, tener en
cuenta que el tiempo entre una palmada y la otra debe ser menor de 500
ms. En realidad conectaríamos un micrófono con un amplificador
operacional 741 a una entrada analógica del Arduino y detectaremos
cuando el sonido sobrepasa un umbral de tensión, por ejemplo 2 V.

 Modo 3 : En este modo, usaremos el display. Comenzará representando un

cero. Cuando se pulse y se suelte el pulsador “P” antes de 2 segundos, el
número que se representará en el display se irá incrementando cada vez
que se pulse y se suelte “P”. Si se mantiene pulsado “P” durante 500 ms
aprox., el display se irá incrementando rápidamente a una velocidad de
500 ms. Los números representados en el display deberán de estar
comprendidos entre el 0 y el 9, y se irán incrementando. El siguiente
número a mostrar después del 9 será el 0.


P4b) Ascensor de 5 pisos.
Realizar el diseño de un ascensor de 4 pisos más planta baja de

forma que dispongamos de 5 pulsadores (uno en cada piso), para
llamar al ascensor.
La cabina del ascensor, deberá disponer de un receptor de
infrarrojos y en cada piso dispondremos de un emisor de infrarrojos
siempre activado, de +5V
forma que cuando la D1

R1
P0 P1 P2 P3 P4
cabina pase por cada piso, el receptor, recibirá
M1
220
LED-RED
D2
señal del emisor que se encontrará colocado en el R5
P0
R6
P1
R7
P2
R8
P3
R9
P4
M2
R2
220
LED-BLUE
1k 1k 1k 1k 1k
lugar adecuado, de forma que la cabina se

encuentre nivelada con respecto al piso donde se
encuentre. +5V ARDUINO
En su estado de reposo, el ascensor se AREF
CABINA 53/26
encontrará parado y situado en la planta baja y el

PB5/SCK
52/25
PB4/MISO
RESET 51/24
~PB3/MOSI/OC2A
50/23
~ PB2/SS/OC1B
49/22
S ~ PB1/OC1A M2
receptor, estará recibiendo señal del emisor,

48/21
PB0/ICP1/CLKO M1
ATMEGA328P-PU
1121
DIGITAL (~PWM)
R3 47/20
ANALOG IN
PD7/AIN1
1k 46/19
7/34 ~ PD6/AIN0 P4
PC0/ADC0 45/18
situado en dicha planta.

8/35 ~ PD5/T1 P3
PC1/ADC1 44/17
9/36 PD4/T0/XCK P2
PC2/ADC2 43/16
10/37 ~ PD3/INT1 P1
PC3/ADC3 42/15
11/38 PD2/INT0 P0
PC4/ADC4/SDA 41/14
12/39 TX PD1/TXD
Debemos disponer de un display que nos

PC5/ADC5/SCL 40/13
RX PD0/RXD S
ARDUINO UNO R3
indique la planta donde se encuentra la cabina.
Como mejora, se deja como ejercicio extra, el añadir las puertas en la cabina de forma
que al llegar a la planta desde la cual se le ha llamado, se abran las puertas de la cabina. Por lo
que las puertas deben disponer de sus finales de carrera correspondientes. Además se puede
añadir una barrera de luz infrarroja en la puerta como medida de seguridad para que no se
puedan cerrar las puertas si existe algún obstáculo.

Los Strings (cadena de caracteres) en Arduino
Aunque en un principio, utilizar strings en un microcontrolador parece no tener

demasiado sentido, hay a veces que es necesario su uso. Supongamos por ejemplo que
queremos realizar una comunicación serie entre arduino y otro dispositivo (PC, otro
arduino, bluetooth, autómata, etc…..) podríamos enviar o recibir un byte, un carácter
(char) o una cadena de caracteres (string).
Para definir una variable de tipo char o un string, lo haremos de una de estas
dos formas :
char variable1=’x’; // ‘x’ es el carácter que asignamos a variable1

char variable2;
string variable3=”prueba”; // “prueba” es el string que asignamos a variable3
string variable4;
variable2=’y’; // ‘y’ es el carácter que asignamos a variable2
variable4=”esto es”; // “esto es” es el string que asignamos a variable4
Para concatenar 2 o más variables de tipo char o de tipo string, primero

debemos fijarnos que el resultado es un string, por lo tanto, en primer lugar, nos

debemos declarar la variable de tipo string que contendrá el resultado de la

concatenación, por lo tanto ;
String Resultado1=””; // “” significa que asignamos un string vacío

String Resultado2;
Resultado2=””;
Resultado1=variable1 + “ – “ + variable2 + “ = z”;
// Resultado1 será  x - y = z  Fijarse en los espacios
Resultado2=variable4 + “una” + variable3+’ ‘+variable1; // ‘ ‘ es un espacio
// Resultado2 será  esto esunaprueba x  Fijarse en los espacios
Antes de usar los String, tenemos que incluir la librería String, de la forma
siguiente :
#include <String.h>
Al incluir esta librera, obtenemos varias funciones que podemos utilizar sobre
cualquier variable de tipo string.
 StringConstructors
 StringAdditionOperator
 StringIndexOf
 StringAppendOperator
 StringLengthTrim
 StringCaseChanges
 StringReplace
 StringRemove
 StringCharacters
 StringStartsWithEndsWith
 StringComparisonOperators
 StringSubstring
Haga click sobre el enlace de cada función para ver cómo se utilizan. En este
curso utilizaremos algunas de estas funciones.

Manejo de una LCD 16x2
Usaremos una shield que además de una LCD de 16x2, dispone también de 6
pulsadores, se trata del LCD Keypad Shield. Para el control se usan 4 bits.
Los pines 4, 5, 6, 7, 8, 9 y 10 son usados para la con el
LCD. El pin análogo 0 es usado para leer los 5 botones. El LCD
soporta ajuste de contraste y backlit on/off.
Aquí podemos ver el esquema interno de este shield :

Al montar la shield, encima de Arduino, tendremos varios pines de Arduino ocupados y

podremos disponer de los siguientes :
Esta shield, viene con una librería llamada “LCD KeyPad”, la cual se debe copiar en la
carpeta libraries del IDE de Arduino, esta librería utiliza a su vez la librería estándar de control
de LCDs llamada “Liquid Crystal”, la cual ya viene incluida por defecto en el IDE de Arduino.
La librería Liquid Crystal :
Permite a la placa Arduino controlar displays LCD basados en el chipset Hitachi

HD44780 (o compatibles), que se encuentra en la mayoría de LCDs de texto. La
biblioteca trabaja en modo 4-bit o en 8-bit (es decir, por medio de 4 u 8 líneas de
datos, además de RS, ENABLE, y, opcionalmente, las líneas de control RW).
LiquidCrystal ( ) : Crea una variable de tipo LiquidCrystal. La pantalla se puede

controlar por medio de 4 u 8 líneas de datos. En el primer caso, omitir los números de
pines para d0 hasta d3 y dejar esos pines no conectados. El pin RW pueden ser
conectado a masa en lugar de conectarse a un pin de Arduino, si es así, omítelo de los
parámetros de esta función.
Sintaxis : LiquidCrystal (Rs, Rw, Enable, d0, d1, d2, d3, d4, d5, d6, d7)
Rs : número del pin de Arduino que está conectado al pin RS del LCD
Rw : número del pin de Arduino que está conectado al pin RW del LCD
Enable : número del pin de Arduino que está conectado al pin Enable del LCD
d0, d1, d2, d3, d4, d5, d6, d7 : números de pines de Arduino que están
conectados a los correspondientes pines de datos del LCD.
d0, d1, d2, y d3 son opcionales, si se omiten, el LCD será controlado usando
solamente cuatro líneas de datos ( d4, d5, d6, d7 ).

Begin( ) : Especifica las dimensiones (ancho y alto) del display LCD.
Sintaxis : Lcd.begin( Columnas , Filas )
Lcd : Una variable de tipo LiquidCrystal.

Columnas : Número de columnas que tiene el display.
Filas : Número de filas que tiene el display.
Clear : Borra la pantalla del display LCD y posiciona el cursor en la esquina superior
izquierda.
Sintaxis : Lcd.clear( )
Lcd : una variable de tipo LiquidCrystal.
home( ) : Posiciona el cursor en la esquina superior-izquierda del LCD. Se trata de la

posición en la que aparecerá el siguiente texto escrito en el display. A diferencia con al
anterior que esta no borra el contenido anterior del display.
Sintaxis: Lcd.home( )
setCursor( ) : Establece la posición del cursor donde empezaran aparecer los

siguientes caracteres escritos en el LCD.
Sintaxis : Lcd.setCursor( Columna,Fila )

Columna : Columna donde posicionar el cursor (0 - primera columna).
Fila : Fila donde posicionar el cursor (0 - primera fila).
write( ) : Escribe un carácter en el LCD.
Sintaxis : Lcd.write( Data )
Lcd: Una variable de tipo LiquidCrystal.

Data : El carácter a escribir en el display.
print( ) : Imprime un texto en el LCD.
Sintaxis : Lcd.print( Data,BASE )

Data : Los datos a imprimir ( char, byte, int... ).

BASE (opcional) : La base en la que se van a imprimir los números: BIN, DEC,
OCT, HEX.
Para mayor detalle de las funciones de esta librería : http://arduino.cc/es/Reference/LiquidCrystal
Modulo Transmisor y receptor de datos a 433,92 Mhz

En domótica, la mayoría de los dispositivos inalámbricos
comerciales usan la frecuencia de 433,92 MHz. Otros dispositivos
de RF de KNX, por ejemplo usan la frecuencia 868,4MHz. Nosotros
usaremos estos módulos que trabajan a 433,92 MHz, y debido al
precio reducido de la pareja podemos añadírselo a nuestro
Arduino para realizar multitud de combinaciones entre diversos
dispositivos a un precio bastante asequible.
Las especificaciones técnicas de los módulos son :
Módulo TX Módulo RX
Tensión de trabajo 3V~12V Tensión de trabajo 5.0Vdc + 0.5V
Corriente max≤40mA (12V), min≤9mA(3V) Corriente ≤ 5.5mA ( 5.0VDC )
Modulación ASK / OOK Modulación ASK / OOK
Frecuencia 315MHz - 433.92MHz Frecuencia 315MHz - 433.92MHz,
Velocidad ≤ 10 Kbps Velocidad < 9.6 Kbps
Para máxima distancia,
20-200 m ( según la tensión de
Distancia TX Distancia RX poner antena de alambre
trabajo )
de 23cm
Vienen emparejados TX y RX
La manera de conectar estos módulos a nuestro Arduino, es de la siguiente forma :
Para usar estos módulos en Arduino, debemos añadir una librería llamada “RCswitch”
a la carpeta “libraries”del IDE del Arduino y nos aparecerán unos ejemplos de utilización.
Esta librería utiliza la interrupción externa 0 ( pin digital 2 ), que estudiaremos más
adelante, de momento únicamente la utilizaremos

Podemos usarlo para comunicar 2 Arduinos, controlar un dispositivo compatible

mediante Arduino o controlar Arduino mediante un dispositivo compatible. Por ejemplo, una
de las marcas comerciales en el campo de la domótica es “avidsen”, cuyo catálogo de
productos podemos visualizar en : http://www.avidsen.com/
Otra marca comercial es por ejemplo “dinuy”, cuyo catálogo de productos podemos
visualizar en : http://www.dinuy.com/
En el taller disponemos del kit compuesto por un Portalámparas y su mando a

distancia de la marca avidsen cuya referencia es 103211. Este kit sirve para encender, apagar
o regular el aumento o disminución de la intensidad de luz con el
mando a distancia. Tiene un alcance de 20m ( pila A23 12V incluida ).
Solo funciona con bombillas de incandescencia E27. La
frecuencia de trabajo es de 433,92 MHz con una modulación ASK/OOK.
En la transmisión se codifica la información con un código, que cuando
llega al receptor, éste se encarga de decodificarlo. Este código se puede
modificar por medio de unos switch que dispone tanto el emisor como
el receptor.
Prácticas ( V )
P5a) Comunicación usando el puerto Serie.
LCD1
LM016L Utilizaremos Putty (Software que simula
un terminal, parecido al HyperTerminal, pero de
licencia libre) para enviar un texto a nuestro
VDD
VSS
VEE
RW
RS
D0
D1
D2
D3
D4
D5
D6
D7
+5V
E
Arduino y éste lo deberá mostrar en una LCD de

1
2
3
4
5
6
7
8
9
10
11
12
13
14
RIGHT
R1
2k
RV1 16x2 (módulo LCD Keypad Shield ). También se
40%
AD0
10k puede usar el Serial Monitor que viene
D8
D9
D4
D5
D6
D7
R2
+5V
UP
330
+88.8
integrado en el IDE de Arduino aunque este no
Volts
R3
ARDUINO
envía la información hasta que no se pulsa
620
DOWN
ARDUINO UNO R3
AREF “Enviar”.
53/26
PB5/SCK
52/25
PB4/MISO
R4 RESET
~PB3/MOSI/OC2A
51/24
1k 50/23
LEFT
~ PB2/SS/OC1B
~ PB1/OC1A
PB0/ICP1/CLKO
49/22
48/21
D9
D8
La configuración del puerto serie será :
ATMEGA328P-PU
1121
DIGITAL (~PWM)
47/20
ANALOG IN
PD7/AIN1 D7
46/19
AD0 7/34 ~ PD6/AIN0 D6
R5 8/35
PC0/ADC0
~ PD5/T1
45/18
D5
3.3k PC1/ADC1 44/17
9/36 PD4/T0/XCK D4
PC2/ADC2 43/16
SELECT 10/37
PC3/ADC3
~ PD3/INT1
42/15
11/38 PD2/INT0
PC4/ADC4/SDA 41/14
12/39 TX PD1/TXD
PC5/ADC5/SCL 40/13
RX PD0/RXD
CTS
RTS
TXD
RXD
En este caso, Arduino se encuentra en el COM4. Nos

debemos fijar que los datos se transmiten en código
ASCII, por lo que la tecla de retroceso (borrado) es el
carácter ASCII 8 en decimal.

El código ASCII :(American Standard Code for Information Interchange — Código Estándar
Americano para el Intercambio de Información ).
El código ASCII utiliza 7 bits para representar los caracteres, aunque inicialmente
empleaba un bit adicional llamado bit de paridad, que se usaba para detectar errores en la
transmisión.

P5b) Puerta de Garaje automática usando RF
Se dispone de un final de
carrera “Fc” para detectar
cunado la puerta se encuentra
cerrada, otro final de carrera
“Fa” para detectar cuando la
puerta está abierta, una barrera
de luz infrarroja, que sin
detectar ningún obstáculo, envía un “1” y cuando detecta algún obstáculo el haz de luz
infrarroja se corta enviando un “0”. La puerta en estado de reposo se encuentra cerrada y
accionando “Fc”, cuando un vehículo quiere entrar o salir, el conductor envía una señal de
radiofrecuencia de 433,92 MHz modulado en ASK y la puerta se abre hasta accionar “Fa”. En
ese momento un temporizador comienza a contar.

Si transcurren “t” segundos sin que “FIR” detecte algún obstáculo, la puerta debe
cerrarse.
Si mientras se está cerrando “FIR” detecta algún obstáculo o algún conductor pulsa el
mando a distancia, la puerta debe abrirse.
Si no hay ningún obstáculo que corte el haz de luz infrarroja y el mando a distancia no
se pulsa, la puerta debe cerrarse completamente, accionando a “Fc” y quedando en reposo
hasta una nueva pulsación del mando a distancia.
Si mientras la puerta está abierta, accionando “Fa”, la barrera infrarroja “FIR” detecta
algún obstáculo, no debe de transcurrir ningún tiempo “t”, empezando a contar en el instante
que “FIR” deje de detectar el obstáculo. Para simular el mando a distancia, utilizar un pulsador,
tal que cuando se pulse, se supone que se ha pulsado el mando y se ha transmitido el código
correctamente.


Se debe modificar la variable “Código Permitido” por el código del mando a distancia
de RF utilizado, para ello se debe visualizar en el Monitor Serial el código que se transmite
cuando se pulsa el pulsador del mando y substituir “ long CodigoPermitido=263507; “ por el código
transmitido por el mando RF.
Sensores ( III )
Sensor DHT11 (Humedad y Temperatura) - Digital
Este sensor DHT11 nos va a servir para medir tanto la humedad relativa como la
temperatura. Lo malo de este sensor es que solo nos va a dar medidas enteras, es decir sin
decimales, ya que la resolución que
presenta es de 1% para la humedad relativa
y de 1ºC para la temperatura.
Pero compensa ya que presenta un

valor muy económico para pequeños
proyectos y que nos permite obtener
medidas tanto para humedad como para
temperatura.
Este sensor se caracteriza

por tener la señal digital calibrada
por lo que asegura una alta calidad
y una fiabilidad a lo largo del
tiempo, ya que contiene un
microcontrolador de 8 bits
integrado. Está constituido por dos
sensores resistivos (NTC y
humedad). Tiene una excelente
calidad y una respuesta rápida en
las medidas.
Puede medir la humedad entre el rango 20% – 90% y la temperatura entre el rango
0ºC – 50ºC.
Cada sensor DHT11 está estrictamente calibrado en laboratorio, presentando una

extrema precisión en la calibración. Los coeficientes de calibración se almacenan como
programas en la memoria OTP, que son empleados por el proceso de detección de señal
interna del sensor.
El protocolo de comunicación es a través de un único hilo (protocolo 1-wire), por lo

tanto hace que la integración de este sensor en nuestros proyectos sea rápida y sencilla.
Además presenta un tamaño reducido, un bajo consumo y la capacidad de transmitir la señal
hasta 20 metros de distancia.

La conexión del sensor a Arduino (sensor solo sin módulo), debemos añadir una
resistencia de pull-up :
Nosotros usaremos este módulo que

ya dispone de la resistencia pull-up y la
conexión se realiza por medio de 3 pines Vcc,
Masa y Data:
Sensor LM35DZ (Temperatura) - Analógico
Otro sensor de temperatura, bastante interesante es el LM35 cuya tensión de salida es

linealmente proporcional a la temperatura Celsius (centígrados).
Es un sensor de temperatura integrado de precisión, cuya tensión de salida es

linealmente proporcional a temperatura en ºC (grados centígrados). No requiere ninguna
calibración externa o ajuste para proporcionar una precisión típica de ± 1.4 ºC a temperatura
ambiente y ± 3.4 ºC a lo largo de su rango de temperatura (de -55 a 150 ºC). El dispositivo se
ajusta y calibra durante el proceso de producción. La baja impedancia de salida, la salida lineal
y la precisa calibración inherente, permiten la creación de circuitos de lectura o control
especialmente sencillos.

Sensor DS18B20 (Temperatura) – Digital
Es un pequeño sensor de temperatura de 9 a 10 bits de precisión desde -55 ºC a 125 ºC

con un margen de error de tan solo 0.5 ºC. No requiere de componentes externos para su
funcionamiento. Cada sensor incorpora de fábrica un número de serie de 64 bits que permite
conectar múltiples sensores en paralelo usando sólo una patilla como bus de datos.
La ventaja principal que presentan estos sensores

es que se pueden conectar hasta 100 dispositivos a un
único pin y a una distancia máxima de nuestro Arduino
de 200 metros. Dichos sensores emplean el protocolo de
comunicación en serie 1-wire diseñado por Dallas
Semiconductor.
Este protocolo de comunicación básicamente es

un bus donde disponemos de un maestro y varios
esclavos en una sola línea de datos (pin de nuestro Arduino) en la que se alimentan. Por
supuesto, necesita igualmente una referencia a tierra común a todos los dispositivos. También
debemos conocer que la línea de datos/alimentación debe disponer de una resistencia de pull-
up conectada a alimentación para cuando no se produzca la transmisión de datos tengamos 5
voltios en dicha línea.
En este tipo de sensores podemos encontrar dos tipos de alimentación :
El primero solo suministra

alimentación mientras se realizan las
operaciones de conversión de
temperatura (modo parásito) , se
deben puentear las patillas GND y VDD
del DS18B20 a GND del Arduino.
El segundo es alimentación de
los sensores mediante una fuente de
alimentación externa conectada a la
patilla VDD del DS18B20, y la patilla
GND al pin GND de Arduino.
Para utilizar este componente en Arduino, debemos añadir las librerías “OneWire” y
“DallasTemperature” dentro de la carpeta “Libraries”.

Prácticas ( VI )
P6a) Medidas de temperatura y humedad con DHT11.
Como aplicación del sensor DHT11, vamos a visualizar a través de un Terminal,

la temperatura y la humedad del taller
Conectar el módulo a nuestro Arduino e introducir el siguiente código :

P6b) Medidas de la temperatura con DS18B20
Vamos a analizar el funcionamiento del sensor de temperatura DS18B20,

modificando un ejemplo que incluye la librería de dicho componente. La conexión con
Arduino se realiza de forma muy sencilla, utilizaremos el modo “parásito”, por lo que
debemos puentear los 2 pines del DS18B20 y conectarlos a masa, el terminal del
centro, lo conectaremos con una resistencia pull-up al pin 2 digital del Arduino.
Debemos añadir las librerías indicadas anteriormente e introducir el siguiente código :
Nota : El transistor no es necesario conectarlo

Introducción al lenguaje HTML

A continuación vamos a comenzar a comunicar nuestro Arduino con más dispositivos.
Una forma de comunicación muy rápida es mediante Internet. Nuestro arduino es capaz de
comunicarse con páginas web, enviando y/o recibiendo información con sólo el requisito de
disponer el shield Ethernet, que algunas placas lo tienen integrado.
Pero antes de estudiar la shield de Ethernet, necesitamos saber el lenguaje HTML que
és en el que se basan las páginas webs.
Podemos utilizar algún programa del tipo Dreamweaver u otro similar en el que
podamos sin tener conocimientos de HTML realizar una página WEB en modo diseño y
posteriormente mediante un botón, visualizar el código que dicho programa ha generado para
crear el fichero HTML correspondiente.
Se adjunta un documento realizado por la Universidad de Murcia donde se explica de

forma muy práctica la creación de páginas webs en lenguaje HTML.
A continuación se estudiará la placa Ethernet y posteriormente se realizarán varios

ejercicios prácticos donde veremos cómo se puede enviar información a través de Internet
usando Arduino, por lo que usaremos el lenguaje HTML para crear páginas WEBs muy
sencillas.
La placa shield Ethernet
A continuación veremos cómo enviar y recibir información

a través de Internet y, para ello, vamos a necesitar la placa
Ethernet Shield de Arduino. Serán necesarios unos conocimientos
básicos de HTML y/o PHP, simplemente para poder hacer la
página Web a nuestro gusto. A través de esta página Web,
podremos enviar y/o recibir información desde un PC, iPad, tablet,
o cualquier dispositivo con conexión WI-FI.
Todos los dispositivos que estén conectados a la misma

red local, a la que esté conectado Arduino tendrán la posibilidad de acceder a esta página.
Está basada en el chip ethernet Wiznet W5100. Soporta hasta cuatro conexiones de
sockets simultáneas.

Usa la librería Ethernet para escribir programas que se conecten a internet usando la
shield. La ethernet shield dispone de unos conectores que permiten conectar a su vez otras
placas encima y apilarlas sobre la placa Arduino.
Importante :
Arduino usa los pines digitales 4, 10, 11, 12, y 13 (SPI)

para comunicarse con el W5100 en la ethernet shield.
Estos pines NO PUEDEN SER USADOS para entradas y/o
salidas genéricas.
 La shield provee un conector ethernet estándar RJ45.

 El botón de reset en la shield resetea ambos, el W5100 y la placa Arduino.
 La shield contiene un número de LEDs para información :
a) PWR: indica que la placa y la shield están alimentadas.

b) LINK: indica la presencia de un enlace de red y parpadea cuando la shield envía
o recibe datos.
c) FULLD: indica que la conexión de red es full dúplex.
d) 100M: indica la presencia de una conexión de red de 100 Mb/s (de forma
opuesta a una de 10Mb/s)
e) RX y TX : parpadea cuando la shield recibe/envía datos
f) COLL: parpadea cuando se detectan colisiones en la red
Podemos observar que la shield Ethernet, dispone de una pegatina en la parte inferior,
donde nos indica la MAC (Media Access Control, "control de acceso al medio") es un
identificador de 48 bits (6 bloques hexadecimales) que corresponde de forma única a una
tarjeta o dispositivo de red. Se conoce también como dirección física. Más información en :
http://es.wikipedia.org/wiki/Direcci%C3%B3n_MAC

Las shields que no dispongan de ninguna pegatina indicando la MAC, se puede asignar
una MAC al azar, pero todas las MAC de los dispositivos de la red local deben ser distintas.
También podemos observar que el Ethernet Shield dispone de un conector para alojar
una tarjeta de memoria microSD, la cual podemos usarla para almacenar o leer los datos que
queramos.
Para analizar con más detalle este shield, se adjunta un documento en el curso,
llamado “Arduino + Ethernet Shield”, en el cual se estudia con mayor detalle.
Prácticas ( VII )
P7a) Servidor Web : Control de un dispositivo desde una página Web HTML.
Lo que vamos a crear con el Ethernet Shield, es un servidor Web, el cual nos
proporcionará el código HTML para poder verlo en nuestro navegador y poder, así, interactuar
con él.
En Internet, un servidor es un ordenador remoto

que provee los datos solicitados por parte de los
navegadores de otros ordenadores. En redes locales (LAN,
Local Area Network), se entiende como el software que
configura un PC como servidor para facilitar el acceso a la
red y sus recursos. Los servidores almacenan información
en forma de páginas Webs y, a través del protocolo HTTP lo
entregan a petición de los clientes (navegadores Webs) en formato HTML.
Un servidor sirve información a los ordenadores que se conecten a él. Cuando los
usuarios se conectan a un servidor, pueden acceder a programas, archivos y otra información
del servidor.
Para acceder a la página Web que creemos, deberemos acceder con una dirección IP
perteneciente a nuestra red, que será la que le hayamos asignado al Ethernet Shield. En el
código que podréis ver más abajo, veréis que la dirección IP que he asignado es
192.168.0.200/24.
¿Qué quiere decir /24?.
Es la máscara de red, al ser /24, quiere decir que tendremos 24 bits a ’1′ y 8 a
’0′, es decir, que será 255.255.255.0.

Para comenzar, abriremos una consola de DOS ( Inicio –

Accesorios – Ejecutar – cmd / o en “Buscar programas y archivos”
tecleamos “cmd” y pulsamos enter ).
A continuación, escribiremos “ipconfig” y, podremos ver en

qué subred estamos. Mi puerta de enlace predeterminada es
192.168.1.1, así que, le asignaré al Ethernet Shield una dirección IP que
se encuentre libre dentro de la red local, por ejemplo
192.168.1.200/24.
El montaje del proyecto es muy sencillo, ya que sólo se

necesita un Led y una resistencia limitadora, conectados en el pin 9 de
Arduino.
El listado del sketch es el siguiente :

Con el programa compilado y cargado en Arduino, si abrimos el navegador de

cualquier PC , móvil, tablet, etc…que se encuentre conectado en la red local por cable o de
forma inalámbrica, y tecleamos la IP 192.168.1.200, entraremos a la Web que hemos escrito
en el sketch, es decir tendremos la siguiente ventana :
Si pulsamos en el botón “ON”, veremos como

el Led se ilumina y si pinchamos en el botón “OFF”,
veremos como el Led se apaga.
Como se puede deducir, si la página web incluye gráficos o es más compleja,

tendríamos problemas para alojar la web en la memoria interna del microcontrolador, por ese
motivo se ha incluido la posibilidad de usar una tarjeta microSD, no obstante, alojar una página
web con gráficos, en la microSD hará que la carga y/o refresco sea muy lenta, por lo que, como
conclusión usaremos la microSD para almacenar o leer datos que se encuentren en ficheros y
haremos que las páginas Webs estén alojadas en servidores normales cuya velocidad y ancho
de banda superarán con creces a la de la placa Ethernet Shield de Arduino.

P7b) Control automático de la temperatura de una habitación con visualización por Web.
Vamos a controlar de forma automática la temperatura de una habitación para

ello vamos a disponer de una shield Ethernet a la cual conectaremos un led (simulando
el dispositivo climatizador), en la patilla 9 con su resistencia limitadora.
Conectaremos un sensor de temperatura

DS18B20 en modo “parásito” en la patilla 2 digital del
Arduino y una resistencia variable de 10 KΩ en la
entrada 0 Analógica del Arduino, esta resistencia
variable servirá para ajustar el umbral de
temperatura en la que el dispositivo climatizador se
active o se desactive.
Si la temperatura de la habitación supera el

umbral establecido, el dispositivo climatizador debe
desactivarse y cuando la temperatura de la
habitación sea inferior al umbral establecido, el
dispositivo climatizador debe activarse.
El resultado una vez compilado y grabado en Arduino, lo podremos comprobar,

abriendo un navegador y tecleando la dirección IP de la shield Ethernet. La página se refrescará
cada 5 segundos.


Comentarios finales
Para finalizar comentaré que cada día surgen nuevas aplicaciones, nuevos proyectos,
nuevos módulos y nuevas investigaciones acerca de Arduino que hace que esta placa tenga
mucha aceptación sobre todo en la Docencia, ya que con poco esfuerzo es posible realizar
proyectos bastante atractivos.
En la actualidad estoy impartiendo Arduino, en el módulo de Instalaciones Domóticas

de segundo curso, del ciclo formativo de grado medio “Instalaciones de Telecomunicaciones”,
que como se sabe los alumnos que cursan estos estudios, disponen de un nivel medio de
electrónica, por lo que se debe adaptar estos contenidos al nivel del alumno.
Los alumnos de este nivel, cuando comienzan a realizar proyectos con sensores,
motores, finales de carrera, relés, móviles, etc…. adquieren una alta motivación y esto conlleva
a que el alumnado se interese por el módulo e incluso algunos alumnos adquieren por su
cuenta la placa Arduino, shields, módulos y componentes electrónicos para realizar proyectos
individuales en su hogar.
Juan Carlos López Gordillo

Ing.Tec.Ind. Telecomunicaciones
Profesor del IES Enric Valor – Silla (Valencia)
Equipos electrónicos

Bibliografía
 PROTEUS. Simulación de circuitos electrónicos y microcontroladores a través de

ejemplos.
Germán Tojeiro Calaza
Marcombo
 Compilador C CCS y simulador PROTEUS para microcontroladores PIC.

Eduardo García Breijo
Marcombo
 Instalaciones Domóticas.
Molina
McGraw-Hill
 Instalaciones automatizadas en viviendas y edificios.

David Lasso Tarraga, Jose Moreno Gil, Elias Rodríguez Diéguez
Paraninfo
 Instalaciones Domóticas.
Miguel Moro Vallina
Paraninfo
 Principios de electrónica.
Malvino
McGraw-Hill
 Curso de Introducción a Arduino.

Ricardo Carpio Richard
CEFIRE – Cheste
 OpenDomo. Seguridad y domótica libre : http://es.opendomo.org/
 Arduino : http://www.arduino.cc/
 BricoGeek : http://blog.bricogeek.com/
 Arduteka : http://www.arduteka.com/arduino/

INDICE DE PRÁCTICAS
PRÁCTICA ( I ) : Entradas y salidas digitales.

P1a) Lectura del estado de un pulsador y visulaización en un led 67
P1b) Pulsadores de marcha y paro 68
PRÁCTICA ( II ) : Gancho móvil.

P2a) Gancho móvil 91
P2b) Gancho móvil v2 , con marcha y paro 91
P2c) Gancho móvil v3 , con marcha, paro y memoría 91
P2d) Gancho móvil v4, usando la EEPROM de Arduino 91
PRÁCTICA ( III ) : Prácticando con LDR y ultrasonidos

P3a) Regulación de luz en un jardín 91
P3b) Puerta automática de acceso a supermercados, hospitales, etc… 101
PRÁCTICA ( IV ) : La importancia del control de los rebotes.

P4a) Diferentes modos de funcionamiento de un pulsador 106
P4b) Ascensor de 5 pisos 109
PRÁCTICA ( V ) : Comunicaciones con Puerto Serie y practicando con RF.

P5a) Comunicación usando el puerto serie de Arduino 116
P5b) Puerta de garaje automática usando RF 118
PRÁCTICA ( VI ) : Midiendo Temperatura y Humedad.

P6a) Medida de tempertaura y humedad con DHT11 124
P6b) Medida de tempertaura con DS18B20 125
PRÁCTICA ( VII ) : Comunicación usando la WEB.

P7a) Servidor Web 128
P7b) Control automático de tempertaura con visualización por Web 131

Curso Arduino

Hochgeladen von

Dokumentinformationen

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Curso Arduino

Hochgeladen von

Copyright:

Verfügbare Formate

CEFIRE ESPECÍFICO DE F.P.

SERVICIO DE FORMACIÓN DEL PROFESORADO

FAMILIA PROFESIONAL ELECTRICIDAD - ELECTRÓNICA

Ponente : Juan Carlos López Gordillo

Comparación entre las placas de Arduino Oficiales y no oficiales. 4

Introducción al Arduino. El Arduino UNO y el Arduino Mega 2560. 23

El IDE oficial de Arduino. Instalación, configuración y primeros pasos. 31

Software relacionado con Arduino. 41

El lenguaje de programación de Arduino. 51

Librerias para Arduino. 69

Como usar la memoria EEPROM de Arduino 86

Sensores I : Luminosidad (LDR) y Ultrasonidos (HC-SR04) 94

Sensores II : Infrarrojos (IR) 103

Los Strings en Arduino 110

Manejo de una LCD 16x2 112

Módulo transmisor y receptor de datos a 433,92 MHz 115

Sensores III : Humedad y Temperatura (DTH11, LM35 y DS18B20) 121

Introducción al lenguaje HTML. La placa Ethernet Shield. 126

Comentarios finales 133

Indice de Prácticas 135

 Conocer las placas de Arduino y los shields existentes.

Juan Carlos López Gordillo Página 1

Recomiendo que se dividan los contenidos de la siguiente forma :

Primera semana (Del Lunes 18/04/2016 al Viernes 22/04/2016 ) :

 Comparación entre las placas de Arduino Oficiales y las compatibles.

Segunda semana ( Del Lunes 25/04/2016 al Viernes 29/04/2016 ) :

 Software relacionado con Arduino.

Tercera semana : ( Del Martes 03/05/2016 al Viernes 06/05/2016 ) :

Cuarta semana ( Del Lunes 09/05/2016 al Viernes 13/05/2016 ) :

 Sensores II : Infrarrojos (IR)

Quinta semana ( Del Lunes 16/05/2016 al Viernes 20/05/2016 ) :

 Sensores III : Humedad y Temperatura (DHT11, LM35 y DS18B20).

Juan Carlos López Gordillo Página 2

Sexta semana ( Del Lunes 23/05/2016 al Viernes 27/05/2016 ) :

 Introducción al lenguaje HTML. La placa Ethernet Shield.

Se utilizará la plataforma Moodle para realizar la comunicación entre los asistentes al

Juan Carlos López Gordillo Página 3

Comparación entre las placas de Arduino Oficiales y no oficiales

Arduinos oficiales y no oficiales o compatibles

Juan Carlos López Gordillo Página 4

No todas son compatibles al mismo nivel.

Juan Carlos López Gordillo Página 5

En los Arduino’s oficiales podemos diferenciar entre dos tipos fundamentales de

Por último, en cuanto al voltaje, no importan demasiado a nivel electrónico, excepto

Juan Carlos López Gordillo Página 6

 Arduino Yun : se basa en el microcontrolador ATmega32u4 y en un chip Atheros

 Arduino Leonardo : es una placa basada en un microcontrolador ATmega32u4 de bajo

Juan Carlos López Gordillo Página 7

 Arduino Mega : su nombre proviene del microcontrolador que lo maneja, un

 Arduino Ethernet : Es un Arduino UNO y un shield Ethernet integrado. Esta placa es

Juan Carlos López Gordillo Página 8

 Arduino Nano : Empezaron incorporando un ATMega328 como el de otras placas

Juan Carlos López Gordillo Página 9

 Arduino Pro : Contiene un microcontrolador ATmega168 o Atmega328, con

 Arduino Pro Mini : Es la hermana pequeña de la versión

 Arduino Esplora : Se diferencia del resto de placas, a parte de su reducido tamaño y

Juan Carlos López Gordillo Página 10

 Arduino BT : es una placa Arduino con un módulo

 Arduino Duemilanove : Apareció en 2009, con microcontrolador ATmega168 o 368, 14

 Arduino Diecimila : Otra placa antigua basada en

Juan Carlos López Gordillo Página 11

Placas no oficiales (compatibles)

 Brasuino: se basa en UNO con LEDs re-ordenados, conector mini-USB, alteración de la

Juan Carlos López Gordillo Página 12